Artificial intelligence has been around for decades, but it has only recently become mainstream. From 2015 onwards, the development of convolutional networks, coupled with the increasing availability of data, and the GPGPU movement brought a renaissance to the field of AI research. However, it has been the popularization of end-user applications like ChatGPT or Midjourney, which has truly made AI mainstream. 

Jumping right into transformer networks or the diffusion process can be a little bit daunting, but luckily for newcomers, there are simpler yet powerful techniques to start with. 

One of the most basic AI algorithms is k-nearest neighbors (KNN). KNN is a simple but effective algorithm that can be used for a variety of tasks, including classification, regression, and anomaly detection. Furthermore, one doesn’t have to implement KNN from scratch, we have Python libraries like scikit-learn that have nice implementations. 

In this post, you will learn how to build a handwritten digit classifier in Python. You will use the scikit-learn library to train and run inference using the KNN algorithm, and learn some of its inner workings. Additionally, you will also learn about some standard practices such as cross-validation and hyperparameter search. By the end of this tutorial, you should have a solid understanding of the KNN algorithm and be able to use it for your own machine learning projects. 


# How does the KNN algorithm work? 

K Nearest Neighbors (KNN) is probably one of the dumbest machine learning algorithms. The machine learning models that fill the headlines these days take weeks to train, and usually require datacenters with lots of compute cores and memory, instead, the most basic form of KNN does nothing at train time, it just saves the training data. Then, when we need to run the algorithm on a new sample, KNN identifies the closest training samples to the new data point and examines them. Depending on the information we extract from those closest samples, we can run classification, regression, or outlier detection, but classification is by far the most popular application. In this sense, the KNN algorithm just extracts the labels of the closest neighbors and returns the most common one.  

Instead, if we want to use KNN for regression or outlier detection we must be a little more clever. For regression, we can get the distance, or similarity, between the new sample and each of the neighbors, and average their features using the similarity as the averaging weight. For outlier detection, we can set a distance threshold, and if no training samples are close enough to the new sample, we can assume it’s an outlier. 

Things can also get trickier if the training dataset is large. In this case, the process of finding the closest samples to a given new one can be pretty slow, because KNN would have to be comparing the new sample to every sample in the dataset. This approach is often referred to as brute force search. Instead, a search tree can be built at train time, so that the nearest neighbors search runs faster. This search tree is usually a KD-tree or a ball tree and, although these names may look intimidating, all they do is looking at a single feature at a time, and dividing the training dataset in two splits, in one of those splits the samples with a value lower than a threshold for the selected feature are stored, and in the other split, the samples with a higher value are stored; this process can be repeated in an hierarchical approach, subdividing each of the splits using another feature. Then, at inference time, we just have to follow the tree splits looking at the corresponding features of the new sample and, when we arrive at a leaf node, we perform brute search on a smaller set of the training data. 

Finally, another tricky part of the KNN algorithm is the way we compare a pair of samples to see how close they are. The most basic distance is the Euclidean distance, or L2 norm, which measures the straight-line distance between two points in the feature space. Another common option is the Manhattan distance, also called L1 norm or taxicab distance, and it measures the distance by adding up the absolute differences between the features of the two points. Finally, one last common distance metric is the Minkowski distance, which has a “p” parameter that controls the order of the distance, and can imitate the Manhattan distance for p = 1, and the Euclidean distance for p = 2. 


# UCI ML hand-written digits dataset

A machine learning algorithm would be of little use if we did not have data to train it. For this example we will use the UCI ML hand-written digits datasets, a collection of images of handwritten digits, from 0 to 9, mostly black and white, and where the image just shows the target digit. 

We will be specifically using the version included with scikit-learn which is a copy of its test set. This version contains 1797 images from a total of 13 people, where each image is 8x8 pixels. During acquisition, images of 32 by 32 pixels were scaled down by dividing them into non-overlapping blocks of 4 by 4 pixels, and counting the number of white pixels in each block. The original size of 32 pixels, when divided by 4, results in a downscaled size of 8 and, since each block in the original image is 16 pixels, the downscaled image should have pixels with values ranging from 0 to 16. 

Instead of manually downloading the dataset, we can load it using the following code: 

```python 
from sklearn import datasets
digits_datset = datasets.load_digits()
```   

The digits_datset.data variable contains the pixel values, and the digits_datset.target variable contains the labels for the images. The labels are numbers from 0 to 9, corresponding to the digit that is shown in each image. 

Once we have loaded the data, we can display it using matplotlib like this: 

```python 
import matplotlib.pyplot as plt

for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(digits_datset.images[i], cmap='gray')
    
plt.show()
```

Which will generate the following plot: 

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/train-a-knn-classifier-with-scikit-learn-your-first-ai-project/digits.jpg" alt='Digits dataset' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 1. </span> UCI ML Digits dataset. This dataset contains images of handwritten digits. Each image is 8x8 pixels. </figcaption>
</figure>  

Additionally, since the dataset included in scikit-learn is just the test set, we should subdivide it into our own training and testing sets. For this, we will be using the train_test_split function of the model_selection module, like this: 

  
```python
from sklearn.model_selection import train_test_split
(train_data, test_data, train_labels, test_labels) = train_test_split(digits_datset.data,
	digits_datset.target, test_size=0.2, random_state=1337)
```

  

For the sake of clarity, the random_state parameter is a seed value controlling how the data will be shuffled. Normally, the data will be randomly shuffled, and each call to the function will shuffle the data differently, however, if we pass a random_state value, we will have a reproducible behavior. 

  

# Training and evaluating the model 

  

First, we import the model and create an object. We will be using 20 neighbors, the KD-Tree search, and p = 2 for the Minkowski distance: 

  
```python
from sklearn.neighbors import KNeighborsClassifier
model = KNeighborsClassifier(n_neighbors=20, algorithm='kd_tree', p=2)
```
  

Now, we can fit the model to the training data using the .fit method: 
  

```python
model.fit(train_data, train_labels)
```


At this point we have a trained model, and we can get the test set performance using the following code: 

```python
from sklearn.metrics import accuracy_score
test_predictions = model.predict(test_data)
accuracy = accuracy_score(test_labels, test_predictions)
print(accuracy)
```

Later, we can also save the model for future use. For this, we can use the pickle module: 

```python
import pickle
with open('model.pkl','wb') as f:
    pickle.dump(model, f)

with open('model.pkl','rb') as f:
	loaded_model = pickle.load(f)
```

  

# How can we select the best parameters? 

In the previous section we used 20 neighbors and p = 2 for the Minkowski distance. However, we didn’t check if we could get better performance using other values. 

In this kind of situation, we can use grid search. This technique involves exhaustively trying out every combination of different parameters in a discrete range, a grid, and selecting the combination that gets the best performance. 

To improve the search process, a common strategy is to do grid search with cross validation. Cross validation is a technique that splits the data into several subsets, k folds. Once divided, a training and evaluation loop is executed k times, each time using k-1 folds for training, and the remaining fold for evaluation. Finally, instead of calculating the accuracy in just one test set, the accuracy is calculated for each validation fold and then averaged.  

  

