Context

MNIST dataset as downloaded by Pytorch libraries.

Dataset

This dataset was created by Buqing Nie

Contents

Abstract

In the last years, neural networks have evolved from laboratory environments to the state-of-the-art for many real-world problems. Our hypothesis is that neural network models (i.e., their weights and biases) evolve on unique, smooth trajectories in weight space during training. Following, a population of such neural network models (refereed to as “model zoo”) would form topological structures in weight space. We think that the geometry, curvature and smoothness of these structures contain information about the state of training and can be reveal latent properties of individual models. With such zoos, one could investigate novel approaches for (i) model analysis, (ii) discover unknown learning dynamics, (iii) learn rich representations of such populations, or (iv) exploit the model zoos for generative modelling of neural network weights and biases. Unfortunately, the lack of standardized model zoos and available benchmarks significantly increases the friction for further research about populations of neural networks. With this work, we publish a novel dataset of model zoos containing systematically generated and diverse populations of neural network models for further research. In total the proposed model zoo dataset is based on six image datasets, consist of 24 model zoos with varying hyperparameter combinations are generated and includes 47’360 unique neural network models resulting in over 2’415’360 collected model states. Additionally, to the model zoo data we provide an in-depth analysis of the zoos and provide benchmarks for multiple downstream tasks as mentioned before.

Dataset

This dataset is part of a larger collection of model zoos and contains the zoos trained on the labelled samples from MNIST. All zoos with extensive information and code can be found at www.modelzoos.cc.

This repository contains two types of files: the raw model zoos as collections of models (file names beginning with "mnist_"), as well as preprocessed model zoos wrapped in a custom pytorch dataset class (filenames beginning with "dataset"). Zoos are trained in three configurations varying the seed only (seed), varying hyperparameters with fixed seeds (hyp_fix) or varying hyperparameters with random seeds (hyp_rand). The index_dict.json files contain information on how to read the vectorized models.

For more information on the zoos and code to access and use the zoos, please see www.modelzoos.cc.

Dataset

This dataset was created by Maunish dave

Contents

DCGAN Magic on MNIST: Enchanting Image Dataset! 🌟🎨

Dive into a realm where pixels awaken with magic! 🚀✨ This captivating dataset unveils the enchanting journey of a Deep Convolutional Generative Adversarial Network (DCGAN) as it breathes life into mesmerizing images on the MNIST canvas.

🌌 GIF Chronicles: Behold time capsules of GIFs, each a magical journey through epochs. Watch as the pixels evolve, dance, and transform, revealing the growth and artistry of our wizardly model.

📸 Snapshot Diaries: Explore meticulously collected snapshots, capturing the essence of every 1000 steps across 10 enchanting epochs. Each image tells a tale of the model's evolution, from its tentative steps to the grandeur of mastery.

🧙‍♂️ Genesis Moments: Step back to the humble beginnings, where the random generator forged base generations, setting the stage for the grand symphony of creativity.

🎩 Crowning Achievements: Marvel at the final generator's crowning glory—the synthesis of captivating, realistic images. Each pixel is a stroke of genius, a testament to the magic of PyTorch and the artistry of our DCGAN.

May your coding be enchanting, and your images spellbinding! 🪄🌈

May the Pixels Be Ever in Your Favor! 🖼💫

Dataset

This dataset was created by Yuan

Contents

Pytorch The MNIST database of handwritten digits has a training set of 60,000 examples, and a test set of 10,000 examples. It is a subset of a larger set available from NIST. The digits have been size-normalized and centered in a fixed-size image THE ORIGINAL DATA SET CAN BE FOUND IN http://yann.lecun.com/exdb/mnist/ This projects uses 2 hidden Layers with 128 and 64 units. SGD optimizer was used to improve the Weights and bias

Dataset

This dataset was created by DanielTxz

Contents

Starter Notebook (PyTorch)

Context

The MNIST Dataset which was a challenge for people in the field of Computer Vision, has long been 'solved'. Vision models have achieved superhuman level of accuracy in the MNIST dataset. The MNIST still remains one of the most important datasets a student or a practitioner of Computer Vision comes across. It is widely used as a benchmark for newer models and architectures. It is used widely to demonstrate new frameworks, new methods, and so on. It is also one of the most famous datasets for teaching Deep Learning.

Such a Dataset was lacking in the Bengali language. The Bengali language has its own digits, and the goal of this dataset is to present an easily usable dataset that is all completely labeled.

