Convolutional Neural Networks

100%

Convolutional Neural Networks

✓ Published0🌍 Public

Last edited Mar 9, 2020

Created on Mar 9, 2020

This example shows how convolutional neural networks (CNNs) classify images, using the MNIST dataset of handwritten digits. It presents the network architecture and training process in Keras, with code that defines convolutional and pooling layers via the Sequential API. The visualization demonstrates how filters extract features from input images, using Python’s TensorFlow and Keras libraries to run the model. It includes practical code snippets from tutorials, showing how to load data, build the CNN, and evaluate its accuracy, while referencing YouTube tutorials and source code repositories for further exploration.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 99f0384031106e9fdc7a0d325cd88606

This example demonstrates a neural network classifier for handwritten digits. A Processing sketch displays the network architecture, and mouse clicks either train the network on 500 random samples from the training set or respond to a single test sample. The code uses Processing's `loadPixels()` and `redraw()` functions, alongside custom `Network`, `loadData()`, and `setupSigmoid()` methods, to visualize the network’s layered connections in real time.

CCharlesFr

65% match

Loading thumbnail…

Gist 628b2fab1b21dd2fd74ddc2e7469261f

This interactive visualization demonstrates a neural network classifying handwritten digits from the MNIST dataset, showing the network’s ten output activations for each input image. It uses Processing’s `loadBytes()` to read 196-byte image data and 10,000 label bytes, splitting the data set so that four out of five cards train the model while every fifth card tests it. The code defines a `Card` class that stores input arrays and output arrays, highlighting the correct answer within the template outputs during label loading.

CCharlesFr

64% match

Loading thumbnail…

Gist 504719be190c80e2cec9228ea8849c7f

This example shows a handwritten digit recognition system built in Processing. It displays a neural network with 196 input nodes, 49 hidden nodes, and 10 output nodes, trained on the MNIST dataset. The sketch loads a sigmoid activation function and constructs the network via the custom `Network` class. As the user draws on a canvas, the network classifies the input and visualizes the activations propagating through the layers. The code uses Processing’s `setup()` and `loadSigmoid()` methods to initialize the model and rendering.

CCharlesFr

64% match

Loading thumbnail…

Gist 2cfcfa50bdb3d72af8a3

This example demonstrates a complete neural network training pipeline for MNIST digit classification using Theano and the Blocks library. It constructs a two-layer MLP with rectified linear and softmax activations, applies L2 weight regularization, and trains the model via gradient descent with a scale step rule. The code uses Blocks' `ComputationGraph`, `VariableFilter`, and `DataStreamMonitoring` to track test cost, while Flatten transforms the MNIST data streams. Training runs for a single epoch with batch sizes of 256 and 1024 for training and testing, respectively.

SSamyMe

60% match

Loading thumbnail…

Gist 0b384246f66fe33ea9666f0d1aec3707

This example displays a neural network’s real-time classification of handwritten digit images from a testing set, cycling through a random card number each time the mouse is pressed. The Processing sketch uses the `Network` class to respond to pixel data from a 196-input layer, then renders the network’s nodes and connections with `smooth()` and `stroke(150)`. The current card index and its label are shown as text at the bottom of the canvas, while the background is cleared each frame with `background(255)`.

CCharlesFr

58% match

Loading thumbnail…

Gist d6e2a2307801a1a2d367875fe3cf671a

This example demonstrates a three-layer neural network learning to classify patterns through supervised backpropagation. The Processing sketch uses a custom `Neuron` class with a training loop that adjusts connection weights based on error signals. The code shows the core training mathematics, including a hyperbolic tangent activation function, delta computation, and weight updates scaled by a fixed learning rate. The visualization itself is not present in this code fragment, which focuses solely on the algorithmic update logic for each neuron’s error and weight adjustment.

CCharlesFr

57% match

Loading thumbnail…

Gist 36fa85de37aeb50756ec65aa6548b25f

This example implements an artificial neural network where individual neurons are drawn as circles on a canvas. Each neuron connects to a set of previous-layer inputs, multiplying their output values by random weights, then passing the summed result through a sigmoid activation function. The code renders each neuron’s fill color based on its output value, using the Processing API’s `ellipse()` and `fill()` functions to visualize activation levels. The neural activity propagates layer by layer, producing a dynamic, self-contained simulation of a feedforward network without external data inputs.

CCharlesFr

53% match

Loading thumbnail…

Gist 232b1f382c6798335ff1f889303e9f62

This example visualizes a neural network’s response to input cards, showing how activation flows from the input layer through the hidden layer to the output layer. The code, written in Processing, defines a `Network` class whose `respond()` method assigns each card’s input values to the input layer’s neurons, then sequentially calls `respond()` on each hidden and output neuron to propagate signals. It uses the `Card` class for data inputs and the `Network`’s internal layer arrays to manage neurons, demonstrating a feedforward computation without any external visualization library.

CCharlesFr

52% match