To do this in Python, we first have to import the GridSearchCV class, Numpy, and create the model, parameter grid, and grid search object: 

```python
from sklearn.model_selection import GridSearchCV
import numpy as np
parameters = {'n_neighbors': np.arange(2, 20, 2), 'p': np.arange(1, 4, 1)}
model = KNeighborsClassifier(algorithm='kd_tree')
grid_search_model = GridSearchCV(model, parameters, scoring='accuracy', n_jobs=-1)
```


The n_jobs = -1 parameter will tell scikit-learn to use all our CPU cores, so that it finishes faster. 

  

Then we can call ```.fit``` to do the grid search with cross validation, it will take some time to finish: 

```python 
grid_search_model.fit(digits_datset.data, digits_datset.target)
```

  

The grid_search_model object will automatically split the data into training and validation sets, and use the cross-validation technique to measure the performance of each parameter combination. Once finished, we can check the best parameters and the best accuracy: 

```python 
print(grid_search_model.best_score_)
print(grid_search_model.best_params_)
```

Finally, we can evaluate the best performing model on the original test set to see if we got any improvement: 

```python 
test_predictions = grid_search_model.predict(test_data)
accuracy = accuracy_score(test_labels, test_predictions)
print(accuracy)
```

Although we may be getting better results in the original test set, the cross validation accuracy is the one that we should be trusting the most. This is because that accuracy was evaluated on k folds. 


# Conclusion 

In this post we learned about the KNN algorithm, a good starting point for those looking to enter the field of machine learning. This algorithm stores the training samples and analyzes new ones by comparing them to the training data. To classify new data, it assigns the most common label among its close neighbors. 

Despite the satisfactory results we saw, the KNN algorithm will fall short on more challenging benchmarks like the Imagenet dataset. The images in the dataset we used are really small, 8 x 8 pixels, are black and white, and do not have any confounding elements in them, whereas real world images are way more complex. 

The next steps could be reading about feature extraction algorithms for images like HOG or SIFT, and more complex classifiers like the SVM or Random Forest. By learning about filter based feature extractors, you will begin familiarizing yourself with the convolution operation, which is one of the cornerstones of convolutional networks. On the other hand, by looking at optimization based models like SVM you will get a better understanding of how machine learning algorithms fit their parameters to the training data. 

In summary, while we achieved nice results, there is still a long way to go. This is just a first step into the field of AI, but a good starting point, nonetheless. 

In this post, you will learn how to build a handwritten digit classifier in Python. You will use the scikit-learn library to train and run inference using the KNN algorithm, and learn some of its inner workings. Additionally, you will also learn about some standard practices such as cross-validation and hyperparameter search.

Train a KNN classifier with scikit-learn: Your first AI project


Generative AI is a rapidly growing field of artificial intelligence that aims to create new content, such as images, text, and music. This technology has the potential to revolutionize the way we create and consume content, and it is already being used in several industries, including the arts, entertainment, and marketing.

In this blog post, we will explore the different ways that generative AI is being used to create new content across different domains. We will put special focus on the two most popular modalities of generative AI: AI for writing text, and AI for generating images. We will also explain briefly but technically the main generative AI systems that power these modalities, such as ChatGPT and Stable Diffusion.

Many users have started interacting with generative AI models through web apps, but they may not fully understand what these models are and how they work. This post will address this gap and help you to learn more about the field of generative AI and the main techniques being used.

# What is generative AI?

Before diving into generative AI, we should first understand the general concept of AI. Some researchers don't tend to like the word AI, as it often is used to overhype machine learning. In fact, most AI we see today is actually machine learning so, what is machine learning? Machine learning is just a way of teaching computers to generate outputs using samples. These samples are usually text, images, or audio, and the outputs are usually a label, a numerical value, or another image, text, or audio. Once trained, these algorithms can analyze new samples, previously unseen, with impressive accuracy.

Generative AI is a subset of machine learning that aims to generate new content, such as audio, images, or text. Generative AI models use specialized architectures, such as transformer networks, generative adversarial networks, or encoder-decoder networks, that can learn from training data and produce realistic and novel creations that reflect the characteristics of the data without fully replicating it.

Generative AI brings huge potential for content creation, as it can streamline the creative process, specially in the drafting stages. Whether it is a social media post, an image for a blog post, or background music, generative AI can help you create quick and high quality drafts that will make your work easier.

# Generative artificial intelligence for text generation

Text based AI applications like GhatGPT have become very popular lately. However, before them, text classifiers were the dominant type of text AI for over a decade. Text classifiers assign a category to a piece of text, something like “positive review” or “negative review”. These models are really useful, since they can streamline tasks such as customer support, where the model can automatically categorize complaints based on the team that needs to address them.

However, in the last few years a new trend has emerged, while previous models could just classify text, general purpose AI text generators capable of following simple instructions have become more popular. These instruction following models are self-supervised at their core, which means that they do not rely on human-labeled data, but instead create their own labels from the data itself. This reduces the need for manually labeling training data, which facilitates the use of ever larger datasets. This way, they can learn from large amounts of unlabeled text data, such as web pages, books, news articles, and more.

By processing huge amounts of data, self-supervised methods can build knowledge and help us complete common tasks such as answering questions. However, even though self supervised algorithms are capable of amassing a large amount of knowledge, they usually need to be fine tuned to achieve the level of interactivity of applications like ChatGPT, Bing Chat, or Bard.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/what-is-generative-AI-and-how-do-AI-writers-and-image-generators-work/bing-chat.png" alt='You can use ChatGPT for free with Bing Chat' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'>You can use ChatGPT for free with Bing Chat.</figcaption>
</figure>

## ChatGPT

ChatGPT is a chatbot capable of very human-seeming interactions. It was launched by OpenAI in late 2022 and became wildly popular overnight. The main reason for the success of ChatGPT was its ability to  generate coherent and engaging responses to natural language requests; you just write your instruction, and ChatGPT will provide an answer. Moreover, you can use ChatGPT for free using Bing chat

ChatGPT is powered by a transformer network, a type of machine learning model that has become very popular since 2017. Transformer networks are very good at natural language processing tasks, such as text summarization, machine translation, or question answering. These networks use a mechanism called attention, which allows them to learn how words in a sequence relate to each other. This makes them suitable for NLP tasks where the meaning of a sentence depends on the context of the words around it.

However, the language modeling capabilities of transformer networks are not enough to train a general purpose chatbot. Models like ChatGPT are usually trained using a multi-step approach. Specifically, this chatbot was first trained for language completion in a self-supervised way, then trained with manual prompt - answer pairs, and then refined using reinforcement learning.

Following this approach, the first step is to build a language model capable of completing sentences. This is achieved by training the transformer network in a self-supervised way, feeding the model a large corpus of books, blogs, and other information found on the internet. The result of the pretraining phase is a large language model (LLM), often known as a pretrained model.

Right now, this pretrained model is very good at completing sentences, but not that good at following instructions. When asked “Write a poem” it may reply “ said the poet”, this is because narrative passages are more frequent on the internet than instruction-answer sequences. In order to overcome this limitation, the pre-trained LLM is fine tuned on a set of instruction - answer pairs that are manually crafted. In this step, also called behavior cloning, the internal knowledge representation of the LLM is slightly adjusted so it's more likely to reply to instructions rather than just completing sentences. 

