Tutorial: Introduction to Keras

March 9, 2023

What Is Keras? What Is It for?

Keras is a high-level, user-friendly API used for constructing and coaching neural networks. It’s an open-source library inbuilt Python that runs on prime of TensorFlow. It was developed to allow quick experimentation and iteration, and it lowers the barrier to entry for working with deep studying

On this article, we’ll talk about easy methods to set up and begin utilizing Keras; the Sequential API; and the steps for constructing, compiling, and coaching a mannequin. We’ll additionally cowl some frequent functions of Keras and potential different assets to take a look at!

Putting in Keras

To start out with, you’ll wish to set up TensorFlow. Relying on which working system you’re utilizing, this would possibly look barely totally different, however for probably the most half, you should use pip, Python’s bundle supervisor:

# First improve pip
pip set up –upgrade pip

# Then set up TensorFlow
pip set up tensorflow

When you’ve put in TensorFlow, all it is advisable do to make use of Keras is to run the next import assertion on the prime of your script or pocket book:

from tensorflow import keras

Keras’ Sequential API

The Sequential API is the best manner to make use of Keras to construct a neural community. Utilizing the Sequential class, it’s doable to stack quite a lot of totally different layer varieties, one after the opposite, to provide a neural community. There are lots of kinds of layers obtainable within the Keras Sequential API. Probably the most frequent layer varieties is the Dense layer, a completely related layer, however there are various others:

Convolutional layer: a layer for processing photographs — used for convolutional neural networks.
Recurrent layer: a layer for processing sequences of information — used for recurrent neural networks.
MaxPooling layer: a layer for down-sampling function maps by taking the utmost worth in non-overlapping rectangular blocks — used for preserving necessary options whereas lowering the prospect of overfitting.
Flatten layer: a layer that flattens the multi-dimensional enter tensors right into a single dimension — used as a transition layer between convolutional or recurrent layers and totally related layers in a neural community.
Dropout layer: a layer that randomly units enter items to 0 (utilizing an outlined frequency) throughout coaching time — used as a regularization approach to forestall overfitting in neural networks.
Embedding layer: a layer that represents phrases or phrases in a high-dimensional vector house — used to map phrases or phrases to dense vectors to be used as enter to a neural community.

These are just some examples of the numerous kinds of layers obtainable within the Keras Sequential API. Every layer is designed to carry out a particular kind of computation on the inputs, and they are often mixed to create highly effective neural community architectures.

Constructing a Mannequin with Keras

To construct a mannequin with the Keras Sequential API, step one is to import the required class and instantiate a mannequin utilizing this class:

from tf.keras import Sequential

mannequin = Sequential()

Subsequent, select the layer varieties you want to embrace, and add them separately to the sequential mannequin you’ve instantiated. For instance, so as to add three Dense hidden layers and one output layer to an enter layer, your code would possibly appear like this:

from tf.keras import Dense

