We welcome the ascension of our artificial overlords!

We depart from TensorFlow Playground to bring you another way to learn about deep learning and neural networks.

TensorFlow provides a robust foundation for building complex neural networks, but its low-level nature can often be daunting for those new to the field. To bridge this gap, high-level APIs have emerged that simplify the process of model creation and experimentation.

Keras: a neural network builder

Keras is an open-source Python library that provides a human user-friendly interface for building and training neural networks. It provides a high-level abstraction over complex tensor operations, allowing developers to focus on model architecture and hyperparameters rather than low-level implementation details.

The components of Keras include:

• Models: define the overall structure of the neural network (Sequential, Functional API).

• Layers: build the individual components of the network (Dense, Convolutional, Recurrent, etc.).

• Compilers: configure the training process (optimizer, loss function, metrics).

Keras' relationship to TensorFlow

Keras primarily leverages TensorFlow as its backend engine to execute computational graphs. While Keras provides a high-level abstraction for building and training models, the underlying tensor operations and optimizations are handled by TensorFlow.

On a more academic level, TensorFlow and Keras each represent different levels of abstraction in deep learning. TensorFlow provides granular control over computational operations, including hardware acceleration, while Keras offers a higher-level interface for building and training neural networks. This abstraction enables rapid prototyping and experimentation without delving into low-level implementation details.

Keras on Python

Installing and importing Keras in Jupyter Notebook is a straightforward process that is no different from what we did to download previous modules.

The Keras backend is the underlying computational engine that powers the framework. It handles tensor operations, optimizations, and hardware acceleration. Popular backends include TensorFlow and Theano. By abstracting away the complexities of these low-level libraries, Keras provides a user-friendly interface for building and training neural networks.

In numerical computations, a small value called the fuzz factor (or epsilon) is often used to prevent division by zero or other numerical instabilities. Keras provides an epsilon function to access this value, which is typically a very small number like 1e-07.

Float types in deep learning determine the precision of numerical representations used in calculations. They influence factors like model accuracy, training speed, and memory consumption. Here is a brief description of 3 common float types:

• float16 (half-precision): uses 16 bits for representation. Offers the smallest memory footprint and fastest computations but suffers from significant precision loss. Suitable for low-precision training or inference on resource-constrained devices.

• float32 (single-precision): uses 32 bits for representation. Provides a balance between precision and performance. Commonly used in most deep learning models due to its reasonable accuracy and computational efficiency.

• float64 (double-precision): uses 64 bits for representation. Offers the highest precision but also consumes more memory and computational resources. Primarily used for specific applications requiring extreme accuracy or numerical stability.

Choosing the most desirable float type involves considering the trade-offs between precision, performance, and memory usage based on the specific requirements of the deep learning model.

Keras' built-in datasets

Keras provides a collection of pre-processed datasets to facilitate rapid prototyping and experimentation. These datasets are typically small to medium-sized and serve as a starting point for learning and testing different models.

• CIFAR-10/-100: image classification datasets with 10 or 100 classes, respectively.

• IMDB: movie review sentiment classification dataset.

• Reuters Newswire: text classification dataset.

• MNIST: handwritten digits dataset, commonly used for image classification tasks.

• Fashion-MNIST: alternative to MNIST with more complex images.

• Boston Housing: regression dataset for predicting house prices.

Using built-in databases can give us a quick start with no need for data preprocessing or cleaning, datasets in a consistent format that make them easy to use with Keras APIs, and benchmarking for comparing different models and algorithms.

Running Keras on Python

We begin with importing the CIFAR-100 dataset from Keras itself…

As demonstrated below, CIFAR-100 is a large dataset at the 5 digits.

And then there is the sheer variety of different topics stored inside it. The name CIFAR-100 means that the dataset has 100 features.

To store the 100 features in Python, use a Dictionary to map a list of similar-trait features per superclass. This is why we did not write a for loop to fetch each variable nonspecifically.

 Today's new subplot type is .imshow(), which displays images instead of generating new elements like previous plots.

Here are the first 25 training results of CIFAR-100. If you want your image plot to display more, simply increase the grid size and the num variable. Be mindful that num must be no larger than the grid size lest your function crashes when run.

Here are the 25 test dataset results. You probably noticed their pixelated textures by now, and you would be observant, because dimensionality reduction is in effect to lower the resolution of the data to work less while producing no less results.