Finally, once the LLM has been fine-tuned using manually crafted instruction - answer pairs, it usually undergoes one last refinement step. In this last step, the model is fine tuned using reinforcement learning, a type of training that allows machine learning models to learn by allowing them to generate full responses, and grading them using a reward model. This reward model is in itself another machine learning model, trained to rank different replies to a prompt and, by using this reward model, the model can improve its performance a little bit more. One prompt may have several good answers, but some of them may be better than others, and this step prioritizes just that: selecting the best answer among the possible ones. Also, it is true that different people may have different opinions on how to rank responses, this may be the reason why ChatGPT, shows a thumbs up/down button next to each reply; this way, the app can gather data on the preferences of its users.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/what-is-generative-AI-and-how-do-AI-writers-and-image-generators-work/chatgpt-diagram.png" alt='Steps to fine tune a pretrained language model to follow instructions' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'>Steps to fine tune a pretrained language model to follow instructions.</figcaption>
</figure>

# Generative artificial intelligence for creating images

Text-to-image AI art generators are a special kind of AI that can produce images from natural language descriptions. Although these models have not received as much attention as ChatGPT, online apps for generating images have mushroomed over the last few years and there are now dozens of nice options capable of generating stunning artworks.

In reality, AI powered image generators have been around for quite some time now. However, as in the case of AI models for language understanding, these older models were not as powerful as the ones we now have. Two good examples of older AI for image generation are GANs, and the neural style transfer technique.

GANs, or Generative Adversarial Networks, which were introduced in 2014 in the paper “Generative Adversarial Networks”, work by putting two neural networks to compete against each other. One network, the generator, tries to create new images that are indistinguishable from real images. The other network, the discriminator, tries to distinguish between real images and fake images created by the generator. These two networks are trained together until a stalemate is achieved, meaning that the generator can fool the discriminator half the time. By doing this, we can train an image generator that can, at least, fool AI image classifiers, although the results can sometimes be far from perfect.

Another example of older AI for generating images is the Neural Style Transfer technique. Introduced in 2016, this technique can create new images that mimic one specific style, while preserving the content of the photos we choose. For example, if we have a photo of a city and a painting by Van Gogh, we can use Neural Style Transfer to create a new image that has the same buildings and streets as the photo, but with the brush strokes and colors of Van Gogh’s style. This technique works by feeding the style and reference image to a pretrained network, and iteratively tweaking the reference image so that the style neural activations are closer to those of the style image.

However, none of these techniques could match the complexity of modern AI generators such as Midjnourney or, as a free alternative, Stable Diffusion. These new models are trained on massive datasets of text-image pairs, which allows them to create much more realistic and detailed images.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/what-is-generative-AI-and-how-do-AI-writers-and-image-generators-work/generated-cat.png" alt='Image of a cat generated using Stable Diffusion' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'>Image of a cat generated using Stable Diffusion.</figcaption>
</figure>


## Stable Diffusion
One of the most popular generative AI image creation tools is Stable Diffusion. Stable Diffusion is a model that can be easily deployed using apps like Web UI, which allows users to generate images by providing simple text prompts. For example, you could enter the text prompt "A cat sitting on a fence" and the Stable Diffusion Web UI will show an image of a cat sitting on a fence generated by the AI model.

Stable Diffusion, contrary to ChatGPT, is an open source model and this allows us to get a deep understanding of its inner workings. This AI model is based on a technique called latent diffusion, which involves adding and removing noise from images in a controlled way. The model learns to create realistic images by reversing the process of adding noise, starting from random noise and gradually removing it until it reaches the desired image. 

This reverse diffusion process, iteratively removing noise from a random image, is achieved using a U-Net architecture. U-Net is one specific kind of convolutional network that was originally designed to segment biomedical images, but is also capable of generating RGB images. This network is usually trained in a supervised manner, with image-image pairs which, in this case, will be the noisy image and the noise that we want to remove at the current reverse diffusion step. When training the model, the U-Net learns to predict the noise we are adding at each diffusion step; then, during inference, the noise predictions generated by the U-Net can be used to reverse the diffusion process, subtracting the noise from the image and then recovering a denoised image from random noise.

However, using the U-Net directly to process images directly would quickly turn prohibitively expensive for moderate to large images. If we look at the original U-Net paper, the authors used images of 512x512 pixels to reduce the memory footprint of the model, but that kind of images would already be prohibitively expensive for Stable Diffusion which has additional layers around the U-Net. Instead of working directly with the image pixels, Stable Diffusion works in a latent space, a compressed representation that stores the information of the processed image in a smaller amount of “pixels”. This is achieved by using a variational autoencoder, a kind of encoder-decoder network that is trained to output the same image it was fed. Once trained, we can feed an image to the variational autoencoder, and use the internal activations of the network as a compressed representation of the image. If we just save the feature block that lies between the encoder and decoder, we can perform the reverse diffusion on that and save a huge amount of computational resources.

Even with all this processing, the model isn't capable of following text prompts yet, we still need to condition the reverse diffusion process. To achieve this, cross attention layers are added to both the encoder and decoder sections of the U-Net model. These cross attention layers work similarly to the self-attention mechanism used by ChatGPT, but take into account both the text information of the prompt, and the visual information of the diffuser. This way, the activations of each layer of the original U-Net architecture are projected using the text prompt.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/what-is-generative-AI-and-how-do-AI-writers-and-image-generators-work/stable-diffusion-diagram.png" alt='Stable diffusion diagram' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'>Stable diffusion diagram.</figcaption>
</figure>

If we put together these three components: the U-Net, the variational autoencoder, and the cross attention layers, we get a model that can generate high quality images following text prompts.

# Conclusion

Generative AI is a game-changer technology with the promise to revolutionize content creation. This kind of AI can produce amazing and original content across different domains, such as images, text, or music, and people are already taking advantage of its capabilities through apps like ChatGPT or Stable Diffusion Web UI. In this blog post, we have introduced the concept of generative AI, and explored the main apps people are using to take advantage of this technology: Stable Diffusion for image generation, and ChatGPT for writing text.

As this technology continues to develop, we can expect to see even more amazing and creative applications in the years to come. For now, the cover photo for this post was created using Stable Diffusion. Additionally, these models are helping creative jobs like marketers write catchy headlines, slogans, or descriptions.

We hope that this blog post has given you an overview of the different ways that generative AI is being used to create new and innovative content across different domains. If you are interested in learning more about generative AI models and how they can help you with your projects, feel free to contact us using the contact page or the chat button.


Generative AI is a rapidly growing field of artificial intelligence that aims to create new content, such as images, text, and music. In this blog post, we will explore the different ways that generative AI is being used to create new content across different domains, with special focus on the two most popular modalities of generative AI: painting images, and writing text.

What is generative AI and how do AI writers and image generators work?

