• The Framework for Learning to Act
• Policy Optimization
  • Learning the Policy
  • Gradient Estimation via Score Function
• Vanilla Policy Gradient, aka REINFORCE
• Actor-Critic Methods
• References

Reinforcement learning (RL) (Sutton, 1998) is all about the interaction between an agent and its environment, where learning occurs through trial-and-error. The agent observes the current state of the environment, takes actions based on these observations, and influences new possible state configurations while receiving rewards based on its actions. The primary objective is to maximize cumulative rewards, which drives the agent's sequence of decisions towards achieving specific goals, such as escaping from a maze, winning an Atari (Mnih. 2013) , or defeating the world champion of Go (Silver, 2016). But how does the agent learn to act effectively to achieve its goal? RL algorithms are designed to maximize the total rewards obtained by the agent, thereby guiding its actions towards these objectives.

In this post, we will introduce the essential concepts of RL required to implement these agents. We will specifically focus on model-free RL, where the agent learns to act without constructing a model of its environment, as opposed to model-based RL, which involves such modeling. The goal is to design agents that learn to perform well solely by consuming experiences from their environment. By understanding the fundamentals of designing such agents, we will explore policy optimization methods, such as REINFORCE and PPO, which are used to refine the agent’s behavior.

With the knowledge gained from this chapter, we will be equipped to set-up and implement this framework under popular research environment such as ATARI pong.

The Framework for Learning to Act

The starting point for designing agents that learn to act is the Markov Decision Process (MDP) framework \cite{Sutton1998}. An MDP is a mathematical object that describes the interaction between the agent and the environment. This interaction is characterized by a tuple $⟨𝒮,𝒜,P,R,{\rho }_0,\gamma ⟩$, where:

• $𝒮$, state space, set of possible states in the environment.
• $𝒜$, action space, set of possible actions available to the agent.
• $P:𝒮\times 𝒜\to \mathrm{\Delta }(𝒮)$, transition probability distribution, which gives the probability of the environment for transitioning to a new state $s_{t+1}$ with a reward $r_t$ given the current state $s_t$ and action $a_t$.
• $R:𝒮\times 𝒜\to ℝ$, reward function, which provides a scalar feedback signal $r_t$ (aka reward) to the agent after taking an action $a_t$ and reaching the subsequent state $s_{t+1}$.
• ${\rho }_0$, initial state distribution, which determines the probability of the agent starting in a particular state.
• $\gamma \in [0,1]$ is the discount factor, which determines the importance of future rewards.

Markov Decision Processes generate sequences of state-action pairs, or trajectories $\tau$, starting from an initial state $s_0\sim {\rho }_0$. The agent's behavior is determined by a policy $\pi :𝒮\to \mathrm{\Delta }(𝒜)$, which maps states to a probability distribution over actions. An action $a_0\sim \pi (s_0)$ is chosen, leading to the next state $s_1$ according to the transition distribution $P$, and a reward $r_0=R(a_0,s_0)$ is received. This cycle repeats iteratively, with the agent selecting actions, transitioning through states, and receiving rewards, as shown on the left side of Figure 1. Thus, the trajectory $\tau$ encapsulates the dynamic sequence of state-action pairs resulting from the agent's interaction with its environment.

The process can continue indefinitely, known as an infinite horizon, or be confined to episodes that end in the terminal state $s_T$, referred to as episodic tasks, such as winning or losing a game, as illustrated on the right side of Figure 1. It is important to note that the transition to the next state depends only on the current state and action, not on the sequence of prior events. This characteristic is known as the Markov property, which states that the future and the past are conditionally independent, given the present (memoryless). In this work, we focus on the episodic setting, where the trajectory begins at $s_0$ and concludes at $s_T$, with a finite horizon $T$. Therefore, the trajectory $\tau$ is defined as $\tau =(s_0,a_0,\dots ,s_{T-1},a_{T-1},s_T)$, summarizing the agent's behavior throughout the episodic task.

In reinforcement learning, the primary goal is for the agent to develop a behavior that maximizes the expected return from its actions results within the environment. This concept of maximization is formalized through the objective function ${𝒥}_{\text{RL}}(\theta )$, which aims to maximize the expected return over a collection of trajectories $ {\tau^{(i)}}_{1:N} $ generated by the policy $\pi$, commonly referred to as "policy rollouts". The term "rollout" is used to describe the process of simulating the agent's behavior in the environment by executing the policy $\pi$ and observing the resulting trajectory $\tau$. The objective function is defined as follows:

The return over a trajectory $\tau$ is defined as the accumulated discounted rewards of the trajectory, $R(\tau )={\sum }_{t=0}^{T-1}{\gamma }^t{r}_t$. The reward signals $r_t$ are the inmmediate effect of taking the actions, and the return is the cumulative rewards obtained during the trajectory, considering a discount factor $\gamma$, which gives more importance to the rewards of nearer actions than to future rewards.

Policy Optimization

In reinforcement learning there are different approaches to solve the MDP formulated in the previous section, which are summarized in Figure 2. The most common are value-based methods and policy-based methods. In value-based methods, the agent learns which state is more valuable and take action that leads to it. In policy-based methods, the agent learns a policy that directly maps states to actions. In this work we will focus on the latter methods, specifically in policy gradients.

Other approaches for finding a policy is by non solving the MDP, but by directly optimizing the policy. This is the case of derivative free optimization (DFO), or evolutionary algorithms, in which the policy is parameterized by a vector $\theta$, and the agent explores the space of parameters by searching. Nothing of the temporal structure and actions of the MDPs are considered in this kind of solution.

Policy gradient methods provide a way to reduce reinforcement learning to stochastic gradient descent, by providing a connection between how function approximation is solved in supervised learning settings, but with the key diffrence that the dataset is collected using the model itself plus a reward signal that acts as a "label".

Learning the Policy

The starting point is to think of trajectories as units of learning instead of individual observations (i.e., actions). What dynamics generate a trajectory? Given a policy ${\pi }_{\theta }$, represented as a function with parameter $\theta \in {ℝ}^d$, whose input is a representation of the state and whose output is action selection probabilities, we can deploy the agent into its environment at an initial state $s_0$ and observe its actions in inference mode or evaluation phase \citep{sutton1999policy}. The agent continuously promotes actions based on the current state $s_t$ until the episode ends in a terminal state, when $t=T$. At this point, we can determine if the goal was accomplished, such as winning the ATARI Pong game, or generating aesthetically pleasing samples from a diffusion model. The returns are the scalar value that assets perfomance whether we have achieved the ultimate goal, effectively acting as a "proxy" of a label for the overall trajectory. Thus, the trajectory serves as our unit of learning, and the remaining task is to establish the feedback mechanism for the learning phase.

Intuitivelly, we want to collect the trajectories and make the good trajectories and actions more probable, and push the actions towards betters actions.

Mathematically, we aim to perform stochastic optimization to learn the agent’s parameters. This involves obtaining gradient information from sample trajectories, with performance assessed by a scalar-value function (i.e. reward). The optimization is stochastic because both the agent and the environment contain elements of randomness, meaning we can only compute estimates of the gradient. Crucially, we are estimating the gradient of the expected return with respect to the policy parameters. To address this, we employ Monte Carlo Gradient Estimation \citep{mohamed2020monte}, specifically using the score function method. From a machine learning perspective, this involves dealing with the stochasticity of the gradient estimates, $\hat{g}$, and using gradient ascent algorithms to update the policy parameters based on these estimates, along with a learning rate $\alpha$ to control the step size of the optimization process,

\theta \leftarrow \theta + \alpha \hat{g}_{N}.

Gradient Estimation via Score Function

The gradient estimation can be obtained using the score function gradient estimator. Let's introduce the following probability objective $ℱ$, defined in the ambient space $𝒳\in {ℝ}^n$ and with parameters $\theta \in {ℝ}^n$,

Here, $f$ is a scalar-valued function, similar to how the reward is represented in the reinforcement learning setting. The score function is the derivative of the log probability distribution ${\nabla }_{\theta }\log p(\mathrm{x};\theta )$ with respect to its parameters $\theta$. We can use the following identity to establish a connection between the score function and the probability distribution $p(\mathrm{x};\theta )$,

\begin{split}
    \nabla_\theta\log p(\mathrm{x};\theta) &= \frac{\nabla_{\theta}p(\mathrm{x}; \theta)}{p(\mathrm{x};\theta)} \\\\
    p(\mathrm{x};\theta) \nabla_{\theta}\log p(\mathrm{x};\theta) &= \nabla_{\theta}p(\mathrm{x};\theta).
\end{split}

Therefore, taking the gradient of the objective $ℱ(\theta )$ with respect to the parameter $\theta$, we have

The use of the log-derivative rule on the above equation to introduce the score function is also known as the log-derivative trick. Now, we can compute an estimate of the gradient, $\hat{g}$, using Monte Carlo estimation with samples from the distribution $p(\mathrm{x};\theta )$ as follows:

We draw $N$ samples $\hat{\mathrm{x}}\sim p(\mathrm{x};\theta )$, compute the gradient of the log-probability for each sample, and multiply by the scalar-valued function $f$ evaluated at the sample. The average of these terms is an unbiased estimate of the gradient of the objective $g$, which we can use for gradient ascent.

There are two important points to mention about the previous equation.

• The function $f$ can be any arbitrary function we can evaluate on $\mathrm{x}$. Even if $f$ is non-differentiable with respect to $\theta$, it can still be used to compute the gradient estimation $\hat{g}$.
• The expectation of the score function is zero, meaning that the gradient estimator is unbiased

The last point is particularly useful because we can replace $f$ with a shifted version given a constant $\beta$, and still obtain an unbiased estimate of the gradient, which can be beneficial for the optimization task:

Using a baseline function to determine $\beta$, that does not depend on the parameter $\theta$, can reduce the variance of the estimator \citep{mohamed2020monte}. The baseline function, which satisfies the property that the score function expectation is zero, can be any function independent of $\theta$. When a baseline is chosen to be close to the scalar-valued function $f$, it effectively reduces the variance of the estimator. This reduction in variance helps stabilize the updates by minimizing fluctuations in the gradients estimates, leading to more reliable and efficient learning.

Vanilla Policy Gradient, aka REINFORCE

The REINFORCE algorithm \citep{williams1992simple} translates the previous derivation of gradient estimation via the score function into reinforcement learning terminology. This is the earliest member of the Policy Gradient family (Figure~\ref{fig:rl-model-free-taxonomy}), where the objective is to maximize the expected return of the trajectory $\tau$ under a policy $\pi$ parameterized by $\theta$ (e.g., a neural network). At each state $s_t$, the agent takes an action $a_t$ according to the policy $\pi$, which generates a probability distribution over actions $\pi (a_t\mid s_t;\theta )$. Here, we will use the notation ${\pi }_{\theta }(\cdot )$ instead of $\pi (\cdot ;\theta )$.

As we mentioned in previous section, a trajectory $\tau$ represents the sequence of state-action pairs resulting from the agent's interaction with its environment. From the initial state $s_0$ to the terminal state $s_T$, the trajectory $\tau$ is a sequence of states and actions, $\tau =(s_0,a_0,\dots ,s_{T-1},a_{T-1},s_T)$, which describes how the agent acts during the episodic task. Let $p_{\theta }(\tau )$ be the probability of obtaining the trajectory under the policy ${\pi }_{\theta }$.

We thus have a distribution of trajectories. Remember that the trajectory $\tau$ is the learning unit for our policy ${\pi }_{\theta }$, as it tells us if the consequences of each action led to a favorable final outcome on the terminal state $s_T$ (e.g. win/lose). The goal is to maximize the exptected return of the trajectories on average, and the return $R(\tau )$ could be the cumulative rewards obtained during the episode or the discounted rewards. The expected return is given by the following expression:

This is the objective we want to maximize, which is a particular case of Equation~(\ref{eqn:probability-objective}) with the scalar-valued function $f(\mathrm{x})=R(\tau )$, representing the return of the trajectory. Let's use the techniques from the previous section to compute the gradient of the objective in Equation~(\ref{eqn:rl-objective}) with respect to the policy parameter $\theta$. The gradient estimation is given by:

What is $p_{\theta }(\tau )$ exactly? Given that the trajectory is a sequence of states and actions, and assuming the Markov property imposed by the MDP, the probability of the trajectory is defined as follows:

In the above expression, $\rho (s_0)$ denotes the distribution of initial states, while $P(s_{t+1},r_t\mid a_t,s_t)$ represents the transition model, which updates the environment context based on the action $a_t$ taken in the current state $s_t$. A crucial step in estimating the gradient is computing the logarithm of the trajectory probability. Following this, we calculate the gradient with respect to the policy parameter $\theta$,

\begin{split}
    \log p\_{\theta}(\tau) &= \log \rho(s_0) + \sum\_{t=0}^{T-1}\log \pi_{\theta}(a_{t}\mid s\_{t}) + \log P(s\_{t+1}, r\_{t}\mid a\_{t}, s\_{t}) \\\\
    \nabla\_{\theta}\log p\_{\theta}(\tau) &= \log \nabla\_{\theta}\rho(s\_0) + \sum\_{t=0}^{T-1}\nabla\_{\theta}\log \pi\_{\theta}(a\_{t}\mid s\_{t}) + \log\nabla\_{\theta} P(s\_{t+1}, r\_{t}\mid a\_{t}, s\_{t}) \\\\
    \nabla\_{\theta} \log p\_{\theta}(\tau) &=  \sum\_{t=0}^{T-1}\nabla\_{\theta}\log \pi\_{\theta}(a\_{t}\mid s\_{t}).
