Gist 50e40854fbb877bb074c

Gist 2d7353459b99c1bc219a

This visualization demonstrates unsupervised learning of a two-dimensional dataset using a denoising autoencoder implemented in Pylearn2. The model, defined in the YAML configuration, learns to reconstruct input points through a hidden layer with tanh activations, minimizing mean squared reconstruction error via stochastic gradient descent. The example shows how the autoencoder’s latent representation evolves over training epochs, with the model saving checkpoints after each epoch. It relies on Pylearn2’s `Train` class, `SGD` algorithm, and `MeanSquaredReconstructionError` cost function, while the data comes from a pickled `training-test.pkl` file.

SSamyMe

78% match

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

62% match

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.

54% match

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.

Gist 7acbe7d13bbc6b2f68c1082286e43733

This example shows the initialization of a three-layer neural network in Java, defining input, hidden, and output neuron arrays. The code creates each layer by calling a `Neuron` constructor, with hidden neurons receiving the input layer and output neurons receiving the hidden layer as references, establishing the network’s connectivity. It uses plain Java class definitions and arrays, without external visualization libraries, focusing on the structural setup rather than rendering. The snippet is part of a larger network initializer, demonstrating how layer dependencies are wired during construction.

Gist 7814a13dbae9fde1771606fe6081513d

This interactive visualization tracks the training progress of a Dueling Double Deep Q-Network (Duel DDQN) agent within the OpenAI Gym CartPole-v0 environment. It plots the reward per episode over time, showing how the agent's performance improves as it learns to balance the pole. The code uses the Python libraries `gym` for the environment and `torch` for the neural network, with command-line arguments specifying hyperparameters like `--gamma` and `--batch_size`. The chart updates in real time, rendering the learning curve as the agent iterates through episodes.

SSohojoe

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.

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.