Artificial Intelligence is much more than a buzzword, it's a powerful force that's shaping the world of tomorrow. From manufacturing to healthcare, AI has rapidly become an integral part of our daily lives, reshaping how we interact, work, and live. In this blog post, we'll show 10 specific examples of how AI is reshaping different industries.

10 real world applications of AI across industries


Face recognition is one of those technologies that have been around for a couple of decades now, but has been heavily revolutionized by recent developments in AI. From automated tagging in social networks, to securing access to our smartphones, face recognition is playing an increasingly important role in our daily lives. However, its inner workings remain a mystery to the general population.

In this blog post, we'll describe how face recognition works, showing specific methods that are commonly used in the industry. We'll also delve into some of the ethical concerns surrounding this technology, such as privacy violations and bias. By the end of this post, you'll have a better understanding of what face recognition is, how it works, and what specific techniques are commonly used in a face recognition system.

# Typical steps in a face recognition pipeline
A face recognition system uses machine learning algorithms to detect faces and match them against a database of previously recorded faces. Depending on the size of this database, we can be talking about face verification, or fully fledged face recognition.

Face verification is the process of comparing two face images to determine if they both show the same person. This one-to-one matching is often used in access control applications such as Face ID. On the other hand, face recognition is the process of identifying one individual from a large database. Face recognition systems are typically more complex than verification systems, since they require robust image processing algorithms and scalable architectures. Face recognition systems may have to account for variable lighting, angles, and different environmental factors. Additionally, they often require a sophisticated architecture to accurately match individuals across a potentially huge database.

Like similar AI-powered image recognition methods these systems have two kinds of errors: false positives, and false negatives. When the face recognition software matches a person's face to a database entry that does not correspond, we are talking about a false positive error. On the other hand, when the face recognition system fails to match someone's face, but that person is registered in the database, we are talking about a false negative error. The relation between false positives, and false negatives is usually a trade off, and researchers have to fine tune the system to balance them depending on the final application. For example, if you are using face recognition to unlock your phone, you may prefer to try a few times rather than allowing other people to use your phone; this means that you want the face recognition system to have a higher false negative than false positive rate.

Nowadays, there are different face recognition libraries such as Deepface that implement a complete analysis pipeline. This recognition pipeline consists of four stages: Detection, alignment, representation, and verification.


## Face detection
Face detection is the first step in a face recognition pipeline. It involves identifying the presence of faces in an image and locating them, usually by computing a set of bounding boxes. This is typically achieved using machine learning models that analyze image features such as color, texture, and shape using a set of complex analysis blocks learned from a training dataset.

A popular family of face detection algorithms is single stage convolutional detectors. These convolutional networks analyze the image in just one pass, without relying on intermediate steps such as proposal generation, achieving fast detection speeds. Some popular architectures typically used in face detection are RetinaFace, SSD, or YOLO. Figure 1 shows the result of using the RetinaFace algorithm to detect faces.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/face-recognition/face-detection.png" alt='Face detection results' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 1. </span> Face detection results. Face detection algorithms such as RetinaFace generate both bounding boxes and facial landmarks locations. </figcaption>
</figure>


## Face alignment
Once detected, a face may be slightly rotated, which can reduce the performance of the face recognition pipeline. In order to achieve the best accuracy possible, a face alignment step is usually introduced. This face alignment procedure involves identifying facial landmarks such as the eyes, nose, or mouth, and then transforming the face image so that the position of these landmarks is standardized.

Some face detection algorithms such as RetinaFace compute the necessary landmark locations to perform face alignment. Specifically, RetinaFace detects both eyes, the nose, and the edges of the mouth. Once detected, we can rotate the image so that both eyes are at the same height. On the other hand, many face detection algorithms don’t explicitly compute any landmark locations. In this case, users can introduce a post-processing step that uses another lightweight network, such as a MobileNet, to regress some landmarks.

## Face representation
Face recognition systems don’t usually rely on the raw face images to perform recognition, instead, they first compute a digital fingerprint of the face. This fingerprint is just a, relatively small, list of numbers that summarize the appearance of the face. Face recognition systems store these lists, also called feature vectors, in large databases that can be queried to find similar faces.

Traditional methods such as LBPH, or Local Binary Pattern Histograms, use simple techniques such as thresholding and histograms to represent the face image. However, with the rise of deep learning these simpler algorithms have become less popular. Nowadays, state of the art face recognition systems use convolutional networks such as ResNet, or vision transformers such as ViT, trained using softmax-based loss functions such as ArcFace.


## Face verification
Once the feature vector that describes a face is computed, a face verification step finds the closest face descriptor in a database and checks if they are similar enough. Traditionally, this is achieved by computing a distance metric between the target vector and each face descriptor in the database. However, this can be prohibitively expensive, so faster methods such as ANN or Approximate Nearest Neighbors are used for databases with millions of individual face descriptors. 

Regardless of the approach, a distance metric is commonly used to compare the target, and registered face descriptors. There are several distance metrics including euclidean distance, cosine distance, or Mahalanobis distance. One of the most simple, the euclidean distance, calculates the distance between two vectors as the square root of the sum of the squared differences between their elements.

# Popular face recognition algorithms
We have already seen the typical steps in a face recognition pipeline. From Haar cascades to deep neural networks, face recognition can be implemented using a wide range of algorithms. In this section we will describe two popular algorithms in a face recognition pipeline: RetinaFace and ArcFace. These algorithms leverage the power of deep networks to provide robust and reliable face detection and recognition, enabling face recognition in real world scenarios such as access control.

## RetinaFace 
RetinaFace is a popular face detection algorithm that follows a convolutional architecture to locate faces in images. The main characteristics of RetinaFace are: 1) Using a single stage to perform detection. 2) Computing multi-scale information using a feature pyramid network. 3) Taking advantage of a context module to enlarge the receptive field used to perform a detection. 4) Learning different tasks at the same time to improve the face detection performance. Figure 2 describes the RetinaFace architecture.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/face-recognition/retinaface.png" alt='RetinaFace architecture' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 2. </span> RetinaFace architecture. RetinaFace uses a single-stage methodology where a multi-task objective is learned. For each face detection, the network computes a face score, the face box, five facial landmarks, and 3D vertices used to generate a face reconstruction. </figcaption>
</figure>

One desirable trait of every face detector is inference speed. In order to maximize this speed, RetinaFace follows a single-stage approach to perform detection. Unlike proposal-refinement networks, RetinaFace extracts information directly from the early convolutional layers of a classification network like ResNet. This information is used to compute the face anchors using a convolutional detection module.

Another key feature of RetinaFace is the use of a feature pyramid network to extract multi-scale features. Detecting faces at different scales is a basic feature of every detector, however, instead of creating an image pyramid and analyzing each scaled image independently, RetinaFace builds a feature pyramid. This feature pyramid adds strong visual information to every intermediate output of a convolutional network to improve the trade-off between scale, and semantic information.

Additionally, in order to maximize the detection robustness, RetinaFace includes a context module to enlarge the effective receptive field used in each detection. By performing multiple sequential convolutions before the detection module, RetinaNet increases the effective receptive field used to compute the bounding boxes.