\end{split}

The distribution of initial states and the transition probabilities are disregarded because they are independent of $\theta$, thereby simplifying significantly the computations needed for gradient estimation. By substituting the final expression from Equation~(\ref{eqn:trajectory-gradient-score}) into the gradient estimation of the objective in Equation~(\ref {eqn:rl-gradient-estimator-vanilla}), we derive the REINFORCE gradient estimator

The core concept is to collect a set of trajectories ${𝒟}^{{\pi }_{\theta }}$ under the policy ${\pi }_{\theta }$ and update the policy parameters $\theta$ to increase the likelihood of high-reward trajectories while decreasing the likelihood of low-reward ones, as illustrated in Figure~\ref{fig:anatomy-rl-trajectories}. This trial-and-error learning approach, described in Algorithm 1, repeats this process over multiple iterations, reinforcing successful trajectories and discouraging unsuccessful ones, thus encoding the agent's behavior in its parameters.

Reducing the variance of the estimator. Using two techniques, reward-to-go and baseline, we can improve the quality of the gradient estimator in Equation~(\ref{eqn:reinforce-gradient-estimator}).

The reward-to-go technique is a simple trick that can reduce the variance of the gradient estimator by taking advantage of the temporal structure of the problem. The idea is to weight the gradient of the log-probability of an action $a_t$ by the sum of rewards from the current timestep $t$ to the end of the trajectory $T-1$. This way, the gradient of the log-probability of an action is only weighted by the consequence of that action on the future rewards, removing terms that do not depend on $a_t$. Let's introduce this technique by using the gradient estimation in Equation~(\ref{eqn:reinforce-gradient-estimator}) and replacing $R(\tau )$ naively using the sum of total trajectory reward \footnote{The same applies for discounted returns or other kind of returns $R(\tau )$.}

As we saw at the end of Section~\ref{sec:gradient-estimation-score-function}, it is possible to reduce the variance of the gradient estimator by using a baseline function, $b(s_t)$, without biasing the estimator. However, is the expectation of the score still unbiased in this setting?

The proof follows a similar argument as shown in Equation~(\ref{eqn:score-function-expectation-zero}), with the key difference being that the expectation is taken with respect $p_{\theta }(\tau )$, which is a sequence of random variables. By leveraging the linearity of the expectation property, we can focus on a single term at step $t$ of Equation~(\ref{eqn:reinforce-gradient-estimator-baseline}) to demonstrate that the baseline does not affect the expectation of the score function. We split the trajectory sequence $\tau$ at step $t$ into: ${\tau }_{0:t}$ and ${\tau }_{t+1:T-1}$, and then expand it into state-action pairs \footnote{A criterion used when splitting the trajectory is that state-action pairs are formed given that $s_t$ is a consequence of action $a_{t-1}$, and taking action $a_t$ results in state $s_{t+1}$. Notice both expectations from step 1 and 2 in Equation~(\ref{eqn:reinforce-baseline-unbiased}).}

We can remove irrelevant variables from the expectation over the portion of the trajectory ${\tau }_{(t+1):(T-1)}$ because we are focusing on the term at step $t$. The only relevant variable is $a_t$, and the expectation ${𝔼}_{a_t}\log {\pi }_{\theta }(a_t\mid s_t)$ is 1. Given that the gradient with respect to $\theta$ of a constant is zero, and $b(s_t)$ is multiplying it, the effect of the baseline on the expectation is nullified. This argument can be applied to any other term in the sequence due to the linearity of the expectation. Therefore, we have proven that using a baseline also keeps the gradient estimator unbiased in the policy gradient setting.

Choosing an appropriate baseline is a critical decision in reinforcement learning \citep{foundations-deeprl-series-l3}, as different methods can offer unique strengths and limitations. Common baselines include fixed values, moving averages, and learned value functions.

• Constant baseline: $b=𝔼[R(\tau )]\approx \frac{1}{m}{\sum }_{i=1}^{m}R({\tau }^{(i)})$.
• Optimal constant baseline: $ b=\frac{\sum_{i}(\nabla_{\theta} \log P_{\theta}(\tau^{(i)}))^{2} R(\tau^{(i)})}{\sum_{i}(\nabla_{\theta}\log P_{\theta}(\tau^{(i)}))^{2}}$.
• Time-dependent baseline: $b_t=\frac{1}{m}{\sum }_{i=1}^m{\sum }_{k=t}^{T-1}R(s_k^{(i)},a_k^{(i)})$.
• State-dependent expected return: $b(s_t)=𝔼[r_t+r_{t+1}+r_{t+2}+\cdots +r_{T-1}]=V^{\pi }(s_t)$.

The control variates method can significantly reduce estimator variance, enhancing the stability and performance of RL algorithms \cite{NIPS2001_584b98aa}. Despite the nuances and differences among baseline methods, the primary concept is the advantage, shown in Equation~(\ref{eqn:pg-objective-with-value-baseline}), which refers to increase log probabilities of action $a_t$ proportionally to how much its returns, $r_t$, are better than the expected return under the current policy, which is determined by the value function $V^{\pi }(s_t)$

What remains is how do we get estimates for $V^{\pi }$ in practice.

Actor-Critic Methods

Actor-Critic referred to learn concurrently models for the policy and the value function. This methods are more data efficient because they amortize the samples collected ${𝒟}^{{\pi }_{\theta }}$ used for Monte Carlo estimations while reducing the variance of the gradient estimator. The actor controls how the agent behaves---by updating the policy parameters $\theta$ as we see in previous sections---whereas the critic measures how good the taken action is, and could be a state-value ($V$) or action-value ($Q$) \footnote{Action-value function ($Q$) refers to the value of take action $a$ on state $s$ under a policy $\pi$.} function. Notice that we are combining in some way both approaches for solving MDPs as is depicted in Figure~\ref{fig:rl-model-free-taxonomy}.

We are introducing a new function approximator for the value function, $V_{\varphi }(s_t)$, where $\varphi$ are the parameters of the value function

The objective is to minimize the mean squared error (MSE) between the estimated value and the empirical return, i.e. we are regress the value against empirical return in a supervised learning fashion

Algorithm 2 describes the steps for a REINFORCE variant with advantage , which combines the actor-critic approach with the traditioinoal REINFORCE algorithm. More components were introduced and can influence in the performance when the algorithm is implemented. For instance, the policy and value networks can share parameters or not. A useful study that make abalations and suggestions to pay attention when these algorithms are implemented is What Matters In On-Policy Reinforcement Learning? A Large-Scale Empirical Study (Andrychowicz, 2020 \cite{andrychowicz2020mattersonpolicyreinforcementlearning}).

References

[1] Sutton, R. S. (2018). Reinforcement learning: An introduction. A Bradford Book.

[2] Mnih, V. (2013). Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602.

[3] Silver, D., Schrittwieser, J., Simonyan, K., Antonoglou, I., Huang, A., Guez, A., ... & Hassabis, D. (2017). Mastering the game of go without human knowledge. nature, 550(7676), 354-359.

[4] Schulman, J. (2016). Optimizing expectations: From deep reinforcement learning to stochastic computation graphs (Doctoral dissertation, UC Berkeley).

This post was highlighted by the Weights & Biases community and published in their Fully Connected blog. You can read the interactive version here.

tl;dr Colabs are powerful, but they make experimentation difficult. In this article, we explore how to change your workflow with HuggingFace and Weights & Biases.

Over the years, I've used many Google Colab notebooks. They're great for experimentation and sharing your deep learning projects with others and save you the hassle of needing to set up a Python environment. That makes it much easier to open a notebook and start to figure out what's actually inside or to jump directly into working on your problem.

Past that, if you’re working on a deep learning problem, you'll undoubtedly require GPUs. Thankfully, Colab provides you with a free usage quota. Exporting into a standard Jupyter notebook is trivial if you want to start a GitHub repository and move the notebook there.

In a nutshell, Colab is an excellent tool to prototype small to mid-size projects and create tutorials and interactive code to share with your community.

Still, they aren't perfect. Here are the two major friction points for Colabs as I see them:

1. Experimenting with your custom dataset challenges reproducibility and makes collaboration harder.
2. Training or fine-tuning a model involves running the Colab multiple times and changing hyperparameters many times. Things quickly get messy. Tracking your experiments in Colab is suboptimal and basically nets out to you using a knife as a fork.

Thankfully, there are two open-source tools that I've started to use to alleviate both problems: Hugging Face Datasets and Weights & Biases. If you'd like to follow along with this article as a Colab, please follow the link above!

In this post, I'll discuss how these tools allow you to transition from a project notebook approach into a more mature deep learning repository with the respective python modules and a command line interface for running your experiments wherever you want.

Example Project: Fine-Tuning an Image Segmentation Model

Our project today involves fine-tuning an image segmentation model (SegFormer) with cellular images from a high-throughput microscope 🔬.

The idea is to train a model using cellular photography with mask labels that denote the living cells. A good model can connect directly to the microscope and help scientists detect cells quickly affected by a given treatment.

