The MNIST database of handwritten digits.

To use this dataset:

import tensorflow_datasets as tfds

ds = tfds.load('mnist', split='train')
for ex in ds.take(4):
 print(ex)

See the guide for more informations on tensorflow_datasets.

https://storage.googleapis.com/tfds-data/visualization/fig/mnist-3.0.1.png" alt="Visualization" width="500px">

The MNIST dataset provided in a easy-to-use CSV format

The original dataset is in a format that is difficult for beginners to use. This dataset uses the work of Joseph Redmon to provide the MNIST dataset in a CSV format.

The dataset consists of two files:

1. mnist_train.csv
2. mnist_test.csv

The mnist_train.csv file contains the 60,000 training examples and labels. The mnist_test.csv contains 10,000 test examples and labels. Each row consists of 785 values: the first value is the label (a number from 0 to 9) and the remaining 784 values are the pixel values (a number from 0 to 255).

Dataset

This dataset was created by Emerson Bertolo

Released under GPL 2

Contents

Here we present a dataset, MNIST4OD, of large size (number of dimensions and number of instances) suitable for Outliers Detection task.The dataset is based on the famous MNIST dataset (http://yann.lecun.com/exdb/mnist/).We build MNIST4OD in the following way:To distinguish between outliers and inliers, we choose the images belonging to a digit as inliers (e.g. digit 1) and we sample with uniform probability on the remaining images as outliers such as their number is equal to 10% of that of inliers. We repeat this dataset generation process for all digits. For implementation simplicity we then flatten the images (28 X 28) into vectors.Each file MNIST_x.csv.gz contains the corresponding dataset where the inlier class is equal to x.The data contains one instance (vector) in each line where the last column represents the outlier label (yes/no) of the data point. The data contains also a column which indicates the original image class (0-9).See the following numbers for a complete list of the statistics of each datasets ( Name | Instances | Dimensions | Number of Outliers in % ):MNIST_0 | 7594 | 784 | 10MNIST_1 | 8665 | 784 | 10MNIST_2 | 7689 | 784 | 10MNIST_3 | 7856 | 784 | 10MNIST_4 | 7507 | 784 | 10MNIST_5 | 6945 | 784 | 10MNIST_6 | 7564 | 784 | 10MNIST_7 | 8023 | 784 | 10MNIST_8 | 7508 | 784 | 10MNIST_9 | 7654 | 784 | 10

[MNIST](https://en.wikipedia.org/wiki/MNIST_database#:~:text=The%20MNIST%20database%20(Modified%20National,training%20various%20image%20processing%20systems.) data in PNG format, derived directly from MNIST in CSV.

The data contains 60,000 labelled train samples and 10,000 labelled test samples. Each sample is a 28x28 grayscale PNG image.

Unzipped directory structure 👇

test/
 0/
  test_image_3.png
  test_image_10.png
  test_image_13.png
  ...
 1/
  test_image_2.png
  test_image_5.png
  test_image_14.png
  ...
 ...
 9/

train/
 0/
  train_image_1.png
  train_image_21.png
  train_image_34.png
  ...
 1/
 ...
 9/

Data collection script

import pandas as pd
from PIL import Image

mnist_train = pd.read_csv("mnist-csv/mnist_train.csv")
mnist_test = pd.read_csv("mnist-csv/mnist_test.csv")

for i in range(10):

  # Convert the training data to png
  train_i = mnist_train.loc[mnist_train.label == i]
  for index, row in train_i.iterrows():
    X = row[1:].to_numpy().reshape(28, 28)
    filepath = (
      f"mnist-png/train/{i}/train_image_{index}.png"
    )
    img = Image.fromarray(X.astype("uint8"), mode="L")
    img.save(filepath)

  # Convert the test data to png
  test_i = mnist_test.loc[mnist_test.label == i]
  for index, row in test_i.iterrows():
    X = row[1:].to_numpy().reshape(28, 28)
    filepath = f"mnist-png/test/{i}/test_image_{index}.png"
    img = Image.fromarray(X.astype("uint8"), mode="L")
    img.save(filepath)

Easy MNIST

MNIST processed into three easy to use formats. Each .zip file contains a labels_and_paths.csv file and a data directory.

  mnist_png.zip

MNIST in the png format. label path 0 5 data/0.png 1 0 data/1.png 2 4 data/2.png 3 1 data/3.png 4 9 data/4.png ... ... ... 69995 2 data/69995.png 69996 3 data/69996.png 69997 4 data/69997.png 69998 5… See the full description on the dataset page: https://huggingface.co/datasets/hayden-donnelly/easy-mnist.

Please find below the descriptions of the three configurations for partitioning the MNIST Train dataset into 10 clients and the MNIST Train data:

1. Balanced Distribution: In the first configuration, the MNIST dataset is partitioned among 10 clients in a balanced manner. This means that the data samples from each class are evenly distributed among the clients. Each client receives a roughly equal number of images from each digit class, ensuring that the distribution of samples across clients is proportional and representative of the overall dataset. [ Config 1]
2. Heterogeneous Distribution (One Class per Client): In the second configuration, the MNIST dataset is partitioned in a heterogeneous manner, where each client is assigned a single digit class exclusively. This means that one client will only receive images of the digit '0', another client will receive images of the digit '1', and so on. In this setup, each client becomes an expert in classifying a specific digit, allowing for specialized training and evaluation. [ Config 2]
3. Mixed Distribution: In the third configuration, the MNIST dataset is partitioned using a mixed distribution approach. This means that the data samples from all digit classes are distributed among the 10 clients, but the distribution is not necessarily balanced. The number of samples assigned to each client may vary for different digit classes, resulting in an uneven distribution across the clients. This configuration aims to capture both the overall diversity of the dataset and the varying difficulty levels of classifying different digits. [ Config 3 ]

Mnist-dataset/
├── config1/
│ ├── client-1/
│ │ └── data.csv
│ ├── client-2/
│ │ └── data.csv
│ ├── client-3/
│ │ └── data.csv
│ └── ...
├── config2/
│ ├── client-1/
│ │ └── data.csv
│ ├── client-2/
│ │ └── data.csv
│ ├── client-3/
│ │ └── data.csv
│ └── ...
├── config3/
│ ├── client-1/
│ │ └── data.csv
│ ├── client-2/
│ │ └── data.csv
│ ├── client-3/
│ │ └── data.csv
│ └── ...
└── mnist_test.csv

***

License: Yann LeCun and Corinna Cortes hold the copyright of MNIST dataset, which is a derivative work from original NIST datasets. MNIST dataset is made available under the terms of the Creative Commons Attribution-Share Alike 3.0 license.

***

Fashion-MNIST is a dataset of Zalando's article images consisting of a training set of 60,000 examples and a test set of 10,000 examples. Each example is a 28x28 grayscale image, associated with a label from 10 classes.

To use this dataset:

import tensorflow_datasets as tfds

ds = tfds.load('fashion_mnist', split='train')
for ex in ds.take(4):
 print(ex)

See the guide for more informations on tensorflow_datasets.

https://storage.googleapis.com/tfds-data/visualization/fig/fashion_mnist-3.0.1.png" alt="Visualization" width="500px">

Context

Fashion-MNIST is a dataset of Zalando's article images—consisting of a training set of 60,000 examples and a test set of 10,000 examples. Each example is a 28x28 grayscale image, associated with a label from 10 classes. Zalando intends Fashion-MNIST to serve as a direct drop-in replacement for the original MNIST dataset for benchmarking machine learning algorithms. It shares the same image size and structure of training and testing splits.

The original MNIST dataset contains a lot of handwritten digits. Members of the AI/ML/Data Science community love this dataset and use it as a benchmark to validate their algorithms. In fact, MNIST is often the first dataset researchers try. "If it doesn't work on MNIST, it won't work at all", they said. "Well, if it does work on MNIST, it may still fail on others."

Zalando seeks to replace the original MNIST dataset

Content

Each image is 28 pixels in height and 28 pixels in width, for a total of 784 pixels in total. Each pixel has a single pixel-value associated with it, indicating the lightness or darkness of that pixel, with higher numbers meaning darker. This pixel-value is an integer between 0 and 255. The training and test data sets have 785 columns. The first column consists of the class labels (see above), and represents the article of clothing. The rest of the columns contain the pixel-values of the associated image.

To locate a pixel on the image, suppose that we have decomposed x as x = i * 28 + j, where i and j are integers between 0 and 27. The pixel is located on row i and column j of a 28 x 28 matrix. For example, pixel31 indicates the pixel that is in the fourth column from the left, and the second row from the top, as in the ascii-diagram below.

Labels

Each training and test example is assigned to one of the following labels:

0 T-shirt/top 1 Trouser 2 Pullover 3 Dress 4 Coat 5 Sandal 6 Shirt 7 Sneaker 8 Bag 9 Ankle boot

TL;DR

Each row is a separate image Column 1 is the class label. Remaining columns are pixel numbers (784 total). Each value is the darkness of the pixel (1 to 255) Acknowledgements

Original dataset was downloaded from https://github.com/zalandoresearch/fashion-mnist Dataset was converted to CSV with this script: https://pjreddie.com/projects/mnist-in-csv/ License

The MIT License (MIT) Copyright © [2017] Zalando SE, https://tech.zalando.com

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

This directory includes a few sample datasets to get you started.

california_housing_data*.csv is California housing data from the 1990 US Census; more information is available at: https://docs.google.com/document/d/e/2PACX-1vRhYtsvc5eOR2FWNCwaBiKL6suIOrxJig8LcSBbmCbyYsayia_DvPOOBlXZ4CAlQ5nlDD8kTaIDRwrN/pub

mnist_*.csv is a small sample of the MNIST database, which is described at: http://yann.lecun.com/exdb/mnist/

anscombe.json contains a copy of Anscombe's quartet; it was originally… See the full description on the dataset page: https://huggingface.co/datasets/sareboloradheradhe/kjfgkjdfgkdjfgjkd.

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- ৯, ৮, ৭, ৬, ৫, ৪, ৩, ২, ১, ০!

Each image is 28 pixels in height and 28 pixels in width, for a total of 784 pixels in total. Each pixel has a single pixel-value associated with it, indicating the lightness or darkness of that pixel, with higher numbers meaning darker. This pixel-value is an integer between 0 and 255, inclusive.

The training data set, (train.csv), has 785 columns. The first column, called "label", is the digit that was drawn by the user. The rest of the columns contain the pixel-values of the associated image.

Each pixel column in the training set has a name like pixelx, where x is an integer between 0 and 783, inclusive. To locate this pixel on the image, suppose that we have decomposed x as x = i * 28 + j, where i and j are integers between 0 and 27, inclusive. Then pixelx is located on row i and column j of a 28 x 28 matrix, (indexing by zero).

For example, pixel31 indicates the pixel that is in the fourth column from the left, and the second row from the top, as in the ascii-diagram below.

The EMNIST dataset is a set of handwritten character digits derived from the NIST Special Database 19 and converted to a 28x28 pixel image format and dataset structure that directly matches the MNIST dataset.

Note: Like the original EMNIST data, images provided here are inverted horizontally and rotated 90 anti-clockwise. You can use tf.transpose within ds.map to convert the images to a human-friendlier format.

To use this dataset:

import tensorflow_datasets as tfds

ds = tfds.load('emnist', split='train')
for ex in ds.take(4):
 print(ex)

See the guide for more informations on tensorflow_datasets.

https://storage.googleapis.com/tfds-data/visualization/fig/emnist-byclass-3.1.0.png" alt="Visualization" width="500px">

MindBigData 2023 MNIST-8B是迄今为止（2023年6月1日）为机器学习创建的最大的大脑信号开放数据集，基于使用定制的128通道设备捕获的单个受试者的EEG信号，复制了Yaan LeCun et all MNIST数据集的全部7万个数字。大脑信号是在受试者一个接一个地观看屏幕上原始数字的像素，同时听真实标签上0到9的语音数字时捕捉的。该数据集包含来自 128 个脑电图通道的 140,000 条记录，每条记录为 2 秒，以 250hz 记录，总共 17,920,000 个脑信号和 8,960,000,000 个数据点。

The purpose of this copy of the MNIST small dataset [mnist_test.csv (20,000 samples) and mnist_train_small.csv (10,000 samples)] copied from sample_data folder in Google Colab is simply to illustrate how WEIRD and totally deformed/unrecognizable are the 1% to 2% test samples that are difficult for a competent Vision model to correctly classify. See for yourself (up to 4 misclassified test samples shown per training epoch) Vision_model_V2.1.py --- Hyperparameters --- [INFO] Loading datasets...… See the full description on the dataset page: https://huggingface.co/datasets/MartialTerran/MNIST_small_colab-sample_data.

The Numerical Images Dataset combines samples from MNIST and Chars74k datasets, providing a rich source of images for number recognition and classification tasks. It includes images in various styles such as handwritten (Hnd), computer font (Fnt), high-quality natural scenes (GoodImg), and low-quality natural scenes (BadImg). The dataset also features augmented versions with rotations, scaling, and noise to improve model robustness. Metadata CSV files provide details such as origin, category, file path, label, brightness, contrast, and dimensions. Labels are also available in multiple languages to support international training applications.

The architecture of the LeNet-5 convolutional neural network (CNN) was defined by LeCun in its paper "Gradient-based learning applied to document recognition" (https://ieeexplore.ieee.org/document/726791) to classify images of hand written digits (MNIST dataset).

This architecture has been customized to use Rectified Linear Unit (ReLU) as activation functions instead of Sigmoid.

It consists of the following layers:

• conv1: Convolution 2D, 1 input channel (28x28), 3 output channels (28x28), kernel size 5, stride 1, padding 2.
• relu1: Rectified Linear Unit (3@28x28).
• max1: Subsampling buy max pooling (3@14x14).
• conv2: Convolution 2D, 3 input channels (14x14), 6 output channels (14x14), kernel size 5, stride 1, padding 2.
• relu2: Rectified Linear Unit (6@14x14).
• max2: Subsampling buy max pooling (6@7x7).
• fc1: Fully connected (294, 147)
• fc2: Fully connected (147, 10)

The fault hypotheses for this work include the occurrence of:

• S0/S1: multiple adjacent stuck-at-0 and stuck-at-1 faults to determine the least significant bits of weights and biases that could be used to store the proposed error correcting codes.
• BF: single, double, and triple bit-flip faults to assess the robustness of the considered CNN

In the memory cells containing all the parameters of the CNN:

• w: weights (float32)
• b: biases (float32)

All the images (10000) from the MNIST dataset have been used as workload.

The weights and biases of the LeNet-5 architecture have been protected using six different error correcting codes that have been deployed in the least significant bits of these elements.

The parity check matrices (H = P I) that define these ECCs are:

• SEC(32, 26) (Hamming) under a classic policy (see methodology below):

11010010001000011101101000 100000

10101001000100011011010100 010000

01100100100010010110110010 001000

00011100010001001110001101 000100

00000011110000100001111011 000010

00000000001111100000000111 000001

• SEC(23, 18) (Hamming) under a conservative policy (see methodology below):

111100001111000000 10000

110011101000111000 01000

101011010100100110 00100

010110110010010101 00010

001101110001001011 00001

• SEC(13, 9) (Hamming) under an aggressive policy (see methodology below):

110111000 1000

101100110 0100

011010101 0010

111001011 0001

• DEC(32, 21) (low redundancy and reduced overhead DEC) under a classic policy (see methodology below):

111000011001010010000 10000000000

110110000011101000000 01000000000

101011000110000010001 00100000000

100101101000110001000 00010000000

011010101100100000100 00001000000

010101010100001001010 00000100000

001100110010010100100 00000010000

000011110001000110010 00000001000

000000001111001101001 00000000100

000000000000111100111 00000000010

000000000000000011111 00000000001

• DEC(28, 18) (low redundancy and reduced overhead DEC) under a conservative policy (see methodology below):

111111000000000000 1000000000

110100111100000000 0100000000

110000100011110000 0010000000

001110010011001100 0001000000

101100001010101010 0000100000

010001001101010110 0000010000

001011000101101001 0000001000

101000011000110101 0000000100

010001110000011011 0000000010

000010100110000111 0000000001

• DEC(17, 9) (low redundancy and reduced overhead DEC) under an aggressive policy (see methodology below):

111110000 10000000

111001100 01000000

110101010 00100000

101010110 00010000

101101001 00001000

100110101 00000100

100011011 00000010

110000111 00000001

This dataset contains the raw data obtained from:

• running exhaustive fault injection campaigns for increasingly multiple stuck-at faults in the least significant bits of all weights and biases (simultaneously) and for all the images in the workload.
• running statistical fault injection campaigns for single, double, and triple bit-flip faults, randomly targeting the considered locations and images in the workload.

Files information

• no_ecc folder: Results obtained for the original (not protected) version of the CNN.
  • golden_run.csv: Prediction obtained for all the images considered in the workload in the absence of faults (Golden Run). This is intended to act as oracle to determine the impact of injected faults.
  • sampling_SBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for single bit-flip faults.
  • sampling_DBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for double bit-flip faults.
  • sampling_TBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for triple bit-flip faults.
  • locating_sensitive_bits folder: Prediction obtained for all the images considered in the workload in presence of stuck-at-0/stuck-at-1 faults that simultaneously target the N least significant bits of all weights and biases. There is one file for each parameter of type of fault and range of targeted bits. Files for bits in the range [11, 0] are not included as they obtain eactly the same results as the Golden Run (faults do not alter the behaviour of the network).
• sec/classic, sec/conservative, and sec/aggressive folders: They contain the results obtained for the CNN protected by SEC(32, 26), SEC(23, 18), and SEC(13, 9), respectively.
  • golden_run.csv: Prediction obtained for all the images considered in the workload in the absence of faults (Golden Run). This is intended to act as oracle to determine the impact of injected faults. It must be noted that this file could be different that the golden_run.csv file for the original version of the CNN, as deploying the ECC in the weights and biases may have affected the behaviour of the network.
  • sampling_SBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for single bit-flip faults. They should all be tolerated by the definition of the ECC.
  • sampling_DBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for double bit-flip faults. They could be more harmful than for the unprotected version of the CNN, as the ECC may erroneously flip correct bits.
• dec/classic, dec/conservative, and dec/aggressive folders: They contain the results obtained for the CNN protected by DEC(32, 21), DEC(28, 18), and DEC(17, 9), respectively.
  • golden_run.csv: Prediction obtained for all the images considered in the workload in the absence of faults (Golden Run). This is intended to act as oracle to determine the impact of injected faults. It must be noted that this file could be different that the golden_run.csv file for the original version of the CNN, as deploying the ECC in the weights and biases may have affected the behaviour of the network.
  • sampling_DBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for double bit-flip faults. They should all be tolerated by the definition of the ECC.
  • sampling_TBF_10000.csv: Prediction obtained for running 10000 statistical fault injection experiments for triple bit-flip faults. They could be more harmful than for the unprotected version of the CNN, as the ECC may erroneously flip correct bits.

Methodology information

First, the CNN was used to classify all the images of the workload in the absence of faults to get a reference to determine the impact of faults. This is golden_run.csv file.

To locate non-significant bits in weights and biases, fault injection experiments were executed targeting all elements of all parameters of the CNN using the following procedure:

• The initial mask targeted only the least significant bit
• Until the mask targets all bits of the elements (32 bits as they are single-precision floating point values):
  • Affect the bits (setting them to 0 or 1 in case of stuck-at-0 or stuck-at-1 faults) identified by the mask for all elements of all parameters.
  • Classify all the images of the workload in the presence of this fault. The obtained output was stored in a given .csv file.
  • Remove the fault from the CNN by restoring the affected bits to its previous value.
  • Add the next adjacent bit to the mask, so it targets an additional least significant

The architecture of the LeNet-5 convolutional neural network (CNN) was defined by LeCun in its paper "Gradient-based learning applied to document recognition" (https://ieeexplore.ieee.org/document/726791) to classify images of hand written digits (MNIST dataset). This architecture has been customized to use Rectified Linear Unit (ReLU) as activation functions instead of Sigmoid, and 8-bit integers for weights and activations instead of floating-point. It consists of the following layers:

conv1: Convolution 2D, 1 input channel (28x28), 3 output channels (28x28), kernel size 5, stride 1, padding 2. relu1: Rectified Linear Unit (3@28x28). max1: Subsampling buy max pooling (3@14x14). conv2: Convolution 2D, 3 input channels (14x14), 6 output channels (14x14), kernel size 5, stride 1, padding 2. relu2: Rectified Linear Unit (6@14x14). max2: Subsampling buy max pooling (6@7x7). fc1: Fully connected (294, 147) fc2: Fully connected (147, 10) The fault hypotheses for this work include the occurrence of:

BF: single, double-adjacent and triple-adjacent bit-flip faults S0: single, double-adjacent and triple-adjacent stuck-at-0 faults S1: single, double-adjacent and triple-adjacent stuck-at-1 faults In the memory cells containing all the parameters of the CNN:

w: weights (int8) zw: zero point of the weights (int8) b: biases (int32) z: zero point (int8) m: m (int32) Images 200 to 249 from the MNIST dataset have been used as workload. This dataset contains the raw data obtained from running exhaustive fault injection campaigns for all considered fault models, targeting all considered locations and for all the images in the workload. In addition, the raw data have been lightly processed to obtain global data related to the particular bits and parameters affected by the faults, and the obtained failure modes. Files information

golden_run.csv: Prediction obtained for all the images considered in the workload in the absence of faults (Golden Run). This is intended to act as oracle to determine the impact of injected faults.
single_faults/bit_flip folder: Prediction obtained for all the images considered in the workload in presence of single bit-flip faults. There is one file for each parameter of each layer. single_faults/stuck_at_0 folder: Prediction obtained for all the images considered in the workload in presence of single stuck-at-0 faults. There is one file for each parameter of each layer. single_faults/stuck_at_1 folder: Prediction obtained for all the images considered in the workload in presence of single stuck-at-1 faults. There is one file for each parameter of each layer. double_adjacent_faults/bit_flip folder: Prediction obtained for all the images considered in the workload in presence of double adjacent bit-flip faults. There is one file for each parameter of each layer. double_adjacent_faults/stuck_at_0 folder: Prediction obtained for all the images considered in the workload in presence of double adjacent stuck-at-0 faults. There is one file for each parameter of each layer. double_adjacent_faults/stuck_at_1 folder: Prediction obtained for all the images considered in the workload in presence of double adjacent stuck-at-1 faults. There is one file for each parameter of each layer. triple_adjacent_faults/bit_flip folder: Prediction obtained for all the images considered in the workload in presence of triple adjacent bit-flip faults. There is one file for each parameter of each layer. triple_adjacent_faults/stuck_at_0 folder: Prediction obtained for all the images considered in the workload in presence of triple adjacent stuck-at-0 faults. There is one file for each parameter of each layer. triple_adjacent_faults/stuck_at_1 folder: Prediction obtained for all the images considered in the workload in presence of triple adjacent stuck-at-1 faults. There is one file for each parameter of each layer. Methodology information First, the CNN was used to classify all the images of the workload in the absence of faults to get a reference to determine the impact of faults. This is golden_run.csv file. After that, one fault injection experiment was executed for each bit of each element of each parameter of the CNN. Each experiment consisted in:

Affecting the bits (inverting it in case of bit-flip faults, setting it to 0 or 1 in case of stuck-at-0 or atuck-at-1 faults) identified by the mask. Classifying all the images of the workload in the presence of this fault. The obtained output was stored in a given .csv file. Removing the fault from the CNN by restoring the affected bits to its previous value. List of variables (Name : Description (Possible values))

IMGID: Integer number identifying the considered image (200-249). TENSORID: Integer number identiying the parameter affected by the fault (0 - No fault, 1 - conv1.w, 2 - conv1.zw, 3 - conv1.m, 4 - conv1.b, 5 - conv1.z, 6 - conv2.w, 7 - conv2.zw, 8 - conv2.m, 9 - conv2.b, 10 - conv2.z, 11 - fc1.w, 12 - fc1.zw, 13 - fc1.m, 14 - fc.b, 15 - fc1.z, 16 - fc2.w, 17 - fc2.zw, 18 - fc2.m, 19 - fc2.b, 20 - fc2.z) ELEMID: Integer number identiying the element of the parameter affected by the fault (-1 - No fault, [0-2] - {conv1.b, conv1.m, conv1.zw}, [0-74] - conv1.w, 0 - conv1.z, [0-5] - {conv2.b, conv2.m, conv2.zw}, [0-149] - conv2.w, 0 - {conv1.z, conv2.z, fc1.z, fc2.z}, [0-146] - {fc1.b, fc1.m, fc1.zw}, [0-43217] - fc1.w, [0-9] - {fc2.b, fc2.m, fc2.zw}, [0-1469] - fc2.w) MASK: 8-digit hexadecimal number identifying those bits affected by the fault ([00000000 - No fault, FFFFFFFF - all 32 bits faulty]) FAULT: String identiying the type of fault (NF - No fault, BF - bit-flip, S0 - Stuck-at-0, S1 - Stuck-at-1) OUTPUT: 10 integer numbers provided by the CNN as output after processing the image. The highest value identifies the selected category for classification. SOFTMAX: 10 decimal numbers obtained after applying the softmax function to the provided output. They represent the probability of the image of belonging to the corresponding category for classification. PRED: Integer number representing the category predicted for the processed image. LABEL: integer number representing the actual category for the processed image.

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.

With this dataset, you can implement different deep learning networks to classify images of hands in poses that correspond to letters in American Sign Language. The dataset is in CSV format, along with some images and a text file describing the dataset. It is similar in many ways to other MNIST datasets.