Finally, RetinaFace also takes advantage of multi-task learning to improve the face detection performance. Instead of just computing the bounding boxes, RetinaNet has four different outputs. The main two outputs are the face bounding boxes, and the face score. However, RetinaFace is also trained to locate 5 facial landmarks, and to recreate the appearance of the located face. This approach allows the algorithm to learn shared representations, improving the robustness of the learned features and, in turn, increasing the face detection performance. Additionally, the regressed face landmarks can be used to align the face patch so that the recognition performance is optimal.

## ArcFace
ArcFace is a face recognition algorithm that uses a deep convolutional neural network to generate highly discriminative face descriptors. Specifically, ArcFace is a loss function engineered to improve the performance of face identity classifiers by enhancing the separation between different face identities in the feature space. The main idea is to train a classification network, such as a ResNet, to classify the identity of each face while having a margin between each identity embedding.

The ArcFace loss is based on the softmax loss, which is commonly used in many deep learning applications, specially in classification applications. However, unlike the softmax loss, which encourages the features of each class to be well separated from each other in the feature space, the ArcFace loss additionally enforces an angular margin between the features of different classes.

This is achieved by modifying how the softmax loss is computed. The softmax loss receives the result of dot multiplying each weight and intermediate variable vectors. Instead of just performing this multiplication, the dot product is rewritten as multiplying the magnitude of both vector times its cosine. Now, if we add a margin to the angle of the specific class we are targeting when computing the loss, the vectors of this class should be separated from the rest by the desired margin. Figure 3 shows how different loss functions enforce different decision margins.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/face-recognition/decision-margins.png" alt='Arcface decision margin' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 3. </span> Different decision margins. Loss functions like ArcFace enforce a separation between the embeddings of different classes. </figcaption>
</figure>

By introducing the angular margin, the ArcFace loss effectively pulls the features of the same class closer together and pushes the features of different classes farther apart, resulting in a more discriminative feature space that improves the accuracy of face recognition. Additionally, the margin can be adjusted to control the degree of inter-class separability, allowing the algorithm to adapt to different levels of classification difficulty.


# Scaling face recognition applications
We have described a face recognition pipeline using RetinaFace for face detection and alignment, and a convolutional classifier trained using ArcFace for face representation. However, as face recognition systems become more prevalent, the need for scalable architectures that can handle large volumes of transactions in real-time becomes increasingly important. Designing a real-world face recognition system requires more than simply deploying a couple of convolutional networks, we need to optimize specific requirements such as latency, throughput, or memory usage. In this section, we will address some key aspects of scaling face recognition applications. First, we address the need to run the face detection and representation networks in real time. Second, we show some strategies to handle training and inference when dealing with millions of face identities.

First things first, how can we scale the detection and representation steps? Well, the main issue with these steps is processing speed, so we can take advantage of cluster technologies such as Kubernetes, Ray, or your cloud provider autoscaler to scale inference workers horizontally. Cluster frameworks such as Kubernetes have gained a lot of popularity for making deployments highly scalable, available, and portable across different infrastructures. However, while Kubernetes is certainly quite powerful it is also resource-intensive and complex to set up and manage. On the other hand, frameworks like Ray have been specifically designed to simplify scaling machine learning workloads. Creating a Ray cluster is as simple as creating a 50-100 line YAML file describing the workers. Ray does not require you to explicitly create deployments, services, or configmaps like Kubernetes, you just define your worker requirements and that's it. Additionally, we can decorate our inference code with 
```python 
@serve.deployment(ray_actor_options={"num_cpus": 0.2, "num_gpus": 0}) 
``` 
to deploy it to the Ray cluster we have just defined. The min_workers and max_workers options, and the hardware requirements of your inference code will determine how your cluster autoscales; you don’t need to define complex pod or cluster autoscaling strategies.

Another key aspect of scaling a face recognition system is managing the storage, retrieval, and matching of face embeddings. For applications dealing with millions of individual identities, this becomes an important issue, since the trivial approach of storing every target embedding in memory, and trying to compute the distance metric across the whole database is too resource intensive. Luckily, we can use search engines like Elasticsearch to efficiently store and compute distance metrics at scale. Following this approach, we have two main options: 1) Computing the similarity metric for all entries by taking advantage of Elasticsearch script queries. 2) Using the KNN search option to run an approximate nearest neighbor search. When our database of individual identities is large enough, running approximate nearest neighbor searches ensures that our queries run efficiently. However, this ANN search may not always return the true K nearest neighbors, which makes scalability a trade off between matching speed, and accuracy.

# Conclusion
Face recognition is a complex technology that encapsulates detection, alignment, representation, and matching algorithms. In this blog post we have described these typical steps of a face recognition pipeline, and we have explained popular algorithms that cover the most relevant stages. As we conclude our discussion on face recognition technology, it's clear that it has the potential to become an instrumental technology in many aspects of our daily lives. On one hand, recent advances in machine learning algorithms have made it possible to detect and match faces with human-like performance. On the other hand, scaling technologies have democratized the deployment of face recognition systems at a massive scale.

Ultimately, the future of face recognition technology will depend on how it's developed and implemented. By not only pushing the performance and scalability of face recognition systems, but also keeping ethical considerations at the forefront, we can harness the potential of this technology to create a better world for everyone.


Face recognition is one of those technologies that have been around for a couple of decades now, but has been heavily revolutionized by recent developments in AI. In this blog post, we'll describe how face recognition works, showing specific methods that are commonly used in the industry.

How does face recognition work?


Artificial intelligence is a revolutionary technology that is disrupting the way we work, live, and interact with each other. However, the increasing complexity of AI systems makes them opaque and hard to reason about. Traditionally, it was enough for AI practitioners to test the reliability of machine learning models by building evaluation datasets, defining some metrics, and computing those metrics over the evaluation sets. However, many users don’t simply trust these metrics, and need a deeper insight on how the models are computing the results. This is how the field of explainable AI or XAI was born.

In this post we will introduce the concept of explainable AI, show different types of explainable AI, and describe some popular algorithms such as Grad-CAM, LIME or SHAP.




{/* <figure className='mt-8 mb-4'>
  <div className='relative h-80'><Image src="/assets/posts/explainable-ai/dog-grad-cam.png" alt='Grad-CAM example' fill className="object-contain"  /></div>
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure N. </span> Class attention map for the class “Dog”.</figcaption>
</figure>

<figure className='mt-8 mb-4'>
  <div className='relative h-80'><Image src="/assets/posts/explainable-ai/husky-explanation.png" alt='Grad-CAM example' fill className="object-contain"  /></div>
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure N. </span> Class attention map for the class “Dog”.</figcaption>
</figure> */}

# What is explainable AI?
Explainable AI, or XAI, is an umbrella term for a set of methods that try to show explicitly why a machine learning model is producing specific results. As AI algorithms become more powerful, they also become more opaque. This opacity is what led researchers to coin the term “black-box”, referring to models where it is hard to understand why they came up with certain results. Figure 1 shows a chart illustrating the typical accuracy-interpretability tradeoff.

