Skip to main content
100%

A notebook describing how to use t-SNE to visualize a neural network learn representations

✓ Published0🌍 Public
Aalvinthai
Last edited Mar 2, 2016
Created on Feb 25, 2017

This notebook demonstrates how a convolutional neural network learns to recognize handwritten digits from the MNIST database by visualizing its internal representations with t-SNE. It shows the network’s high-level feature layer (h_fc2) projected into two dimensions at various training stages, revealing clusters that correspond to digit classes. The code trains a LeNet-style model using TensorFlow, then applies sklearn.manifold.TSNE to the learned activations. Matplotlib renders the resulting scatter plots, with each point colored by its true label, illustrating how representations become more separable as training progresses.

AI-generated description

Similar vizzes

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

tSNE + Tensorflow

This example uses a TensorFlow-based t-SNE optimizer within a webpage to reduce 200 random 10-dimensional points to a 2D embedding. The code initializes a `tf.randomUniform` tensor, passes it to `tsne.tsne()`, and calls `compute()` to produce coordinates, which are printed to the console. The visualization relies on the TensorFlow.js and tfjs-tsne libraries, with D3 v4 loaded but not actively used for rendering in this minimal setup.

MMNoichl
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…

test-tsne

This example demonstrates how to project high-dimensional data onto a two-dimensional plane using t-SNE (t-Distributed Stochastic Neighbor Embedding). The visualization displays the resulting coordinates as small circles within an SVG canvas, with each point representing an item from a small dataset of twelve samples. The t-SNE algorithm is implemented through the custom `tsnejs` library, which processes pairwise distances calculated from the input data. The rendering uses D3.js v4 to create the SVG elements and position them according to the computed embedding coordinates.

MMNoichl
64% match
Loading thumbnail…

Gist 895545c65773a661a6035d5ebc9d1313

This notebook demonstrates a TensorFlow/Keras implementation of the Hausdorff distance metric, visualized with synthetic image data. It uses `skimage.draw.circle` to generate a ground-truth circle image, then computes and displays the Hausdorff distance between predicted and actual binary masks via matplotlib. The visualization includes an inline image plot of the mask, rendered as an interactive matplotlib axes image, alongside the execution of the metric computation within the Keras backend.

Aakeshavan
62% match
Loading thumbnail…

Gist 98636bb57280e38492740cdbe9c4901c

This example demonstrates a deep learning workflow for classifying brain images using TensorFlow and Keras. It loads CSV data from the braindr dataset, displaying a pandas DataFrame with vote counts, rater identities, and mean ratings for each image. The code builds a convolutional neural network with layers like Conv2D, MaxPooling2D, Dropout, and LeakyReLU, using Keras' Sequential API. It configures the model for GPU execution, imports optimizers such as RMSprop and Adam, and prepares callbacks like ModelCheckpoint for training.

Aakeshavan
62% match