## Introduction
When evaluating the performance of a machine learning model, it is often useful to have a visual representation of the results. 

In some cases, you may want to produce a small report that includes multiple plots arranged in a matrix format, without having to manually arrange the plots or interact with the user interface.

To address this need, the following function provides a convenient solution for plotting a matrix of subplots using the data from a pandas DataFrame. 

The function allows you to easily arrange the plots in a matrix format, without having to worry about configuring the plot or interacting with the user interface.

This function offers a simple and efficient way to produce a small visual report of the performance of a machine learning model, allowing you to focus on analyzing the results and making informed decisions, rather than spending time on manual plot arrangement and user interface interactions.

![Multiple Subplots Matplotlib](/images/articles/en/technology/multiple-subplots-matplotlib/1.jpg)
<div class="imgDescription">Folder with 4 images.</div>

## Code
```python
import datetime
import os
from matplotlib import pyplot as plt
from PIL import Image

def create_multiple_subplots(df, images_path):
    """
    Creating multiple subplots with matplotlib
    :param df: dataframe [image, probability, class]
    :param images_path: local path of the images (example: 'input/images')
    :return: None, show and save the plot
    """
    date_now_str = datetime.datetime.now().strftime('%Y.%m.%d')
    total_images = len(df)
    total_root = int(math.sqrt(total_images))
    root_power = total_root ** 2
    root_rest = total_images - root_power
    cols= total_root
    rows = total_root
    if 0 < root_rest <= total_root:
        cols = cols + 1
    fig, axs = plt.subplots(ncols=cols, nrows=rows, figsize=(7, 9), constrained_layout=True)
    image_index = 0
    for i in range(rows):
        for j in range(cols):
            ax = axs[i, j]
            if image_index < total_images:
                print(image_index)
                img = Image.open(os.path.join(images_path, df['image'].iloc[image_index]))
                ax.set_title(df['class'].iloc[image_index] + '\n' + float_to_str(df['probability'].iloc[image_index]))
                ax.imshow(img)
            else:
                ax.set_title('Empty\n' + '[' + str(i) + ', ' + str(j) + ']')
                img = Image.open(os.path.join(images_path, df['image'].iloc[0]))
                width, height = img.size
                blank_img = Image.new('RGB', (width, height), (255, 255, 255))
                ax.imshow(blank_img)
            image_index += 1
    fig.suptitle(date_now_str, fontsize=14)
    plt.show()
    fig.savefig('/test-results-' + date_now_str + '.jpg')
```

![Multiple Subplots plt](/images/articles/en/technology/multiple-subplots-matplotlib/2.jpg)
<div class="imgDescription">Folder with 5 images.</div>

## Explanation
This code defines a function "create_multiple_subplots" which generates multiple subplots using the Matplotlib library and saves it as an image file.

The function takes two arguments:

* df: a pandas DataFrame containing three columns 'image', 'probability', and 'class'.
* images_path: a local path to the images.

The first section of the code imports the necessary libraries, including datetime for working with dates, 'os' for interacting with the file system, pyplot from matplotlib for plotting the subplots, and Image from 'PIL' for working with image files.

![Multiple Subplots](/images/articles/en/technology/multiple-subplots-matplotlib/3.jpg)
<div class="imgDescription">Folder with 17 images.</div>

The function starts by generating a date string to use as the title of the plot. Then, it calculates the number of images to be plotted, the number of columns and rows needed to arrange the subplots, and sets up the subplots using the 'subplots' function from 'matplotlib'.

Next, the function loops through each row and column of the subplots and adds a plot to each subplot. If there are fewer images than subplots, it will add empty subplots to fill the remaining spaces. 

For each subplot, the function opens the corresponding image from the 'images_path' using the 'Image.open' method, sets the title of the subplot using the values from the df DataFrame, and adds the image to the subplot using the 'imshow' method.

After adding all the subplots, the function sets the title of the whole plot using the generated date string and shows the plot using the 'show' method. Finally, the function saves the plot as an image file in the local file system.

![Multiple Subplots](/images/articles/en/technology/multiple-subplots-matplotlib/4.jpg)
<div class="imgDescription">Folder with 29 images.</div>

<hr>

# Summary
Creating multiple subplots with Matplotlib can be useful in computer vision projects when you want to visually compare or inspect multiple images or visualizations side by side. 

It allows you to arrange multiple images or plots in a matrix form and provides a compact way to display a large number of images or plots in a single figure.

For example, in a machine learning project, you may want to visualize the results of a model's predictions on a test dataset. By using multiple subplots, you can display multiple images with their predicted class labels and confidence scores in a single figure. 

This can help you quickly inspect the performance of the model, identify any errors or mistakes in the predictions, and make adjustments to the model if necessary.

In general, using multiple subplots allows you to visually compare and analyze different aspects of the data in a compact and organized manner, making it an important tool for data exploration and analysis in computer vision projects.

<hr>

### References
1. <a href="https://matplotlib.org/devdocs/tutorials/intermediate/arranging_axes.html#sphx-glr-tutorials-intermediate-arranging-axes-py" target="_blank" rel="noopener">Arranging multiple Axes in a Figure - matplotlib.org</a>

How to create matplotlib plot with multiple columns and rows in one plot (matrix shape).

Creating Multiple Subplots With Matplotlib Python

## How to Generate Requirements.txt File
In the following steps, I'll guide you through the process of generate a requirements file using the terminal. 

Firstly, simply follow the instructions and I will then provide a more in-depth explanation of each step.

---