Black-box models are hard to apply in some fields, like medicine or finance, where human oversight is often required. However, for this oversight to be effective, users should have tools to verify the model’s outputs. Users should be able to see why a loan was approved or why a treatment was selected. This is  one of the main reasons why the field of explainable AI gained popularity after the rise of black-box deep learning models.

However, the term “explainable AI” does not only apply to black box models, as it is a broad field without a fully consolidated scope. For instance, the term “explainable” is often associated with post-processing algorithms that analyze a black-box model. While, on the other hand, an “interpretable” model usually means that the model itself can provide some sort of explanation.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/explainable-ai/accuracy-interpretability.png" alt='Accuracy-interpretability tradeoff' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 1. </span> Accuracy-interpretability tradeoff.</figcaption>
</figure>

Thanks to explainable AI algorithms, we can find hidden biases in the way models operate and better characterize their outputs. Explainable AI algorithms are a fundamental tool for organizations who suspect that a model may be computing misleading predictions, and want to build confidence before pushing it to a production environment.

# Why does explainable AI matter?
Explainability and interpretability is crucial in AI because it allows humans to understand and trust the decisions made by intelligent systems. Without proper understanding, users will often mistrust, or even fear AI.

In some critical applications of AI, such as credit scoring in the U.S., explainability is not only important, but necessary. Creditors are required to notify customers of the specific reasons for denying a credit application. Another example is the use of personal information to perform automatic inferences in Europe; here, users have the right to get an explanation of the decision reached using automated systems that use personal information and produce effects that significantly affect them.

While regulatory requirements are a good reason to pursue AI explainability, they are not the only good reason. For instance, an AI model may recommend a treatment plan for a patient, and the doctor may not agree with that plan. At first sight, this may look like an error in the machine learning model, however, if we include some sort of explanation for why the model is recommending that treatment plan, the doctor may be able to identify some variable he overlooked and finally agree with the model.

Explainability also helps identify and address biases in AI systems. If an AI system is making decisions based on biased data or algorithms, explainability can help identify where those biases are coming from and how to address them. This is important because biased AI can perpetuate and even amplify existing inequalities.

# Explainable AI taxonomy
AI explainability is a somewhat vague term that is used to group different techniques aimed at increasing the trust users have on machine learning models. In order to better understand the wide spectrum of the explainable AI field, this section will show the different types of AI explainability techniques. These techniques will be categorized following four different criteria: 1) Intrinsic or post hoc. 2) Model specific or agnostic. 3) Local or global explanation. 4) Explanation results.

## Intrinsic or post hoc
Some machine learning models have intrinsic properties that make them interpretable. Two popular examples are linear models and decision trees. Each of the feature weights in a linear model can be interpreted as the importance of that feature. On the other hand, the average information gain for all the nodes using a specific feature in a decision tree, can be used as a feature importance indicator.

However, most machine learning models do not have an explicit way of indicating the importance of each feature. For these models, we need to use a separate algorithm that computes explanations based on the way the model behaves.

## Model-specific or agnostic
Some explainability techniques can be applied to any machine learning model, whereas others can only be applied to specific models.

A popular example of model-specific explainability algorithms is Grad-CAM, which uses the activation maps of convolutional layers to provide visual explanations. If a model doesn’t have convolutional layers, or the convolutional network does not have a specific structure, Grad-CAM can’t be applied effectively.

On the other hand, algorithms such as LIME or SHAP can be applied to any machine learning model. These algorithms treat the machine learning model as a black box, and play with the input samples and model results to compute explanations.

## Sample or model centered

Some explainability techniques are aimed at identifying why the model computed a specific result for a sample. For instance, Grad-CAM computes activation maps for a specific sample after running this sample through the convolutional network.

On the other hand, other explainability techniques try to explain how the model operates in general. SHAP is a good example of this approach, which tries to determine the importance of each feature using Shapley values.
## Explanation results
Explainability techniques produce different sorts of explanations. Some techniques compute feature summaries, such as a single number for each feature indicating its importance. Other techniques rely on extracting the internal information of specific models, such as the feature weights of a linear model. Another popular example is to use a simpler, interpretable, model to approximate the results of the black-box model; these simpler models are usually called surrogates.


# Examples of explainable AI
We have already seen the wide variety of explainable AI techniques, however, during the last years a few algorithms have stood out. Methods such as SHAP have gained a lot of traction thanks to their applicability, whereas traditional interpretability techniques such as inspecting decision trees have stood the test of time. In this section we will give a brief introduction to some popular explainable AI algorithms.

## Decision trees
Decision trees are a popular machine learning model for non-linear data. Tree models split the data iteratively in a tree-like structure. In this tree, each node represents a decision where a cutoff value for a certain feature splits a set of samples into two subgroups. The selected feature and cutoff value for each node is chosen to maximize the information gain between this node and its children. Specifically, we compute the entropy of the parent, and child nodes, weighted by how many samples reached them, and try to maximize the entropy gain using the following equation.

<div className='my-6 md:my-8 text-xs md:text-base'>
$$
IG = E(parent) - \sum w_i E(child_i)
$$
</div>

The good thing about this approach is that we can use this information gain as an indicator of the feature importance. However, depending on how we build the tree, the same feature may be used more than once. Because of this, when computing the importance of a certain feature, we have to check all nodes using this feature and weight the information gain of each node using the fraction of samples that reached it.


## Grad-CAM
The topic of explainability started gaining importance with the rise of convolutional networks. These convolutional networks are capable of achieving astounding results, however, with this increased capability, comes an increased model opacity. To help users debug convolutional networks, the Gradient-weighted Class Activation Maps (Grad-CAM) method was created.

Grad-CAM produces visual explanations from any convolutional classification model. In summary, this method has the following steps: 1) Find the last convolutional layer of the model you want to inspect. 2) Run an image through the convolutional network to get a prediction. 3) Get the activations of the last convolutional layer. 4) Get the gradients of the model output with regard to the last convolutional layer. 5) Average the gradients so that we have one value for each convolutional filter. 6) Sum the last convolutional activations weighted by averaged gradients.

The intuitive explanation is that the last convolutional layer should highlight the areas of the image that are important for the output of the model. Also, when a specific filter of the last convolutional layer changes a bit, but the output of the model changes a lot, this means that this specific filter is important for the model output; in other words, the gradient of the output with respect to this filter is large. This way, we can “select” the activations of the last convolutional filter using this gradient information. Figure 2 shows an example Grad-CAM visualization.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/explainable-ai/dog-grad-cam.png" alt='Grad-CAM visualization' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 2. </span> Class attention map for the class “Dog”.</figcaption>
</figure>

## LIME
Another popular algorithm to generate explanations is LIME, or Local Interpretable Model-agnostic Explanations. LIME is a model-agnostic algorithm, meaning that it does not impose specific requirements on the model it explains. This is different from Grad-CAM, which required the model to have one last convolutional layer just before computing the final outputs.

LIME works by generating random samples around the sample we want explanations for, and checking how the model behaves on these new random samples. The “Local Interpretable” part of LIME means that it will try to build an interpretable model, such as a linear regression model, using these local samples. For instance, in the case of images, LIME starts by dividing the input image in superpixels, and generates variations of this image by randomly turning off some superpixels. Then, LIME builds a linear model fitting the presence or absence of these superpixels to the output of the black box model, and generates superpixel visualizations based on the fitted linear coefficients. Figure 3 shows a LIME explanation.

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/explainable-ai/husky-explanation.png" alt='LIME visualization' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 3. </span> LIME explanation for a biased classifier. The model used the snow to infer the “Husky” class.</figcaption>
</figure>


## SHAP
While LIME is usually targeted at getting local explanations for specific samples, SHAP is better suited to compute both global and local explanations.

SHAP is an explainable AI algorithm inspired by Shapley values, a game theory method that tries to distribute the “payout” between different players. These players can be interpreted as features, in the context of machine learning algorithms.


The  general idea is to compare the output of the model for a given sample, and the same sample with a feature withheld. This is evaluated for all feature combinations, in order to take into account how different features “cooperate” to achieve specific results. Finally, the feature contributions across all combinations are averaged, and we end up with the contribution of each feature for a specific result. This process is summarized in the following equation.

