Gist 2cfcfa50bdb3d72af8a3

100%

Gist 2cfcfa50bdb3d72af8a3

✓ Published0🌍 Public

Last edited Dec 3, 2015

Created on Dec 3, 2015

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.

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

62% match

Loading thumbnail…

Gist 50e40854fbb877bb074c

This example demonstrates a training pipeline for a denoising autoencoder using Pylearn2’s `DenseDesignMatrix` and `yaml_parse`. It shows how layer-wise pretraining is configured through YAML templates, with hyperparameters like batch size, hidden units, and epochs injected dynamically. The code constructs a small synthetic dataset from ranged arrays, saves it as a pickle, then trains the first layer by writing a modified YAML file and invoking `train_yaml`. The model is ultimately serialized to `dae_l1.pkl`.

SSamyMe

62% 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

62% 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

60% match

Loading thumbnail…

Gist 9b63d483619f2d9eebd0d3d91fe22dbc

This example demonstrates a neural network with a training loop that adjusts output and hidden layer errors, using custom classes for network layers and nodes. The code shows a `Network` class with a `train` method that iterates through output and hidden layers, calling `setError` and `train` on each node. It relies on a custom object-oriented API rather than a specific visualization library, with the network structure implied through layer arrays and methods like `m_output_layer` and `m_hidden_layer`. The visualization would likely depict node connections and weight updates, though no rendering library is present in this snippet.

CCharlesFr

59% 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

58% 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

57% match

Loading thumbnail…

Gist 48900009bc9111ca9bba882570795f41

This example visualizes a three-layer neural network using Processing. It shows the input layer arranged in a grid, a hidden layer in a smaller grid, and an output layer spread horizontally, with each node drawn as a visual element. The code uses Processing’s `pushMatrix`, `translate`, and `popMatrix` to position each node at computed coordinates. The layout is fixed, with the layers placed at different screen positions, and the output layer is drawn with a flag to change its appearance. No data is loaded, and the network structure is hardcoded in the class.

CCharlesFr

54% match