Skip to main content
100%

An artificial neural network

✓ Published0🌍 Public
Aantonyross
Last edited Mar 7, 2016
Created on Mar 7, 2016

This example demonstrates a Python-based artificial neural network that learns patterns from input data to predict or classify future unseen data. The code implements a multi-layer perceptron with configurable hidden layers, using logistic, linear, or softmax output types, and includes early stopping to prevent overfitting during training. It relies on NumPy for matrix operations and Pandas for data handling, with the network trained via backpropagation and momentum. The visualization shows how the network iteratively reduces error, as printed during training, while the confusion matrix method provides classification performance metrics.

AI-generated description

Similar vizzes

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
67% match
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
60% 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
60% match
Loading thumbnail…

Convolutional Neural Networks

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.

Aaaizemberg
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 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
59% 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
58% 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
58% match