<div className='my-6 md:my-8 text-xs md:text-base'>
$$
\phi_i =\sum_{S\subseteq F \backslash \{i\}}\frac{|S|!(|F|-|S|-1)!}{|F|!}(f(x_{S\cup\{i\}})-f(x_{S})
$$
</div>

The problem with SHAP is that it samples every possible feature combination. If a model only operates using 4 features, SHAP only has to sample 64 coalitions. However, with just 30 features we would have to evaluate the model on millions of samples. Because of this, the authors have created specific versions such as KernelSHAP or TreeSHAP that try to minimize the computational burden.

KernelSHAP is still a model agnostic approximation, but it uses a linear model to approximate a subset of all possible coalitions. This approach is quite similar to LIME, however, the contribution of each sample is weighted differently. In LIME, the weight was computed according to the distance between the target sample, and the newly generated sample. In SHAP, the weight is computed according to the number of features used. In fact, according to the authors “If you use the Shapley kernel we proposed as LIME's local kernel then the linear LIME method will produce estimates of SHAP values”. The following figure shows the result of explaining a XGBoost regressor trained on the Boston dataset. 

<figure className='mt-8 mb-4'>
  <Image src="/assets/posts/explainable-ai/shap.png" alt='SHAP visualization' width='896' height='0' className="w-full h-auto" />
  <figcaption className='text-gray-800 mt-1 text-sm'> <span className='font-medium'> Figure 4. </span> SHAP explanation for a XGBoost model trained on the Boston dataset.</figcaption>
</figure>

# Conclusion
Explainable AI is an increasingly critical aspect of the machine learning lifecycle. As AI continues to play an ever-growing role in our lives, it is essential that we can understand the decisions made by these systems. By making AI models more transparent and interpretable, we can increase trust in their decisions and help ensure that they are making fair and ethical choices.

In this post we gave an overview of AI explainability, introducing the concept of model explainability, presenting a wide overview of the AI explainability landscape, and showing specific examples of commonly used techniques.

As AI continues to become more pervasive in society, it is clear that explainability will become a critical factor. By prioritizing AI explainability, we can build trustworthy systems that help us make reliable decisions.


The increasing complexity of AI systems makes them opaque and hard to reason about. Some practitioners no longer solely rely on the typical metrics and need a deeper insight on how the models are computing the results. In this post we will introduce the concept of explainable AI, show different types of explainable AI, and describe some popular algorithms such as Grad-CAM, LIME or SHAP.

A brief introduction to explainable AI


Today, machine learning can be run on almost any device. However, when it comes to training neural networks, the hardware you choose will significantly condition the necessary financial outlay, and the time it will take for the network to learn.

There are two major options when choosing hardware to train convolutional networks. On the one hand, you can use services like AWS, Azure, or Google Cloud. These services allow you to create a custom server, configuring the amount of RAM, how many CPUs you want, or what graphics card (GPU) you need. However, if you have ever calculated how much these services cost, you will have seen that they are not cheap, being able to pay almost €300 to use a server with a GPU for 24 hours. There are ways to reduce the cost of these services, such as using preemptible servers. This is not a perfect solution, since the service provider reserves the right to shut down the server if it needs to use that hardware, this makes you have to create fault-tolerant software, reducing the hardware cost on the one hand, but increasing the cost. of the software.

An alternative to using cloud services is to buy your own PC, specifically configured for machine learning. This will mean significant economic savings, since cloud services use server graphics cards that are significantly more expensive, and offer a series of services such as high availability, which do not benefit you much when training convolutional networks. . In addition, the use of your own PC will facilitate the development of software, since you will work with the data locally, and you will be able to see graphic information more easily.

In this article we explain what components you should buy to train your own models while saving money. We will choose every part of the PC without considering preconfigured computers that are usually more expensive, and the goal will be to achieve high performance using consumer hardware. All this with a budget of €3000.

The good news is that a PC only has 8 components that we must choose from. These components are GPU, CPU, RAM, hard drive, motherboard, power supply, cooling, and case.

## Graphics card or GPU

The GPU is the component that will do most of the heavy computation when you train a convolutional network. Primarily, these calculations include convolutions, matrix multiplications, and activation functions.

The GPU you choose must meet three fundamental requirements. First of all, it must have enough memory to store all the information used during the training. This information includes how much each of the neural network parameters (connection weights, convolution filter values...) contributes to the analysis error. In this way, thanks to having this information stored, the training process can tune the variables of the neural network so that it works a little better in each training cycle. The second requirement is processing speed, which is typically correlated to the amount of memory the GPU includes. The processing speed determines the number of images to be processed per second. This way, a faster GPU will take less time to train, allowing you to do more experiments and increasing your productivity. Finally, deep learning libraries such as PyTorch or TensorFlow use CUDA, a framework developed by NVIDIA to perform parallel computing on graphics cards, so the graphics card you buy must be from this brand to ensure maximum compatibility.

Every two years, NVIDIA releases a series of GPUs, with the 20 series being the current family of graphics cards. Within this series, the model with the fastest memory and processing speed is the 2080 Ti with 13.45 TFLOPs (trillion operations per second) and 11 GB of GDDR6 memory. Its price is approximately €1300.

Being the most important component when it comes to training convolutional networks, this article could be extended a lot if it included graphics card comparisons. For this reason, I recommend that you pay attention to the following blog entry, where different GPUs are compared based on their performance and price.


## CPU

During the training of neural networks, one of the most important functions of the CPU is to execute all the operations of the data "path" that goes from reading data on the hard disk, to moving the data to the GPU for for the convolutional network operations to be executed.

The CPU plays a key role in the training of deep learning architectures since, in many cases, it is in charge of decoding, normalizing, and performing other preprocessing techniques. This way, if the CPU is not fast enough, it will take time for data to reach the GPU, making the graphics card idle while it waits for data, and slowing down training.

The importance of the CPU increases if it is necessary to preprocess the data in each training iteration. A solution that is often used, especially when the computer does not have enough RAM to store the entire data set, is to read the data from the hard drive at each training iteration. This increases the workload of the CPU, since before executing the convolutional network the processor must convert the data to the corresponding format. If you have programmed your network with Keras, you can use the tf.data.Dataset API to optimize the data path. This API allows you to load data with the CPU while executing a convolutional network with the GPU, or parallelize the execution of preprocessing algorithms. On the other hand, TensorFlow and PyTorch use vector operations like SSE or AVX, so you must have a compatible CPU to get the most out of these libraries.

In terms of brands, the leading manufacturer in market share is Intel. This brand releases a generation of new CPUs every year, and they are currently on generation 10. Each generation has 3 main models called i3, i5, and i7 ordered from lowest to highest performance respectively. You must also be careful since each model has variants, for example, some variants of the i7 processor are i7-10700, which does not allow changing the clock frequency, and i7-10700k that does allow it. The i7-10700k processor is priced at around €440, which leaves us with a total of €1740 so far.


## RAM

RAM memory is a component that you should also choose taking into account what type of model you want to train. In many cases you will find yourself with a simple model, and a small data set, which allows you to load everything into RAM. Storing all data in RAM will, in many cases, result in a reduction in the amount of time spent training, as fewer data preprocessing operations will be performed.

However, the aforementioned consumer processors have a relatively low limit on the amount of RAM they can use. Depending on the chosen processor specifications, we could not use more than 128GB of RAM on our computer. Also, if we combine this with the fact that the price of DDR4 RAM memory is above €5 per GB, you could spend a significant amount of money so that, in many cases, you have excess memory, and in other cases you lack , but is mitigated by using TensorFlow to optimize the data path.

A reasonable decision is to keep the amount of RAM in the 32-64GB range so that the price of the PC does not skyrocket (even more). For this configuration, we will use 2 16GB sticks of the Corsair Vengeance LPX DDR4 3200 model. This means an additional €170, making a total of €1,910.


## HDD

The hard drive is used to save training data. Traditionally, the most frequently checked metric on hard drives was their storage capacity. This changed with the advent of solid-state hard drives, which greatly increase the speed of reading and writing data.

When you train machine learning algorithms, you have to take those two metrics into account. On the one hand, the hard drive must have enough capacity to store all the training data. But on the other hand you want to have a hard drive with a read speed fast enough to keep the GPU busy all the time. Also, you must take into account that in some cases you will use the TFRecord format to save data, which means an increase in the space occupied by the data, not only because they are duplicated, but also because you will be saving the data directly in matrix form. Finally, you have to check the speed of the hard drive you want to buy, although M.2 hard drives have grown in popularity, the fact of having an M.2 format is not synonymous with speed. Read speeds range from around 400MB/s to nearly 2.5GB/s, surpassing the access speed of first-generation DDR RAM.

In this PC we will use the Samsung 970 EVO Plus (1TB) model, which has an approximate price of €250. Thus we add €2160.


## Motherboard

The motherboard is the component to which you connect the CPU, GPU, and RAM so that they work together. It must be Intel 10 series compatible, have a PCI express x16 slot to plug the GPU into, and run on DDR4 RAM.

Something to keep in mind is that although a PCI express slot is physically x16, inside it may be working as x8, or even 4x. This means a lower speed in data transfer and can penalize the training time, for this reason you must be careful when choosing a motherboard, and read the manufacturer's specifications well. The PCI express configuration becomes more important when you want to use multiple graphics cards, since it is more common for the second x16 slot on a motherboard to run at a slower speed.

For this PC we have chosen MSI's MPG Z490 Gaming Plus motherboard. This motherboard ticks all the boxes, uses Intel's 10-series compatible Z490 chipset, has one x16 slot working in x16 mode (although the second x16 slot works in x4 mode), and has 4 slots for DDR4 RAM. This motherboard costs €190, totaling €2,350 so far.


## Power supply


The power supply is responsible for providing current to the different components of the computer. The main characteristics are the output watts, the efficiency, and the number of connectors.

First of all, you must choose a source that is capable of powering all the components. The chosen GPU consumes 300W according to the manufacturer's specifications, all other components combined are in the 250-300W range. This means that you must assume a consumption of 600W, but it does not mean that you can buy a 600W source, you still have to count the efficiency, and verify that the chosen source has enough connectors to power everything.

The efficiency of the power supplies is marked with the distinctive “80 Plus” and the White, Bronze, Silver, Gold, Platinum, and Titanium variants. The efficiency of the 80 Plus sources goes from 82%, for the White models, to 94% for the Titanium. If you put yourself in the worst case, an efficiency just above 80%, the calculation results in a source of 600W/80%=750W.

Finally, not all 750W power supplies will have a sufficient number of connectors to power the equipment. The critical point of this PC is the GPU, which needs 3 PCIe connectors (6+2).

One source that ticks all the boxes is Corsair's TX750M. It offers 750W, has 4 PCIe connectors, and has an efficiency of the 80 Plus Gold type. This source costs €120, and puts the PC at €2470.


## Refrigeration


When the CPU starts pre-processing the data, its temperature will start to rise. In case the temperature exceeds 90ºC, its speed will be automatically reduced to allow it to cool down and prevent damage.

CPUs usually come with a small fan. This fan is aimed at users who will not leave the PC working for several hours in a row. However, if you train your network on a PC with this fan, it could get hot enough to reduce performance. If CPU performance drops, it could end up becoming a bottleneck, resulting in an underutilized graphics card, and lengthening training time.

An alternative is third-party heatsinks, or liquid cooling kits. These components offer higher CPU cooling performance, and make less noise. Also, if you want to overclock, a liquid cooling kit will allow you to push the performance a bit further.

For this PC we have chosen Corsair's Hydro H100x liquid cooling kit. This kit has an approximate price of €90, adding a total of €2580.


## Case


The case will store the different components of the PC. The main requirement of the case is its size, it must be compatible with the ATX motherboard format, it must be long enough to fit the graphics card, and it must have a hole for the radiator and fans. As an end user, you can also choose whether you want it to have a side window, front ports, or even sound deadening panels.

In this article we have chosen the Corsair Carbide 275Q model, it has enough space for the GPU and ventilation, in addition to having acoustic panels that will reduce the noise of the PC by a couple of decibels. This box costs €85, which means a total of 2645.




## What models can you train with this PC?
The hardware we have chosen will be enough to train most networks. You will be able to train classification networks like ResNet or Xception, segmentation networks like U-Net or DeepLab, and location networks like YOLO. In general, you will be able to use "minibatches" of images up to 512x512 pixels, from this size there will come a time when not even an image will fit in the GPU memory, because all the intermediate results of the processing are saved to correct the error. Still, there will be many networks that you can train for images close to 512x512 in size, for this you will need to use a reduced batch size, and make some small adjustments, such as replacing batch normalization with batch renormalization.

There will also be problems that you cannot deal with this PC. For example, you won't be able to train a Transformer architecture from scratch, due to the large amount of data that is typically used. According to current records, to train BERT in one hour you would need 1472 NVIDIA V100 GPUs. Still, you can download a pretrained model and refine it with your dataset.








In this article we explain what components you should buy to train your own models while saving money. We will choose every part of the PC without considering preconfigured computers that are usually more expensive.

Frequently asked questions