We are talking about reproducibility and collaboration so that you can follow the Google Collab Notebook (it's the same at the banner at the start of the post). The notebook has three sections:

1. Image Segmentation Walkthrough with SegFormer 📸: Model usage on this specific domain task and how the dataset interacts with them.
2. Training + Weights & Biases experiment tracking 🪄 + 🐝: training, hyperparameter optimization, and experiment tracking using Weights & Biases (W&B).
3. Training script via command line 🚀: A section to experiment with different model configurations using a training script.

These three sections broadly follow the development of the project. First, we'll understand how to use the model and the dataset manipulation to feed it. Next, we'll start working on training, namely what we want to track and record, and the hyperparameters configurations (such as the learning rate and batch size).

These two initial sections work as an internal exploration and as documentation for anyone who wants to understand the project. The third and final step is an engineering effort to make life easier and get the job done.

Hugging Face Datasets

If you've dabbled in machine learning, chances are you've worked on the classic MNIST dataset alongside PyTorch. The code below makes this easy so you don't have to run boilerplate code or download MNIST every time you want to experiment. You can instead focus on learning new models and concepts.

import torchvision.datasets as datasets
MNISt=datasets.MNIST(root='./data', train=True, download=True, transform=None)

In the same spirit of pulling MNIST from PyTorch, we want our data for this project in a central repository, ready to consume, and easy to share. We can get these three features for free using the HuggingFace dataset repository.

In Figure 2, we have a picture of the dataset repository of the example project, a page where you have a preview and documentation of the data. There is also a repository for storing images, text, or other data you have and there is no limit size for the data storage reported in the documentation. Still, I created a repository that stored the NIH Chest X-ray dataset (> 40gb) without problems, and there are datasets with terabytes of memory.

The purpose of investing time in creating a repository for your dataset is that you'll end up with a Python module for downloading and loading the data in the same fashion that torchvision.datasets provides you with the MNIST and others benchmark datasets.

Below you can see how we load the dataset for the cell segmentation example project:

from datasets import load_dataset

repo_name = "alkzar90/cell_benchmark"
train_ds = load_dataset(repo_name, split="train", streaming=False)
val_ds = load_dataset(repo_name, split="validation", streaming=False) 
test_ds = load_dataset(repo_name, split="test", streaming=False) 

How does HuggingFace know how the dataset load (i.e. read files and split the data)?

1. The module supports common data types by default, such as tabular, images, text, audio, etc. You need to follow a template for storing the organized dataset, something like torchvision.datasets.ImageFolder approach (i.e. data_split/label/image_001.jpg). This helps the Hugging Face dataset module figures out how to load your data.
2. Sometimes you must accommodate multiple datatypes (CUB 200 2011 dataset), or you might want to provide different configuration of the dataset for various tasks such as image classification and object detection (in the dataset preview rock glacier dataset, notice the data subset option), or your dataset type lacks default support by the library. In this case, you must write a custom python (simple example / complex example) loader script to tell the module how to navigate the file structure, deal with data and labels.

The datasets repository works similarly to a GitHub repo. You can get version code and data with commits, collaborate with others via pull requests, and have README for general dataset documentation. There is also support for apache arrow format to get the data in streaming mode, Finally, when the data is too heavy to load at once, you can download it, and via the caching system, you can load batches on demand in memory.

Experiment tracking with W&B

Weight & Biases (W&B or wandb) provides free services for logging information about your project into a web server that you can monitor from a dashboard. It’s helpful to think of your W&B project as a database with tools for interacting with your experiment information.

Once you have a W&B account, you can create a project such as alcazar90/cell-segmentation to log the information from each experiment you run.

In section 2 of the google colab, sub-section “🦾 Run experiment”, you'll initialize a run with wandb.init providing the following arguments: (i.) name of the project and (ii.) a config dictionary that provides context about your experimentation such as number of epochs, batch size, etc. Also, you can name your runs something memorable, but if you don’t, W&B create random expressions such as resplendent-rocket-27 or abundant-moon-38 (yes, the number is the experiment number).

Commonly, there will be a lot of runs in your project because when you get a taste of the improvements in you can make in how you log information, you'll find yourself getting a ton of new ideas.

PROJECT = 'cell-segmentation'
wandb.init(project=PROJECT, config={"epochs": EPOCHS, "batch_size": BS, "lr": LR,
                                    "lr_scheduler_exponential__gamma": GAMMA, 
                                    "seed": SEED})

# Add additional configs to wandb if needed
wandb.config['len_train'] = len(datasets.train_ds)
wandb.config['len_val'] = len(datasets.valid_ds)

For example, you can see the config information in the dashboard from the run auspicious-paper-44 in the overview option at the left menu. There is a table describing the context of this experiment (mostly hyperparameters settings in this case):

After initializing a run and logging the config, we want to log information during the model training. Typically we want to track the main metrics in the train and validation set; these will be floating points across time that we log using wandb.log.

for epoch in tqdm(range(EPOCHS)):
  ...
  metrics = {"train/train_loss": train_loss, 
               "train/epoch": (step + 1 + (n_steps_per_epoch * epoch)) / n_steps_per_epoch, 
               "train/example_ct": example_ct,
               "train/cur_learning_rate": scheduler.state_dict()["_last_lr"][0]}
  ...
  val_metrics = {"val/val_loss": val_loss, 
                 "val/val_accuracy": accuracy,
                 "val/mIoU": mIoU}
  wandb.log({**metrics, **val_metrics})

W&B knows how to display these metrics, so it makes charts for you automatically in the run’s dashboard.

Beyond the obvious things to log (like training and validation loss), you can log whatever you want for your specific project. In the Figure 5, I log information from the dev set into a wand.Table includes:

• The actual image and mask
• The predicted mask
• The probability map (it’s so cool)
• The intersection over union (iou) metric for individual examples

Notice in the code that wand.Table has image columns that we add using wand.Image and requires numpy arrays as input, but you can also log plots created with matplotlib, like in the case of the probability column. These allow us to have tables with rendered images as values that we can inspect quickly. This feature is convenient as a complement to traditional metrics. However, for generative image models, checking the pictures you generated by the model during training gives you more information about your model than tracking the loss.

Finally, on your project’s main page, in the “Table” option at the left menu, you have a bird-eye view of all runs and their metrics to compare. You can export this info into a csv file or download it by API to analyze.

Note 1: Whenever you initialize a run (wandb.init), W&B will ask you to provide the API key for authentication; you can find it at W&B>settings>API keys.

Note 2: There is a short course of W&B called "Effective MLOps: Model Development" to learn the fundamentals.

Training Script Via Command Line 🚀

In the last section, we saw how to integrate W&B to log information about our model training. Still, fine-tuning a model or training from scratch requires a lot of experimentation. The idea is to iterate and try many configurations.

And sure, you can do this in the notebook, but doing it that way is redundant and non-optimal. Think about re-running every time the code cells after you change the batch size in your data loaders, for example. That's not ideal. The next step is to wrap all the code cells required to train your model into a training script, such as downloading the dataset, creating the data loaders, importing utility functions, and setting hyperparameters and training configurations.

Wrapping the code into a training script, plus using the argparse module, you'll be able to call the training script directly from the command line:

!python finetune_model.py --train_batch_size 4 --validation_batch_size 3\
     --init_learning_rate 3e-4 --learning_rate_scheduler_gamma 0.92\
     --num_train_epochs 15 --reproducibility_seed 42313988\
     --log_images_in_validation True --dataloader_num_workers 0\
     --model_name "huggingface-segformer-nvidia-mit-b0"\
     --project_name "cell-segmentation"

You can see the training script here, but the main heavy work is done by the argparse module where you can define a parser protocol to define and read the parameters for running the script via the command line. The idea is as follows:

import argparse 

def parse_args(input_args=None):
  parser = argparse.ArgumentParser(description="Training loop script for fine-tune a pretrained SegFormer model.")
  
  parser.add_argument(
    "--train_batch_size", type=int, default=4, help="Batch size (per device) for
    the training dataloader"
  )
  ...

Thus far, we'll developed the entire code project in Google Colab, created a HuggingFace dataset repository, and integrated W&B to log the model training information. But the project doesn’t have any home in GitHub.

When is it actually necessary to create a code repository for the project? It depends. For example, if creating the dataset requires pre-processing scripts and tests, keeping all those files in a GitHub repository makes sense. Regardless, the moment we develop the training script, creating a GitHub repository for the training script and its dependencies is a good decision. We want to make the training script accessible, even for us. In the last section of the google colab notebook, I downloaded the training script from the GitHub repo to train using the computation provided by colab.

!wget https://raw.githubusercontent.com/alcazar90/cell-segmentation/main/finetune_model.py

Side actions to do with your repo: upload a Jupyter notebook version of the Colab and write a nice readme to provide context.

Next Steps 🦶🏼

If you (or I) wanted to continue the project, some next steps to consider:

1. Create a bash script for running a .txt file with different training configurations.
2. Create files to separate code from training.py, such as model.py for code related to downloading and loading models and inference.py for computing evaluation metrics.
3. Use a cloud provider such as Lambda Cloud to connect via ssh and run the training script. Check if the results save in W&B.
4. Explore how to use Hugging Face GitHub actions/webhooks to save model checkpoints in HF every time the training script outperforms the current best model. Check hugging face sync action, and HuggingFace Webhooks
5. Study cases for popular deep learning code repositories such as the OpenAI whisper model and nanoGPT.

Conclusion

Using W&B and Hugging Face makes projects like the one above a lot easier to manage, reproduce, and understand. Having the code ready in a Colab gives us GPU access and makes running discrete steps a breeze.

I hope this piece helps you as you consider how best to experiment in your project. If you have any questions, feel free to drop them in the comments below. Thanks!

How can we train a model to generate novelty images while preserving the style? What is a generative model? what is a diffusion model? Is there a way to control the image generation process (aka sampling)? In this short post, I will answer these questions at a high level with a mini project implementation, the Ukiyo-e style postcard generator App.

The project, in a nutshell, consists of the following:

1. Take a bunch of images with the Ukiyo-e style
2. Trained (finetune really) a diffusion model to learn a distribution of our images
3. Use the learned "unconditional distribution" to generate novel images with ukiyo-e stylish
4. Explore ways to gain control when we sample new pictures from our distribution
5. Wrap the whole inference pipeline: model (distribution) + image generation (sampling) into a Gradio App

What is Ukiyo-e style?

Pictures-of-the-floating-world..., that's what means the Japanese word Ukiyo-e. It's a term to refer to an entire art gender, so don't be confused that it is an artist's name or a pseudonym. Its roots are popular, even vulgar, and accessible, so it was easy to find Ukiyo-e prints in Japanese houses. It was a genre that took influence from the west and china, but at some point, it influenced Europe and the western world. If you want to know more about this Japanese art genre, I highly recommend this interactive piece from the New York Times titled A Picture of Change for a World in Constant Motion" (Farago 2020). It's a journey from this popular genre's history and distinctive elements.

The dataset ukiyoe2photo contains pictures of the floating world, which I used in this project to learn a model to generate new images with ukiyo-e stylish. The below figure shows some of the ukiyo-e images in the dataset.

Unconditional image generation

What is unconditional image generation?

Unconditional image generation is the task of generating images with no condition in any context (like a prompt text or another image). Once trained, the model will create images that resemble its training data distribution.

My goal here is to highlight the main elements involved in a Denoising Diffusion Probabilistic Model (Ho 2020), or DDPM for short, and its training dynamic. I will write a more detailed and technical post about this model in the future.

Let's start with the training dynamic; a diffusion model consists of two chain processes of the same number of steps, $T$.

1. A forward process: in which the model takes an input image and gradually destroys it, adding gaussian noise until the entire image structure is reduced to just noise
2. And a backward process: an inverse process encoded by a distribution with learnable parameters whose goal is to predict the noise added in each transition step (i.e. denoising)

There are important elements to take into account:

• We use gaussian distributions for both processes, yeah the lovely normal distribution $𝒩(\mu ,\sigma )$
• Both processes are markovian; that means the distribution of a given step t depends on the immediately previous state $t-1$ or $t+1$ in the case of the backward process
• The gaussian distribution of the forward process ($q(\cdot )$ in the above diagram) has fixed parameters; in other words, we don't have to learn any parameter here
• In contrast, the gaussian distribution for the backward process ($p_{\theta }(\cdot )$ in the diagram) has learnable parameters $𝛉$
• We used a noise schedule to destroy the images; this means that we have a deterministic function to inject the amount of noise during the $T$-length forward process
• We used a neural network architecture (e.g. U-net) to predict the parameters of the backward gaussian distribution $p_{𝛉}$
• If we have a process of length $T=1000$ (like Ho 2020), ${𝐱}_0$ is the image input, ${𝐱}_{1000}$ is pure noise of the same input resolution, and any intermediate ${𝐱}_t$ with $0<t<T$ is a latent state; a blend of some degree between the input image and noise level (given by the noise scheduler)
• The last means that every latent space has the same resolutions as the input (a difference from other variational autoencoder models)
• The advantage of using a noise scheduler + gaussian distribution with known parameters $q(\cdot )$ is that we have a closed expression to compute the latent state at any given level $t$ (we don't need to calculate the entire chain from $0$ to $t$).

Back to the training dynamic, a one parameter update cycle looks like the following:

1. Get a batch of images $\mathrm{x}$ from our dataset (batch_size, width, height)
2. Sample random gaussian noise $\mathrm{ϵ}$ for each image (batch_size, width, height)
3. Pick a random vector $\mathrm{t}$, which determine in which part of the forward process we are for each of the images (batch_tize,) (think we are extending parallel non-equal length chains)
4. Compute the latent state $\mathrm{z}$: each image in the batch use their corresponding $t$ level in $\mathrm{t}$ with the closed expression. The noise scheduler knows how to blend the image with the noise at the right level (batch_size, width, height)
5. Pass $\mathrm{z}$ for the model $p_{𝛉}$ to get the predicted noise ${ϵ}^{\ast }$
6. Using the mean squared error as a loss function, we compare the actual noise ($\mathrm{ϵ}$) with the predicted noise (${\mathrm{ϵ}}^{\ast }$). Remember that we know the actual noise beforehand because our noise schedule needs it to blend it with the image and create the latent state.
7. Backprop to compute the gradients
8. Update the parameters in the direction that minimizes the loss

num_epochs = 1  # number of epochs
lr = 1e-5  # learning rate
grad_accumulation_steps = 2  # how many batches to accumulate the gradient before the update step
optimizer = torch.optim.AdamW(image_pipe.unet.parameters(), lr=lr)

for epoch in range(num_epochs):
    for step, batch in tqdm(enumerate(train_dataloader), total=len(train_dataloader)):
        # get a batch image 
        clean_images = batch["images"].to(device)
        # Sample noise to add to the images
        noise = torch.randn(clean_images.shape).to(clean_images.device)
        bs = clean_images.shape[0]

        # Sample a random timestep for each image
        timesteps = torch.randint(
            0,
            image_pipe.scheduler.num_train_timesteps,
            (bs,),
            device=clean_images.device,
        ).long()

        # Add noise to the clean images according to the noise magnitude at each timestep
        # (this is the forward diffusion process)
        noisy_images = image_pipe.scheduler.add_noise(clean_images, noise, timesteps)

        # Get the model prediction for the noise
        noise_pred = image_pipe.unet(noisy_images, timesteps, return_dict=False)[0]

        # Compare the prediction with the actual noise:
        loss = F.mse_loss(
            noise_pred, noise
        )  

        # Update the model parameters with the optimizer based on this loss
        loss.backward(loss)

        # Gradient accumulation:
        if (step + 1) % grad_accumulation_steps == 0:
            optimizer.step()
            optimizer.zero_grad()

It looks straightforward, but there are many theoretical building blocks to end using a mean squared error loss. The code above uses the hugging face diffuser library 🧨, so some lines are more complex—for instance, image_pipe.scheduler_add_noise knows exactly how to blend the images with the noise to get a determined latent state at $t$. It's initialized before with the $T$ length, noise schedule type, etc. The object image_pipe.unet contains the neural network architecture to process the images; remember that the latent space is of the same shape that the input (i.e. image). The last explained the decision by the authors to choose a U-net architecture, well known because the output has the exact dimensions as the input.

Training a generative model such as DDPM takes a long time and requires a lot of images. Instead, we can get fair results without much training and pictures using the same approach but with a pre-trained model as a starting point, such as Google/ddpm-celebahq-256. Of course, we need to make some compromises to the model resolutions we are using to finetune our data; the Google model was trained using a 256px resolution.

Now we can use the model to sample 12 postcards:

x = torch.randn(12, 3, 256, 256).to(device)  # Batch of 12 
for i, t in tqdm(enumerate(scheduler.timesteps)):
    model_input = scheduler.scale_model_input(x, t)
    with torch.no_grad():
        noise_pred = image_pipe.unet(model_input, t)["sample"]
    x = scheduler.step(noise_pred, t, x).prev_sample

Notice that we need to denoise the gaussian random noise to get samples from the model throughout the backward process chain. In the next section, we will add some complexity to this inference pipeline beyond the model and the noise scheduler. You can find the model used to generate the images in alkzar90/sd-class-ukiyo-e-256.

There are psychodelich images, dreamy ones without some realistic object, but still with an artistic appeal. Observe the opaque pastel colours characteristic of the Ukiyo-e style.

Classifier Guidance

What is the guidance technique? We can take this unconditional image generation process and guide it toward images that have a desired attribute or property of interest we want. It could be like conditioning the image distribution hackily because we don't need to learn the conditional distribution like in popular text-to-image models such as Stable Diffusion or Dall-E2; we reuse the same model. Instead, we guide the sampling process (or denoising) by introducing a loss function that measures the property of interest in the sample generated, orienting the denoising process to minimize the designed objective. Specifically, in the Ukiyo-e style postcard generator App, we used:

• Colour guidance: samples images that have a (guess) desired colour
• Text prompt guidance: sample images according to a text description

So, before we look that generating a new image, or sampling, means taking a pure gaussian noise and passing through this denoising process. But we do it in many little steps; you take the noise and denoising slowly, passing through an entire stochastic Markovian process of saying T=1000 steps (Ho 2020,). When we use guidance, we append a gradient graph to the sample tensor and calculate the loss for the sample in each state w.r.t our objective attribute (e.g. colour or text prompt). Then we compute the gradient and update the tensor in the direction that minimizes the loss, guiding the following sample image to be more appealing to the attribute that measures the loss. The process is called classifier guidance, and it was introduced in the paper Diffusion Models Beat GANs on Image Synthesis (Dhariwal 2021).

Now a beautiful image of a sakura tree...

We will use "a sakura tree" as a text prompt and the same starting gaussian noise as above, for which we got 12 ukiyo-e-postcard. But, this time, we will drive the sampling process using the gradients we get by comparing the sample image text encoding in each step $t$ with the text prompt encoding vector.

Compare these new postcards with the others. Notice how the text guidance makes that sakura tree's pattern emerge during the denoising process: branches and pink leaves here and there, with hallucination touches. The model is neither perfect nor trained with surgery hands, but it's still amazing that we have gained some control over the sampling process. Behind the curtains, to generate the above images, the following steps happen:

1. Download a pre-trained model to generate image captions such as OpenAI CLIP model
2. Pass the noise tensor to the model to get an encoding vector
3. Use a loss function that compares the vector for the current sample state w.r.t. encoding for the text prompt; the last vector is always the same because the prompt doesn't change during the process
4. Compute the sample gradient w.r.t loss value and update the sample values in the direction that minimizes the loss
5. Repeat the process during the whole stochastic Markovian process

Generally, any designed loss uses a scale factor to increase/decrease the attribute effect. It allows you to move between novelty and fidelity. Moreover, there's nothing to block you from using more than one objective; the Ukiyo-e postcards generator uses colour, and text prompts together as guidance, and each loss contributes to accumulating gradients that modify the sample in each denoising step. Of course, there could be some gradient interaction effects. Imagine that you want green images, but at the same time, you are using the text prompt "a volcano lava" you will put against the red/brown implicit colours in the text prompt with the green one.

Wrap the inference pipeline into an App

Now that we have a trained model and know how to control the sampling process of the unconditional distribution, why not wrap the entire inference pipeline into a friendly interface such as a Gradio App?

Let's start by setting some context; Gradio is a framework that allows us to build machine-learning apps pretty fast based on the task for which our model was designed. For instance, in a generative image model, in which the inference process requires fixing different parameter types such as factor scale (slider), text prompt (text input), or colour (colour selector), plus we always expect an image as output. Gradio helps us accommodate these requirements, hiding many tedious details that save you valuable time.

In addition, Hugging Face gives you free space to host your App running on a CPU (you can power up the running using a GPU, but you need to pay). It's an excellent combo to provide you with a friendly web interface with minimal resources. There is a trend in the generative model community for using this interface to show and prototype their models' properties and features, such as Stable Diffusion 2.1 Demo or Diffuse the rest. Therefore, taking time to learn Gradio is an excellent decision to share your project with a friendly facade.

Here is the python script with the pipeline and the App code, also a screenshoot of how does it look the Ukiyo-e style postcard generator App:

As you can see, it is easier to pick the colour you want and enter a text prompt to guide the sampling; control the scale factors for experimenting with different guidance intensity levels. Using a seed is convenient for reproducing the gaussian noise, which the denoising process use as a starting point for generating the images, so you can edit iteratively the image generated by playing with the scale factors.

PD: Unfortunately, this kind of model involves a lot of computation, and the gradio App is running using huggingface space with CPU, so that means the whole inference pipeline takes a lot of time. But, the good news is if you don't have patience, you can run the Gradio App using the google colab notebook pointing out at the start of this post with the GPU setting.

Uno de los puntos interesantes del capítulo es la introducción del conjunto de técnicas bajo el nombre de data augmentation ✨. Es una idea simple pero ingeniosa ya que no va en la línea directa (y más obvia) de mejorar el desempeño del modelo a través del diseño de la arquitectura, sino el foco se mueve a los datos. Parte esencial pero definitivamente no la más popular (?). El punto es que cualquier sistema bajo la categoria de machine learning (incluyendo deep learning) tiene una relación indisoluble con los datos, y ocupar data augmentation es una forma de incrementar la diversidad de nuestro dataset usando data sintetica creada a partir del dataset original.

Enfocandonos en datos que son imagenes, la generación de nuevos datos se realiza al aplicar transformaciones sobre una imagen. Arriba se observan distintas variaciones de la misma imagen, vemos como la imagen de un elfo sufré alteraciones como rotaciones, saturación del color, etcétera. Esto ayuda aumentar artificialmente la variación en nuestros datos, y si todo sale bien lograr una mejora en la generalización del modelo. Intuitivamente esto se podría explicar porque la saturación de color ayuda a evitar que el modelo dependa mucho del color verde en detectar elfos y permitir identificarlos en otros entornos menos comunes pero probables (e.g. montañosos con paleta más cargada a colores tierra), o incorporar mayor diversidad en las poses de los dibujos de elfos que el algoritmo ve durante el entrenamiento, logrando así disminuir el sesgo de las poses más comunes con que se dibujan y representan a los elfos.

La librería fastai operativamente implementa las transformaciones de imagen durante cada época, donde con alguna probabilidad se aplica una o más perturbaciones sobre la imagen, o se muestra su versión de la original.

db  = DataBlock(
    blocks = (ImageBlock, CategoryBlock),
    get_items = get_image_filees,
    splitter = RandomSplitter(valid_pct=0.2, seed=42),
    get_y = parent_label,
    item_tfms=Resize(128),
    batch_tfms=aug_transforms(mult=2)
    )
    
dls = db.dataloaders(images_path)

Recordemos que el objeto DataLoaders es una instancia de la clase encargada de proveer mini-batches al algoritmo durante el entrenamiento y enviarlas a la GPU. Por lo tanto, las transformaciones especificadas en el argumento batch_tfms en DataBlock son las que se ejecutaran en la GPU para todo las imagenes del mini-batch, transformaciones que van aplicandose época-tras-época.

Si bien el segundo capítulo no detalle mucho más, en la documentación de fastai se puede encontrar más información de cómo aplicar varias transformaciones y combinarlas. Además, hay metodologias para encontrar el conjunto de transformaciones más óptimo para un dataset especifico como la detallada en el paper AutoAugment: Learning Augmentation Policies from Data (Cubuk 2018). De hecho, el modulo vision de PyTorch, en torchvision.transforms.AutoAugment se encuentran los conjuntos de transformaciones óptimos según la metodologia del paper anterior para los datasets: Imagenet, CIFAR10, y SVHN. Una alternativa es ocupar alguna de estas transformaciones versus ocupar transformaciones arbitrariamente definidas.

Finalmente terminar con cómo interpretar teorícamente la técnica de data augmentation. Existe una justificación bayesiana cuya línea argumentativa es tratada en el post A Bayesian view of data augmentation (O'Rourke 2019) , y también hay una breve sección en la nueva edición del libro de Kevin Murphy página 622, citó del libro: "the data augmentation mechanism can be viewed as a way to algorithmically inject prior knowledge" 💉🧠.

Cuestionario

1. Where do text models currently have a major deficiency?

   • R: Si bien los modelos de texto son buenos generando prosa apropiada al contexto, estos modelos no son consistentes ni capaces de garantizar respuestas correctas.

2. What are possible negative societal implications of text generation models?

   • R: Los modelos de generación de texto reproducen los sesgos implicitos contenidos bajo los textos en que fueron entrenados. Un impacto social negativo es reproducir y amplificar este tipo de sesgos debido a la facilidad con que pueden escalar ya sea en redes sociales u otras aplicaciones.

3. In situations where a model might make mistakes, and those mistakes could be harmful, what is a good alternative to automating a process?

   • R: Utilizar un sistema en conjunto con un experto, el primero entrega recomendaciones, o alternativas como predicciones, y el experto puede utilizarlas para complementar su análisis o para validar los resultados evitando cometer errores y a la vez tomando ventaja de un sistema de apoyo. Siempre se puede descartar la sugerencia del modelo si no es pertinente.

4. What kind of tabular data is deep learning particularly good at?

   • R: Data tabular que contiene columnas con texto (e.g. comentarios de clientes o reviews sobe una película) u otra información tabularizada pero no estructurada (e.g. imagen de avatar de los usuarios en un foro).

5. What's a key downside of directly using a deep learning model for recommendation systems?

   • R: Los sistemas de recomendación son buenos entregando recomendaciones que le pueden gustar al usuario pero no necesariamente son opciones de utilidad. Si un sistema de recomendación me entrega vinilos de artistas que ya conozco, no hay mucho valor en estas opciones, porque es muy probable que ya conozca todas las alternativas y no necesite un sistema de recomendación para eso.

6. What are the steps of the Drivetrain Approach?

   i. Objetivo: ¿Qué buscamos lograr con nuestro producto de datos? ii. Levers: ¿Qué input podemos controlar para lograr nuestro objetivo? iii. Data: ¿Qué datos disponemos o podemos adquirir que sean relevantes para llevar acabo las acciones y cumplir el ojetivo? iv. Modelo: ¿Qué acciones concretas generamos en base a nuestros levers (aka inputs)?

   

7. How do the steps of the Drivetrain Approach map to a recommendation system?

   • Objetivo: Aumentar las ventas a través de recomendaciones novedosas y encantadoras para nuestros clientes.
   • Levers: Rankear las recomendaciones de la mejor forma posible para lograr el aumento de ventas.
   • Data: ¿Qué datos necesitamos recolectar para aumentar las ventas? (e.g. reproducciones de nuevos artistas o información de las compras de última temporada).
   • Modelo: Construir dos modelos de probabilidad de compra, uno condicionado en ver las recomendaciones y otro no. La diferencia entre ambas probabilidades es la función de utilidad de entregar una recomendación al cliente.

8. Create an image recognition model using data you curate, and deploy it on the web.

   • R: Bestiario es una simple aplicación para identificar clases de criaturas (i.e. elfos, trasgos, zombies y caballeros) desde imagenes. En otro post escribire sobre los pasos y desarrollos del proyecto

9. What is DataLoaders?

   • R: Un DataLoader es una clase auxiliar para implementar la abstracción de gestionar y proveer datos al modelo. Las 4 líneas de código siguientes son la funcionalidades básicas de esta clase destacadas en el capítulo:

   class DataLoaders(GetAttr):
       def __init__(self, *loaders): self.loaders = loaders
       def __getitem__(self, i): return self.loaders[i]
       train, valid = add_props(lambda i, self: self[i])
   

10. What four things do we need to tell fastai to create DataLoaders?

    i. ¿Con qué tipo de datos vamos a trabajar (e.g. imagenes, audio)? -> blocks=(ImageBlock, CategoryBlock) ii. ¿Cómo obtener la lista con las observaciones (datos)? -> get_items=get_image_files iii. ¿Cómo se encuentran etiquetados las observaciones? -> get_y=parent_label iv. ¿Cómo crear el conjunto de validación? -> splitter=RandomSplitter(valid_pct=0.2, seed=42)

11. What does the splitter parameter to DataBlock do?

    • R: El argumento splitter dentro de DataBlock especifica el porcentaje de observaciones que serán destinadas al conjunto de validación además de garantizar la reproducibilidad de los resultados.

12. How do we ensure a random split always gives the same validation set?

    • R: Utilizando un número de semilla (e.g. seed=42) para garantizar que el generador de números aleatorios produzca la misma secuencia de valores y por ende resultados.

13. What letters are often used to signify the independent and dependent variables?

    • R: La letra $y$ se utiliza para representar la variable dependiente (i.e. output) y la $x$ para las variables independientes (i.e. input).

14. What's the difference between the crop, pad, and squish resize approaches? When might you choose one over the others?

    • R: Primero, es importante estandarizar nuestras imagenes para transformarlas en tensores y que luego puedan ser insumidas por la arquitectura del modelo. La mayoría de las veces que recolectamos imagenes en la web, o de diferentes fuentes, notaremos que las imagenes tendrán distintas dimensiones. ¿Cómo estandarizarlas? Hay distintas formas y cada una puede tener un impacto en la calidad de nuestros datos.

      • Crop: Corta la imagen para generar un cuadrado de la dimensión requerida usando el largo o ancho completo. Se puede perder información relevante de la imagen respecto a la dimensión que sea truncada, como la parte trasera un auto que puede permitir discriminar entre un tipo de auto 🚓 y otro 🏎️. -> Resize(128)
      • Pad: Agregar regiones negras en los bordes para completar las dimensiones, lo que termina generando información nula que será simplemente pérdida en recursos computacionales (pensemos en millones de observaciones que necesitan esta transformación para quedar estandarizadas). -> Resize(128, ResizeMethod.Pad, pad_mode='zeros'))
      • Squish: Contraemos o expandemos la imagen para lograr la dimensión requerida. El problema es que podemos deformar el significado de lo que representa la imagen, por ejemplo, tenemos una imagen de una tetera de té 🫖 y la debemos expandir para alcanzar las dimensiones requeridas, y la tetera termina siendo una especie de balon más inflado ⚽ que aimensiones reales del objeto. -> Resize(128, ResizeMethod.Squish))

    • ¿Cuando escoger una sobre otra? Depende mucho de la naturaleza de las imagenes y que representan. Imagenes de números y letras pueden ser afectadas si se recorta alguna parte distintiva de un número particular, un 7 podría ser muy un 1 si la imagen se cropea de cierta forma. Sin embargo, si estamos identificando paisajes que son muy distintos (e.g. pradera y oceanos) el cropping no importar mucho.

15. What is data augmentation? Why is it needed?

    • R: Data augmentation es un conjunto de técnicas para aumentar de forma artificial los datos a través de perturbaciones aleatorias sobre estos sin alterar su significado intrínsico. Por ejemplo, si rotamos o modificamos la saturación de color de una foto de un perro, esta imagen continuará siendo la representación de un perro independiente las transformaciones aplicadas. Es importante notar que en la practica, cuando se aplican estas perturbaciones, no se aumentan los datos previo al proceso de entrenamiento. Pensemos que solo entre dos transformaciones como rotación y saturación de color, el espacio de configuraciones entre el producto cruz de estas dos operaciones dan lugar a infinitas versiones de una imagen, sino mas bien durante el entrenamiento, se muestran distintas versiones de un input agregando mayor variación y diversidad durante el ajuste de parámetros.

16. Provide an example of where the bear classification model might work poorly in production, due to structural or style differences in the training data.

    • R: Los ángulos de las fotos utilizadas para el conjunto de entrenamiento pueden variar a las obtenidas respecto a la posición de la camara en parque o lugar en que se utilicé el modelo. Otro problema pueden ser las variaciones del entorno en producción que no fueron capturadas en el dataset de entrenamiento apropiadamente como cambios de luminosidad por estaciones del año.

17. What is the difference between item_tfms and batch_tfms?

    • R: La diferencia entre item_tfms y batch_tfms es que el primero se aplica previo al proceso de entrenamiento a modo de pre-proceso de imagenes (e.g. estandarizar todas las imagenes a ciertas dimensiones como 128x128) y utiliza la CPU. En cambio, batch_tfms se aplica cada vez que el DataLoader entrega un mini-batch, o conjunto de observaciones, al modelo y generalmente se aplican usando la GPU para aplicar de manera eficiente las transformaciones sobre el mini-batch completo y que el modelo realice el ajuste de parámetros con las perturbaciones aleatorias particulares en esa epoch.

18. What is a confusion matrix?

    • R: Una matriz de confusión es una tabla que resume el desempeño predictivo de un modelo de clasificación. El cálculo de las métricas que contiene debe realizarse sobre el conjunto de pruebas, observaciones que no fueron utilizadas durante el proceso de entrenamiento del modelo para dar cuenta sobre la generalización del modelo en datos que nunca ha visto. Abajo hay un ejemplo de matriz de confusión sobre un modelo de imagenes que busca clasificar entre 10 tipos de vestimentas del dataset FashionMNIST. La diagonal representa el accuracy para cada una de las clases, mientras más blanco el color de la diagonal mejor, en este caso mayor número de imagenes de prendas fueron correctamente clasificadas en su categoría. En cambio, las celdas que no son parte de la diagonal representan el error que el modelo incurrió clasificando respecto a las 9 clases restantes. En particular se observa que el modelo presenta mayores dificultades en clasificar imagenes de shirt: $75$% de accuracy y en la mayoría de los casos las confunde con T-shirt/top y coat con un error de $8.4$% y $6.8$% respectivamente.

19. What does export save?

    • R: El comando learn.export() guarda un archivo con extension .pkl con el valor de los parámetros entrenados y la arquitectura del modelo para cargarlo e instanciarlo posteriormente. Un archivo .pkl es un archivo pickle creado por un modulo de python que serializa objetos en una serie de bites.

20. What is it called when we use a model for making predictions, instead of training?

    • R: Cuando utilizamos un modelo para realizar predicciones se le conoce por inferencia, esta siendo utilizado como programa y no en modo de entrenamiento o ajuste. No confundir con el término estadístico.

21. What are IPython widgets?

    • R: Los widgets de IPython es una forma de utilizar javascript en el contexto de jupyter notebook. Recordemos que cuando trabajamos con jupyter notebook tenemos un servidor local corriendo detrás, por lo que podemos tomar ventajas de tecnologías web.

22. When would you use a CPU for deployment? When might a GPU be better?

    • R: Si el modelo no requiere capacidad para responder a un gran flujo de consultas el uso de CPU para el deployment es recomendable por su costo y administración. Evitando el gasto innecesario de usar una GPU para realizar multiples inferencias si la aplicación no copa la capacidad de esta y las mayores dificultades técnicas de gestionarlas. Por lo tanto, la ventaja de ocupar GPU es cuando el modelo recibe un gran número de solicitudes simultaneas para realizar inferencia y que la GPU puede procesar al mismo tiempo.

23. What are the downsides of deploying your app to a server, instead of to a client (or edge) device such as a phone or PC?

    • Envio de información del dispositivo edge al servidor puede implicar mayores recursos computacionales para mantener tiempos de latencia tolerables al cliente.
    • Temas de privacidad de información y compliance producto de enviar los datos al servidor.

24. What are three examples of problems that could occur when rolling out a bear warning system in practice?

    i. Detectar osos en imagenes capturadas de noche, debido a que el conjunto de datos de entrenamiento solo contiene imagenes de día, la inferencia sobre este tipo de observaciones será de mala calidad predictiva. ii. Que los tiempos de inferencias esten dentro de lo necesario para que el guardaparques pueda responder de manera oportuna a la alertas. Por más que el sistema identifique correctamente a los osos, si se demora demasiado carece de utilidad en producción. iii. Diferentes posiciones de osos que las camaras puedan captar y que no se encuentran representadas en el conjunto de entrenamiento. Por lo que serán ignoradas por el modelo o tendrá una mala calidad predictiva.

    • Nota: recordar que los posibles comportamientos de una red neuronal emergen del intento del modelo por ajustar el ejemplo que quiere predecir al conjunto de entrenamiento sobre el cual fue entrenado y que representa una distribución particular.

25. What is out-of-domain data?

    • R: En general, el concepto hace referencia a datos que difieren respecto a los datos utilizados para entrenar el modelo, como los descritos en los ejemplos de la respuesta anterior.

26. What is domain shift?

    • R: Los datos que el modelo insume en producción cambian con el tiempo, distanciandose cada vez mas respecto del conjunto de datos que se utilizó para ajustar el modelo y afectando su desempeño sobre nuevas observaciones. Por ejemplo los gustos en música van adaptandose a nuevas tendencias y estilos culturales que van emergiendo en cada generación, por lo que un modelo estático que solo ha sido entrenado una vez y no toma en consideración estos cambios verá mermada su utilidad en el tiempo.

27. What are the three steps in the deployment process?

    i. Proceso manual: correr modelo en paralelo y revisar todas las predicciones para tener idea del estado del modelo, así como potenciales problemas y mejoras. Importante que las predicciones no gatillen ningúna acción automática y el proceso sea ejecutado de manera manual. ii. Lanzamiento con alcance limitado: modelo en funcionamiento con alcance limitado y de bajo riesgo. Esto puede ser definido por zona geográfica o funcionamiento sobre un periodo de tiempo acotado. La constante supervision humana es importante. iii. Expansion gradual: aumentar el alcance del modelo gradualmente, se requieren buenos sistema de monitoreo y reporte para detectar cualquier problema relevante, pensando que ya no tendremos el input de quien realizaba la ejecución manual respecto a nuevos comportamientos que el proceso debe tomar en cuenta. Considerar siempre que podria salir mal.

Breve historia redes neuronales

Se define Deep Learning a muy alto nivel como una técnica computacional para realizar predicciones en base datos usando redes neuronales compuestas de multiples capas. Cada una de estas capas recibe un input y entrega un output, así refinando los resultados a medida que la información avanza en la red. Hay un proceso de entrenamiento guiado por algún algoritmo que busca mínimizar el error (e.g. SGD, Adagrad, Adam) de las predicciones generadas por el modelo y el verdadero valor entregado por los datos. Estas redes neuronales profundas se utilizan en varios campos de investigación como Natural Language Processing (NLP), Computer Vision, Image Generation, Robotics, Recommendation Systems, entre otros.

Luego el capítulo construye una breve línea de tiempo sobre los modelos de redes neuronales.

• 1943: Warren McCulloh y Walter Pitts desarrollan el modelo matemático de una neurona artificial en el paper A logical Calculus of the Ideas Immanent in Nervous Activity.
• 1957: Frank Rossenblat implementa el primer modelo de neurona artificial llamado Perceptron con la capacidad de "aprender".
• 1969: Marvin Minsky y Seymour Papert publican el libro Perceptron sobre el trabajo de Rossenblat. Demuestran que una capa de estas neuronas es incapaz de aprender funciones simples como XOR. Sin embargo, en el mismo libro, demuestran como subsanar este problema añadiendo más capas de neuronas (aka multilayer perceptron).
• 1970-1985: Disminución importante en investigaciones sobre redes neuronales, con la excepción de un grupo acotado de investigadores. En el último episodio de la temporada 2 del podcast The Robot Brains Podcast, entrevistan a Geoffrey Hinton, y cuenta una anéctoda sobre la presentación de una investigación que realizaba en 1973 que utilizaba redes neuronales. Luego de la presentación, y con una audiencia bastante escéptica, una de las pregunta que recibió Hinton fue porqué usaba esos métodos, cuando Minsky y Papert "habían dicho" que no servían (supuestamente en el libro Perceptron).
• 1986: Se pública el libro Parallel Distributed Processing (PDP) de varios tomos por David Rumelhart, James McClelland, y Cia. Basandose y profundizandose en los trabajos previos de Rossenblat + Minksky el libro formaliza aún más la teoría y aspectos de implementación.
• 2012: El grupo de Geoffrey Hington gana la competencia Imagenet disminuyendo de forma drástica el error del modelo versus la solución del resto de los participantes y de las certamenes anteriores.

Hay muchos más detalles y contribuciones en la historia de la Inteligencia Artificial y el uso de redes neuronales, Jürgen Schmidhuber ahonda en esto, ofreciendo una serie de detalles y referencias interesantes en el siguiente video estrenado en la conferencia AIJ a finales del año 2020.

¿Qué es Machine Learning?

El capítulo cita y comenta el ensayo Artificial Intelligence: A Frontier of Automation de Arthur L. Samuel (1962), quien acuñó el término machine learning y fue director de investigación en comunicaciones de IBM. El ensayo comienza dismitificando las consideraciones antropomórficas y afirmaciones grandilocuentes sobre el campo de la Inteligencia Artificial, y a la vez legitimando su validez e impacto como disciplina en la resolución de problemas espécificos como traducir automáticamente del ruso al inglés, capacidad de reconocer dígitos escritos a mano, o texto escrito de puño y letra, además de la resolución de juegos de mesa que permiten explorar el diseño de agentes con capacidad de búsqueda e inferencia. El ensayo también acota el scope en que opera la Inteligencia Artificial respecto al rol del computador, descartando lo que no es. Arthur plantea la analogía de que lo que distingue a un buen trabajador de uno no tan bueno, la capacidad del primero de investigar y aprender el cómo realizar la tarea, mientras el segundo debe ser guiado paso a paso en la resolución de esta. Esto significa que más allá de la complejidad del software--como cálcular el estrés producido por el viento sobre las alas de una avión-- estaríamos frente a instrucciones detalladas previamente por un programador, y por lo tanto, sería una inteligencia empaquetada y entregada a la máquina.

"Programming a computer for such computations is, at best, a difficult task, not primarily because of any inherent complexity in the computer itself but, rather, because of the need to spell out every minute step of the process in the most exasperating detail. Computers, as any programmer will tell you, are giants morons, not giants brains" (Samuel, pag. 13)

El objetivo, y la idea de inteligencia artificial de Arthur, era especificar la tarea a la máquina y que esta pudiera encontrar por su cuenta la solución. Arthur formula ciertos requerimientos críticos para que una máquina tenga la capacidad de búscar soluciones, y lo hace dando el ejemplo de programar a un computador para que juegue damas. En esencia, una vez que uno tiene la representación de un tablero en el computador y las reglas que gobiernan el juego, este puede tomar acciones para generar movimientos y explorar las consecuencias de distintos estados del tablero. Sin embargo, veremos que la tarea de ir explorando las posibles secuencias de combinaciones hacía adelante es un camino sin fin, pensemos en las ${10}^{170}$ configuraciones de tablero que representa el juego Go y que superan el número de átomos en el universo, un cometido imposible incluso para un computador. No se debe plantear la búsqueda en términos de objetivos secundarios (i.e. ir por un caballo, o dar este movimiento) sino de alguna otra forma.

It is here that we encounter the idea of machine learning. Suppose we arrange for some automatic means of testing the effectiveness of any current weight assignment in terms of actual performance and provide a mechanism for altering the weight assignment so as to maximize the performance. We need not go into the details of such a procedure to see that it could be made entirely automatic and to see that a machine so programed would "learn" from its experience (Samuel, pag. 17)

El diagrama contiene los conceptos a los que se refiere Arthur, una máquina dotada con un mécanismo de feedback automático, la experiencia se produce a través de comparar las etiquetas y predicciones basadas en características de los datos. Y luego la capacidad de asignar los pesos del programa para cambiar el estado del programa y guiar la búsqueda de soluciones en dirección a máximizar el desempeño (i.e. tableros ganadores). Utilizando este paradigma Arthur creo un programa para jugar damas que termino superando a uno de los campeones estatales en EEUU.

Una lectura complementaria que me recordó el ensayo, e interesante como mirada actualizada, es un post de Andrej Karpathy que nombra a la descripcción realizada por Arthur de la máquina averiguando las instrucciones como software 2.0. Eso sí, con la expección de que Karpathy limita el paradigma exclusivamente a redes neuronales.

"Neural networks are not just another classifier, they represent the beginning of a fundamental shift in how we develop software. They are Software 2.0" (Karpathy)

Karpathy se basa en la comparación de la forma tradicional de escribir programas, o software 1.0, en donde se diseña el set de instrucciones para desarrollar una solución, y donde cada línea escrita por el programador es producto de decisiones que darán forma a un punto dentro del espacio de posibles programas. Respecto a una red neuronal, o software 2.0, al cuál se le especifica un objetivo, a través de pares de input y output, además de un esqueleto de código que será la arquitectura del modelo y definirá el "espacio del programa" con los posibles detalles a modificar. La red neuronal a través de un proceso de ajuste de parámetros (i.e. weight assignment en palabras de Arthur), guíado por su mécanismo de evaluación (i.e. loss), explorará diferentes configuraciones dentro del espacio y se quedará con la solución--encapsulada en los valores de sus parámetros--que mejor satisfagá el criterio de evaluación. El diagrama a continuación aparece en el post y es una manera de ilustrar lo anterior:

"To make the analogy explicit, in Software 1.0, human-engineered source code (e.g. some .cpp files) is compiled into a binary that does useful work. In Software 2.0 most often the source code comprises 1) the dataset that defines the desirable behavior and 2) the neural net architecture that gives the rough skeleton of the code, but with many details (the weights) to be filled in. The process of training the neural network compiles the dataset into the binary — the final neural network." (Karpathy)

Otro tema interesante tratado por Karpathy es que sí entendemos las redes neuronales no como un simple clasificador, sino como una nueva formar de pensar el desarrollo de programas, es posible observar de mejor manera patrones y tendencias que faciliten la creación de software 2.0. Igual como se utilizan un conjunto de herramientas para apoyar la creación de software 1.0 (i.e. IDE, versionamiento, package managers). Karpathy escribe que será natural disponer de un stack para la creación de software 2.0. Lo interesante es que desde la publicación del post el año 2017 hasta la fecha, han proliferado una serie de herramientas que constituyen parte del stack que Karpathy vislumbró. Por ejemplo, se nombra:

• El equivalente a un repositorio para albergar código de software 1.0 como GitHub -> En la actualidad contamos con el hub de datasets de HuggingFace, una implementación de lo que Karpathy describe "in this case repositories are datasets and commits are made up of additions and edits of the labels.".
• Etiquetar o re-etiquetar inputs para definir el objetivo del programa. Proyectos como Snorkel se han creado con un enfoque centrado en los datos (weak supervision), donde para un conjunto de datos sin etiqueta, o sin una calidad de etiquetado garantizado, es posible utilizar heuristicas en base a juicio experto para etiquetar de forma programática (i.e. labeling function) los datos.
• Algo similar a package managers (e.g. pip, conda) pero con checkpoints de modelos ya entrenados. De nuevo, hub de modelos de HuggingFace que permite fácilmente importar modelos y usar transfer learning para adaptarlos a nuevas tareas. Esto bajo el parádigma software 2.0 sería usar un programa para escribir otro programa.

¿Qué es una red neuronal?

Una neurona es un producto punto entre un input ($𝐱$) y un set de parámetros ($𝐰$) más un coeficiente que se llama bias ($𝐛$). Al resultado de esta operación se le aplica una función de activación ($\sigma (\cdot )$), por lo que una neurona queda espeficada como:

Si tenemos una red neuronal, organizamos conjuntos de neuronas capa por capa, por lo que la información input-output de esta va fluyendo por la red. Si concatenamos la información de dos neuronas, sería algo como:

\begin{split} \hat{y}^{(2)} &= \sigma(\boldsymbol w^{\top}\sigma(\boldsymbol w^{\top}\boldsymbol x + \boldsymbol b) + \boldsymbol b) \ &= \sigma(\boldsymbol w^{\top}\hat{y}^{(1)} + \boldsymbol b) \end{split}

Se le suele llamar hidden layers a las capas internas (i.e. diferentes al input y output del modelo) dado que su resultado no se observa de forma directa. Es posible continuar este encadenado de funciones para ir construyendo modelos con más capas. Sin embargo, analizando la expresión anterior, una red neuronal perfectamente se podría entender como un stack de regresiones logisticas.

Un punto importante es que una red neuronal no concatena un conjunto de neuronas como una simple cadena, o linked list, sino que por cada capa tenemos varias neuronas. Los pesos (o parámetros) de estas conexiones ya no serían el vector $𝐰$ sino estarían codificados en una matriz o tensor $𝐖$.

La función de activación tiene dos roles:

1. Las funciones de activación nos permiten tener multitples pendientes para distintos valores, algo que una función lineal por definición no permite.
2. La función de la última capa concentra los outputs de la operación lineal en un rango de valores determinado y requerido según el problema que estamos resolviendo.

Redes neuronales y aprendizaje de características

"Attemp have been made to mechanize both of these steps (creation of concepts & weight assignment), but, to date, very little progress has been made with respect to the concept-formation step, and most of the workers have been content to supply man-generated concepts (features) and to develop machine procedures for assigning weights to these concepts" (Samuel, pag. 17)

Una de las ventajas de las redes neuronales, y de porqué Karpathy se refiere solo a redes neuronales cuando habla de software 2.0, es la capacidad de aprender representaciones de los datos. Modelos estadísticos más tradicionales se enfocan solo en el paso de la asginación de pesos, o fitting, relegando la representación de los datos como un paso previo para que el modelo pueda insumir los conceptos que habla Arthur. Por lo tanto el modelo no tiene capacidad o no se encuentra en su diseño aprender características/features de los datos. En cambio, las redes neuronales con múltiples capas tienen la capacidad de incorporar dentro del ajuste de parámetros el aprendizaje de la representación de los datos, el paso de "creación de conceptos" a la cual se refiere Arthur en la cita del comienzo de esta sección. Lo que es de gran utilidad para lidiar con datos no estructurados como imagenes o texto, cuya representación la mayoría de las veces no es trivial de construir, o en otras palabras, su feature engineering es prohibitivo. Diferencias interesantes entre deep learning y estadística más tradicional en el post "The uneasy relationship between deep learning and classical statistics".

En el capítulo se cita y comenta el paper Visualizing and Understanding Convolutional Networks (Zeiler, Ferguson 2013) para ejemplificar lo anterior. Creo presentar este artículo es de gran utilidad porque (i) demuestra que estos modelos no son cajas negras impenetrables y (ii) es una demostración súper visual de la creación de concepto por parte de redes neuronales. Además de mostrar la expresibilidad de las capas más profundas en aprender conceptos de mayor jerarquía en base a conceptos más primitivos. Los resultados de este estudio permitieron al grupo de investigación entender mejor el modelo Alexnet que ganó la competencia Imagenet el 2012, para luego realizar modificaciones en la arquitectura del modelo, y ganar el certamen el año siguiente. Acá el abstract del paper:

Abstract: Large Convolutional Network models have recently demonstrated impressive classification performance on the ImageNet benchmark (Krizhevsky et al., 2012). However there is no clear understanding of why they perform so well, or how they might be im- proved. In this paper we address both issues. We introduce a novel visualization technique that gives insight into the function of inter- mediate feature layers and the operation of the classifier. Used in a diagnostic role, these visualizations allow us to find model architec- tures that outperform Krizhevsky et al. on the ImageNet classification benchmark. We also perform an ablation study to discover the performance contribution from different model layers. We show our ImageNet model generalizes well to other datasets: when the softmax classifier is retrained, it convincingly beats the current state-of-the-art results on Caltech-101 and Caltech-256 datasets.

Entrenar modelos con fastai y transfer learning

Este es un libro práctico y ya dentro del primer capítulo se realiza una breve demostración de como implementar un modelo de clasificación. El objetivo es identificar gatos y perros en imagenes usando la librería fastAI y el Oxford Pet dataset. Si bien la tarea es simple, lo que encontré más interesante no es el desempeño del modelo, sino la introducción de la técnica utilizada para resolver el problema, transfer learning, que esta en el core de a API. Esta técnica se basa en utilizar un modelo pre-entrenado, que ya tuvo un proceso de ajuste de parámetros, para adaptarlo a una nueva tarea. La ventaja es que ya desde el inicio contamos con capacidad instalada por el modelo anterior, lo que en algunos casos nos permite transferirla a nuestro nuevo modelo, y obtener buenos resultados sin la necesidad de contar con demasiados datos.

Al cargar los datos se hace hincapíe en el objeto path de python. Se utiliza un dataloader que es una abstracción utilizada por PyTorch para gestionar el dataset (i.e. minibatches, etiquetas, etc).

from fastai.vision.all import *
path = untar_data(URLs.PETS)/'images'

def is_cat(x): return x[0].isupper()
dls = ImageDataLoaders.from_name_func(
  path, get_image_files(path), valid_pct=0.2, seed=42,
  label_func=is_cat, item_tfms=Resize(224)
)

ImageDataLoadeers.from_name_func() es una de las funciones constructoras para inicializar el dataloader. Esta función en particular permite crear un dataloader directamente de las imagenes que se encuentran en un directorio, y cuyos nombres contienen la estructura con las etiquetas del dataset. Por lo tanto, se recibe una función para extraer las imagenes (get_image_files), se especifica el porcentaje del conjunto de validación (valid_pct), además de la función para extraer las etiquetas (label_func) y el argumento item_tfms que nos permite aplicar transformaciones a las imagenes del dataset como ajustar su tamaño, recortarlas, entre otras.

Una vez que inicializams el dataloader podemos entrenar el modelo. El objeto learner en la librería fastai controla el proceso de aprendizaje e insume todos los elementos necesarios (i.e. modelo, data, optimizador, etc). Existen learners específicos para arquitecturas conocidas como cnn_learner que es para redes con arquitecturas con capas convolucionales. Se observa que uno de los argumentos es resnet34 (34 por el número de capas), acá estamos especificando que utilizaremos este modelo pre-entrenado para adaptarlo a nuestro problema. Cuando se utiliza transfer learning no se ajustan los parámetros desde 0, sino que aplicamos fine_tune(num_iter) para (i) ajustar los parámetros de la cabeza del modelo, capa encargada de adaptar el modelo al nuevo problema, y (ii) ajustar los parámetros por cada época especificada en el argumento de la función pero con la salvedad ir ajustando con mayor velocidad los parámetros de las últimas capas respecto a los de las primeras, lo que tiene sentido si pensamos que las primeras capas ya fueron entrenadas.

learn = cnn_learner(dls, restnet34, metrics=error_rate)
learn.fine_tune(1)

Una vez que los parámetros fueron ajustados podemos utilizar el modelo como cualquier programa, el cual recibe un input y entrega un output, este modo se conoce como fase de inferencia. Finalmente, y dado que el programa creado en este capítulo fue diseñado para resolver un problema de percepcción visual que responde a la query ¿la imagen contiene un gato o un perro?. Podríamos integrarlo dentro de otro software que, por ejemplo, deje entrar a nuestro gato abriendole la puerta del patio pero que no haga lo mismo con el perro de algún vecino.

img = PILImage.create(uploader.data[0])
is_cat, _, probs = learn.predict(img)
print(f"Es un gato?: {is_cat}.")
print(f"Probabilidad de que sea un gato: {probs[1].item():.6f}")

La librería es de alto nivel y tiene abstracciones sobre el loop de aprendizaje para entrenar un modelo. Destacable que en núcleo de la API se encuentra la técnica de transfer learning.

Cuestionario

1. Do you need these for deep learning?

   • Lots of math T/F
   • Lots of data T/F
   • Lots of expensive computers T/F
   • A PhD T/F

2. Name five areas where deep learning is now the best tool in the world.

   • R: Natural Language Processing, Computer Vision, Recommendation Systems, Image Generation, Text Generation.

3. What was the name of the first device that was based on the principle of the artificial neuron?

   • R: Mark I Perceptron, desarrollado por Frank Rossenblat. Una foto de la pequeña máquina se puede ver acá.

4. Based on the book of the same name, what are the requirements for parallel distributed processing (PDP)?

   • Un conjunto de unidades de procesamiento
   • Un estado de activación
   • Una función de output para cada unidad
   • Un patrón de conectividad entre las unidades
   • Una regla de propagación para propagar patrones de actividad a través de la red de connectividad
   • Una regla de activación para combinar los inputs incidiendo en una unidad con el estado actual de esa unidad para producir un output
   • Una regla de aprendizaje donde los patrones de conectividad sean modificados por la experiencia (data)
   • Un ambiente donde el sistema opere

5. What were the two theoretical misunderstandings that held back the field of neural networks?

   • R: El primer malentendido que tuvieron las redes neuronales fue por el trabajo realizado por Marvin Minsky y Seymour Papert en su libro titulado Perceptron, donde demostraron que el Percepton no era capaz de aprender funciones matematícas elementales como la función exclusive or. Sin embargo, en el mismo libro demuestran que agregando una capa adicional al Perceptron, el modelo tenía la flexibilidad de aprender cualquier función. Otro malentendido es que estos modelos son cajas negras impenetrables. Si bien presentan desafios a la hora de su interpretación, en el capítulo se da como ejemplo el trabajo Visualizing and Understanding Convolutional Networks (Zeiler, Fergus 2013) para dismitificar que las redes neuronales son modelos inescrutalbles. Este paper investigó los parámetros de la red en cada capa e identificó los features que el modelo aprendió una vez ajustado. Utilizando esta información los autores mejoraron la arquitectura AlexNet y ganaron el siguiente certamen de Imagenet el año 2013.

6. What is a GPU?

   • R: Graphical Processing Unit (GPU). Esta pieza de hardware es útil para computar múltiples operaciones en paralelo. Dado que entrenar redes neuronales implica realizar muchas multiplicaciones y sumas, las GPU han probado ser exitosas para entrenar estos modelos.

7. Open a notebook and execute a cell containing: 1+1 What happens?

   • R: Devuelve el resultado de 2.

8. Follow through each cell of the stripped version of the notebook for this chapter. Before executing each cell, guess what will happen.

   • R: Done.

9. Complete the Jupyter Notebook online appendix (https://oreil.ly/9uPZe)

   • R: Done.

10. Why is it hard to use a traditional computer program to recognize images in a photo?

    • R: El desarrollo de un programa tradicional implica escribir las instrucciones a la máquina de manera detallada. En palabras de Arthur Samuel "Programming a computer for such computations is, at best a difficult task, ...because of the need to spell out every minute step of the process in the most exasperating detail". En tareas de percepcción, como reconocer objetos en una imagen, los humanos lo hacemos con facilidad pero a nivel subconsciente. Por lo tanto, abstraer y crear estas instrucciones requiere de un gran esfuerzo (feature engineering) y heuristicas para resolver el problema. Además varían según el contexto particular (radiografia, números) no siendo generalizables.

11. What did Samuel mean by "weight assignment"?

    • R: Asignar valores a los parámetros del modelo. El proceso de entrenamiento de una red neuronal es simplemente un proceso de estimación o ajuste de los parámetros.

12. What term do we normally use in deep learning for what Samuel called "weights"?

    • R: El término más utilizado en la actualidad es el de parámetros (i.e. especificado en la mayoría de los frameworks actuales).

13. Draw a picture that summarizes Samuel's view of a machine learning model.

14. Why is it hard to understand why a deep learning model makes a particular prediction?

    • R: Todo modelo estadístico enfrenta dificultades para comprender las predicciones a medida que la complejidad del modelo aumenta (i.e. más parámetros y capas) y cuando los datos sobre los que el modelo se encuentra operando difieren de manera importante respecto con los que fue entrenado (i.e. distribution shift). Sobretodo vimos que una de las ventajas de las redes neuronales es su capacidad modular de crecer incorporando capas y diferentes arquitecturas, pero esto tambien dificulta la interpretabilidad de las predicciones. Siempre se debe ser cauto con la interpretabilidad y afirmaciones sobre las capacidades de un modelo, y aplicar varios métodos para inspeccionar y ver el funcionamiento interno de los parámetros.

15. What is the name of the theorem that shows that a neural network can solve any mathematical problem to any level of accuracy?

    • R: El nombre del teorema es Universal Approximation Theorem. El siguiente video de Michael Nielsen es una explicación visual sobre este teorema:

16. What do you need in order to train a model?

    • R: Del diagrama de más arriba podemos inferir que para entrenar un modelo necesitamos datos (elipses azules), y por esto se entiende el input (e.g. imagen, texto, características tabularizadas) y etiquetas de buena calidad, sin esto último el mécanismo de feedback, compuesto por la función de costo (elipse morada) y la regla de actualización, no puede guiar el ajuste de los parámetros (elipse café). Se requiere una forma funcional del modelo (aka arquitectura) para realizar las predicciones (elipses rosadas) en base a los inputs, las cuáles el mécanismo de ajuste contrastará respecto a las etiquetas. Una vez que el modelo fue entrenado, tenemos un programa que recibe inputs y entrega outputs, el cual puede utilizarse como componente dentro de cualquier software.

17. How could a feedback loop impact the rollout of a predictive policing model?

    • R: El modelo se ajusta a partir de datos. Si el modelo indica predicciones para que las policias se focalicen en cierto sector geográfico, con mayor probabilidad aumentaran los arrestos e incidentes registrados en esa zona debido a la focalización de actividades de patrullaje policial. En consecuencia, habrá un mayor número de información adicional de esa zona cuando se incorporé nueva información al modelo. Al volver ajustar el modelo, los ajustes de parámetros reforzaran la relación de criminalidad en ese sector, aumentando el número de predicciones y respaldando las acciones policiales definidas. Y así obtenemos un positive feedback loop, mientras más usamos el modelo mayores sesgos producimos en los datos.

18. Do we always have to use 224x224 pixel images with the cat recognition model?

    • R: La dimensión de 224x224 responde a razones historicas cuando se diseño una arquitectura en particular. Es posible aumentar la resolución de la imagen y asi el modelo capturará mayor información, pero a un costo computacional mayor. De manera contraria, menor resolución implica una disminución en el desempeño del modelo, pero mayor eficiencia computacional. Otra razón historica a la hora de entrenar redes neuronales son que el tamaño de los batch aumenta en potencias de 2, ver No, We Don't Have to Choose Batch Sizes As Powers of 2 (Sebastian Rashcka). Además de la influencia de los random seeds para entrenar modelos, "Torch.manual_seed(3407) is all you need: On the influence of random seed in deep learning architectures for computer vision" (David Picard).

19. What is the difference between classification and regression?

    • R: La diferencia entre los problemas de clasificación y regresión tiene que ver simplemente con el tipo de variable de respuesta que estamos modelando. Si es una variable discreta (i.e. perro, gato, nivel socioeconomico) es un problema de clasificación. En cambio, si la variable de respuesta es continua (i.e. salario) es un problema de regresión.

20. What is a validation set? What is a test set? Why do we need them?

    • R: El conjunto de validación se utiliza para computar métricas durante el entrenamiento del modelo. Recordar que las métricas son de consumo humano. Además el conjunto de validación nos permite probar distintas configuraciones del modelo especificadas por los hiperparámetros. En cambio, el conjunto de pruebas, o test set, es un conjunto de datos reservado exclusivamente para reportar la performance final de nuestro modelo, una vez que se probaron todas las ideas e iteraciones de experimentos.

21. What will fastai do if you don't provide a validation set?

    • R: La librería fastai automáticamente separa el dataset en 80/20, separando un 20% de los datos para el conjunto de validación. Si se requiere cambiar este porcentaje se debe especificar en el argumento valid_pct del dataloader.

22. Can we always use a random sample for a validation set?

    • R: No siempre se debe usar un conjunto de validación aleatorio. La mayor importancia tanto del conjunto de validación como el conjunto de prueba es que sean representativos de datos futuros que no hemos visto. Y tomar un conjunto de datos y obtener una fracción de manera aleatoria no siempre es la respuesta. Imaginemos el caso de series de tiempo, no tiene mucho sentido tomar una muestra aleatoria del dataset para construir el conjunto de validación, pero si tiene sentido aislar una parte final de la serie para evaluar el modelo simulando datos futuros nunca antes visto. Otro ejemplo tiene que ver con posible redundancia en las observaciones que de no aislarlas apropiadamente, el modelo obtenga buenos resultados en el conjunto de validación solo porque ha memorizado ciertas características de este grupo de observaciones particulares, en vez de encontrar un patrón general. Por ejemplo, si tenemos la misma mascota en diferentes fotos del dataset, lo correcto sería que todos los ejemplos de esa mascota queden aislados en un mismo conjunto y no en separadas en ambos conjuntos.

23. What is overfitting? Provide an example.

    • R: El sobreajuste de un modelo se refiere al fenómeno cuando el modelo comienza a memorizar el ruido, o parte "idiosincrática" del conjunto de datos destinado al entrenamiento, tomando en cuenta efectos particulares del dataset en el ajuste de sus parámetros y no realizando ajustes que capturen patrones generalizables en los datos. El objetivo es entrenar un modelo que obtenga un buen desempeño en datos nunca antes vistos y no memorizar perfectamento los datos de entrenamiento. Por ejemplo, si utilizamos un modelo para predecir el precio de viviendas, y el modelo durante el entrenamiento se sobreajustó, sus parámetros reflejaran condiciones particulares del grupo de viviendas utilizadas para ajustar el modelo y no un patrón generalizable sobre los fundamentos en los precios de la vivienda que sean de utilidad para cualquier otra vivienda que no se encuentre en el dataset. El modelo tendrá peor desempeño en viviendas que no se encuentren en los sectores cubiertos dentro del conjunto de entrenamiento, o que sus características difieran respecto a los rangos de valores en las características de las viviendas de entrenamiento.

24. What is a metric? How does it differ from loss?

    • R: Una métrica sirve para medir el desempeño del modelo según algún objetivo como nivel de error, precisión, sesgo en las predicciones, o alguna métrica especifica de negocio (KPI). En otras palabras, las métricas son de consumo humano, y están estrechamente relacionadas con el problema que se busca resolver. En cambio, la función de costo esta diseñada para el proceso de ajuste de los parámetros del modelo. Es parte del mécanismo de retroalimentación automático del modelo. Por ejemplo, que la función de costo haya disminuido 20% en 100 iteraciones no nos dice nada respecto a si estamos identificando mejor las transaccions fraudulentas dentro de la red de pagos, pero la historia es diferente si nuestro accuracy mejoró 20%. Algo que si nos garantiza la función de costo es un mécanismo de retroalimentación respecto a las predicciones del modelo según un estado particular de parámetros (i.e. set de valores), y efectuar los cambios pertinentes de estos en la dirección que minimiza la función de costo. Por esta razón, la función debe cumplir ciertas propiedades como ser diferenciable, eficiente en computar, etcétera. En conclusión, la función de costo es para el computador y la métrica para el humano.

25. How can pretrained models help?

    • R: Un modelo pre-entrenado ya paso por un proceso de ajuste de parámetros, por lo que cuenta con algún grado de capacidad que permite acelerar el aprendizaje en nuevos datos. Estas capacidades en el mejor de los casos pueden ser características, o features, que el modelo derechamente ya aprendió y pueden ser generalizables. Por ejemplo, en el caso de un problema de clasificación de imagenes, disponer de una característica que ya identifica "esquinas" siempre será de utilidad, y es algo que se puede reutilizar. En un caso no tan óptimo, un modelo pre-entrenado puede verse como una partida en caliente para el nuevo proceso de ajuste y proveernos de una buena inicialización de parámetros versus una inicialización completamente aleatoria.

26. What is the "head" of a model?

    • R: La cabeza del modelo es la última capa que se agrega a una arquitectura de un modelo pre-entrenado especifica para el dataset que estamos trabajando. Cuando utilizamos un modelo pre-entrenado, debemos adaptar la capa final de la arquitectura del modelo a las dimensiones del output del problema que queremos "transferir" el modelo. Por ejemplo, si el modelo pre-entrenado fue ajustado en el dataset ImageNet el cual busca identificar 1000 categorías y nuestro problema solo requiere distinguir entre dos, debemos adaptar la cabeza del modelo a una salida de largo 2.

27. What kind of features do the early layers of a CNN find? How about the later layers?

    • R: Los features de las primeras capas son más primitivos, o básicos, como texturas, gradientes o esquinas. En cambio, a medida que vamos avanzando en las capas, los features que aprende la red van siendo de mayor nivel como figuras geometricas, caras, etcétera. Una explicación de esto tiene que ver con las capas convolucionales, las cuáles son capas volumétricas que despliegan varios filtros o kernels que se especializan en una misma región de pixeles (aka receptive field), aprendiendo conceptos y aprovechando la estructura de "localidad" de la imagen: pixeles más cercanos tinen mayor relación que pixeles más distantes. Además, entre capas convulocionales, este tipo de arquitecturas suelen utilizar una capa de pooling, básicamente es una técnica de downsampling, reduciendo imagenes por ejemplo de 28x28 a 14x14 compactando los pixeles de la imagen a través de una operación de agregado, lo que luego, al aplicar otra capa convolucional tiene el efecto de aumentar la cobertura de los nuevos kernels sobre la información de la imagen, aumentando su receptive field. De esta forma las últimas capas comienzan aprender conceptos de mayor jerarquía al relacionar distintas regiones iniciales que los filtros observaban y a construir en base a los conceptos más primitivos.

28. Are image models useful only for photos?

    • R: No, se puede utilizar modelos de imagen para todo problema que se pueda reformular como una imagen (e.g. sonido-a-espectogramas). Regla general, si un humano es capaz de interpretar un gráfico de cierto fenómeno que no es un problema inherente de imagen, es probable que una arquitectura diseñada para modelos de imagenes funcione bien.

29. What is an architecture?

    • R: Las redes neuronales son funciones. La arquitectura es la forma funcional que toma una red neuronal, la cual esta compuesta por las diferentes capas y conexiones descrita en los parámetros. En la imagen a continuación se preseneta la forma funcional del modelo que ganó la competencia ImageNet 2012, llamada AlexNet:

30. What is segmentation?

    • R: Es un problema dentro del campo de visión por computadora que consiste en identificar el contenido al que pertenece cada pixel dentro de una imagen (i.e. autos, semaforos, peatones, etc).

31. What is y_range used for? What do we need it?

    • R: Sirve para especificar el rango de la variable de respuesta cuando el problema es de regresión, es decir, tenemos una variable de respuesta tipo continua.

32. What are hyperparameters?

    • R: Los hiperparámetros son variables que controlan algunos aspectos sobre el proceso de entrenamiento del modelo. Por ejemplo, la cantidad de regularización o la magnitud de la tasa de aprendizaje. Son parámetros sobre parámetros dado afectan el ajustes sobre los parámetros de una u otra forma.

33. What's the best way to avoid failures when using AI in an organization?

    • R: Siempre diseñar y crear un buen conjunto de validación para evaluar correctamente la generalización de los modelos. Si se trabaja con terceros, quienes se les encargará resolver un problema utilizando modelos ajustados en base a datos, siempre guardar un conjunto de prueba que no hayan visto los proveedores. Así tendremos capacidad para diagnosticar correctamente el desempeño del modelo. Otro punto importante es paralelamente elaborar un buen modelo base para saber de antemano el posible potencial de mejora utilizando modelos más complejos para resolver el problema.

Further Research Questions

Última actualización: 09/07/2022

Why is a GPU useful for Deep Learning? How a CPU is different, and why is it less effective for deep learning?

Hay una charla realizada por Stuart Oberman, vicepresidente de NVidia, en Stanford realizada el 2017 que da un buen overview acerca sobre las GPU: Nvidia GPU Computing: A Journey From PC Gaming to Deep Learning (slides de la presentación).

GPU computing se divide en dos grandes grupos:

1. Simulación: drug design, options pricing, wheather forecasting
2. Visualización: seismic imaging, automotive design, medical imaging

NVIDIA introdujo la GPU en 1999, un único procesador para acelerar juegs de video y gráficas 3D.

Objetivo: acercarse a la calidad de imagen de estudios de video renderizadas de manera offline , pero en tiempo real. Esto significa millones de pixeles por frame, > 60 frames por segundo. Uso de largos arrays de floating points para explorar paralelismo a lo ancho y profundo.

El modelo G80 fue la primera GPU que introdujo un procesador unificado para sombras (unified shader processor). Todas las etapas de sombra usan el mismo set de instrucciones y se ejecutan en la misma unidad: streaming multiprocessor (CUDA).

CUDA: C++ for throughput computers, on-chip memory managmenet, asunchronous, parallel API, programmability makes it possible to innovate.

La slide número 22 hace una comparación interesante entre el paradigma que guia un GPU versus a un CPU:

Latency Oriented:

• Fewer, bigger cores with out-of-order, speculative execution
• Big caches optimized for latency
• Math units are small part of the die

Throughput Oriented

• Lots of simple compute cores and hardware scheduling
• Big register files. Caches optimized for bandwidth.
• Math units are most of the die

Definiciones de los conceptos anteriores según el libro Designing Data-Intensive Application de Martin Kleppmann:

Throughput

Throughput is the number of records we can process per second, or the total time it takes to run a job on a dataset of a certain size

Latency

Latency is the duration that a request is waiting to be handled -- during which it is latent, awaiting service

Response time

Response time is what the client sees: besides the actual time to process the request (the service time), it includes networks delays and queueing delays

Pascal GP100: primer modelo de NVIDIA adaptado para Deep Learning, 21 TFLOPS fp16 for Deep Learning training and inference acceleration. Primera vez que se agrega datatype fp16 con el objetivo de acelerar el entrenamiento e inferencia de modelos de Deep Learning.

Tensor Core: matriz de precision hibrida. FP16 para AB y acumula con FP32 (o FP16).

Try to think three areas where feedback loops might impact the use of machine learning. See if you can find documented examples of that happening in practice.

TODO...

The above visualization shows 20 different lines that exhibit a clearly convergence rate pattern between the hyperparameter $\eta$ and some performance measure such as the log-likelihood. How can we map the $\eta$ values to its specific lines? The natural option is used colours, but you immediately notice that we have a problem with such large quantity of different values for $\eta$. Ok, it's not really a problem, you can just designed a custom_palette (e.g. MetBrewer repo) and code as follow:

from cycler import cycler
import matplotlib as mpl

custom_palette = ['#hexcode_1', ..., '#hexcode_20']
custom_cycler = (cycler(color=custom_palette))
plt.rc('axes', prop_cycle=custom_cycler)

If you didn't know what Cycler is, it is just a convenient way that matplotlib provides to iterate for different style options such as colours, line styles, and others.

But wait…, there is a constraint here; we want to exhibit a pattern through the colours--as we increase the magnitude of $\eta$ the log-likelihood convergence rate increase as well--so we need this notion of a gradient. Look at the $\eta$ values; there are jumping in regular steps of 0.005. That could be annoying for picking a colour's sequence because we would have to be accountable for the regularity between any consecutive colours.

So, a continuous colormap (CMAP) solve the previous issue, just we need a way to discretize and pick N=20 colours.

cmap = plt.get_cmap(CMAP, N)
custom_palette = [mpl.colors.rgb2hex(cmap(i)) for i in range(cmap.N)]

Can we do better? Yes! It is possible to decouple the precision from the colour mapping to each of the 20-labels by highlighting particular lines (e.g. best, worst) using annotations. Then use a colourbar to communicate the $\eta$'s effect on the convergence rate as its value increases. The visualization will be way cleaner than the above visualization with two columns of labels.

The trick is done by ScalerMappable and requires passing two elements:

1. A cmap that can we recover from our custom_palette ListedColormap(custom_palette) or using directly the original ('RdBu' in this case)
2. A boundary on each discrete colour in the colourbar using BoundaryNorm that takes two inputs: the list and length of values (i.e. different $\eta$ values)

from matplotlib.colors import ListedColormap, BoundaryNorm
from matplotlib.cm import ScalarMappable

cbar = plt.colorbar(ScalarMappable(norm=BoundaryNorm(learning_rates, 
                                                     ncolors=len(learning_rates)), 
                                   cmap=ListedColormap(custom_palette)));
cbar.ax.tick_params(labelsize=7) 

                         That's the way computer talks to each other.

A confusion matrix is a practical and conceptually simple tool to evaluate a classification model. So we need to honour it with a simple way to compute it, like Gauss in the past, without the magic of from sklearn.metrics import confusion_matrix would do it with simple linear algebra operations:

A confusion matrix is the matrix multiplication by the true and predicted labels, both encoding as one-hot vectors.

If we have the true labels of 4 observations in vector $𝐲=[1,0,2,1]$, and 3 different classes (i.e. 0, 1 and 2), their one-hot encoding will be:

Some classification model gives us the predicted label for each observation in the vector $\widehat{𝐲}=[2,0,2,0]$, by the same logic above, the one-hot encoding will be:

A confusion matrix is the matrix multiplication by the true and predicted labels, both encoding as one-hot vectors.

As you notice, the confusion matrix summarizes the information correctly of both vectors.

• The sum of the diagonal elements tells us that two observations were correctly classified by the model
• The model correctly classified one observation for class 0
• The model didn't assign any label to class 1, producing two errors
• The model confuses two class' 1-observations, one with a 2 and the other with a 0, look at the second row

Now with import numpy as np

We need two steps to compute our confusion matrix.

First, we need a way to transform a vector $𝐯$ with k-classes into their one-hot-encoding version, v_one_hot = one_hot_econding(v):

def one_hot_encoding(v):
  '''Return the one-hot encoding vector for k-classes label vector'''
  num_classes = np.unique(v).size
  return np.eye(num_classes)[v]

Second, compute the confusion matrix, ${𝐓}^{\top }\widehat{𝐓}\in {𝐙}_{0+}^{K\times K}$, for k-classes; there are many ways of doing it with numpy as you can see in the following code. Below I used the canonical notation to name the true labels (y) and the predicted ones (y_pred):

# 1st option: Using the matrix multiplication '@' operator
one_hot_encoding(y).T @ one_hot_encoding(y_pred)

# 2nd option: Using np.dot()
np.dot(one_hot_encoding(y).T, one_hot_encoding(y_pred))

# 3rd option: Using np.matmul()
np.matmul(one_hot_encoding(y).T, one_hot_encoding(y_pred))

And we are done! Of course, you can always get your confusion matrix from your favourite store ;)

from sklearn.metrics import confusion_matrix
confusion_matrix(y, y_pred)

                         That's the way computer talks to each other.

Wed, May 12th, 2022

To my future self:

My learning process using VIM key bindings was stuck on move commands; even though I realized the power of moving freely and accurately around the editor, I haven't a reason to waste my life with key bindings. This post is a never-ending excuse to continue developing my VIM workflow. If I am reading this now, I am sure I forgot something.

Repeating a char or a seq of chars n times

Sequence: ESC-n-i-char/seq-ESC-ESC

• n: number of times
• i: insert mode
• char/seq: char or sequence of chars

Usage: Create a header for a file or when I need to repeat an arbitrary sequence of characters.

Basic replacing in the current line :s or in all llines :%s

Sequence: :s/this/for that/g or :%s/this/for that/g

• :s: is short for "substitute" on the current line
• :%s: is short for "substitute" on the whole document
• this: is the pattern you want to replace
• for that: you want instead
• g: is short for "global" and refers to replacing more than the first occurrence

Usage: guess what!

Change upper-to-lower case and viceversa

Sequence: guu (upper-to-lower) or gUU (lower-to-upper) the current line

• U: Change lower-to-upper case
• u: Change upper-to-lower case
• VIM selection + {u or U}: change the selection given u or U behavior

                         That's the way computer talks to each other.

Directional derivatives are the conceptual tool to measure the effect on a function by changing the input in any direction within the input space. It's possible to compute the directional derivatives using the jacobian-vector product, implemented by the automatic differentiation JAX library.

Partial derivatives $\partial f/\partial x_i$ give us the rate of change if we slightly modify the ith element of the input vector $𝐱$ by h, letting the rest constant.

The above definition can be more compactly using vector notation.

The $e_i$ vector represents a unit vector in the direction of $i$ with the same number of dimensions that ${𝐱}_{\mathrm{𝟎}}$. The only element of $e_i$ different from 0 is the ith-element with a value of 1.

As you can see in the initial diagram, in a 2D input space, there are two partial derivatives:

• $\partial f/\partial x$: computing parallel to the x-axis ($e_1$ typical known as $\hat{i}$)
• $\partial f/\partial y$: computing parallel to the y-axis ($e_2$ typical known as $\hat{j}$).

Computing derivatives using unit vectors such as $e_i$ give us the change of $f$ on the direction on $i$, or parallel to the i-axis. How can we compute the derivative of $f$ given a slight nudge of the inputs in any arbitrary direction?

Directional derivatives is a way to compute the rate of change on $f$ in the direction of $𝐯$.

Think as $𝐯$ as a weighted vector of the n-directions of the input space. We aren't limited to the changes on $f$ in parallel directions in the input space.

We can compute directional derivatives using the dot product between the jacobian vector ($\nabla f$) and the vector $𝐯$. For instance, for a two-dimensional input space, $𝐯=(v_1,v_2)$, and any arbitrary point $p$:

More general:

Let's focus on computing the above using the function jax.jvp, which jvp stands for the jacobian-vector product.

The function jax.jvp computes the directional derivative and whose arguments are:

1. A differentiable function $f$ to compute the jacobian $\nabla f$
2. A primal vector $𝐩$ to evaluate the jacobian $\nabla f(p)$
3. A tangent vector $𝐯$ which represent the direction in which we want to calculate the derivative.

jax.jvp returns a tuple with $(f(p),\nabla f_v(p))$

Example

We compute the directional derivative of $f(x,y)=x^{2}y$ hand-coding all the necessary elements and then checking the results given by jax.jvp.

def fun(x, y): return x**2 * y
def fun_dx(x, y): return 2*x*y
def fun_dy(x, y): return x**2

We define the primal vector $𝐩$ and the tangent vector $𝐯$ in which we want to compute the directional derivative.

p = [1., 1.]
v = [1., 2.]

Evaluate $f(p)$:

# *n-list/n-tuple unpack the element e0, e1, ..., en
fun(*p)
> 1.0

Compute the directional derivative using the fun_dx and fun_dy.

fun_dx(*p) * v[0] + fun_dy(*p) * v[1]
> 4.0

Now using jax.jvp we obtain the same results: $f(𝐩)$ and ${\nabla }_{𝐯}f(𝐩)$.

jax.jvp(fun, p, v)
> (DeviceArray(1., dtype=float32, weak_type=True),
   DeviceArray(4., dtype=float32, weak_type=True))

A surface plot will show the output space, and a contour plot the input space of $f(x,y)=x^{2}y$. We will compute the directional derivatives for three points and their respective directional vectors.

Look the directional vectors in the plot, or tangent vectors as JAX refers to them, there are of different lengths. It's important to remark that if we want the "slope definition" for directional derivatives we need to transform $𝐯$ in a unit length vector (divide the directional derivative definition by $||v||$). Remember that partial derivatives are computed using unit vectors ($e_i$).

primal_a = jnp.array([-5., 3.2])
primal_b = jnp.array([5., -3.2])
primal_c = jnp.array([0., 0.])
va = jnp.array([-7.5, 5.7])
vb = jnp.array([7.5, -5.7])
vc = jnp.array([-1.0, -0.7])
unit_va = va/va.dot(va)**.5
unit_vb = vb/vb.dot(vb)**.5
unit_vc = vc/vc.dot(vc)**.5
# Computing making the directional vectors unit length
_, slope_a = jax.jvp(fun, primal_a.tolist(), unit_va.tolist())
_, slope_b = jax.jvp(fun, primal_b.tolist(), unit_vb.tolist())
_, slope_c = jax.jvp(fun, primal_c.tolist(), unit_vc.tolist())
slope_a, slope_b, slope_c
> (DeviceArray(40.60427, dtype=float32, weak_type=True),
   DeviceArray(-40.60427, dtype=float32, weak_type=True),
   DeviceArray(-0., dtype=float32, weak_type=True))