How to Compile Neural Network in Tensorflow

After creating a neural network model in a TensorFlow, you must know how to compile neural network model in a TensorFlow. This step is like preparing your tensorflow model for training.

Here, I will explain how to configure the TensorFlow model with different components, which helps the model learn and assess its performance.

You will be introduced to some real-life analogies related to the components used with the tensorflow model. Understanding these analogies will clarify your concepts of how the TensorFlow model learns from the dataset.

What does Compile Neural Network in Tensorflow Mean?

Once you have created your model, for example, a sequential model, you need to configure the model for training purposes. Here, compiling means setting the model components necessary for training.

These components include optimizer, loss functions, and evaluation metrics. Let me explain these concepts in simple language.

Think that there is a pet owner who has a friend, and the friend is not familiar with differentiating between dogs and cats. Here, the task of the pet owner is to train their friend to recognize and classify dogs and cats correctly.

Optimizer: It is like a set of training techniques the pet owner can teach to their friend. These techniques could involve showing various pictures of dogs and cats, explaining distinct features, and adjusting the learning process based on how quickly their friend catches the difference. The optimizer aims to optimize the friend’s ability to identify the pets correctly.

In the same way, tensorflow provides several optimizers that can be used while training the model. These optimizers exist in the tensorflow.keras. optimizers package, these optimizers are:

  • SGD (Stochastic Gradient Descent Optimizer)
  • Adagrad (Adagrad Optimizer)
  • RMSprop (RMSprop optimizer)
  • Adam (Adam optimizer uses Adam algorithm)
  • Adadelta (uses Adadelta algorithm)
  • Adadfactor (uses Adadfactor algorithm)
  • Adam (uses Adam algorithm)
  • Nadam (uses Nadam algorithm)
  • Lion (uses Lion algorithm)

Above are the different optimizers, and other optimisers are in that package. So, the optimizers are algorithms that are used while training the model.

Loss Functions: The loss function is like a score the pet owner assigns to the friend based on how well he recognises the pet.

If the friend correctly recognizes a dog and a cat, the score is low (which means the loss is low). If there are mistakes in identification, the score is high (which means the loss is high). Here, the goal is to minimise the recognition error, indicating that the friend is getting better at distinguishing between dogs and cats.

In the same way, the loss function is used to find the error that the model makes; this error indicates how well the model is learning, and this error should be minimal, or the goal is to minimise this error.

Tensorflow provides a package called tensorflow.keras.losses, which contains many loss functions that can be used in the model, and these are as follows:

  • BinaryCrossentropy(): Calculate the binary cross entropy for binary classification problems.
  • CategoricalCrossentropy(): Calculate the categorical cross-entropy for multi-classification problems.
  • MeanSquaredError(): Computes the mean squared error for regression problems.
  • MeanAbsoluteError(): Computes the mean absolute error to measure the absolute difference between predicted and actual values.
  • Huber(): It is a mix of MeanSquaredError and MeanAbsoluteError.
  • Hinge()
  • SquaredHinge()

There are other loss functions in tensorflow.keras.losses module, explaining everything here in detail is not possible.

Evaluation Metrics: Evaluation metrics are like accuracy scores that pet owner uses to measure how well their friend can generalize their learning to new pets. The friend is given a set of unknown pets, and the accuracy score indicates the percentage of correct classification.

This helps the pet owner assess their friend’s ability to distinguish between dogs and cats beyond the training examples.

In the same way, metrics are used to evaluate the model’s performance, and the accuracy score is calculated, which indicates how well the model has learned.

Tensorflow provides many metrics that exist in the package called tensorflow.keras.metrics, and these metrics are:

  • binary_accuracy
  • accuracy
  • f1_score
  • recall
  • sensitivity
  • categorical_accuracy
  • poisson
  • precision
  • sparse_categorical_accuracy
  • f2_score
  • mean

The tensorflow.keras.metrics contains many more metrics that can measure the model’s performance.

Now that you know the components’ purpose, you must know how to compile the model with them.

To compile the model, TensorFlow has a method called compile(), which accepts different argument values, as shown below.


This time, explaining the argument is not necessary, but you have to provide the three argument values always, which are shown below.


The three arguments are:

  • Optimizer: Specify the optimizer algorithm for the model.
  • loss: Specify the loss function for the model.
  • metrics: Specify the metric for the model.

Suppose you have created a model named ‘model_1’, and to configure this model using the compile() with optimizer, loss and metrics, look at the code below.

model_1.compile(optimizer='sgd', loss='mean_absolute_error', metrics=metrics.f1_score)

The above code, model_1 is configured with sgd optimizer, mean_absolute_error loss function, and f1_score metrics.

This is how to compile a neural network model in tensorflow.

After compiling the model, the next step is to train the model on the training data.


You learned how to configure the tensorflow model using important parameters such as optimizers, loss, and metrics. You also learned the purpose of these parameters and how they help the model learn from the dataset.

You may like to read: