You may have paused when you first heard the term “epoch”. While it’s a simple term, the first time you encounter it, you may feel intimidated. Then there’s the question that lurks in your head: “Wait… How do you pronounce that?”

You’re not the only one, my friend. Here’s all you need to learn about epochs – both the term and its practical significance in machine learning.

First things first… how do you say it?

Let’s clear up the confusion. Some say EH pick while others say EE pock. The most commonly accepted and common pronunciation is EE-pock. It’s like “clock” but with an extra “ep.”

No matter how you pronounce it, the people on the field will understand. You can pronounce it however you feel most comfortable. Once we’ve settled this, let’s learn what the word means.

What is an Epoch?

Imagine an epoch is a complete pass of your data. Imagine that you are learning a language with a set of flashcards. A single epoch is like going through the entire set of flashcards.

The dataset that you use to train a TensorFlow machine learning model may have thousands (or millions) of columns. This dataset must be processed by the model several times in order to learn patterns. Each cycle of the dataset is an epoch.

Example:

Imagine you are training a model that can recognize numbers written in handwriting (like those on a cheque or form). One epoch is equivalent to the model looking at each of 10,000 images. It calculates the errors, improves predictions and begins “learning” during this round.

One pass is not enough. Your model won’t become useful with just one epoch. Like rereading a novel to better grasp its themes, a model requires several epochs in order to improve.

Why are Epochs important?

The epochs are important because they help the model learn in a progressive manner. Consider it in this way:

• First Epoch The model is still a bit confused.
• Second Epoch It begins to recognize patterns. For example, “Oh, this is what 3 looks like.”
• Later Epochs The model refines its understanding and recognizes subtle details.

It is important to generalize the model well enough that it can perform accurately with data it has never seen before.

Epochs and the Big Picture

The two concepts that you will encounter in machine-learning are iterations and batches. This is how they work together:

• Dataset – This is all the data that you use to train your model. As an example, you could use 50,000 images of cats and dog.
• Batch : Because processing an entire dataset all at once may be too much work for your computer, it is divided into smaller groups, called batches. (For example, 100 images in a batch). The model runs one batch and adjusts weights according to the error. It then moves on to the next batch.
• Epoch : When the model has completed a cycle of the dataset and gone through all batches, this is an epoch.

Analogy is a great way to make it clear:

Imagine that you are learning how to play the guitar.

• The dataset you are trying to master is the entire song.
• Divide it into smaller batch. For example, practice the intro, verse and chorus separately.
• epoch occurs when you have played through the song from beginning to end.

With more epochs you become better, and your song sounds less like noise, and more like music. The same is true for your model. It helps to repeat the training over multiple epochs.

How many epochs do you need?

It’s a combination of science and trial-and error to determine the “right” epochs. Your model will not be able to accurately predict if you use too few epochs. You can overfit your model if you use too many epochs. This means that the model will perform well with training data, but struggle on new data.

General Rule:

• Start by using 10-20 epochs, and watch how the accuracy of your model improves.
• Use tools such as validation curves to determine when the model begins plateauing (only getting very small improvements).

TensorFlow makes it simple to experiment with different epochs. When using the .fit()method to train a model you can simply set the epochs parameter, as shown below:

model.fit(x_train, y_train, epochs=15, batch_size=32) 

This would train the model over 15 epochs, while processing 32 samples in each batch.

Wrapping it All Up

In simple terms, an epoch is a full pass of your dataset. This tiny cog is a vital part of the machine learning engine. Even though the name may be difficult to pronounce or fancy, its purpose remains simple.

No matter what you call it – EH pick or EE-pock — just remember that it means progress. Your model will improve with each new epoch just as you would when learning a new skill.

You can now confidently train TensorFlow models. If someone asks you how to pronounce the word “epoch”, feel free to add a friendly “However, you want to say, don’t forget it’s importance!”