The NumtaDB database exists for a while, but to get to the ease that MNIST provides, some work has to be put on it. This dataset aims to do just that. It provides the ease you are provided with when you are using the MNIST Dataset.

Content

The dataset contains more than 72,000 files which are all completely labeled. The labels are supplied in the CSV file provided. The dataset does not contain a train-validation-test split, as it can be done trivially.

Acknowledgements

• Folks at and contributing to Bengali AI, who created the NumtaDB database which is a huge undertaking. This dataset is created solely from that dataset with no additional data.
• Yann LeCun for creating MNIST which served the DL community and research in a major and unique way.

Inspiration

Bengali is spoken by 228 million people all over the world. Bengali digits are predominantly used in billboards, signs, car signs in several states of India, and Bangladesh. This dataset is intended to be used in commercial and non-commercial settings.

• Research- This context is important to researchers of Vision whether they are interested particularly in Bengali application in industry or academia. This dataset provides an example for application of newly developed methods in a digit dataset other than English. This also provides the opportunity to quickly prototype solutions while doing research, because this dataset is aimed towards providing ease and comfort in its usage.
• Education- This dataset paves the way for educators to teach Deep Learning techniques quickly using this dataset.
• Commerce- As this dataset is provided with the CC-BY-SA-4.0 license, it is free for commercial use.

Citation

If you use this dataset for research or project, it is important that you cite both of these entries below-

@dataset{banglamnist,
  author = {Ritobrata Ghosh},
  year = {2021},
  title = {Bangla-MNIST},
  publisher = {Kaggle},
  address = {Kolkata}
}

Or,

Ghosh, Ritobrata; Bangla-MNIST via Kaggle, doi: 10.34740/kaggle/dsv/2029296 And, BengaliAI

It's exciting to have a dataset that provides the ease of MNIST for Bengali digits. Fascinating things are possible. Let's begin- ৯, ৮, ৭, ৬, ৫, ৪, ৩, ২, ১, ০!

This dataset is a customized and restructured version of the well-known MNIST handwritten digit dataset by Yann LeCun, Corinna Cortes and Christopher J.C. Burges from THE MNIST DATABASE of handwritten digits. The adjustments are intended to improve usability and make it easier integration into various machine learning workflows.

Key Features:

Restructured Image Files: Each digit image is saved as a .png file in separate directories for training and testing.

CSV Metadata: Includes train_labels.csv and test_labels.csv, mapping image filenames to their respective labels.

Improved Accessibility: Simplified folder structure for easier dataset exploration and model training.

Format: Images are grayscale (28x28 pixels), suitable for most deep learning frameworks (TensorFlow, PyTorch, etc.).

Usage:

This dataset is ideal for: - Developing and testing classification models for handwritten digit recognition. - Exploring custom preprocessing pipelines for digit datasets. - Comparing model performance on a restructured MNIST dataset.

Format of the Dataset

The dataset contains 282,472 grayscale images, each measuring 40 x 40 pixels, depicting a diverse range of 82 distinct German characters, digits and mathematical symbols.

In contrast to the MNIST dataset, where image alignment varies, all the images in this dataset are perfectly aligned. They are centered within a 40 x 40 bounding box, ensuring they touch either the left and right sides or the top and bottom borders. This alignment significantly simplifies the training task, leading to excellent performance metrics.

https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2F3f097e77fc4749eba40178b04b01ef1b%2FkleineCollage.png?generation=1695246766636700&alt=media" alt="">

The training and testing data is stored in two separate CSV files. In each file, the first column represents the Unicode character, while the subsequent 1600 values correspond to the grayscale values of the flattened image. If you find any aspect unclear, please refer to our attached code, which offers a comprehensive logic for training a CNN in PyTorch. You can easily select the specific classes on which you intend to train. Notably, when exclusively training on the digits from 0 to 9, we achieved an impressive accuracy and Matthews Correlation Coefficient (MCC) of roughly 99% on the test data. You can find the code for the PyTorch classifier in the attached notebook or clone it here.

Class-Distribution of the Dataset

Distribution Whole Dataset	Distribution Train Dataset	Distribution Test Dataset
https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2Fc9a50f889741ed685743750706d6bda5%2Fwhole_data_set_distribution.png?generation=1694545357333237&alt=media" alt="">	https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2F619258dbcf3f99151e43ec71e6b4ee51%2Ftrain_distribution.png?generation=1694545455622118&alt=media" alt="">	https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2F52768d30470b7ac6242f4da2b83bdcc5%2Ftest_distribution.png?generation=1694545479167771&alt=media" alt="">

Generation of the Dataset

The dataset was collaboratively curated by approximately 1000 German high school students between the age of 11-19 years. All characters where detected and extracted by an adjusted and optimized flood fill algorithm and scaled to 40 x 40 pixel images. Here you can find an explanation video in German language: https://youtu.be/NvfL90UcdU4?t=218

Digits	Characters 1	Characters 2
https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2Fe8a03b00b91d0f43ce2eaad35ffdabe0%2FErste%20Datenbank.jpg?generation=1694639572748410&alt=media" alt="">	https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2Fd6776d8aa3bd656d9a3c20bb0d479cb9%2FTabelle_1.jpg?generation=1694639589911920&alt=media" alt="">	https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F4714368%2F515f13b62c352b081355ad828adb5639%2FTabelle_2.jpg?generation=1694639600758334&alt=media" alt="">

The dataset was used to build these two apps: Grundschulscanner (Korrektur von Mathe Aufgaben) Chemiescanner (Reaktionsgleichungen lösen). Feel free to download them.

Context

https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F769452%2Ff6e2d0f05093e42a67119bde723b24d5%2Fdata-original.png?generation=1600931282565624&alt=media" alt="">

The Chinese MNIST dataset uses data collected in the frame of a project at Newcastle University.

Project Description

One hundred Chinese nationals took part in data collection. Each participant wrote with a standard black ink pen all 15 numbers in a table with 15 designated regions drawn on a white A4 paper. This process was repeated 10 times with each participant. Each sheet was scanned at the resolution of 300x300 pixels. It resulted a dataset of 15000 images, each representing one character from a set of 15 characters (grouped in samples, grouped in suites, with 10 samples/volunteer and 100 volunteers).

Further Data Processing

I downloaded from the original project page the raw images. Based on images names, I created an index for each image, as following:

original name (example): Locate{1,3,4}.jpg 
index extracted: suite_id: 1, sample_id: 3, code: 4 
resulted file name: input_1_3_4.jpg 

I also added the mapping of each image code to the actual numeric value of Chinese number character and the actual Chinese character. Here is described the mapping

https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F769452%2F61c54df3540346d4b56cd611ba41143d%2Fchanracter_mapping.png?generation=1596618751340901&alt=media" alt="">

Content

The dataset contains the following:

• an index file, chinese_mnist.csv
• a folder with 15,000 jpg images, sized 64 x 64. See the images folder description for details.

Acknowledgements

I want to express my gratitude to the following people: Dr. K Nazarpour and Dr. M Chen from Newcastle University, who collected the data.

Inspiration

You can use this data the same way you used MNIST, KMNIST of Fashion MNIST: refine your image classification skills, use GPU & TPU to implement CNN architectures for models to perform such multiclass classifications.

https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F950187%2Fd8a0b40fa9a5ad45c65e703b28d4a504%2Fbackground.png?generation=1703873571061442&alt=media" alt="">

The process for collecting this dataset was documented in paper "https://doi.org/10.12913/22998624/122567">"Development of Extensive Polish Handwritten Characters Database for Text Recognition Research" by Mikhail Tokovarov, dr Monika Kaczorowska and dr Marek Miłosz. Link to download the original dataset: https://cs.pollub.pl/phcd/. The source fileset also contains a dataset of raw images of whole sentences written in Polish.

Context

PHCD (Polish Handwritten Characters Database) is a collection of handwritten texts in Polish. It was created by researchers at Lublin University of Technology for the purpose of offline handwritten text recognition. The database contains more than 530 000 images of handwritten characters. Each image is a 32x32 pixel grayscale image representing one of 89 classes (10 digits, 26 lowercase latin letters, 26 uppercase latin letters, 9 lowercase polish letters, 9 uppercase polish letters and 9 special characters), with around 6 000 examples per class.

How to use

This notebook contains a PyTorch example of how to load the dataset from .npz files and train a CNN model. You can also use the dataset with other frameworks, such as TensorFlow, Keras, etc.

For .npz files, use numpy.load method.

Contents

The dataset contains the following:

• dataset.npz - a file with two compressed numpy arrays:
  • "signs" - with all the images, sized 32 x 32 (grayscale)
  • "labels" - with all the labels (0-88) for examples from signs