**Terminal**
<br>
At the bottom of PyCharm, click the Terminal tab (venv must be activate).
![requirements](/images/articles/en/technology/requirements-txt-pycharm/1.png)

**pip**

For Python 3:
```shell
pip3 freeze > requirements.txt
```

For Python 2:
```shell
pip freeze > requirements.txt
```

**Result**
![requirements](/images/articles/en/technology/requirements-txt-pycharm/2.png)

<hr>

## Install dependencies from requirements.txt

If you open a project where the required libraries are not installed, the following window will appear:<br>
![PyCharm Virtual Enviromaent](/images/articles/en/technology/requirements-txt-pycharm/3.png)

You can observe the installation process in the bottom right corner.
![requirements](/images/articles/en/technology/requirements-txt-pycharm/4.png)

<b>OR</b>

In case you did not encounter the window, you can carry out the same operation using the terminal.
Ensure that you are within the virtual environment (venv) in the terminal before executing the following command:
```shell
pip install -r requirements.txt
```

<hr>

## Why?
Think of the "requirements.txt" as a shopping list for your Python project. 
Just like you would write down a list of items you need to buy at the grocery store, 
you use the requirements file to list all the software components that your Python project needs to run properly.

The requirements file is like a map for your project, showing exactly what tools and components are needed, and in what version. 
This is important because different versions of a software component can work differently, 
and you want to make sure your project is using the right version.

The requirements file also makes it easier to share your project with others. If you want to share your project with someone else, all they need is the "requirements.txt" file, and they can easily set up the same environment you used to develop the project.

<hr>

## The terminal
In PyCharm, the terminal can be opened by clicking the "Terminal" button in the bottom-right corner of the window. Once the terminal is open, you can interact with it just as you would with a regular terminal window.

The terminal in PyCharm is a feature that allows you to access the command line interface of your operating system directly from within the PyCharm development environment. This allows you to perform various tasks, such as running command-line scripts and installing packages, without leaving the PyCharm environment.

Some common tasks that can be performed in the PyCharm terminal include creating and activating virtual environments, installing packages, running command-line scripts, and accessing the file system.

![terminal](/images/articles/en/technology/requirements-txt-pycharm/5.png)

The advantage of using the terminal in PyCharm, or any other development environment, over visual processes in the Integrated Development Environment (IDE) is that terminal commands can be easily automated.

When you perform a task in the terminal, such as installing a package or running a script, you can save the commands used in a script or a Makefile. This script or Makefile can then be executed as needed, without having to manually perform the steps in the IDE every time.

This is particularly useful for tasks that need to be performed repeatedly, such as setting up a development environment or deploying an application. By automating these tasks, you can save time and reduce the risk of errors that can occur when performing tasks manually.


<hr>


## Virtual environment (venv)
Virtual environments are necessary in Python because they provide a way to isolate the packages and dependencies required by a specific project from the system-level Python installation. This allows you to manage dependencies and packages for each project independently, without having to worry about version conflicts or other compatibility issues.

You can ensure that your project has the exact same dependencies and versions of packages as when it was originally developed. This helps to ensure reproducibility when developing, testing, or deploying your code.

Virtual environments provide a convenient way to manage the packages installed for your project. This makes it easier to install, upgrade, or remove packages as needed, without affecting other projects on your system.

By using virtual environments, you can reduce the risk of security vulnerabilities caused by outdated or vulnerable packages. You can also avoid installing packages that you do not need, which can help to reduce the attack surface of your code.

<hr>


## requirements.txt

"requirements.txt" is a file used in Python to specify the dependencies for a project. It lists the required packages and their version numbers. Key points include:
* It is a plain text file that can be created using any text editor.
* The file should list one package per line, with the package name and version number separated by an equal sign.
* The version number can be specified in several ways, such as exact version (example: "package==1.0.0"), minimum version (example: "package>=1.0.0"), or range of versions.
* The "requirements.txt" file is a useful tool for sharing projects with others and for ensuring that the project will run on a different environment with the correct dependencies.

<hr>

## Dependencies
Dependencies refer to the packages or modules required by a Python project to run, 
They are the software components that a particular software program relies on to function properly.

These packages or modules are typically available from online repositories, such as the Python Package Index (PyPI), and can be easily installed using a package manager like pip. 
When a Python project requires a specific package, it lists that package as a dependency in a requirements file.

Dependencies are like helpers for your Python project. Think of them as extra tools or software components that your project needs in order to run properly. 

![Dependencies](/images/articles/en/technology/requirements-txt-pycharm/6.jpg)

By using dependencies in your project, you can save time and effort. For example, instead of writing all the code yourself, you can use code that others have already written. This can be especially helpful if you're working on a project that's similar to something someone else has already done.

Another advantage of using dependencies is that they can make your project more efficient. For instance, you can use code that's been tested and optimized by others, so you don't have to figure it all out yourself.

Finally, dependencies can give your project extra capabilities that you might not have had otherwise. For example, you might want to add a new feature to your project, and there might already be a dependency that provides that feature.

<hr>


## Summary
So, to sum it up, "requirements.txt", virtual environments, and dependencies are all important pieces of the puzzle when it comes to Python programming. 
They help you keep your projects organized, make it easier to work with others, and ensure that you have all the tools you need to get the job done.

<hr>


### References
1. <a href="https://stackoverflow.com/a/33468993" target="_blank" rel="noopener">Create requirements.txt - stackoverflow</a>

How to generate a requirements.txt file with PyCharm IDE to specify the dependencies for a Python project.

Python

Creating Multiple Subplots With Matplotlib Python

PyCharm Create requirements.txt File to manage Python Dependencies