mannequin.add(Dense(input_shape=(16,))
mannequin.add(Dense(8))
mannequin.add(Dense(4))
mannequin.add(Dense(2))
mannequin.add(Dense(1))

On this instance, we’ve added an implicit enter layer with 16 nodes and three hidden layers with 8, 4, and a pair of nodes, respectively. Lastly, we’ve added an output layer with only one node.

Picture through our forthcoming “Deep Studying Fundamentals” lesson within the “Introduction to Deep Studying in TensorFlow” course.

Compiling a Mannequin with Keras

When you’ve constructed a mannequin utilizing the Keras Sequential API, you’ll must compile it earlier than it may be used for coaching. When compiling the mannequin, you’ll must specify each a loss operate and an optimizer. There are lots of totally different choices to select from:

Loss capabilities:

Imply Squared Error (MSE): a typical loss operate for regression issues — measures the common squared distinction between the expected and precise values.
Binary Crossentropy: a loss operate for binary classification issues — measures the cross-entropy between the expected and precise binary distributions.
Categorical Crossentropy: a loss operate for multi-class classification issues — measures the cross-entropy between the expected and precise categorical distributions.

Optimizers:

Stochastic Gradient Descent (SGD): a easy optimization algorithm that updates the parameters by computing the gradient of the loss operate with respect to the parameters.
Adam: an optimization algorithm that adapts the training fee based mostly on the historic gradient data.
RMSprop: an optimization algorithm that makes use of a transferring common of squared gradients to normalize the gradient updates.

These are just some examples of the numerous loss capabilities and optimizers obtainable in Keras. The selection of loss operate and optimizer will rely upon the precise drawback you’re attempting to resolve and the traits of your information.

For instance, to compile a mannequin with Imply Squared Error because the loss operate and Adam because the optimizer, we might use the next code:

mannequin.compile(loss=‘mean_squared_error’, optimizer=‘adam’)

Becoming a Mannequin with Keras

Lastly, to make use of Keras for deep studying, the compiled mannequin should be match to a coaching dataset. The coaching dataset must be ready utilizing a course of that separates the unbiased variables, the options (or X variable) from the dependent variable, the goal (or y variable). These variables must also be transformed to NumPy arrays and reshaped as wanted, and the input_shape parameter of the neural community will must be configured to match the coaching information form. As soon as all of those preprocessing steps are in place, you may merely match the mannequin to the coaching information like so:

mannequin.match(X_train, y_train)

To guage the efficiency of the mannequin after coaching, you should use consider:

test_loss, test_accuracy = mannequin.consider(x_test, y_test)

Placing It All Collectively

Now that we’ve seen all the steps required to construct and practice a mannequin in Keras, let’s put all of it collectively and try an instance utilizing the MNIST dataset constructed into TensorFlow datasets. First, we have to make the mandatory imports and cargo the dataset:

from tensorflow import keras
from tensorflow.keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

For this dataset, we additionally must do some preprocessing and reshaping of the information to organize for the mannequin:

x_train = x_train.reshape(x_train.form[0], 28, 28, 1).astype(‘float32’) / 255
x_test = x_test.reshape(x_test.form[0], 28, 28, 1).astype(‘float32’) / 255

y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

Then it’s time to construct your mannequin! Following the steps above, we are able to construct a convolutional neural community utilizing a variety of layer varieties, like so:

mannequin = keras.fashions.Sequential()
mannequin.add(keras.layers.Conv2D(32, kernel_size=(3, 3),
activation=’relu’,
input_shape=(28, 28, 1)))
mannequin.add(keras.layers.MaxPooling2D(pool_size=(2, 2)))
mannequin.add(keras.layers.Flatten())
mannequin.add(keras.layers.Dense(128, activation=’relu’))
mannequin.add(keras.layers.Dense(10, activation=’softmax’))

Lastly, compile and practice the mannequin as directed, and consider the outcomes:

mannequin.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(), metrics=[‘accuracy’])
mannequin.match(x_train, y_train, batch_size=128, epochs=12)

test_loss, test_accuracy = mannequin.consider(x_test, y_test)
print(‘Check accuracy:’, test_accuracy)
Check accuracy: 0.8313000202178955

And that’s it! Now you could have constructed a profitable mannequin in Keras. With an accuracy of round 83%, the mannequin is ready to make dependable predictions on unseen information. In the event you run this code your self, your outcomes might differ barely, however not by a lot.

Purposes and Subsequent Steps

Now that you just’ve discovered why and easy methods to use Keras, you could be questioning what kinds of functions you should use it for. Neural networks are utilized in a variety of areas. Some common functions embrace the next:

Laptop Imaginative and prescient: picture classification, object detection, semantic segmentation, and different laptop imaginative and prescient duties.
Pure Language Processing: language translation, textual content classification, sentiment evaluation, and extra.
Recommender Programs: suggestion methods for merchandise, motion pictures, music, and so forth.
Time Collection Prediction: for predicting inventory costs, gross sales, climate patterns, and different time sequence forecasting.

These are just some examples of the numerous functions of neural networks. The flexibility of neural networks to be taught complicated relationships in information and make predictions based mostly on that studying makes them a flexible device for a variety of issues.

In the event you’d wish to go additional together with your research of Keras and TensorFlow, and get some hands-on observe with these instruments, you’ll wish to try some upcoming Dataquest programs!

Introduction to Deep Studying with TensorFlow
Convolutional Neural Networks
Sequence Fashions
Pure Language Processing