• label_mapping.csv - a csv file with columns label and char, mapping from ids to characters from dataset
• images - folder with original 530 000 png images, sized 32 x 32, to use with other loading techniques

Acknowledgements

I want to express my gratitude to the following people: Dr. Edyta Łukasik for introducing me to this dataset and to authors of this dataset - Mikhail Tokovarov, dr. Monika Kaczorowska and dr. Marek Miłosz from Lublin University of Technology in Poland.

Inspiration

You can use this data the same way you used MNIST, KMNIST of Fashion MNIST: refine your image classification skills, use GPU & TPU to implement CNN architectures for models to perform such multiclass classifications.

Starter Notebook

ABOUT (from project's README)

Keras style model.summary() in PyTorch

Keras has a neat API to view the visualization of the model which is very helpful while debugging your network. Here is a barebone code to try and mimic the same in PyTorch. The aim is to provide information complementary to, what is not provided by print(your_model) in PyTorch.

Usage

• pip install torchsummary or
• git clone https://github.com/sksq96/pytorch-summary

from torchsummary import summary
summary(your_model, input_size=(channels, H, W))

• Note that the input_size is required to make a forward pass through the network.

Examples

CNN for MNIST

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchsummary import summary

class Net(nn.Module):
  def _init_(self):
    super(Net, self)._init_()
    self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
    self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
    self.conv2_drop = nn.Dropout2d()
    self.fc1 = nn.Linear(320, 50)
    self.fc2 = nn.Linear(50, 10)

  def forward(self, x):
    x = F.relu(F.max_pool2d(self.conv1(x), 2))
    x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
    x = x.view(-1, 320)
    x = F.relu(self.fc1(x))
    x = F.dropout(x, training=self.training)
    x = self.fc2(x)
    return F.log_softmax(x, dim=1)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # PyTorch v0.4.0
model = Net().to(device)

summary(model, (1, 28, 28))

----------------------------------------------------------------
    Layer (type)        Output Shape     Param #
================================================================
      Conv2d-1      [-1, 10, 24, 24]       260
      Conv2d-2       [-1, 20, 8, 8]      5,020
     Dropout2d-3       [-1, 20, 8, 8]        0
      Linear-4          [-1, 50]     16,050
      Linear-5          [-1, 10]       510
================================================================
Total params: 21,840
Trainable params: 21,840
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.06
Params size (MB): 0.08
Estimated Total Size (MB): 0.15
----------------------------------------------------------------

VGG16

import torch
from torchvision import models
from torchsummary import summary

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
vgg = models.vgg16().to(device)

summary(vgg, (3, 224, 224))

----------------------------------------------------------------
    Layer (type)        Output Shape     Param #
================================================================
      Conv2d-1     [-1, 64, 224, 224]      1,792
       ReLU-2     [-1, 64, 224, 224]        0
      Conv2d-3     [-1, 64, 224, 224]     36,928
       ReLU-4     [-1, 64, 224, 224]        0
     MaxPool2d-5     [-1, 64, 112, 112]        0
      Conv2d-6    [-1, 128, 112, 112]     73,856
       ReLU-7    [-1, 128, 112, 112]        0
      Conv2d-8    [-1, 128, 112, 112]     147,584
       ReLU-9    [-1, 128, 112, 112]        0
    MaxPool2d-10     [-1, 128, 56, 56]        0
      Conv2d-11     [-1, 256, 56, 56]     295,168
       ReLU-12     [-1, 256, 56, 56]        0
      Conv2d-13     [-1, 256, 56, 56]     590,080
       ReLU-14     [-1, 256, 56, 56]        0
      Conv2d-15     [-1, 256, 56, 56]     590,080
       ReLU-16     [-1, 256, 56, 56]        0
    MaxPool2d-17     [-1, 256, 28, 28]        0
      Conv2d-18     [-1, 512, 28, 28]    1,180,160
       ReLU-19     [-1, 512, 28, 28]        0
      Conv2d-20     [-1, 512, 28, 28]    2,359,808
       ReLU-21     [-1, 512, 28, 28]        0
      Conv2d-22     [-1, 512, 28, 28]    2,359,808
       ReLU-23     [-1, 512, 28, 28]        0
    MaxPool2d-24     [-1, 512, 14, 14]        0
      Conv2d-25     [-1, 512, 14, 14]    2,359,808
       ReLU-26     [-1, 512, 14, 14]        0
      Conv2d-27     [-1, 512, 14, 14]    2,359,808
       ReLU...