The Event Horizons

How to Build an Host ? Episode I

admin — Tue, 02 Jan 2024 13:24:00 +0000

How to Build a Host?

Episode I

By Jordan Moles on January 2, 2024

In the year 2051, a fortunate group of young scientists is granted the exclusive opportunity to explore the mysteries of WestWorld. Their behind-the-scenes journey takes an extraordinary turn as they are invited to a unique conference orchestrated by the enigmatic park director, Dr. Ford. At the core of this encounter lies a captivating dive into the realm of Deep Learning, offering participants an unprecedented experience and unveiling the secrets of the symbiosis between cutting-edge technology and the bold imagination of WestWorld.

At the Crossroads of Intelligence

Ladies and gentlemen, welcome to WestWorld, a groundbreaking amusement park where technological innovation and artistic audacity converge to create an unparalleled immersive experience. I am Dr. Ford, the Director of this groundbreaking park, and I am here to unveil the computational intricacies and mathematical vision that underpin this extraordinary project.

Our ambition extends far beyond a mere recreation of the Wild West. WestWorld pushes the boundaries of imagination by introducing hosts, androids of unparalleled sophistication capable of interacting indistinguishably with our visitors. It’s not just entertainment; it’s an exploration of the deepest realms of artificial intelligence: Deep Learning.

At the heart of this technologically forged paradise, our quest aims to continually push the boundaries of what’s possible. Our hosts don’t merely replicate preprogrammed actions; they react, learn, and evolve in real-time. Nurtured for years by a vast database, we’ve trained, validated, and subjected them to tests (supervised learning), ensuring they provide a unique experience and have the ability to learn autonomously thereafter.

The neural networks that power them, drawing inspiration from the complexity of the human brain, equip them with the versatility needed to perform a variety of tasks, from driving a carriage to horseback riding, from reading to writing, from recognizing their counterparts to expressing empathy through emotion recognition. This sublime union between machine and human thought goes beyond classical Machine Learning models such as K-Nearest Neighbors, decision trees, or support vector machines. Each interaction with a visitor represents an opportunity to refine their cognitive skills (unsupervised learning), providing a unique experience at every moment, even if this aspect will not be explored in this conference.

At WestWorld, our mission extends beyond providing simple entertainment; we give birth to virtual worlds that transcend reality. For enlightened minds like yours, eminent actors in this endeavor, it’s an expedition to the frontier of technology and humanity, a fusion of artistic creativity and advanced computing power. Our goal today is to initiate you into the fundamental concepts of neural networks by introducing the multilayer perceptron and unveiling the process through which our hosts learn to recognize numbers. In an upcoming conference, we will explore in detail how they manage to identify other individuals. Get ready to embark on an adventure where the line between man and machine blurs, opening horizons as vast as imagination itself.

At the Beginning: The Biological Neuron

Numbering around 86 billion and connected by thousands or even tens of thousands of synapses, these highly specialized cells, encoded in our genetic heritage for billions of years, are called neurons.

Assembled into a network, these neurons, which we classify as “biological” in contrast to “artificial,” generate human thought and what we label as intelligence. However, they are not the only brain cells in action. Other cell types play a fundamental role and contribute to the neuronal process, with their essential presence being indispensable to the very existence of neurons.

The structure

The fundamental structure of the nervous system, consisting of interconnected excitable cells, plays a crucial role in the transmission of information within our neural network. It comprises several key components that orchestrate its function.

The dendrites act as interfaces with the environment, forming the neuron’s input. In large numbers, these extensions respond to various stimuli, such as light at the eyes or pressure on the skin, generating electrical discharges, also called action potentials, directed toward the cell body. The synapse, the connection point between neurons, plays a crucial role at this juncture, where the neuron receives signals from previous neurons or from the outside. These signals, whether inhibitory or excitatory (+1 or -1), converge onto the neuron, and when their sum exceeds a critical threshold, the neuron activates, thus producing an electrical signal.

The cell body, central to the process, performs a summation of the intensity of electrical influx from all dendrites. If this sum exceeds a critical threshold, the neuron activates and generates an electrical discharge transmitted to the axon, the neuron’s single output pathway. This critical threshold, determining supra-threshold excitation, holds big significance.

The axon, as the common final pathway, branches into multiple extensions, connecting the neuron to other neurons through the following dendrites and synapses. These points of connection, anatomically represented as synaptic clefts, are essential for the transfer of information between neurons. The axon’s termination, marked by neurotransmitter vesicles, releases these chemical messengers into the synaptic cleft. In turn, the dendrite of the next neuron, equipped with receptors, binds the neurotransmitters, thus triggering the formation of an electrical current in the dendrite.

Regarding the information transmitted by the neuron, it is important to understand its electrochemical dualism. Initially created in electrical form at the dendrites in response to a stimulus, the information propagates through the cell body to the axon. At its termination, the electrical influx triggers the release of neurotransmitters, transforming the information into a chemical form at the synapse.

It is important to emphasize that this information flows in only one specific direction, from the dendrites to the axon. The dendrite captures the signal, and the axon broadcasts it, creating unidirectionality in the flow of neuronal information. This subtle electrochemical dance within the neuron forms the foundation of our understanding, thoughts, and interaction with the world around us.

How does it Works ?

As the pivot of the nervous system, it reveals itself as the master cell capable of transmitting electrochemical signals throughout the organism. These signals, resulting from depolarizations of the plasma membrane and the release of chemical molecules at connection points with other cells, form the foundation of neurotransmission.

Each neuron, dedicated to specific tasks, contributes to a complex network that enables diverse functions such as memory, motor skills, learning ease, and even speech recognition, among others.

The variety of neurons, reflecting the diversity of roles they fulfill, makes them essential actors in the complex orchestration of the functions of the nervous system. Through their extensions, the dendrites and the axon, these cells establish vital connections with innervated organs and other neurons, consolidating their central role in the functions of the nervous system.

The First Artificial Neuron in History

Ladies and gentlemen, it is now appropriate to introduce to you the famous artificial neuron, a major concept in computer science inaugurated by W. McCulloch and W. Pitt as early as 1943, a bygone era.

Although devoid of physical reality, this remarkable element provides a simple algorithmic replica of its biological counterpart, thus marking the beginning of a fascinating journey into the world of artificial intelligence.

Its Structure and Functioning

The structure of the artificial neuron is characterized by several key elements, including input and synaptic weights, the cell body, and the output. Each of these aspects contributes crucially to information processing within artificial neural networks. Let’s explore each of them in detail.

We Collect the Information

Let’s start with the input. In computer science, the input represents the data to be processed, such as a sequence of characters, an image, a gold density, or even a video.

Each artificial neuron receives a variable number of inputs from upstream neurons, which we’ll denote as X. These inputs are signals that activate the neuron and are accompanied by weights (represented by “w” for “weight”) that quantify the strength of the connection.

The set of these inputs forms the first stage of information processing by the artificial neuron.

The Artificial Cell Body: a Mathematical Function

The Aggregation Phase: Inspired by the functioning of dendrites, synaptic weights are assigned to each input value, representing the relative importance of different connections to the neuron. The inputs, thus weighted, are then summed, incorporating a bias (a constant value). For now, we consider synaptic weights of either +1 (excitatory) or -1 (inhibitory), but we will generalize this later.

The Activation Phase: Following the aggregation phase, an activation function determines whether the neuron should be activated. Initially, we choose a threshold function (known as the Heaviside step function). This function returns an output $y=1$ if the previous weighted sum exceeds a threshold value and 0 otherwise (here is a graphical representation).

Activation functions play a essential role in information processing and can take various forms, including the step function, the sigmoid function (remember the sigmoid), the rectified linear unit (ReLU) function, or even the hyperbolic tangent function.

Processed Information

The output of the artificial neuron is the final result of the information processing contained in the input data X, either y=0 (activated) or y=1 (deactivated). It can be transmitted to other neurons, thus forming a complex chain of calculations that characterizes the overall operation of artificial neural networks.

This initial model of the artificial neuron was later termed the “Threshold Logic Unit” due to its ability to process only logical inputs of either 0 or 1. Researchers successfully demonstrated that this model could replicate certain logical functions such as the AND and OR gates. By interconnecting multiple units in a manner similar to the connections between neurons in our brains, it seemed possible to solve virtually any boolean logic problem.

Despite the excessive enthusiasm generated by this announcement, I want to assure you that, at the time, a significant portion of the scientific community believed that we could develop artificial intelligences capable of entirely replacing humans.

Scientist in the audience, looking at the hosts next to Dr. Ford: “They weren’t entirely wrong!” Laughter in the room.

Dr. Ford resumes with a smile: Indeed, not entirely wrong, just that their timeline wasn’t suited to this prediction. Nevertheless, this anticipation did not materialize directly. Although this model laid the groundwork for what is now known as Deep Learning, it had several limitations, notably the absence of a learning algorithm. Thus, users had to manually determine the values of the parameters “W” if they wished to apply this model to real-world applications.

A Simple Example

Normally, these are basics, but let’s start with a brief explanation of Boolean algebra for the two scientists in the background.

Boolean algebra, named after the British mathematician George Boole, is a branch of mathematics that focuses on the representation and manipulation of logical information through operations on variables called booleans. These variables can only take two values, typically denoted as 0 and 1, representing the states false (no) and true (yes), respectively.

Widely used in computer science, electronics, and other information processing-related fields, Boolean algebra is fundamental to the design of logical circuits, algorithms, and serves as the basis for propositional logic.

In Boolean algebra, the fundamental operations are logical AND, logical OR, and logical NOT. These operations apply to pairs of Boolean variables and produce a Boolean result.

An Example within an Example

Now, to better understand these operations, let’s consider an example of a room with a switch A and a sensor B detecting the presence of people, controlling the lighting.

Switch A AND Sensor B (A AND B):
– If switch A is on (A = 1) AND sensor B detects people (B = 1), then condition C “the light turns on” is TRUE (C = 1).
– If switch A is off (A = 0), even if sensor B detects people (B = 1), condition C is FALSE (C = 0).
– If switch A is on (A = 1) but sensor B does not detect people (B = 0), condition C is also FALSE (C=0).
– If both switch A and sensor B are off (A=0 and B=0), condition C is FALSE (C=0).

Switch A OR Sensor B (A OR B):
– If switch A is on (A = 1) OR sensor B detects people (B = 1), then condition C is TRUE (C=1).
– If switch A is off (A = 0) OR sensor B detects people (B = 1), then condition C is TRUE (C=1).
– If both, if switch A is on (A = 1) or sensor B does not detect people (B = 0), then the condition is TRUE (C=1).
– If switch A is off (A = 0) or sensor B does not detect people (B=0), then condition C is FALSE (C = 0).

In these examples, the AND operation requires the switch to be on and people to be detected for the condition to be true. Conversely, the OR operation requires either the switch to be on or people to be detected for the condition to be true.

We can summarize everything in these two tables:

A	B	A AND B
0	0	0
0	1	0
1	0	0
1	1	1

A	B	A OR B
0	0	0
0	1	1
1	0	1
1	1	1

These basic operations can be combined to form more complex logical expressions, allowing for the representation of conditions (not just two, as in the previous example) and logical reasoning.

Boolean algebra finds practical applications in the design of logic circuits, control systems, computer science, and other fields where binary logic is used to model states and decisions.

Revenons au Neurone

The scientist from the background raises his hand to ask a question: “But what does a neuron have to do with Boolean algebra?”

Dr. Ford delves into the explanations: “Let’s simplify and consider a formal neuron that simply accepts two input variables $x_1$ and $x_2$ arranged in an input vector (this is the information the neuron receives).

\begin{equation*} \mathbf{X}=\left[ \begin{array}{c} x_{1} \\ x_{2} \end{array} \right]. \end{equation*}

Knowing that the inputs can only take the values 0 or 1 in our case, we have only 4 possible input vectors:

\begin{equation*} \left[ \begin{array}{c} 0 \\ 0 \end{array} \right]\quad \left[ \begin{array}{c} 0 \\ 1 \end{array} \right]\quad \left[ \begin{array}{c} 1 \\ 0 \end{array} \right]\quad \left[ \begin{array}{c} 1 \\ 1 \end{array} \right] \end{equation*}”

They are also defined by two synaptic parameters $w_1$ and $w_2$, which are also placed in a vector, denoted as $\mathbf{W}$.

\begin{equation*} \mathbf{W}=\left[ \begin{array}{c} w_{1} \\ w_{2} \end{array} \right]. \end{equation*}

These can take values of either 1 or -1. So, as before, we have only 4 possible weight vectors:

\begin{equation*} \left[ \begin{array}{c} -1 \\ -1 \end{array} \right]\quad \left[ \begin{array}{c} -1 \\ 1 \end{array} \right]\quad \left[ \begin{array}{c} 1 \\ -1 \end{array} \right]\quad \left[ \begin{array}{c} 1 \\ 1 \end{array} \right] \end{equation*}

Now we can begin the aggregation phase, which first takes an input, associates it with a corresponding weight, sums it up, and adds a bias denoted as b. Here is the result:

\[ \Sigma = w_1 x_1 + w_2 x_2 + b \]

We place all of this in a table.

Then we move on to the activation phase, meaning we introduce the obtained value $\Sigma$ into our threshold function, denoted as H, which determines the neuron’s output as follows:

\[ y = H(\Sigma + b) \]

Applying a similar reasoning, we observe that a neuron with a single input can either have no effect (identity neuron) or perform a logical NOT operation.

By establishing a connection with Boolean algebra, we have demonstrated how this model can perform fundamental logical operations, such as OR and AND.

However, despite its advancements, this model alone has two major limitations: firstly, it is limited to simple operations, and secondly, it lacks any learning mechanism. As illustrated earlier, the only operations we can perform are OR and AND, and we must manually determine the weight values to carry out these specific logical operations. These limitations have motivated the further development of more sophisticated models in the field of Deep Learning. By networking these neuron models, we gain the ability to solve virtually any Boolean logic problem. Furthermore, if we allow the model to learn autonomously, it becomes possible to address more complex issues and significantly expand its capabilities.

The advent of the Perceptron

The perceptron, designed by the American psychologist Frank Rosenblatt around fifteen years after the introduction of the formal neuron concept by McCulloch and Pitt, represents a significant advancement with the introduction of the first Deep Learning learning algorithm.

The perceptron model shares a striking similarity with the one we have just studied. In fact, the only difference between the perceptron and the previous formal neuron lies in the addition of a learning algorithm that enables it to determine the values of its parameters W, in order to achieve the desired outputs y, thus eliminating the need for manual search by humans.

F. Rosenblatt drew inspiration from Hebb’s law in neuroscience, suggesting that the strengthening of synaptic connections between two biological neurons occurs when they are excited together, a phenomenon known as the “cells that fire together, wire together” principle. This synaptic plasticity is crucial in the construction of memory and learning.

The Hebb's Law

The learning algorithm of the perceptron involves training the artificial neuron on reference data (X, y). With each activation of the input X simultaneously with the presence of the output y in the data, the parameters W are strengthened. F. Rosenblatt formulated this idea with the following equation:
\[ W^* = W + \delta(y_{\text{ref}} – y)X \]
where the new weights $ W^* $ are updated with a learning rate $ \delta $. $ y_{\text{ref}} $ is the reference output, y is the output produced by the neuron, and X is the neuron’s input.

This formula adjusts the weights to minimize the difference between the expected output and the output produced by the neuron. Thus, if the neuron produces an output different from the expected one (e.g., y=0 instead of y=1), the weights associated with the activated inputs are increased. This process continues until the neuron’s output converges to the expected output.

Model Limitations

Ladies and gentlemen of the scientific community, let us now consider a perceptron composed solely of two inputs $x_1$ and $x_2$. Its aggregation function is thus $f(x_1, x_2) = w_1x_1 + w_2x_2$, and, due to its form, it can model linear relationships. However, this simplicity comes with limitations when faced with nonlinear problems.

Dr. Ford astutely points out, “The perceptron, at its core, is like a tool with a narrow perspective. It may succeed in making rough predictions, but it struggles to grasp the complexity of nonlinear relationships present in the real world.”

A scientist from the audience, displaying a profound understanding, remarks, “It’s like trying to predict the behavior of a circle by drawing only a line with a ruler.”

Dr. Ford, smiling, responds, “Exactly! That’s why we are exploring more complex approaches to model the richness of relationships.”

A few more Perceptrons

To overcome this initial problem, let’s first introduce three perceptrons that we will connect together. The first two will each receive inputs $x_1$ and $x_2$, perform their calculations based on their parameters, and then send an output $y$ to the third perceptron. The third one will also perform its own calculations to produce a final output.

Try programming three neurons as described above, and you can plot the graphical representation of the final output based on the inputs $x_1$ and $x_2$. This will yield a nonlinear model, much more interesting.

This model will then be your first artificial neural network, consisting of 3 neurons distributed across two layers: an input layer and an output layer. You can add as many layers and neurons as you want, but the more you add, the more computational time and resources will be required for simulating complex results. You can also change the topology, meaning the nature of connections between neurons. This will depend on the problem at hand. That’s what we will explore next.

Neural Networks

Neural networks, also known as artificial neural networks, are computational models inspired by the structure and functioning of the human brain. They consist of interconnected artificial neurons organized into layers. Each neuron receives inputs, performs processing operations, and then produces an output. These outputs are then transmitted to the neurons in the next layer, creating a layered architecture.

Neural networks typically include three main types of layers:

1. Input Layer: Receiving input data from the system, each node in this layer represents a feature or input variable.

2. Hidden Layers: These layers perform data transformation operations. Each node in a hidden layer takes inputs, applies weights and biases, and produces an output. They are really important for the network to learn complex representations of the data.

3. Output Layer: Producing the final prediction or classification, this layer synthesizes the information learned by the hidden layers to generate the ultimate output.

The choice of hidden units is an active area of research in machine learning. The number of hidden layers is referred to as the depth of the neural network. The question of how many layers make a network “deep” does not have a single answer. Generally, deeper networks have the capacity to learn more complex functions.

There are several types of neural networks based on the topology of connections between neurons. The topology can vary depending on the specific architecture of the network, but some regularities are commonly observed. Here are some examples of topologies:

• Multi-layer perceptron (MLP): Each neuron in a layer is connected to all neurons in the next layer. It is a simple configuration used, notably, for image classification.

• Convolutional Neural Network (CNN): Specialized in image processing, it uses filters to analyze local parts, reducing the number of parameters and extracting important features.

• Recurrent Neural Network (RNN): Designed to process sequential data, it uses recurrent connections to consider the temporal sequence of data.

• Long Short-Term Memory (LSTM): An extension of RNNs, LSTMs handle longer sequences by mitigating the vanishing gradient problem.

• The Autoencoder Network: Intended for unsupervised learning, the autoencoder network consists of an encoder layer and a decoder layer. Its goal is to reproduce the input while generating a latent representation. Emphasis is on dimension reduction, particularly useful with large volumes of data. By substituting this data with a representation in a lower-dimensional space, processor efficiency is optimized, enhancing the model’s effectiveness (discussed in another article).

• Residual Neural Network (ResNet): Introduced to address the vanishing gradient problem, ResNets use residual connections to facilitate learning of deeper representations.

In this exploration, we will particularly focus on feedforward neural networks. It is the first type of artificial neural network, the simplest one, where information moves only forward, from input nodes to output nodes, without cycles or loops (it is said to be acyclic, distinguishing it from recurrent networks). The single perceptron we have already seen, and its well-known extension, the multi-layer perceptron, which we will delve into shortly.

But by the way, I forgot, how do we train a neural network to do what we ask of it, meaning how do we find the parameters $w$ and $b$ to obtain the right model?

The entire audience remains silent.

Don’t worry; we are about to discuss that now.

Cognitive Programming of Hosts for Handwritten Digit Recognition: The Multilayer Perceptron

Before our hosts can excel in more advanced tasks, such as recognizing humans or even emotions, it is imperative to initiate them into the fundamentals, starting with the recognition of handwritten digits because, as the proverb goes, “Before learning to run, one must learn to walk.”

To guide them in this (supervised) learning, we use a series of images of digits, each visually representing the correspondence between the handwritten form and the respective digit.

Next, our hosts are challenged to recognize the presented digits.

This classification model forms the first artificial neural network for our hosts, comprising an input layer, several hidden layers (to be determined), and an output layer. Such a multilayer network, where complexity can be increased by adding more layers and neurons, but it will require more computational time.

Now, let’s explore the process to which our hosts are subjected during their programming to master this task.

Assimilation des Données d'Entraînement (DataSet)

Our hosts are supplied with training data, consisting of 60,000 examples of 28 pixel by 28 pixel resolution grayscale images of handwritten digits and their respective correspondences. This data is needed for teaching hosts to generalize from existing examples. And 10,000 test images of the same format to examine them, i.e. how well they have classified the images. Here are the numbers from 0 to 9:

Such images are simply arrays of data containing numbers from 0 to 255. Each of the 60,000 arrays is “flattened” to form 60,000 X vectors with 784 coordinates corresponding to the total number of pixels in an image with a y label between 0 and 9.

Building the Cognitive Model

The cognitive model represents the structure of the neural network in our hosts’ minds, encompassing aspects such as the number of layers, the number of neurons per layer, learning parameters (W and b), and even activation functions. Model design is highly dependent on the specific nature of the task at hand.

Weights and biases will undergo continuous adjustments throughout training to minimize the error between model predictions and expected outputs. Appropriate initialization and updating of these parameters is useful to optimize network performance. Other parameters such as the number of layers and the number of neurons will be adjusted manually to find the most efficient model within a reasonable timeframe and without consuming excessive resources, as it is undesirable for a host to take 30 seconds to recognize a handwritten digit, or to be inactive during this task.

Forward propagation

The first step in this cognitive process is forward propagation: the host brain circulates information from the pixels of the first layer to the last, producing an output y (the handwritten digit label).

Let’s analyze how it works.

• The input layer consists of just 784 neurons, each analyzing one pixel of the image. It has no parameters.

• The hidden layers (sigmoid): next, we endow our hosts with two hidden layers, each comprising 100 neurons with a sigmoid activation function.

The output of the first layer is a vector $A^1$ containing 100 coordinates (one for each neuron). The calculations carried out for each element are simple and are based on the perceptron model: we calculate the aggregation function and then apply the activation function to it.

We write everything compactly in matrix form.

\begin{align*}
Z^{1} &= W^{1}\cdot X+b^1\\
A^{1} &= \frac{1}{1+\exp{(-Z^{1})}}
\end{align*}

The second hidden layer provides a vector $A^2$ also containing 100 coordinates. We do the same for the second layer

\begin{align*}
Z^{2} &= W^{2}\cdot A^{1}+b^2\\
A^{2} &= \frac{1}{1+\exp{(-Z^{2})}}
\end{align*}

• The output layer: Finally, since the aim is to classify numbers from 0 to 9, an output layer of 10 neurons, accompanied by a softmax activation function, is more than sufficient.

\begin{align*}
Z^{3} &= W^{3}\cdot A^{2}+b^2\\
A^{2} &= \frac{1}{1+\exp{(-Z^{3})}}
\end{align*}

The softmax function assigns probabilities to each possible class. For each input image, it assigns a probability of belonging to class 0, 1, 2, …, up to 9. Here’s an example

Digits	0	1	2	3	4	5	6	7	8	9
Probabilities	0.00000028	0.00000000023	0.000017	0.000070	0.00000000019	0.00000030	0.000000000018	0.99	0.0000018	0.000022

According to this table, there’s virtually no doubt that this number is 99% 7, so the host will assign it this number. In general, the host will assign the image the label with the highest probability.

This function therefore allows results to be interpreted as the confidence of the model in each class, and facilitates decision-making in the context of a multiclass classification task.

Cognitive Error Analysis: The Cost Function

In the second phase, the host neural network analyzes the error between the model’s output y (its prediction) and the expected reference output (y_{text{ref}}). This evaluation is carried out using a cost function frequently used in classification tasks, including handwritten digit recognition. In this case, it’s the categorical cross-entropy, which we’ve already encountered (in another form).

We recall its expression:

\begin{align*}L(W,b)=-\frac{1}{n}\sum_{k=1}^n\left[y^{(k)}\log{y_{\text{ref}}}+\left(1-y^{(k)}\right)\log{\left(1-y_{\text{ref}}\right)}\right].\end{align*}

In general, $y_{ref}$ can be the final output but also any neuron layer output $A^{i}$ with i the i-th layer which we place in an array named $\mathbf{A}$. This gives the following matrix formula:

\begin{align*}L(W,b)=-\frac{1}{n}\left[\mathbf{y}\log{\mathbf{A}}+\left(1-\mathbf{y}\right)\log{\left(1-\mathbf{A}\right)}\right].\end{align*}

This is a fundamental element in the cognitive analysis of the model, and measures the difference between the probabilities predicted by the model and the actual probabilities of the classes. Its aim is to appropriately quantify the discrepancy between the neural network’s predictions and the true labels associated with the digit images. Efficient minimization of this cost function during training helps to fine-tune the model parameters for better performance. de chiffres. Une minimisation efficace de cette fonction coût lors de l’entraînement contribue à affiner les paramètres du modèle pour une meilleure performance.

Mechanisms of Comprehension

The third step is backpropagation. The hosts measure how this cost function varies in relation to each layer of the model, working backwards from the last to the first. In other words, they will analyze the error of the output and the penultimate layer, then the penultimate layer and the penultimate layer and so on, all the way back to the input layer.

In short, we need to calculate how the error propagates from the output to the input in order to reduce it. On this network with two hidden layers, this results in 6 terrifying expressions (if you remember just the previous sentence, that’s fine):

Starting with the last one (from the exit to the second one)

\begin{align*}
\frac{\partial L(\mathbf{W},b)}{\partial \mathbf{W}^3} =\frac{\partial L}{\partial \mathbf{A}^3} \times \frac{\partial \mathbf{A}^3}{\partial \mathbf{Z}^3} \times \frac{\partial \mathbf{Z}^3}{\partial \mathbf{W}^3}
\end{align*}

\begin{align*}
\frac{\partial L(\mathbf{W},b)}{\partial \mathbf{b}^3} =\frac{\partial L}{\partial \mathbf{A}^3} \times \frac{\partial \mathbf{A}^3}{\partial \mathbf{Z}^3} \times \frac{\partial \mathbf{Z}^3}{\partial \mathbf{b}^3}
\end{align*}

penultimate (second to first)

\begin{align*}\frac{\partial L(\mathbf{W},b)}{\partial \mathbf{W}^2} =\frac{\partial L}{\partial \mathbf{A}^3} \times \frac{\partial \mathbf{A}^3}{\partial \mathbf{Z}^3} \times \frac{\partial \mathbf{Z}^3}{\partial \mathbf{A}^2}\times\frac{\partial \mathbf{A}^2}{\partial \mathbf{Z}^2} \times \frac{\partial \mathbf{Z}^2}{\partial \mathbf{W}^2}\end{align*}

and finally the Input (from the first to the input)

\begin{align*}\frac{\partial L(\mathbf{W},b)}{\partial \mathbf{W}^1} =\frac{\partial L}{\partial \mathbf{A}^3} \times \frac{\partial \mathbf{A}^3}{\partial \mathbf{Z}^3} \times \frac{\partial \mathbf{Z}^3}{\partial \mathbf{A}^2}\times\frac{\partial \mathbf{A}^2}{\partial \mathbf{Z}^2}\times \frac{\partial \mathbf{Z}^2}{\partial \mathbf{A}^1}\times\frac{\partial \mathbf{A}^1}{\partial \mathbf{Z}^1} \times \frac{\partial \mathbf{Z}^1}{\partial \mathbf{W}^1} \end{align*}

\begin{align*}\frac{\partial L(\mathbf{W},b)}{\partial \mathbf{b}^1} =\frac{\partial L}{\partial \mathbf{A}^3} \times \frac{\partial \mathbf{A}^3}{\partial \mathbf{Z}^3} \times \frac{\partial \mathbf{Z}^3}{\partial \mathbf{A}^2}\times\frac{\partial \mathbf{A}^2}{\partial \mathbf{Z}^2}\times \frac{\partial \mathbf{Z}^2}{\partial \mathbf{A}^1}\times\frac{\partial \mathbf{A}^1}{\partial \mathbf{Z}^1} \times \frac{\partial \mathbf{Z}^1}{\partial \mathbf{b}^1} \end{align*}

Optimisation Mentale

Finally, the fourth stage is mental optimization. Hosts mentally adjust each model parameter using gradient descent (remember that? see the article Wall-E: The Little Gold Miner), before returning to the first stage, forward propagation, to start a new training cycle.

\begin{align*}\mathbf{W^*}=\mathbf{W}-\delta \frac{\partial }{\partial \mathbf{b}}L(\mathbf{W},\mathbf{b})\\
\mathbf{W^*}=\mathbf{W}-\delta \frac{\partial }{\partial \mathbf{W}}L(\mathbf{W},\mathbf{b})
\end{align*}

where $\delta$ is the learning rate of all neurons.

In summary, this process enables our hosts to master handwritten digit recognition to some extent, with a success rate of around 83%, although this performance is not exceptional. Here are some of the mistakes our guests make:

Clearly, some handwritten numbers can be confusing, even to the human eye, while others seem to be unmistakably identifiable, like the 3 above.

So, by adjusting a few parameters, it becomes relatively easy to significantly improve the model’s performance and reach 94% accuracy, a key skill in their journey towards acquiring more advanced cognitive tasks.

As our guests progress, they’ll broaden their scope of expertise, unlocking new possibilities for more immersive experiences at Westworld.

The Hosts of Westworld: From Numbers to Faces.

In conclusion, my dear guests, our first exploration into the mysteries of Deep Learning ends here. I’m delighted to have revealed a number of concepts to you, including formal neurons, perceptrons and multi-layer perceptrons. We’ve analyzed a concrete example where the hosts of Westworld, through their processors, have acquired the ability to recognize and interpret handwritten numbers with disconcerting accuracy.

But make no mistake, this neural network alone is far from sufficient when the world to be analyzed has a higher resolution. The number of training parameters that had to be adjusted for our multi-layer perceptron (there were many! 89,610 parameters) of just two hidden layers of 100 neurons was relatively small to be run on low-power machines. Now imagine simulating such a model with hundreds of layers and thousands of neurons per layer. It would be impossible! This is why other techniques have been developed, such as convolutional neural networks, which use filters to analyze characteristic elements of the image.

Finally, and I’ll leave it at that, don’t visualize an artificial intelligence that discerns faces, complex objects or emotions as “intelligent”. For even if hosts seem to come strikingly close to humanity in their interactions, let’s always remember that they are nothing more than machines.

Dr. Ford - "Remember, hosts are not real. They are not conscious."

Bibliography

F. Rosenblatt, The Perceptron, A perceiving and recognizing automaton, Cornell Aeronautical Laboratory,‎ 1957

F. Rosenblatt, The Perceptron: A Probabilistic Model For Information Storage And Organization in the Brain, Psychological Review, vol. 65, no 6,‎ 1958

M. Tommasi, Le Perceptron, Apprentissage automatique : les réseaux de neurones, cours à l’université de Lille 3.

D.B. Parker, Learning Logic , Massachusetts Institute of Technology, Cambridge MA,‎ 1985.

G. Saint-Cirgue, Machine Learnia, Youtube Channel.

USI Events, Deep learning, Yann LeCun on Youtube.

Note: for more information on the code provided, please visit GitHub. Link in the footer!

Handmade Perceptron


import numpy as np
import matplotlib.pyplot as plt

# Set the random seed for reproducibility
np.random.seed(42)

# Generate points for class 0
class0_points = np.random.normal(loc=[3, 6], scale=[1, 1], size=(200, 2))

# Generate points for class 1
class1_points = np.random.normal(loc=[7, 3], scale=[1, 1], size=(200, 2))

M0 = np.zeros((class0_points.shape[0], 1))
M1 = np.ones((class1_points.shape[0], 1))

X = np.concatenate([class0_points, class1_points], axis=0)
y = np.concatenate([M0, M1], axis=0)


# Create an initialization function to initialize parameters W and b of our model
def initialization(X):
    np.random.seed(seed=0)
    W = np.random.randn(X.shape[1], 1)
    b = np.random.randn(1)
    return W, b

W, b = initialization(X)

print(W.shape)

# Next, create an iterative algorithm where we repeat the following functions in a loop:

# Start with the function that represents our artificial neuron model, where we find the function Z = X.W + b and the activation function A
def model(X, W, b):
    Z = X.dot(W) + b
    A = 1 / (1 + np.exp(-Z))
    return A

A = model(X, W, b)

# Next, create an evaluation function, i.e., the cost function that evaluates the model's performance by comparing the output A to the reference data y
def log_loss(A, y):
    return (1 / len(y)) * np.sum(-y * np.log(A) - (1 - y) * np.log(1 - A))

# In parallel, calculate the gradients of this cost function
def gradients(A, X, y):
    dW = (1 / len(y)) * np.dot(X.T, A - y)
    db = (1 / len(y)) * np.sum(A - y)
    return dW, db

dW, db = gradients(A, X, y)

print(dW.shape)
print(db.shape)

# Finally, use these gradients in an update function that updates the parameters W and b to reduce the model's errors
def update(dW, db, W, b, learning_rate):
    W = W - learning_rate * dW
    b = b - learning_rate * db
    return W, b

# Create a prediction function
def predict(X, W, b):
    A = model(X, W, b)
    return A >= 0.5

# Create an artificial neuron
def artificial_neuron(X, y, learning_rate=0.1, n_iter=100):
    # Initialize W, b
    W, b = initialization(X)

    # Visualize the loss
    Loss = []

    # Create a training loop
    for i in range(n_iter):
        A = model(X, W, b)
        Loss.append(log_loss(A, y))
        dW, db = gradients(A, X, y)
        W, b = update(dW, db, W, b, learning_rate)

    # Calculate predictions for all data
    y_pred = predict(X, W, b)

    # Display the performance of our model (e.g., accuracy), comparing the reference data y with our predictions
    # print(accuracy_score(y, y_pred))

    # Visualize the loss to see if our model has learned well
    plt.plot(Loss)
    plt.grid(ls='--')
    plt.show()
    return W, b

# Train the artificial neuron
W, b = artificial_neuron(X, y)

# Test on new data
new_data = np.array([6, 4])

plt.scatter(X[:, 0], X[:, 1], c=y, cmap='Dark2', label='Class 0 (Blue) / Class 1 (Orange)')
plt.scatter(new_data[0], new_data[1], c='red', label='New Data (Red)')
plt.title('Classification with an Artificial Neuron')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.grid(ls='--')
plt.legend()
plt.show()

prediction = predict(new_data, W, b)
print(f"Prediction for new data: {prediction}")

# Create the decision boundary
x0 = np.linspace(-1, 11, 100)
x1 = (-W[0] * x0 - b) / W[1]

plt.plot(x0, x1, c='red', lw=2, ls='--', label='Decision Boundary')
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='Dark2', label='Class 0 (Green) / Class 1 (Grey)')
plt.title('Classification with a Perceptron and Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.grid(ls='--')
plt.legend()
plt.show()

Handmade Multilayer perceptron for digit recognition


import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from sklearn.metrics import log_loss, accuracy_score
from keras.datasets import mnist
from sklearn.preprocessing import OneHotEncoder

# Load MNIST data
(X_train, y_train), (X_test, y_test) = mnist.load_data()


# Display one image for each digit
fig, ax = plt.subplots(nrows=1, ncols=10, figsize=(20, 4))
for digit in range(10):
    digit_indices = np.where(y_train == digit)[0]
    ax[digit].imshow(255 - X_train[digit_indices[0]], cmap='gray')
    ax[digit].set_title(f'Digit {digit}')
    ax[digit].axis('off')

plt.tight_layout()
plt.show()



# Reshape and normalize input data
X_train_reshape = X_train.reshape(X_train.shape[0], -1) / 255.0
X_test_reshape = X_test.reshape(X_test.shape[0], -1) / 255.0

# Transpose labels if needed
y_train = y_train.reshape(-1, 1)
y_test = y_test.reshape(-1, 1)

# One-hot encode labels
encoder = OneHotEncoder(sparse=False, categories='auto')
y_train_onehot = encoder.fit_transform(y_train)
y_test_onehot = encoder.transform(y_test)

# Select a subset of data
m_train = 5000
m_test = 1000

X_train_reshape = X_train_reshape[:m_train, :]
X_test_reshape = X_test_reshape[:m_test, :]
y_train_onehot = y_train_onehot[:m_train, :]
y_test_onehot = y_test_onehot[:m_test, :]

print(X_train_reshape.shape)
print(X_test_reshape.shape)
print(y_train_onehot.shape)
print(y_test_onehot.shape)




# Neural network initialization function
def initialization(dimensions):
    np.random.seed(seed=0)
    parameters = {}
    C = len(dimensions)
    for c in range(1, C):
        parameters['W' + str(c)] = np.random.randn(dimensions[c], dimensions[c-1])
        parameters['b' + str(c)] = np.random.randn(dimensions[c], 1)
    return parameters

# Neural network forward propagation function
def forward_propagation(X, parameters):
    activations = {'A0': X}
    C = len(parameters) // 2
    for c in range(1, C + 1):
        Z = parameters['W' + str(c)].dot(activations['A' + str(c-1)]) + parameters['b' + str(c)]
        activations['A' + str(c)] = 1 / (1 + np.exp(-Z))
    return activations

# Neural network backpropagation function
def back_propagation(X, y, activations, parameters):
    m = y.shape[1]
    C = len(parameters) // 2
    dZ = activations['A' + str(C)] - y
    gradients = {}
    for c in reversed(range(1, C + 1)):
        gradients['dW' + str(c)] = (1/m) * np.dot(dZ, activations['A' + str(c-1)].T)
        gradients['db' + str(c)] = (1/m) * np.sum(dZ, axis=1, keepdims=True)
        if c > 1:
            dZ = np.dot(parameters['W' + str(c)].T, dZ) * activations['A' + str(c-1)] * (1 - activations['A' + str(c-1)])
    return gradients

# Neural network update function
def update(gradients, parameters, learning_rate):
    C = len(parameters) // 2
    for c in range(1, C + 1):
        parameters['W' + str(c)] = parameters['W' + str(c)] - learning_rate * gradients['dW' + str(c)]
        parameters['b' + str(c)] = parameters['b' + str(c)] - learning_rate * gradients['db' + str(c)]
    return parameters

# Neural network prediction function
def predict(X, parameters):
    activations = forward_propagation(X, parameters)
    C = len(parameters) // 2
    Af = activations['A' + str(C)]
    return (Af >= 0.5).astype(int)

# Neural network training function
def neural_network(X, y, hidden_layers=(100, 100), learning_rate=0.1, n_iter=1000):
    np.random.seed(0)
    dimensions = [X.shape[0]] + list(hidden_layers) + [y.shape[0]]
    parameters = initialization(dimensions)
    train_loss = []
    train_acc = []
    for i in tqdm(range(n_iter)):
        activations = forward_propagation(X, parameters)
        gradients = back_propagation(X, y, activations, parameters)
        parameters = update(gradients, parameters, learning_rate)
        if i % 10 == 0:
            C = len(parameters) // 2
            train_loss.append(log_loss(y, activations['A' + str(C)]))
            y_pred = predict(X, parameters)
            current_accuracy = accuracy_score(y.flatten(), y_pred.flatten())
            train_acc.append(current_accuracy)
    plt.figure(figsize=(12, 4))
    plt.subplot(1, 2, 1)
    plt.plot(train_loss, label='train loss')
    plt.legend()
    plt.subplot(1, 2, 2)
    plt.plot(train_acc, label='train acc')
    plt.legend()
    plt.show()
    return parameters

# Train the neural network
parameters = neural_network(X_train_reshape.T, y_train_onehot.T, hidden_layers=(100, 100), learning_rate=0.1, n_iter=5000)

# Predict on test data
y_pred = predict(X_test_reshape.T, parameters)

# Print accuracy on test data
test_accuracy = accuracy_score(y_test_onehot.flatten(), y_pred.flatten())
print(f"Test Accuracy: {test_accuracy}")

Multilayer perceptron for digit recognition



import numpy as np
import tensorflow as tf
import keras
import matplotlib.pyplot as plt
from keras.datasets import mnist


# Load MNIST data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Display one image for each digit
fig, ax = plt.subplots(nrows=1, ncols=10, figsize=(20, 4))
for digit in range(10):
    digit_indices = np.where(y_train == digit)[0]
    ax[digit].imshow(255 - X_train[digit_indices[0]], cmap='gray')
    ax[digit].set_title(f'Digit {digit}')
    ax[digit].axis('off')

plt.tight_layout()
#plt.show()

# Reshape and normalize input data
X_train = X_train/ 255.0
X_test = X_test / 255.0




hidden1 = 100
hidden2 = 100

model = keras.Sequential([
    keras.layers.Input((28, 28)),
    keras.layers.Flatten(),
    keras.layers.Dense(hidden1, activation='relu'),
    keras.layers.Dense(hidden2, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

batch_size = 512
epochs = 16

history = model.fit(X_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    verbose=1,
                    validation_data=(X_test, y_test))

# Plot the training history
plt.plot(history.history['accuracy'], label='train accuracy')
plt.plot(history.history['val_accuracy'], label='validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
#plt.show()

plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'], label='validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
#plt.show()

# Evaluate the model on the test set
score = model.evaluate(X_test, y_test, verbose=0)
print('Test Loss:', score[0])
print('Test Accuracy:', score[1])

# Predictions on the test set
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=-1)






print(y_pred[0])


plt.figure(figsize=(20, 4))
plt.imshow(255 - X_test[0], cmap='gray')  
plt.title(f'Digit: {y_test[0]}')
plt.axis('off')
plt.show()

print(model.summary())

The article How to Build an Host ? Episode I first appeared on The Event Horizons.

Waste Allocation Load Lifter: Earth Class

admin — Sat, 02 Dec 2023 19:19:35 +0000

Waste Allocation Load Lifter: Earth Class

Episode III

By Jordan Moles on December 2, 2023

As a robot faithful to its mission and amidst occasional gold estimations, Wall-E does not forget its primary task: sorting waste. It is during its expeditions to remote locations on the planet that it encounters the ultimate challenge that stimulates its curious mind. Among the objects it gathers, Wall-E comes across a diverse collection of old electronic components—some in good condition that it brings back to the base, and others defective that it stores in a corner.

Passionate about such objects, it begins to unscrew, pull apart, and carefully categorize each component into two distinct categories (binary classification): on one side, the precious metal pieces that it will sort later (multiclass classification), and on the other, the worthless plastic. The fundamental question is: how does it accomplish such a mission?

It is strongly recommended to have read episodes I and II before continuing!

Wall-E's New Horizons: The Classification

The epic journey of our intrepid lone robot, Wall-E, takes on a fascinating new dimension as he explores the vast realm of classification. After brilliantly mastering the art of regression in the previous episode (see the article “Wall-E: The Little Gold Miner“), Wall-E courageously embarks on a new phase by delving into binary classification between precious metals and plastics. This initial preparatory step marks the beginning of a more complex quest, where Wall-E boldly deploys his classification skills to navigate through the diverse metals that line his path.

Building on his initial successes, Wall-E decides to broaden his scope by tackling the multi-class classification of metals, making the K-Nearest Neighbors (KNN) algorithm his preferred ally. This new challenge requires Wall-E to gain a deeper understanding, as he must not only distinguish between two categories but also classify different types of metals such as bronze, gold, and silver.

This new phase of his adventure marks Wall-E’s transformation towards broader and more sophisticated classification horizons. Each step of this exploration adds a new dimension to his skills, preparing Wall-E to face more complex challenges than simple binary sorting. In this endeavor, model selection proves crucial to ensure the accuracy of his predictions. Wall-E apprehends the importance of the cross-validation process and meticulously explores the nuances of hyperparameter tuning, thereby ensuring the robustness and efficiency of his model.

The Key Element: Always the Data

In his exploration to decipher the nature of electronic components, Wall-E draws upon the information stored during his learning experiences with his creators. This approach aims to build an extensive and diverse set of samples, running in parallel with his challenges related to regression.

Meeting the Samples

Each example $k$ was an element with specific characteristics, such as density $x^{(k)}$, thermal conductivity $x_2^{(k)}$, electrical conductivity $x_3^{(k)}$, etc. To illustrate our case simply, we will consider only the density variable $x^{(k)}$ for now.

Thus, for each sample $k$, Wall-E notes whether it is a metal (labeled as $y^{(k)}=1$) or plastic (labeled as $y^{(k)}=0$). These samples and their labels form his training dataset. Here is a concrete example of 5 samples (among the 650 he already knows).

	Density	Type of Component
Sample 1	2.165747	Plastic
Sample 2	7.151579	Metal
Sample 3	0.901240	Plastic
Sample 4	19.24357	Metal
Sample 5	12.54564	Metal

The Decision Boundaries

The difference with the previous problem is that here we need to define what we call a decision boundary. Let’s explain this concept simply. Instead of looking at each object individually, Wall-E decides to divide this space into different regions. Each region would be intended to receive a specific type of object, either metal or plastic. The boundaries of these regions will define decision boundaries, and that’s where the heart of the classification problem lies.

When Wall-E draws these boundaries, he wants to ensure that similar objects are in the same region. This means that objects close to each other in density tend to have the same label, either metal or plastic. Ideally, he would like these two groups to be perfectly separated, as if they were in distinct boxes. A simple line could do the trick.

However, reality is not always so simple. Sometimes, there are objects that are misplaced and end up on the other side of the line. This is what happens in our example when some plastics have a higher density than some metals (such as rubber and lithium, which end up on the left side of the decision boundary). This poses a challenge for Wall-E. He must now judge his work based on the quality of the separation. The clearer the separation, the better. Misclassified objects are like errors on his sorting sheet, and as usual, he wants to minimize these errors.

Wall-E is also aware that he should not complicate things by drawing zigzagging and complex boundaries. These complicated boundaries might capture all objects, but it could also lead to overfitting, where each object is in its own region. This is called overfitting (we’ll see that in a few sections).

Creation of the Binary Classification Model

Driven by the desire to make sense of these electronic components, Wall-E embarks on the creation of a binary classification model. This model will take the features of a component as input and output a prediction of its nature. After exploring different approaches, including linear regression as he knows with the function $f(x) = ax + b$ (with parameters a and b) that does not fit the data at all,

Wall-E opts instead for a classic Logistic Regression model, whose associated function (ranging between 0 and 1) is expressed as follows:

\begin{align*}
\sigma(x)=\frac{1}{1+\exp{(-x)}}
\end{align*}
It is called the logistic or sigmoid function (due to its “S”-shaped curve, see figure on the side).

By applying this function to our dataset, we obtain
\begin{align*}
\sigma(z)=\frac{1}{1+\exp{(-z)}}
\end{align*}

where $z$ can be a linear function like $ax + b$ or a polynomial function like $ax^2 + bx + c$ (a polynomial of degree 2), with $a$, $b$, and $c$ as parameters to be adjusted.

The significant advantage of such a function is that we can easily define a decision boundary by setting what is called a decision threshold value.

To formally understand why we introduce such a function, it is crucial to grasp that in the world of classification, Wall-E’s idea is to estimate the probability of an sample belonging to each category (metal or plastic). This allows confidently classifying each new observation into the category associated with the highest probability. Thus, when the estimation is close to the correct answer, the probability should be very close to 1, and conversely, if the estimation deviates from reality, the probability is almost zero.

The robot draws inspiration from this fundamental notion when he approaches the concept of the sigmoid function. He understands that this function can be used to transform the results of logistic regression into probabilities. As if applying a kind of mathematical filter to his evaluation, the sigmoid function assigns to each component a probability of belonging to a given category. Thus, if this probability is greater than 0.5, the object is classified in the “metal” category, and if it is less than 0.5, it is classified as plastic.

Prediction Evaluation: The Cost Function

Wall-E has developed his model, but he wants to evaluate the accuracy of his predictions. To do this, he undertakes to use one of the regression cost functions, the Mean Squared Error (MSE, see the article “Wall-E: The Little Gold Miner“), defined as follows:

\begin{align*}
MSE(a, b) =\frac{1}{n} \sum_{k=1}^{n} \left(\sigma(x^{(k)})- y^{(k)}\right)^2.
\end{align*}

However, he finds himself facing a new significant challenge, as illustrated in the image on the side.

This cost function does not exhibit convexity; in fact, it has multiple local minima. This characteristic makes the gradient descent algorithm less effective because, using the analogy of a mountainous terrain, Wall-E might get trapped in a local minimum that is not necessarily the global minimum of the curve.

He introduces a new cost function using the logarithm:

\begin{align*}
L(a,b)=-\frac{1}{n}\sum_{k=1}^n\left[y^{(k)}\log{\left\{\sigma\left(ax^{(k)}+b\right)\right\}}+\left(1-y^{(k)}\right)\log{\left\{1-\sigma\left(ax^{(k)}+b\right)\right\}}\right]
\end{align*}

This complex cost function, although it may seem intimidating at first, is actually a powerful tool for evaluating the model’s performance. Let me delve deeper to explain why Wall-E chose this function and how it works.

The main goal of a cost function is to measure how well the model’s predictions match the actual values. The closer this match, the lower the value of the cost function. In the case of the first cost function, Wall-E had used a more direct approach, where he compared the model’s predictions (obtained by applying the sigmoid function to weighted inputs) to the true values. However, he noticed that this approach could pose problems during optimization.

The new cost function introduced by Wall-E uses the logarithm for a specific reason. It consists of two parts: one for cases where the class label is 1 (metal) and one for cases where the label is 0 (plastic). Let’s see in detail how these parts work.

The first part of the cost function, when a label is 1, is represented by the following term:
\begin{align*}
-y^{(k)}\log{\left\{\sigma\left(x^{(k)}\right)\right\}}
\end{align*}

Here, $y^{(k)}$ is the true class value for training example $k$, and $x^{(k)}$ is the corresponding input. When $y^{(k)}$ is 1 (the example belongs to the metal class), and the prediction $\sigma\left(x^{(k)}\right)$ approaches 1, the value of $-\log{\left\{\sigma\left(x^{(k)}\right)\right\}}$ tends toward 0, contributing to a low cost value for this example (the error is low because our prediction is good). On the other hand, if the prediction is close to 0, the value of $-\log{\left\{\sigma\left(x^{(k)}\right)\right\}}$ becomes very large, leading to an increase in cost.

The second part of the cost function addresses cases where the label is 0:

\begin{align*}
-\left(1-y^{(k)}\right)\log{\left\{1-\sigma\left(x^{(k)}\right)\right\}}
\end{align*}

When $y^{(k)}$ is 0 (the example belongs to the plastic class) and the prediction $\sigma\left(x^{(k)}\right)$ is close to 0, the term $\log{\left\{1-\sigma\left(x^{(k)}\right)\right\}}$ tends toward 0, contributing to a low cost. However, if the prediction approaches 1, $\log{\left\{1-\sigma\left(x^{(k)}\right)\right\}}$ becomes large, increasing the cost.

Thus, when $y^{(k)}$ is 1 in the cost function, only the first part of the function comes into play, and if it is 0, the other part is considered.

The total cost function is the average of these two parts, taken over the entire training set $n$, to obtain an overall measure of the model’s fit to the training data. This allows evaluating the model’s prediction errors in a way that penalizes more significant errors.

Now, why choose such a complex cost function? The goal is to enable more efficient optimization of the model. This cost function has the advantage of possessing a convexity property, meaning it has only one global minimum and no local minima. This greatly facilitates the use of optimization algorithms such as gradient descent to adjust the model parameters. By avoiding local minima, Wall-E can be more confident that the optimization will lead to a higher-quality solution.

The Return of the Gradient Descent

Do you remember gradient descent for regression? We do exactly the same thing but with the new cost function. Algorithmically, we have:

• Our robot calculates the gradients of the cost function at each iteration, which can be expressed mathematically as follows:
\begin{align*}
\frac{\partial L(a, b)}{\partial a}&=\frac{1}{n}\sum_{k=1}^n\left(\sigma\left(ax^{(k)}+b\right)-y^{(k)}\right)x^{(k)},\\
\frac{\partial L(a, b)}{\partial b}&=\frac{1}{n}\sum_{k=1}^n\left(\sigma\left(ax^{(k)}+b\right)-y^{(k)}\right).
\end{align*}
Fortunately, we have a similar form as before.

• It updates the parameters with the new parameters $a^*$ and $b^*$, which are expressed as:
\begin{align*}
a^*&=a-\delta\times\frac{\partial L(a, b)}{\partial a}\\
b^*&=b- \delta\times\frac{L(a, b)}{\partial b}
\end{align*}

• It repeats this process until it finds the minimum of the cost function.

The Power of the Little Waste Sorter

This is how we find ourselves at the heart of his waste sorting mission. Data tables spread out before him, adorned with vectors and matrices revealing the mysteries of electronic component samples. There is the vector $\mathbf{Y}$ composed of n elements corresponding to the n samples of electronic components.

\begin{equation*} \mathbf{Y}=\begin{bmatrix} y^{(1)} \\ y^{(2)} \\ \vdots\\ y^{(n)} \end{bmatrix} \end{equation*}

Alongside this vector, a matrix $\mathbf{X}$ appears, consisting of n rows and m+1 columns. This matrix contains the specific features of each sample, here only one feature of density and its bias column.

\begin{equation*} \mathbf{X}=\left[ \begin{array}{cc} x^{(1)} & 1\\ x^{(2)} & 1\\ \vdots & \vdots\\ x^{(n)} & 1 \end{array} \right]. \end{equation*}

Remember that, in general, we have:

\begin{equation*} \mathbf{X}=\left[ \begin{array}{cccc} x^{(1)}_1 & \cdots & x^{(1)}_m & 1\\ \vdots & \ddots & \vdots & \vdots \\ x^{(n)}_1 & \cdots & x^{(n)}_m & 1 \end{array} \right]. \end{equation*}

We also have a “parameter” vector $\mathbf{P}$ gathering the model parameters $a$ and $b$, which will be used to minimize the cost function.

\begin{equation*} \mathbf{P}=\begin{bmatrix} a \\ b \end{bmatrix}. \end{equation*}

This classification task can be compared to a problem he has already solved, where he estimated the price of gold based on its purity. To tackle this new challenge, Wall-E uses a similar approach based on the sigmoid function, translating his calculations into matrix form.

• The Collect is carried out by displaying the data in a matrix: each sample, with its density features and class, finds its place in this matrix.

• Model Creation is the process where Wall-E defines the parameters displayed in the column $\mathbf{P}$ taken at random, which are used to establish the relationship between density and the nature of the component using the sigmoid function in a somewhat barbaric matrix form (where the sigmoid is applied to each coordinate).

\begin{equation*}
\mathbf{\sigma(X\times P)}=\left[
\begin{array}{c}
\frac{1}{1+\exp{(-ax^{(1)}+b)}}\\
\frac{1}{1+\exp{(-ax^{(2)}+b)}} \\
\vdots \\
\frac{1}{1+\exp{(-ax^{(n)}+b)}} \\
\end{array}
\right].
\end{equation*}

• The Cost Function is redefined as follows:
\begin{align*}
L(\mathbf{P})=-\frac{1}{n}\left[\mathbf{Y\cdot\log{\left\{\sigma(X\times P)\right\}}}+\mathbf{(1-Y)\cdot\log{\left\{1-\sigma(X\times P)\right\}}}\right].
\end{align*}

where $\cdot$ represents the dot product.

• Finding the minimum is equivalent to calculating the gradient:
\begin{align*}
\frac{\partial }{\partial \mathbf{P}} L(\mathbf{P})=\frac{1}{n}\mathbf{X\cdot\left(\sigma(X\times P)-Y\right)}
\end{align*}
et à appliquer itérativement la descente de gradient pour mettre à jour le paramètre $\textbf{P}$:
\begin{align*}
\mathbf{P^*}=\mathbf{P}-\delta \frac{\partial }{\partial \mathbf{P}}L(\mathbf{P})
\end{align*}
where $\mathbf{P^*}$ is the new parameter.

Wall-E, through a rigorous execution of all the required steps, has perfected his ability to sort plastic from metal. He is now ready to classify any material you provide him! Explore the final curve he has obtained.

Our favorite robot has opted for the use of a linear function in his logistic regression. The optimal parameters he determined after the gradient descent are $a = 16.85$ and $b = 9.71$.

Analysis of the graph reveals that if the robot encounters a material with a density of 1.5, for example, it can assert with an accuracy of about 80% that it is plastic. For a density of 0.5, it can identify the material as plastic with an accuracy of 98%, while a density of 4 leads it to conclude it’s metal with an accuracy of 99%.

Thus, thanks to its logistic regression model, the robot can generally determine with an accuracy of 93% whether the provided material is metal or plastic. However, to further refine its predictions, it would be beneficial to explore more complex features in the sigmoid function, such as using polynomials with a greater number of parameters to adjust, for example.

Moreover, the model could be significantly enhanced by adopting more sophisticated algorithms than logistic regression. Approaches such as Random Forests, Support Vector Machines (SVM), or even k-Nearest Neighbors (which we will explore in the next sections) could offer optimized performance.

Another strategy to strengthen the model’s capacity would be to provide it with a broader set of features, such as electrical conductivity, thermal conductivity, etc., or to increase the amount of data. By enriching the dataset in this way, the robot could improve its understanding of existing nuances between different types of materials, leading to more accurate and robust classifications.

Beyond Waste Sorting: Determining Metal Types

Exploring deeper into the realm of metal classification, Wall-E faces a more intricate challenge: determining the specific type of metal among a variety of alloys, including bronze, gold, silver, and many others.

To tackle this challenge, Wall-E’s tool of choice becomes the k-Nearest Neighbors (KNN) algorithm.

It’s worth noting that we have created the dataset from scratch by randomly selecting the features of the samples, but close enough to the fixed values of density and electrical conductivity of pure metals (which determine a metal’s ability to conduct electricity). Here is the list of all the pure metals we have recorded for Wall-E with their respective characteristics.

Type of Metal	Electrical Conductivity (in Giga S/m)	Density
Steel	1.5	7.500 - 8.100
Aluminium	37.7	2.700
Silver	63	10.500
Beryllium	31.3	1.848
Bronze	7.4	8.400 - 9.200
Carbone (graphite)	61	2.250
Copper	59.6	8.960
Tin	9.17	7.290
Iron	9.93	7.860
Iridium	19.7	22.560
Lithium	10.8	5.30
Magnesium	22.6	1.750


Mercury	1.04	13.545
Molybdenum	18.7	10.200
Nickel	14.3	8.900
Gold	45.2	19.300
Osmium	10.9	22.610
Palladium	9.5	12.000
Platinium	9.66	21.450
Lead	4.81	11.350
Potassium	13.9	0.850
Tantalum	7.61	16.600
Titanium	2.34	4.500
Tungsten	8.9	19.300
Uranium	3.8	19.100
Vanadium	4.89	6.100
Zinc	16.6	7.150

This simulates metallic alloys, where each alloy is considered to be composed of a pure metal to be determined and impurities that slightly modify its characteristics. Wall-E’s database includes 300 samples for each type of metallic alloy. Here are five of them, each characterized by its distinctive properties.

Type of Metal	Electrical Conductivity (in Giga S/m)	Density
Steel	2.7093	7.7446
Vanadium	5.8000	7.5000
Iron	9.2600	8.4000
Gold	43.000	18.500
Bronze	7.51320	8.7000

Wall-E’s goal will be to classify each metallic sample he finds based on its density and electrical conductivity into a category of pure metals.

Contrast with Binary Classification and Complexities of Multiclass Classification

Wall-E, having mastered binary classification to distinguish precious metals from plastics, realizes that the next step, multiclass classification, poses a more complex challenge. While binary classification simply divides objects into two distinct categories, such as metal or plastic, Wall-E must now differentiate between specific types. The simplicity of a decision boundary like a line, used in binary classification, is no longer sufficient.

In this new territory, Wall-E must navigate a complex feature space where metals can overlap. This complexity demands a more sophisticated approach, and this is where Wall-E turns to a method that takes into account the subtleties of relationships between metals.

The Power of Proximity: K Nearest Neighbors

In this quest, Wall-E turns to the KNN algorithm, or K Nearest Neighbors, which is a classification method based on the fundamental concept of proximity in the feature space.

The essential idea behind KNN is to group similar objects in the feature space. In our context, this means that if a piece of bronze shares similar characteristics with other pieces of bronze, these objects will be located close to each other in this multidimensional space. Wall-E skillfully exploits this notion to assign each piece of metal a label corresponding to its type.

Its operational process is quite intuitive. When a new piece of metal needs to be classified, Wall-E measures its specific characteristics, such as density, electrical conductivity, etc., thus positioning it in the feature space. The algorithm then identifies the k nearest neighbors of this new piece in this space. These neighbors are the pieces of metal that share similar characteristics.

Once the neighbors are identified, KNN assigns the new piece the type of metal that receives the most votes among these close neighbors. It’s as if each neighbor is voting for the category to which it belongs, and the type of metal with the highest number of votes is assigned to the new piece.

This flexible and proximity-based approach allows Wall-E to accurately classify metals, even without having an in-depth understanding of the specific characteristics of each type. Thus, KNN becomes an effective ally in Wall-E’s quest to determine the type of metal by harnessing the power of proximity in the feature space.

Metal Classification Process: Neighbors in Action

Wall-E searches through its relatively extensive database, which includes various types of metals and alloys, each associated with specific characteristics such as electrical conductivity, density, and other unique properties. These features constitute the dimensions of the feature space where each metal is represented. Unfortunately, Wall-E hasn’t had the time to measure all the properties of each metal and must therefore make do with only density and electrical conductivity.

When a new piece of metal comes in, Wall-E activates the KNN algorithm to determine its type. The process unfolds as follows:

• Feature Measurement: Wall-E measures the characteristics of the new piece of metal, placing it in the feature space.

• Identification of Close Neighbors: KNN identifies the k nearest neighbors of the new piece in this feature space. These neighbors are pieces of metal that share similar characteristics.

• Majority Votes: By examining the metal types of the neighbors, Wall-E assigns the new piece the type that receives the most votes among the close neighbors, i.e., the majority metal type.

This process of proximity and voting enables Wall-E to accurately classify the new piece of metal, even without an in-depth knowledge of the specific characteristics of each type. He excels at this!

Embarking on a quest in search of electronic artifacts aboard his spaceship, our intrepid explorer engages in a meticulous process of disassembly and measurement, scrutinizing the density and electrical conductivity of each unknown component. Thanks to the KNN algorithm, finely tuned with an optimal parameter k of 20 neighbors, chosen after thorough trials (see the next section), he can confidently assert his ability to identify any metal alloy with an assurance approaching 95%.

A technological feat that attests to the precision of his classifications.

The first object subjected to his analysis reveals a density of 18.5 and an electrical conductivity of 43 gigasiemens per meter. Our explorer is filled with enthusiasm, realizing that he has come across gold!

Even better, his certainty reaches an impressive score of 100%, as clearly suggested by the graph alongside.

The second component capturing his attention is a grayish metal plate, displaying traces of rust. The measurements reveal a density of 8.4 and an electrical conductivity of 9.26 gigasiemens per meter.

The application of his KNN algorithm hints at a high probability of an iron alloy, with a certainty of 70%. However, a degree of uncertainty remains, leading him to also consider possibilities such as bronze (20% probable) or tin (10% probable). The mystery persists, unveiling the complexity of the discovered metallic elements.

Finally, the last component, with a density of 7.5 and electrical conductivity of 5.8 gigasiemens per meter, unveils a complex metallic composition.

In-depth analysis by the KNN algorithm indicates a predominance of a particularly rare metal: vanadium, likely around 70%. It is closely followed by tin at 25%, and finally iron at a proportion of 5%.

Wall-E quickly grasps the intricacies of the analysis process, especially the complexity that arises when metals overlap on the graph. He acknowledges that predicting with absolute certainty of 100% can become challenging in these situations. However, despite these challenges, the results obtained by the KNN algorithm remain exceptional.

The algorithm’s performance in metal classification, even in scenarios where features overlap, attests to its efficiency and robustness. Thus, Wall-E can leverage this powerful technique to explore and classify various metallic components with increased confidence.

The Art of Model Selection

In the heart of its quest for sorting electronic components (Classification) and even in estimating the price of gold (Regression), the little robot becomes aware of the need to navigate with caution

Exploring New Horizons: Training and Testing

He quickly grasps the importance of never evaluating his model on the same data used for training.

To illustrate this point, let’s imagine that Wall-E is teaching young robots to analyze meteorites, offering various courses and providing practical exercises for their training, with the intention of evaluating them at the end of their school cycle.

However, Wall-E is aware that if he assesses the performance of his apprentices on the same meteorites used during his class, it would make the task too easy. The robots would simply recognize specific features they have already encountered, without a genuine understanding.

To avoid this bias, Wall-E implements a clever approach: he divides the set of exercises (his dataset) into two distinct parts, creating the training set and the test set.

The training set, typically representing 80% of the data, is dedicated to training the model; Wall-E guides the young robots through lessons and exercises using this data. On the other hand, the test set, consisting of 20% of the data, is reserved for the final evaluation of the model.

Thus, when testing the knowledge acquired by the robots on new meteorites, Wall-E ensures that they can apply their skills to novel situations, thereby avoiding mere memorization of the training data. This process ensures that the model is capable of generalizing and providing accurate predictions even on previously unseen data.

Rising to Excellence: Model Validation

Proud of his machine learning training and evaluation skills, Wall-E, as an experienced data scientist, is now dedicated to improving the accuracy of his model. To achieve this, he must adjust the model’s hyperparameters, a task similar to fine-tuning the settings of a radio antenna for optimal reception. For example, in the case of his previous model, adjusting the number of neighbors in his KNN Classifier.

However, Wall-E is aware of the pitfalls that could arise if he optimizes the model’s performance on the test set. This would render the test set data unusable for the final evaluation. To avoid this, Wall-E introduces a third section in his dataset: the validation set. This section allows him to explore model settings that offer the best performance while preserving the test set data for impartial evaluation.

When comparing different models, such as KNN Classifiers with 2, 3, 20, or even 100 neighbors, Wall-E follows a rigorous methodology. He starts by training these models on the training set. Then, he selects the model that performs the best on the validation set. Finally, to estimate real-world performance, he evaluates this chosen model on the test set.

Wall-E illustrates these choices by plotting two essential curves: performance on the training set and performance on the validation set.

The curves below represent the training and validation scores as a function of different values of the explored parameter, such as the number of neighbors in the case of KNN Classifiers.

This visualization allows for the detection of crucial trends, including model overfitting or underfitting based on the parameter values.

More specifically, the validation curve for the number of neighbors (k) in KNN provides answers to key questions.

• Overfitting: The significant gap between the training score and the validation score may indicate overfitting, meaning the model is too complex and loses generalization. Overfitting is an undesirable behavior in machine learning where the learning model gives accurate predictions for training data but not for new data.

• Underfitting: On the other hand, when a model has not learned the patterns in the training data well and fails to generalize correctly to new data, it is referred to as underfitting. An underfitting model performs poorly on training data and leads to unreliable predictions.

• Sensitivity to Parameter Choice: Observing variations in model performance with different values of the number of neighbors allows Wall-E to choose an optimal value for k, maximizing model performance.

By adopting this systematic approach, Wall-E ensures making informed decisions for the optimal configuration of his model, avoiding the pitfalls of overfitting or underfitting and ensuring optimal performance in real-world contexts.

In his case, both curves quickly reach an accuracy score of 95.7% from around 20 to 25 neighbors and plateau around this value as the number of neighbors increases. A detailed analysis of the curves (which we won’t go into here) would indicate that the optimal score is achieved with 20 neighbors.

Although he has a deep understanding of the process, Wall-E knows there’s one crucial detail remaining: how to ensure the dataset split is the best? He finds the solution in cross-validation.

The Dance of Models: Cross-Validation

Wall-E employs a clever cross-validation methodology to enhance the robustness of his model selection. Specifically, he embraces the K-fold method, where the dataset is split into K parts (here, 5 parts). During training, Wall-E’s model is systematically trained on K-1 of these partitions and validated on the remaining partition, repeating this process K times. This ensures a more reliable and stable evaluation of the model’s performance, making sure that no particular partition overly influences the results.

Furthermore, Wall-E also leverages Stratified K-fold, an intelligent variant of K-fold that takes into account the class distribution in the dataset. This approach ensures that each fold maintains a proportional representation of all classes, crucial when classes are not evenly distributed. Thus, Wall-E ensures a robust model selection, resistant to variations in data splitting, while also considering class distribution for even more precise evaluation.

There are, of course, other data splitting strategies that may adapt more or less effectively depending on the available data, which we will discuss in a future article.

The Learning Waves: Learning Curves

Eager to determine if his model could benefit from improvement through the addition of more data, Wall-E delves into a more thorough exploration by examining learning curves.

These curves provide a visual representation of how the model’s performance evolves based on the amount of training data provided. While adding data may initially lead to performance improvement, Wall-E has the insight to recognize that these benefits eventually reach a threshold. Understanding when the model reaches its limits becomes invaluable wisdom, allowing for a judicious use of time and resources.

Examining this curve, he notices that a sufficiently accurate estimation could have been obtained using fewer than 1000 metal samples, roughly around 37 alloys of each type. Even by accumulating 300 metal samples for each type (300 times 27, totaling 8100 objects), he observes that it brings little significant improvement to his model (its accuracy plateaus at 95.7%). Fortunately, he collects data for the joy of it!

Thus, Wall-E gracefully dances to the rhythm of the learning waves, navigating with finesse through the complex landscape of model selection. By mastering the intricacies of learning curves, Wall-E ensures he makes the most of his model improvement process.

The End of a Trilogy, the Beginning of a Technological Era

This final episode marks the moving conclusion of the captivating saga of the little robot Wall-E, an adventure that began with the fundamentals of machine learning and supervised learning. From his first steps into the realm of artificial intelligence, Wall-E has evolved through various chapters, exploring the basics of machine learning, delving into the in-depth study of regression, and finally, climbing the complex peaks of classification.

The first step saw Wall-E learn the ins and outs of supervised learning, a discipline that allowed him to understand how to use a database to train a model. This inaugural phase laid the groundwork for his quest to understand the complex world of data and algorithms.

The second act of this saga immersed the robot in the universe of regression, where he learned to predict continuous values based on input variables (gold based on its purity). This chapter expanded his horizons, leading him to master concepts such as gradient descent and cost function, essential tools in his machine learning toolkit.

Finally, the last episode saw our budding data scientist confront classification, an even more complex challenge involving the distinction between different types of electronic components. Modest beginnings with binary sorting (metal-plastic) evolved into a bold exploration of multi-class classification (sorting precious metals), highlighting techniques such as the K Nearest Neighbors algorithm and meticulous model selection.

Thus, this poignant conclusion of Wall-E’s saga symbolizes not only the end of an exceptional story but also the realization of gradual and methodical learning in the vast realm of machine learning. The little waste-sorting robot has traversed an impressive path, from understanding basic concepts to mastering sophisticated techniques, leaving behind a legacy of learning and perseverance. This saga, rich in lessons, concludes with the certainty that Wall-E is now ready to face new challenges in the complex world of artificial intelligence. Who knows, perhaps one day he will match EVE, paving the way for new explorations and discoveries.

Bibliography

G. James, D. Witten, T. Hastie et R. Tibshirani, An Introduction to Statistical Learning, Springer Verlag, coll. « Springer Texts in Statistics », 2013.

D. MacKay, Information Theory, Inference, and Learning Algorithms, Cambridge University Press, 2003.

T. Mitchell, Machine Learning, 1997.

F. Galton, Kinship and Correlation, Statistical Science, Institute of Mathematical Statistics, vol. 4, no 2,‎ 1989, p. 80–86, 1989.

C. Bishop, Pattern Recognition And Machine Learning, Springer, 2006.

G. Saint-Cirgue, Machine Learnia, Youtube Channel.

J. Tolles, W-J. Meurer, Logistic Regression Relating Patient Characteristics to Outcomes. JAMA. 316 (5): 533–4, 2016.

B-V. Dasarathy, Nearest Neighbor (NN) Norms: NN Pattern Classification Techniques, 1991.

G. Shakhnarovich, T. Darrell, P. Indyk, Nearest-Neighbor Methods in Learning and Vision, 2005.

Hastie, Tibshirani, Friedman, The elements of statistical learning. Springer. p. 195, 2009.

S. Konishi, G. Kitagawa, Information Criteria and Statistical Modeling, Springer, 2008.

Note: All the necessary data tables are available on GitHub.

Logistic Regression Plastic-Metal


import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import os
print("Current Working Directory:", os.getcwd())

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import OrdinalEncoder




# Replace 'path/to/your/excel/file.xlsx' with the actual path to your Excel file
excel_file_path = 'PlasticMetal_data.xlsx'

# Read the Excel file
result_df = pd.read_excel(excel_file_path)

# Display the Pandas DataFrame
print(result_df)


X = result_df['Density']
y = result_df['Material']

# Data preparation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Convert labels to the appropriate format for binary classification
ordinal_encoder = OrdinalEncoder(categories=[['Plastic', 'Metal']])
y_train_encoded = ordinal_encoder.fit_transform(y_train.values.reshape(-1, 1))
y_test_encoded = ordinal_encoder.transform(y_test.values.reshape(-1, 1))

# Reshape y_train and y_test
y_train_reshaped = y_train_encoded.ravel()
y_test_reshaped = y_test_encoded.ravel()

# Reshape X_train and X_test
X_train_reshaped = X_train.values.reshape(-1, 1)
X_test_reshaped = X_test.values.reshape(-1, 1)

# Create the model
model = make_pipeline(StandardScaler(), LogisticRegression(random_state=42))

print(model)

# Create parameter dictionary
params = {
    'logisticregression__penalty': ['l2', None],
    'logisticregression__solver': ['lbfgs'],
    'logisticregression__max_iter': [100, 200, 300, 500, 1000]
}

# Create a search grid
grid = GridSearchCV(model, param_grid=params, cv=5)

# Train the model
grid.fit(X_train_reshaped, y_train_reshaped)

print(grid.best_params_)
print(grid.best_score_)

modelB = grid.best_estimator_

# Model evaluation
accuracy = modelB.score(X_test_reshaped, y_test_reshaped)
print(f"Model accuracy: {accuracy}")

# Predictions
predictions = modelB.predict(X_test_reshaped)

print(predictions)
print(ordinal_encoder.inverse_transform(np.array([[1], [0]])))

coefficients = modelB.named_steps['logisticregression'].coef_
intercept = modelB.named_steps['logisticregression'].intercept_

print("Coefficients:", coefficients)
print("Intercept:", intercept)

# Plot the sigmoid function with normalized data
density_values = np.linspace(0, X_train_reshaped.max(), 300).reshape(-1, 1)
probabilities = modelB.predict_proba(density_values)[:, 1]

# Find the density corresponding to a probability of 0.5
decision_boundary = density_values[np.argmax(probabilities >= 0.5)]

# Plot the sigmoid function
plt.figure(figsize=(10, 6))
plt.scatter(X_train_reshaped, y_train_reshaped, c=y_train_reshaped, cmap='Dark2_r', alpha=0.5)
plt.plot(density_values, probabilities, color='blue', linewidth=2, label='Sigmoid Function')
# Add the vertical line corresponding to a probability of 0.5
plt.axvline(x=decision_boundary, color='red', linestyle='--', label='Decision Boundary')
plt.title('Final Representation of the Sigmoid Function')
plt.xlabel('Density')
plt.ylabel('Probability of Metal')
plt.grid(ls='--')
plt.legend()
plt.show()

# Suppose you have a new material with a certain density
new_material_density = 4  # Replace this value with the actual density of your new material

new_material_density_reshaped = np.array(new_material_density).reshape(-1, 1)

print(modelB.predict(new_material_density_reshaped))

# Make the prediction with the model
probability_of_metal = modelB.predict_proba(new_material_density_reshaped)[:, 1]

# Display the result
print("Probability of being metal:", probability_of_metal)

Metal Classification Algorithm, Validation Curves, and Learning Curves


import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import os
print("Current Working Directory:", os.getcwd())


from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split, GridSearchCV, validation_curve, learning_curve
from sklearn.preprocessing import LabelEncoder



# Replace 'path/to/your/excel/file.xlsx' with the actual path to your Excel file
excel_file_path = 'metals_samples.xlsx'

# Read the Excel file
result_metals_df = pd.read_excel(excel_file_path)

# Display the Pandas DataFrame
print(result_metals_df)


X = result_metals_df[['Density', 'Electrical Conductivity']]
y = result_metals_df['Metal Type']


# Data preparation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Convert labels to the appropriate format for binary classification
label_encoder = LabelEncoder()
y_train_encoded = label_encoder.fit_transform(y_train)
y_test_encoded = label_encoder.transform(y_test)

# Create the model
model = make_pipeline(MinMaxScaler(), KNeighborsClassifier())

print(model)

# Create parameter dictionary
params = {
    'kneighborsclassifier__n_neighbors': [2,3,4,5,6,7,8,9,10, 15, 20, 25, 30, 40,  100],
    'kneighborsclassifier__weights': ['uniform', 'distance'],
    'kneighborsclassifier__p': [1, 2]
}

# Create a search grid
grid = GridSearchCV(model, param_grid=params, cv=5)

# Train the model
grid.fit(X_train, y_train_encoded)

print(grid.best_params_)
print(grid.best_score_)

modelB = grid.best_estimator_

# Model evaluation
accuracy = modelB.score(X_test, y_test_encoded)
print(f"Model Accuracy: {accuracy}")

# Predictions
predictions = modelB.predict(X_test)


#for i in range(0, 32):
    #print(label_encoder.inverse_transform(np.array([i])))



# Sample
X_sample = pd.DataFrame({'Density': [7.5], 'Electrical Conductivity': [5.8], 'Metal Type' : [np.NaN]})  
X_sample = X_sample[['Density','Electrical Conductivity']]


# Predict using the scaled sample
prediction = modelB.predict(X_sample)
prediction_proba = modelB.predict_proba(X_sample)

print("Predicted Metal Type:", label_encoder.inverse_transform(prediction))
print("Prediction Probabilities:", prediction_proba)

# Probability Prediction
prediction_proba = modelB.predict_proba(X_sample)


# Validation Curves

k_range = np.arange(1,100)

#train_score, val_score = validation_curve(model, X_train, y_train_encoded, param_name='kneighborsclassifier__n_neighbors',param_range=k_range, cv =5)

#plt.plot(k_range,val_score.mean(axis=1), label='Validation')
#plt.plot(k_range,train_score.mean(axis=1), label='Train')
#plt.xlabel('Number of Neighbors (k)')
#plt.ylabel('Score')
#plt.grid(ls='--')
#plt.legend()
#plt.title('Validation and Train Curves for k-NN')
#plt.show()

# Learning curves

#N, learn_train_score, learn_val_score = learning_curve(modelB, X_train, y_train_encoded, train_sizes=np.linspace(0.01, 1.0, 50), cv = 5)

#print(N)
#plt.plot(N,learn_val_score.mean(axis=1), label='Validation')
#plt.axhline(y=0.957, c='red', ls='--', label = 'Threshold')
#plt.plot(N,learn_train_score.mean(axis=1), label='Train')
#plt.xlabel('Train Sizes')
#plt.ylabel('Score')
#plt.grid(ls='--')
#plt.legend()
#plt.title('Validation and Train Learning Curves for k-NN')
#plt.show()


# Displaying probabilities with class names
for i, metal_class in enumerate(label_encoder.classes_):
    print(f"Probability for class '{metal_class}': {prediction_proba[0, i]}")





plt.figure(figsize=(10, 6))
scatter = plt.scatter(X_train['Density'], X_train['Electrical Conductivity'], c=y_train_encoded, cmap='Dark2_r', alpha=0.5)
plt.scatter(X_sample['Density'], X_sample['Electrical Conductivity'], c='red', s=50, marker='X', alpha=0.8)
plt.axvline(x=tuple(X_sample['Density']), c='red', ls='--', alpha=0.8)
plt.axhline(y=tuple(X_sample['Electrical Conductivity']), c='red', ls='--', alpha=0.8)
plt.xlabel('Density')
plt.ylabel('Electrical Conductivity (S/m)')
plt.grid(ls='--')
# Configure the colorbar correctly
cbar = plt.colorbar(scatter, ticks=range(len(label_encoder.classes_)))
cbar.set_label('Metal Alloys')
cbar.set_ticklabels(label_encoder.classes_)
plt.title('Unknown Metallic Sample Based on Density and Electrical Conductivity')
plt.legend()
plt.show()

The article Waste Allocation Load Lifter: Earth Class first appeared on The Event Horizons.

Wall-E: The Little Gold Miner

admin — Thu, 02 Nov 2023 04:51:38 +0000

Wall-E: The Little Gold Miner

Episode II

By Jordan Moles on November 2, 2023

Unlike its robotic counterparts of the past, Wall-E stood out with its insatiable curiosity and desire to learn. Every day, it wandered through the forgotten corners of the planet, on a quest for buried and overlooked treasures. During one of its expeditions, in an abandoned old mine, Wall-E made a remarkable discovery: sparkling gold samples hidden beneath layers of soil and rock. Intrigued by these golden glimmers, it wondered if it could have fun estimating their value.

As a robotic scholar, it knew that assessing the price of these nuggets depended on their purity. It was at this precise moment that it embarked on exploring a problem of utmost simplicity: Linear Regression.

It is highly recommended to have read Episode I before continuing!

Into the Depths of Knowledge: Regression

The story of our intrepid lone robot continues, and he finds himself facing a fascinating category of problems: regression. These puzzles push him to develop new skills to estimate numerical values based on input data, and they hold a significant place in his vast repertoire of explorations.

Wall-E, the small waste-collecting robot, encounters regression problems whenever he wants to predict a numerical value based on certain features or continuous variables. Picture him analyzing the data he has gathered while striving to determine the price of a gold nugget based on its purity. In this quest, he must establish a mathematical relationship between the data he has, such as the purity of the gold, and the values he wants to predict, namely the prices of these precious nuggets.

One of the challenges Wall-E faces is choosing the appropriate regression model. He wonders whether to opt for a simple linear regression, meaning he assumes a linear relationship between the purity of gold and its price, or if he should explore more complex models, such as polynomial regression. The choice of the model is crucial as it will affect the accuracy of his predictions.

Another issue Wall-E must solve is how he will evaluate the performance of his model. He cannot afford to make mistakes in his estimates, as an error in estimating the price of gold could lead to potentially disastrous consequences. He explores various error measures, such as mean absolute error and root mean square error (for now, it’s gibberish), to assess the accuracy of his predictions.

One of the most intriguing challenges Wall-E faces in regression problems is optimizing the model parameters. He must go through an iterative process of adjusting these parameters to minimize the error between his predictions and the actual values. Wall-E then embarks on gradient descent, a technique that helps him find the optimal parameters by minimizing a cost function that aggregates the model’s errors.

Every regression problem Wall-E tackles is unique, as the data and objectives vary. However, his perseverance and ingenuity, combined with his machine learning skills, allow him to overcome these challenges and accurately estimate numerical values, whether it’s the price of gold or any other regression task.

The Data Collection

Shortly after humanity’s escape, the young robot felt a gust of loneliness sweeping through its printed circuits. To occupy itself after a day of hard work, it explores distant lands, sifts through the debris of large gold reserves, analyzes each precious alloy, scrutinizes the smallest gold nugget to determine its purity, and compiles all the earthly gold samples, displaying them in a table with their respective prices (here are the first 5 samples out of 150).

	Gold Purity	Gold Price
Sample 1	0.3745	1028.1347
Sample 2	0.9507	1456.2091
Sample 3	0.7320	1260.2042
Sample 4	0.5987	1145.5583
Sample 5	0.1560	958.0828

When indicated, this table constitutes a learning database. Each sample k is characterized by two elements: its purity $x^{(k)}$ which varies between 0 (not gold) and 1 (pure gold), and its price $y^{(k)}$ (which can range from 0 to infinity).

The collection of these samples represents a crucial moment in the life of this robotic scholar. Here are two essential aspects that it must take into consideration to make accurate estimates.

Large number of data: Wall-E quickly realizes that to obtain reliable estimates, he must have a large number of samples in his database.

Indeed, if we only consider two samples, as illustrated here, it is impossible to determine whether the price behavior is linear or not.

Many estimation curves could pass through these two points without reflecting reality. Like the two curves below, for example.

Data Diversity: another crucial detail to consider during the harvest is the variety of data.

Suppose Wall-E only considers pure samples or samples with extremely close purity (see the figure opposite).

In this situation, all samples will have almost the same price, preventing him from estimating the price of other gold alloys.

Conclusion of the Harvest: It is, therefore, imperative to gather a multitude of randomly chosen samples to avoid these limitations and ensure obtaining accurate estimates for a wide range of gold alloys.

Creation of the Linear Model

From these data, Wall-E develops what we have called a linear model $f(x)=ax+b$ where aa and bb are the parameters of the model. An effective model minimizes the differences between Wall-E’s predictions $f(x)$ and the actual values yy of the samples. Like a kind of modern gold prospector, Wall-E adjusts these parameters to best align his estimates with reality, creating an equation that subtly connects purity and the value of gold. Here is his initial attempt, which is not incredible at all.

Measuring Gold Treasures: The Cost Function

The next step in Wall-E’s learning process is to evaluate the performance of this model, meaning measuring the errors between its predictions and the values in the dataset.

For the small robot, the procedure is simple: each estimation, denoted k, in the dataset is compared to reality. Depending on the chosen approach, Wall-E’s program returns the corresponding error for each prediction, which we will denote as $err(k)$.

Each of Wall-E’s estimations is thus associated with its own margin of error. Over iterations, these errors accumulate in number until reaching the total number of examples n in the dataset.

Therefore, all these errors are gathered in a function called the Cost Function, denoted $Γ(a, b)$. It is a function depending on the parameters to be adjusted and simply calculates the average of all errors. Therefore, it is written as follows:

\begin{align*}\Gamma(a, b) &=\frac{err(1)+err(2)+\cdots+err(n)}{n}=\frac{1}{n}\sum_{k=1}^n err(k)\end{align*}

An important property to consider about this function is its convexity, meaning that its curve ‘faces upward everywhere.’ More precisely, this means that if you draw a line between two points on the curve, it always stays above or at the same level as the curve. Such curves always have a global minimum! This will be useful to us later.

However, what is error? How can it be defined? Before addressing these questions, it is crucial to discuss a mathematical concept: distance, which allows quantifying the separation between two given points.

Distances Explained by Hal

Wall-E, in the midst of contemplation, sought to understand why he needed to pay attention to the concept of distance. Perplexity engulfed him as he observed Hal, his loyal companion cockroach, sneak silently through the corners of the laboratory.

What could this meticulous and methodical exploration of space by Hal possibly signify?

He was far from imagining that behind these silent and discreet movements, Hal was, in his own way, sharing the subtleties of distances. Each maneuver between the objects in the room illustrated an essential mathematical rule. They counted up to four.

Positivity. In this choreography, Hal demonstrated the first rule: the positivity of distances. Explaining in his own way that the distance between his favorite hiding spot and the waste pantry was always positive, a fact simply illustrated by his trajectory (a length is not negative).

Wall-E, being a good scientist, expressed it in mathematical terms: The distance between any two points A and B must be positive or zero. This is written as,
\begin{align*}
\forall A, B \in E, \quad d(A,B)\geq 0.
\end{align*}

This symbol $“\forall”$ means “for all” and $“\in”$ means “in”. It reads, for all arbitrary elements A and B (here we are talking about points) in E, the distance between A and B is positive or zero.

Symmetry. The concept of symmetry was then highlighted by Hal, demonstrating how his movements from point A to point B were always identical, whether he went from B to A or from A to B. His subtle back-and-forth marked the idea of symmetry in this dance between points.

The little robot introduced this idea into his circuits: The distance between A and B must be the same as between B and A. Mathematically,
\begin{align*}
\forall A, B \in E, \quad d(A,B)=d(B,A).
\end{align*}

Separation. However, the most surprising demonstration for Wall-E was that of separation. Hal went to fetch two seeds that he placed in two different locations in the room. He then began a frenetic dance, leaving one seed fixed and bringing the other one back to it by performing a series of quick back-and-forths until finally sticking the two seeds together.

In this way, he wanted to illustrate to Wall-E that if the distance between these two points was zero, then the two points coincide. An impressive and clear representation of the separation rule.

He understood the lesson, which he translated into his own language: If the distance between A and B is zero, then A and B coincide.

\begin{align*}\forall A, B \in E, \quad d(A,B)=0 ⇒A=B.\end{align*}

This symbol “⇒” means “imply”.

The Triangle Inequality. However, Hal’s lesson did not stop there as there was still another essential rule to analyze. He continued his exploration by illustrating the triangle inequality.

By moving between his hiding spot, Wall-E, and the pantry, Hal showed that the distance between his hiding spot and Wall-E is always less than the distance between his hiding spot and the pantry plus the distance between the pantry and Wall-E. This clever trick, teaching that the shortest path between two points is a straight line, captivated Wall-E.

He hastened to transcribe it all: If I take three points A, B, and C that do not coincide, then the distance between A and B is always less than or equal to the distance between A and C plus the distance between C and B.

\begin{align*}
\forall A, B, C \in E, \quad d(A,B)\leq d(A,C)+d(C,B).
\end{align*}

Thanks to Hal, Wall-E grasped that formally, a distance is a function that compares two points in a given space by assigning a non-negative real number, expressing the “length” between these two points, and follows specific rules.

This space can be the familiar two-dimensional plane as demonstrated by the cockroach or our three-dimensional space, or even much more exotic spaces.

His abstraction skills also allow him to understand that there are different types of distances, among which the most well-known is the Euclidean distance (also called the 2-distance).

or the l’$\infty$-distance (also called the infinity-distance), which assesses the maximum distance between these points along any dimension.

However, there is also the Manhattan distance (or 1-distance for purists), named so because it reflects the distance a taxi would have to travel in a network of streets forming orthogonal grids (typical of the street layout in Manhattan, hence the name).

We will explore these intricacies in detail in an upcoming article.

A Fatal Error

Now, why delve into the concept of distance in the context of evaluating Wall-E’s predictions? In fact, this leads us to consider what errors truly represent between the predictions and the actual values in the dataset.

Imagine that Wall-E evaluates the first sample, a one-kilogram gold alloy with a purity of 0.72 and an actual price of 1231 bolts, but predicts 1331 bolts. You observe a difference of -130 bolts. Here, we obtain a negative value, but in another example, it could be positive. This duality between positive and negative values is not practical.

To solve this problem, two options are available to us:

• The first option is to consider the absolute value of each difference (remove the minus sign when present). The error obtained is called the absolute error, denoted AE.

In the previous example, we would have $AE(1) = | 1231–1331| = |-130|=130$.

• The second option is to calculate the square of each difference. This error is called the squared error, noted SE.

Here, we would have a squared error $SE(1)= (1231–1331)^2=(-130)^2=16900$.

We notice that the second option greatly amplifies the errors, but we will see how to balance these differences later.

Thus, by applying either of these options, we choose how we want to measure errors, i.e., a distance. The $\infty$-distance for the first or the Euclidean distance for the second.

Now, the procedure is simple: each estimate, denoted by k, in the Dataset is compared to reality. Depending on the chosen approach, Wall-E’s program returns the corresponding error. Moreover, depending on the chosen distance, the cost function is named differently:

• If we consider the approach of absolute errors, it is called the Mean Absolute Error, denoted MAE, and is written as:

\begin{align*} MAE(a, b) &=\frac{AE(1)+AE(2)+\cdots+AE(n)}{n}=\frac{1}{n}\sum_{k=1}^n AE(k)\\ &= \frac{1}{n}\sum_{k=1}^n\left|f\left(x^{(k)}\right) – y^{(k)}\right|=\frac{1}{n} \sum_{k=1}^{n} \left|ax^{(k)} + b- y^{(k)}\right|. \end{align*}

• While the approach of squared errors provides us with a cost function called Mean Squared Error, denoted MSE, and is written as:
\begin{align*}
MSE(a, b) &=\frac{SE(1)+SE(2)+\cdots+SE(n)}{n}=\frac{1}{n}\sum_{k=1}^n SE(k)\\
&= \frac{1}{n}\sum_{k=1}^n\left(f\left(x^{(k)}\right) – y^{(k)}\right)^2=\frac{1}{n} \sum_{k=1}^{n} \left(ax^{(k)} + b- y^{(k)}\right)^2.
\end{align*}

To rescale the errors calculated by this function, we simply take its square root. The function obtained in this way is called the Root Mean Squared Error, noted RMSE.

Here’s an example to illustrate the calculation where Wall-E estimates the value of only five samples (with five differences).

Differences	-100	7	-2	42	13
Errors AE	100	7	2	42	13
Errors SE	10 000	49	4	1764	169

Calculation of MAE

Calculation of RMSE

\begin{align*}MAE(a, b) =\frac{100 + 7 + 2 + 42 + 13}{5} = 32.8.\end{align*}

\begin{align*}RMSE(a, b) =\sqrt{\frac{10000 + 49 + 4 + 1764 + 169}{5} }= 48.96.\end{align*}

Why choose one or the other? To answer this question, let’s introduce Eve.

In addition to her ability to distinguish organic objects, she has a sophisticated self-defense system. She has been trained to estimate the distance (in centimeters) between the impact of her shots and the center of the target. Eve trains two models to find the one that will minimize errors.

	Error 1	Error 2	Error 3	Error 4	MAE
Model 1	20	0	0	0	5
Model 2	6	5	6	4	5.25

	Error 1	Error 2	Error 3	Error 4	RMSE
Model 1	20	0	0	0	10
Model 2	6	5	6	4	5.31

Here we observe that the MAE of model 1 is smaller than that of model 2, so Eve will choose model 1 to estimate her shots.

However, in the first model, we can see that Eve makes almost no errors except for her first shot where she is off by 20 cm.

This is a non-negligible and dangerous quantity, as it could cause harm to someone if her arsenal is not precise enough.

In this table, it’s completely different; we observe that the RMSE of model 1 is much worse than model 2 as it shows a much larger error.

Eve would tend to choose model 2 in this case. In fact, RMSE penalizes large errors much more than MAE.

If Eve favors Mean Absolute Error (MAE), it means she wants to minimize the absolute differences between the impact of her shots and the target. This suggests that for Eve, each difference has the same importance. A difference of 20 units is considered twenty times more important than a difference of 1 unit.

On the other hand, if Eve chooses to favor Root Mean Squared Error (RMSE), it means she wants to emphasize large differences. In this case, more significant errors have a more significant weight. Indeed, a difference of 20 units is 400 times more important than a difference of one unit. So, if Eve wants to eliminate shots with very large differences, the model based on RMSE would be more suitable.

These choices of cost functions depend on Eve’s goals: if she wants to reduce large differences, she will favor MSE. On the other hand, if she wants a balanced assessment of all differences, she will opt for MAE. Also, there are other ways to measure errors, but we won’t discuss them here.

A Small Step for the Robot, a Giant Leap for the Algorithm

What Wall-E enjoys most is learning by himself which parameters minimize the cost function, that is, the parameters that give us the best possible model. To find these optimal parameters, Wall-E uses a well-known optimization algorithm called gradient descent. Imagine this step as if Wall-E is meticulously adjusting the knobs of his mathematical model to reach the level of expertise needed in predicting the price of gold based on its purity.

Let's Descend!

The concept of gradient descent is simple: envision Wall-E lost on the slopes of a waste mountain in thick fog, recycling what’s left for him to do. Unfortunately for him, his batteries are dangerously fading, so he must reach his small spaceship located at the lowest point, but he can only see the immediate slopes around him. Thus, at each step of length $\delta$ (that’s the Greek letter delta), he chooses the direction that makes him descend as quickly as possible. As he advances, he adjusts his direction based on the slopes he perceives, gradually approaching the lowest point.

Of course, the choice of the value $\delta$ is crucial in gradient descent. Because imagine if Wall-E takes steps that are too small, he will take too long to reach the bottom, or if he uses his jetpack to fly over very large distances, he might overshoot his refuge.

Let’s go back to our initial problem. The mountain of waste symbolizes our cost function, Wall-E’s position parameters on the mountain represent the parameters of our linear regression model, and the steps translate what is called Wall-E’s learning rate. So, breaking down Wall-E’s actions algorithmically, we have:

• Our robot calculates the gradients, meaning the slope along the two axes (a and b) of the cost function at each iteration. Mathematically, this involves calculating these two quantities:

\begin{align*} \frac{\partial \Gamma(a, b)}{\partial a}\quad\text{et}\quad \frac{\partial \Gamma(a, b)}{\partial b} \end{align*} Mathematicians will have understood it well; this is nothing more than the calculation of the derivative of a function with several variables.

• He updates the parameters, bringing him closer and closer to the minimum of the cost function. The updated parameters are referred to as $a^*$ and $b^*$ and write \begin{align*} a^*&=a-\delta\times\frac{\partial \Gamma(a, b)}{\partial a}\\ b^*&=b- \delta\times\frac{\partial \Gamma(a, b)}{\partial b} \end{align*} Thus, the new parameters are simply defined as the old position minus the learning rate $\delta$ multiplied by the value of the slope. By analogy, it’s Wall-E’s position after taking a step in the direction where the slope is the steepest.

• He restarts until he finds the minimum of the cost function.

It’s important to understand that gradient descent is an iterative process, meaning it repeats many times until Wall-E reaches a point where the cost function is minimal, and its predictions are as accurate as possible.

Regarding the learning rate, some details need to be clarified. As in the previous metaphor, the choice of the value of $\delta$ is crucial.

A too small $\delta$ could slow down convergence because parameter adjustments would be tiny at each step, while a too large $\delta$ could lead to oscillations or even prevent convergence, as adjustments might overshoot the desired minimum. Therefore, choosing the value of $\delta$ is therefore crucial for Wall-E’s algorithm to converge efficiently towards the optimal solution.

When will we arrive ?

It’s been a little while now that our brave robot has been moving desperately in the dark, blinded by Mother Nature. He wonders when he will reach the bottom of the mountain. Just like in this situation, in machine learning, reaching the minimum of the cost function – the equivalent of shelter for Wall-E – can seem tricky. His position is uncertain, and to get there, Wall-E must adjust his progress, taking into account the length of his steps and the number of these steps.

To navigate, Wall-E must meticulously record each of his positions along the mountain’s slope, which is called the descent story. By keeping an accurate record of each step, he can then plot his trajectory, creating a “descent curve.” This allows him to visualize his path, measure his progress, and determine if he is close to the lowest point. Below is an example, assuming Wall-E is randomly placed on the mountain.

In the field of Machine Learning, the descent story is actually called the cost history as it provides the values of the cost function based on key variables such as the learning rate and the number of iterations of the gradient descent algorithm.

Moreover, its graphical representation, referred to as the descent curve, is actually called the learning curve. It is essential for assessing the performance of a model because it dynamically illustrates the evolution of the model’s accuracy.

In this particular case, after about ten steps, Wall-E seems to stop descending further, indicating that it has reached its shelter. The additional 40 steps are therefore unnecessary. This information is crucial in computer science, as it allows us to avoid running the algorithm unnecessarily, potentially saving time and resources, especially when certain simulations can take considerable time, ranging from days to weeks.

In its Printed Circuits: Estimating the Price of Gold

But what exactly is happening in the electronic brain of our adorable robot? Before performing any addition, Wall-E translates not only the entire dataset into a table but also the model parameters and gradients: a kind of encrypted language for machines known as matrix form that greatly simplifies calculations. More precisely, this gives rise to a vector. $\mathbf{Y}$ composed of n elements corresponding to the prices of the n gold samples,

\begin{equation*} \mathbf{Y}=\begin{bmatrix} y^{(1)} \\ y^{(2)} \\ \vdots\\ y^{(n)} \end{bmatrix} \end{equation*}

accompanied by a matrix $\mathbf{X}$ with n rows and $m+1$ columns that accurately encapsulates each of the m features (in this case, there is only one $m=1$) and a column containing only 1s, which we’ll call the “bias.”

\begin{equation*} \mathbf{X}=\left[ \begin{array}{cc} x^{(1)} & 1\\ x^{(2)} & 1\\ \vdots & \vdots\\ x^{(n)} & 1 \end{array} \right]. \end{equation*}

This last one simply allows us to perform the necessary matrix calculations for learning. It’s worth noting that, in general, we have

Simultaneously, a vector called “parameter” $\mathbf{P}$ (a column) makes its entrance, carefully bringing together all the parameters of our model, namely a and b.

\begin{equation*} \mathbf{P}=\begin{bmatrix} a \\ b \end{bmatrix}. \end{equation*}

Don’t forget that we are looking for $\mathbf{P}$ such that it minimizes the cost function. Thanks to this, Wall-E can express all the learning steps easily and estimate the price of a gold nugget with an unknown value:

• The Harvest is carried out by displaying the data in a matrix: each sample, with its purity and price characteristics, finds its place in this matrix.

• The Model Creation is the process where Wall-E defines the parameters shown in the column $\mathbf{P}$ chosen randomly, which are used to establish the linear relationship between the purity and the price of gold. $\mathbf{F(\mathbf{X})}=\mathbf{X\times P}$.

• The Cost Function is redefined as follows: \begin{align*} \Gamma(\mathbf{P})=\frac{1}{n}\left(\mathbf{F(X)-y}\right)\cdot\left(\mathbf{F(X)-y}\right) \end{align*} where $\cdot$ denotes the dot product (we will talk about the scalar product in another article).

• Finding the Minimum involves calculating the gradient: \begin{align*}\frac{\partial }{\partial \mathbf{P}} \Gamma(\mathbf{P})=\frac{1}{n}\mathbf{X\cdot\left(F(X)-y\right)}\end{align*} and iteratively applying gradient descent to update the parameter P: \begin{align*}\mathbf{P^*}=\mathbf{P}-\delta \frac{\partial }{\partial \mathbf{P}}\Gamma(\mathbf{P})\end{align*} where $\mathbf{P^*}$ is the new parameter.

Wall-E, by carefully applying all the steps, is now ready to estimate the price of gold based on the purity you provide! Here is the final curve he obtains.

The parameters a and b of the blue line are respectively equal to 493.56 and 886.18. For the gradient descent, he used a learning rate of 0.2 and performed about twenty iterations of the algorithm.

It can be easily observed that by choosing a gold alloy with a purity of 0.6, its estimated price would be around 1200 bolts.

Knowledge Transfer and Model Performance: Lessons Applicable to All Regressions

All the steps and calculations performed to estimate the price of gold based on its purity through linear regression are fundamentally similar to those carried out for nonlinear regression or other types of machine learning models!

Wall-E, the little robot passionate about estimating the price of gold, follows a well-defined sequence to train its model, minimize error, and adjust parameters to predict the price of gold based on its purity. The process involves transforming data into matrices, creating the model, defining the cost function to evaluate errors, minimizing this function by iteratively adjusting parameters, and finally obtaining the optimal parameter to accurately estimate the price of gold.

This process is flexible and can be applied to different situations and types of learning models, thus adapting to more complex problems requiring more sophisticated models. Wall-E’s success in estimating the price of gold demonstrates the power and efficiency of these methods, paving the way for broader and more diverse applications of machine learning in various contexts.

But there is still one last thing to consider: The Coefficient of Determination, also known as $R^2$. It plays a crucial role in evaluating Wall-E’s model performance as it measures how well the model fits the data compared to the variations in it. In mathematical terms, it is written as follows:

\begin{equation}R^2 = 1 – \frac{\sum_{k=1}^{n} \left(y^{(k)}- f(x^{(k)})\right)^2}{\sum_{k=1}^{n} (y^{(k)}- \bar{y})^2}\end{equation}

where $\bar{y}$ is nothing but the average of our sample values (in our case, it is simply the mean price). Despite its seemingly complex appearance, it conceals a simple fraction to understand. By rewriting it in a more digestible form, we have,

\begin{equation}R^2 = 1 – \frac{Errors}{Variance}.\end{equation}

Remember (see the article “Beating the Game Master“) that variance is a measure of the dispersion of sample values.

So, for Wall-E, getting an $R^2$ close to 1 would be ideal, implying that the right fraction is close to 0. This means that errors are largely negligible compared to how the data disperses, and the model proposed by Wall-E fits well with the sample values.

On the contrary, if $R^2$ is close to 0, it would indicate that the model does not explain the data variability well, and predictions may be less reliable because errors are of the same order of magnitude as the variance.

With all these explanations, Wall-E embarked on calculating the coefficient of determination $R^2$ to assess the quality of his previous model.

The result is quite gratifying, with a commendable score of 0.93. In other words, the model fits remarkably well with the data, covering approximately 93% of the observed variability.

This performance confirms the effectiveness of his approach in estimating the price of gold based on its purity!

However, Wall-E, as an tireless perfectionist, is not content with already achieved success. He is constantly seeking ways to improve his model.

Thus, he decides to transcend the initial linear model by opting for a polynomial approach (of degree 2). He modifies the reference function to $f(x) = ax^2 + bx + c$ and meticulously repeats all the steps of the algorithm, leaving nothing to chance. Here are the results he obtained.

The curve fits the data really well, and for good reason. With parameters values of 273.84, 404.43, and 837.08, he achieves an outstanding coefficient of determination of 97%!

Observe here that a gold sample with a purity of 0.6 would be worth around 1160 bolts.

In contemplating this success, one cannot help but eagerly anticipate Wall-E’s future explorations in the complex world of modeling and machine learning.

Successful Exploration of the Intricacies of Regression: Next Step, the Fascinating World of Classification

In this captivating exploration of regression problems, we delved into the fascinating universe of mathematical modeling, with Wall-E as our intrepid guide. From gradient descents to learning curves, and through the definition of errors, we demystified key aspects of regression, unveiling the underlying magic of Machine Learning.

As we let Wall-E rest his circuits after his regression exploits, get ready to embark on a new adventure in our upcoming article. We’ll delve into the mysteries of classification problems, exploring how models can learn to categorize and make decisions in a world of complex data. Stay tuned for an even deeper dive into the dynamic universe of machine learning with Wall-E as your faithful travel companion!

Bibliography

G. James, D. Witten, T. Hastie et R. Tibshirani, An Introduction to Statistical Learning, Springer Verlag, coll. « Springer Texts in Statistics », 2013

D. MacKay, Information Theory, Inference, and Learning Algorithms, Cambridge University Press, 2003

T. Mitchell, Machine Learning, 1997

F. Galton, Kinship and Correlation (reprinted 1989), Statistical Science, Institute of Mathematical Statistics, vol. 4, no 2,‎ 1989, p. 80–86

C. Bishop, Pattern Recognition And Machine Learning, Springer, 2006

G. Saint-Cirgue, Machine Learnia, Youtube Channel

D.V. Lindley, Regression and correlation analysis, 1987

Non-Optimal Linear Regression


import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Parameters of the quadratic function
a = 400
b = 200
c = 900

# Generate 150 points between -100 and 100
np.random.seed(42)

X = np.random.uniform(0, 1, 150)

# Create Y values based on the quadratic function with Gaussian noise

Y = a * X**2 + b * X + c + np.random.normal(0, 15, 150)

# Reshape the data for modeling
X = X.reshape(-1, 1)
Y = Y.reshape(-1, 1)

# Perform linear regression
model = LinearRegression()
model.fit(X, Y)

# Display the data
plt.figure(figsize=(8, 6))
plt.scatter(X, Y, color='red',label='Data Points')
plt.plot(X, 500 * X +  c, color='blue', linewidth=2, label='Linear Regression Line')
#plt.plot(X, model.predict(X), color='blue', linewidth=2, label='Linear Regression Line')
plt.title('Linear Regression on Gold Price based on Purity')
plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.legend()
plt.grid(ls='--')
plt.show()

Optimal Linear Regression with Learning Curve


import numpy as np
import matplotlib.pyplot as plt

# Parameters of the quadratic function
a = 400
b = 200
c = 900

# Generate random data
np.random.seed(42)
x = np.random.uniform(0, 1, 150)
y = a * x**2 + b * x + c + np.random.normal(0, 15, 150)
y = y.reshape(y.shape[0], 1)  # Reshaping y to fit the required shape

# Create the feature matrix X
X = np.vstack((x, np.ones(len(x)))).T

# Initialize the theta parameters for the linear model
theta = np.random.randn(2, 1)

# Define the linear model function
def model(X, theta):
    return X.dot(theta)

# Define the cost function
def cost_function(X, y, theta):
    m = len(y)
    return 1 / (2 * m) * np.sum((model(X, theta) - y)**2)

# Define the gradient calculation function
def grad(X, y, theta):
    m = len(y)
    return 1 / m * X.T.dot(model(X, theta) - y)

# Define the gradient descent function
def gradient_descent(X, y, theta, learning_rate, n_iterations):
    cost_history = np.zeros(n_iterations)
    for i in range(n_iterations):
        theta = theta - learning_rate * grad(X, y, theta)
        cost_history[i] = cost_function(X, y, theta)
    return theta, cost_history

# Define the learning rate and number of iterations
learning_rate = 0.2
n_iterations = 20

# Perform gradient descent to optimize the parameters
theta_final, cost_history = gradient_descent(X, y, theta, learning_rate, n_iterations)

# Make predictions with the optimized parameters
predictions = model(X, theta_final)

# Plot the data points and the linear model predictions
plt.scatter(x, y, c='r',label='Data Points')
plt.plot(x, predictions, c='blue',label='Linear Regression Line')
plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Linear Regression on Gold Price and Gold Purity')
plt.legend()
plt.grid(ls='--')
plt.show()

# Plot the cost history during gradient descent
plt.plot(range(n_iterations), cost_history)
plt.xlabel('Number of Steps')
plt.ylabel('Descent')
plt.title('Descent History during Gradient Descent')
plt.grid(ls='--')
plt.show()

# Calculate the coefficient of determination (R-squared)
def coef_determination(y, pred):
    u = ((y - pred)**2).sum()
    v = ((y - y.mean())**2).sum()
    return 1 - u / v

# Print Final theta

print(theta_final)

# Print the R-squared value
print(coef_determination(y, predictions))

# Display the first 5 samples of the data
print("First 5 samples of the data:")
for i in range(5):
    print(f"Sample {i + 1} - Gold Purity: {x[i]:.4f}, Gold Price: {y[i][0]:.4f}")

Polynomial Regression


import numpy as np
import matplotlib.pyplot as plt

# Parameters of the quadratic function
a = 400
b = 200
c = 900

# Generate random data
np.random.seed(42)
x = np.random.uniform(0, 1, 150)
y = a * x**2 + b * x + c + np.random.normal(0, 15, 150)
y = y.reshape(y.shape[0], 1)  # Reshaping y to fit the required shape

# Create the feature matrix X

X = np.vstack((x**2,x, np.ones(len(x)))).T


print(X.shape)

# Initialize the theta parameters for the linear model
theta = np.random.randn(3, 1)

# Define the polynomial model function
def model(X, theta):
    return X.dot(theta)

# Define the cost function
def cost_function(X, y, theta):
    m = len(y)
    return 1 / (2 * m) * np.sum((model(X, theta) - y)**2)

# Define the gradient calculation function
def grad(X, y, theta):
    m = len(y)
    return 1 / m * X.T.dot(model(X, theta) - y)

# Define the gradient descent function
def gradient_descent(X, y, theta, learning_rate, n_iterations):
    cost_history = np.zeros(n_iterations)
    for i in range(n_iterations):
        theta = theta - learning_rate * grad(X, y, theta)
        cost_history[i] = cost_function(X, y, theta)
    return theta, cost_history

# Define the learning rate and number of iterations
learning_rate = 0.2
n_iterations = 20

# Perform gradient descent to optimize the parameters
theta_final, cost_history = gradient_descent(X, y, theta, learning_rate, n_iterations)

# Make predictions with the optimized parameters
predictions = model(X, theta_final)


# Plot the data points and the polynomial regression predictions
plt.scatter(x, y, c='r', label='Data Points')
plt.plot(x, predictions, c='blue', label='Polynomial Regression Line')
plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Polynomial Regression on Gold Price and Gold Purity')
plt.legend()
plt.grid(ls='--')
plt.show()

# Plot the cost history during gradient descent
plt.plot(range(n_iterations), cost_history)
plt.xlabel('Number of Steps')
plt.ylabel('Descent')
plt.title('Descent History during Gradient Descent')
plt.grid(ls='--')
plt.show()


# Calculate the coefficient of determination (R-squared)
def coef_determination(y, pred):
    u = ((y - pred)**2).sum()
    v = ((y - y.mean())**2).sum()
    return 1 - u / v

# Print Final theta
print(theta_final)

# Print the R-squared value
print(coef_determination(y, predictions))

The article Wall-E: The Little Gold Miner first appeared on The Event Horizons.

Defeat the Game Master

admin — Mon, 02 Oct 2023 19:03:17 +0000

Defeat the Game Master

By Jordan Moles on October 2, 2023.

In the heart of a dimly lit tavern, lost somewhere in a strange multiverse of Dungeons and Dragons, a group of individuals as diverse as they were noisy gathered. Thunderous laughter echoed through the smoky establishment as dice of all shapes whirled through the air, coming to rest with a satisfying clatter to determine the fate of their owners. Seated on rickety stools around an old, weathered wooden table, our heroes, or at least what one could call them, were gearing up for a well-deserved evening of beer, dice, and camaraderie.

Let's Make Introductions!

At the center of this eclectic gathering, the Ranger stood, self-proclaimed leader of the team.

His main mission was to maintain peace within the group, especially between the Elf and the Dwarf, two individuals known for their disagreements.

However, despite his efforts, he was often overwhelmed by despair, especially when things went awry. The Ranger wasn’t specialized in any particular skill but rather versatile.

He had the unfortunate habit of overestimating his abilities and attempting to use talents he didn’t quite master.

To his left, the Barbarian held his place.

He was a colossal figure with bulging muscles, wielding a sword as an extension of his mighty arm. The Barbarian’s life boiled down to two passions: combat and carousing with the Dwarf.

He held no fondness for magic, which he saw as a weakness. He was often quick to judge the other group members as weaklings or cowards if they didn’t share his fervor for melee.

On the other side of the table, the Elf lounged with natural grace. With her enchanting beauty, she appeared to be free from all worries. Her carefree and lighthearted demeanor stood in stark contrast to her companions.

Her behavior was often seen as eccentric, although she seemed unaware of it.

She maintained a tumultuous relationship with the Dwarf, their mutual antipathy having become legendary among the tavern’s regulars.

Next to the Barbarian, the Dwarf, a robust and choleric warrior, prepared to enter the arena of the impending game. His primary obsession was money, and he was willing to do anything to fill his purse, even embarking on perilous adventures with companions he couldn’t stand, especially the Elf, with whom he had an abominable relationship.

The Dwarf was also an expert in complex calculations, particularly when it came to distributing loot among the group members, taking into account various criteria such as time spent together, the danger of situations, and the experience gained in battles.

He never missed an opportunity to savor good hams and brandish his small axe, which he wielded with great skill.

In the shadows, the Rogue, dressed discreetly, observed the scene. His sharp eyes scanned for the next purse to steal.

His legendary agility and dexterity made him a master in the art of theft, but it also meant that he couldn’t resist pilfering small things, even among his companions.

His dark demeanor and black leather tunic left little trace as he slipped into the shadows. His lock-picking, thieving, and espionage tools were carefully concealed under a discreet belt.

Next to the Elf, the Magician sat. She was a woman with deep red hair, passionate about all sorts of literature, with a particular fascination for spellbooks.

Unfortunately, her magical talents were limited, and she didn’t particularly shine in that area. Despite her lack of magical aptitude, she made up for it with her in-depth knowledge of books.

In terms of attire, she typically wore a long dark blue robe adorned with silver motifs that resembled sparkling stars. Her outfit was complemented by a matching pointed hat, adding a touch of mystery to her appearance. She also wore a leather belt with pockets for storing small magical items and components for her spells.

The Magician remained an invaluable source of knowledge for the group and played a central role within the company, effectively sharing leadership with the Ranger.

Finally, by their side stood the Ogre, an imposing creature. His insatiable appetite manifested in primitive grunts. Although he was of a kind nature, he remained a constant source of trouble, overturning chairs and breaking glasses at regular intervals.

His actions were primarily dictated by instincts, which made him akin to the Barbarian, with whom he shared a passion for good food. However, he had a special connection with the Magician, the only one capable of understanding his language.

The Rules of the Game

After several pints of beer, heated arguments, questionable jokes, and epic anecdotes, the atmosphere in the tavern was at its peak. The loud laughter and off-key singing of the adventurers filled the room, while the overwhelmed waitresses tried to fulfill the ever-increasing orders.

The Magician, fueled by the festive ambiance, decided that the moment had come to add an extra touch of excitement to the evening. She suddenly pulled out a set of 14 mysterious dice from her bag, 2 each, immediately grabbing the attention of her companions. Curious looks fell upon the dice as conversations gradually quieted.

With a mischievous smile lighting up her face, she announced in a clear voice, “My friends, we’re going to spice up this evening with a dice game! Who’s ready to try their luck?”

The Magician’s announcement sparked a wave of enthusiasm among the already tipsy adventurers.

The Dwarf, always eager for opportunities to gain gold but unwilling to wager his own, slammed the table with his calloused hands and exclaimed, “By the beards of our ancestors, I’m in!”

The Elf, despite her frequent disagreements with the Dwarf, smiled and said, “Why not? It could be fun.”

Even the Ogre, whose limited facial expression didn’t reveal much, emitted a consenting grunt.

The Ranger, followed by the Barbarian and the Rogue, quickly went to fetch some supplies, a cheese board, and some country ham before attentively listening to the rules of the game.

The Magician, delighted to see that her idea had been so well-received, rummaged through her bag and pulled out a large parchment. It contained the fundamental laws that had to be read before playing. They were written in a peculiar manner, resembling runes that only the Magician could decipher, but here is the note magically transcribed into our language:

Dear mortal, beware, for I shall initiate you into the profound mysteries that govern these sacred dice. They are subject to enigmatic laws that you must understand before unleashing them on the table. Follow my words carefully, and you shall discover the hidden power behind each roll. Here is the most important one, the one that defines them all.

Let ($\Omega$, A) be a measurable space, where $\Omega$ is the universe and A is a sigma-algebra. A probability measure is a measure with a total mass of 1, and it satisfies the following three axioms:

• For any set E in A, the probability $\mathbb{P}$(E) is a real number between 0 and 1.

• The probability of the universe $\Omega$ is equal to 1, meaning $\mathbb{P}(\Omega) = 1$.

• Probability is $\sigma$-additive, which means that for any finite or countable family of pairwise disjoint sets $(E_i, i \in I)$ in A, the probability of their union is equal to the sum of the individual probabilities:

\begin{equation*}\mathbb{P}\left(\bigcup_{i\in I} E_i\right) = \sum_{i\in I} \mathbb{P}(E_i)\end{equation*}

In particular, the probability of the empty set ($\emptyset$) s equal to 0, i.e., $\mathbb{P}(\emptyset) = 0$.

The Elf, the Barbarian, and the Ranger scratch their heads in confusion, while the Dwarf, always attentive to the prospect of winning gold, silently nods. The Magician, seeing that her explanations haven’t been understood by everyone, decides to simplify further.

She takes a small piece of paper from her pocket and begins to explain more concisely: “Alright, let’s forget about the complicated terms. The universe is simply all possible outcomes. For example, when we roll a die, the possible outcomes are 1, 2, 3, 4, 5, and 6. That’s the universe, which we denote as $\Omega=\{1, 2, 3, 4, 5, 6\}$.

Then, a sigma-algebra is the set of all subsets of the universe, meaning all possible groups of results we can obtain. For example, a subset could be the set of even numbers, which is $\{2, 4, 6\}$.

Do you follow so far?

Let’s move on to the axioms. The first one is simple: it just says that the probability of an event is always between 0 and 1. In other words, this means that the probability of getting a result is always either zero (impossible) or one (certain).

The second axiom is even simpler. It says that the total probability of all possible outcomes is always 1. So if we add up the probability of getting each number on our die, it must always equal 1.

The third axiom, a bit more complex, means that if we have two events that cannot happen at the same time (disjoint), then the probability of either one happening is simply the sum of the probabilities of each. For example, the probability of getting a 1 or a 6 when rolling a fair die is the sum of the probability of getting a 1 and the probability of getting a 6.

I hope this clarifies things a bit!”

The Magician, aware that her companions are starting to get impatient with the technical terms, decides to simplify the explanations further to make the concepts more accessible.

She continues her narrative: “Now, let’s forget about the complex terms for a moment. The laws of probability can be described in three major categories of characteristics, as indicated on this parchment:”

•«There are position parameters that influence the central tendency of the probability distribution. They determine the values around which the probability is most concentrated, which means where most of the results cluster. Among these parameters, we have the expectation, which is a measure of the average, the median, which is the central value, and the mode, which is the most frequent value.”

Normal distribution with a mean of 5 and a variance of 10.

• “Then there are scale parameters, which measure how spread out or tight values are around those central values. Variance, standard deviation, and interquartile range are examples of these parameters. We often focus on variance, which works like this:

If it’s close to zero, it suggests that individual values are similar and cluster closely around the mean.

Conversely, high variance indicates that individual values are farther from the mean, with a greater overall spread.”

Two normal distribution laws with a mean equal to 5 and a variance equal to 2, and the other one with a mean equal to 20.

• “Finally, we have the shape parameters. They describe how probabilities change as we move away from the central values.

For example, skewness measures if the distribution is tilted to one side or the other, and kurtosis, or the coefficient of kurtosis, examines how closely values are concentrated near the mean.“

Normal distribution with zero skewness and a normal distribution with skewness equal to 10.

The Law of the Die

The Magician paused before concluding: “Now that we’ve gone over these concepts, let’s dive into the heart of the matter that seems to interest you: the discrete uniform probability distribution.”

The Elf: (whispering to the Barbarian) Oh, it’s about time; it’s almost bedtime.

The Barbarian: (chuckling) Yeah, I hope this magisterial lecture ends before midnight.

The Ranger: (smiling) Maybe we should prepare some blankets for our tired comrades.

The Magician, looking at them with an amused expression, decides to continue despite her companions’ teasing remarks.

The Magician: The discrete uniform distribution is perhaps the most important probability distribution you need to understand here. It ensures equiprobability, meaning that each outcome has an equal probability for each mode in a finite set of possible modes.

The Dwarf loses patience with all the jargon and snatches the parchment from the Magician’s hands.

The Dwarf: (furrowing his brows) Hold on… does this old parchment say I should give you a gold piece? I’m not sure why I should do that.

The Barbarian: (laughing) Haha! The parchment predicts the future! Come on, Dwarf, give her the coin!

The Dwarf refuses to give up his coin, but the impatient Barbarian punches him in the head.

The Barbarian: (laughing) Come on, Dwarf, do it for education! It only costs a coin.

The Ogre: (banging the table and laughing heartily), Zog zog.

The Elf: Well done.

The Dwarf, slightly dazed from the blow, reluctantly hands over a gold piece to the Magician along with the parchment.

The Magician: Perfect, thanks for your contribution. So, to better understand, imagine a fair coin. When you toss it, each side has an equal chance of appearing, which is 1/2.

Discrete uniform distribution with two outcomes (Coin toss).

For my dice, it’s the same thing. A standard die has 6 faces, which corresponds to 6 modes, and if it’s balanced, we say they are all equiprobable.

Discrete uniform distribution with six outcomes (Roll of a die).

The Thief: (curiously) Show me that coin, I’d like to examine it closely to better understand the heads or tails.

The Magician: (handing the coin to him) Of course, here’s the coin. It’s balanced, so each side has an equal chance of landing.

The Elf: (raising a hand) Wait, what can we say about the die, too?

The Magician: (smiling) Many things. Here are the main characteristics of these dice:

We call $X$ the random variable that follows the discrete uniform distribution (the roll of a die).

• The expectation: it’s like the average, and for a standard die, it’s $\mathbb{E}(X)= \frac{6+1}{2}=3,5$

• The median: it’s the middle value, also $m(X)= \frac{6+1}{2}=3,5$ for a fair die.

• The mode: there isn’t one here because each face has the same probability of appearing.

• The variance: it measures the spread of results, and for a fair die, it’s approximately $V(X)=\frac{6^{2}-1}{12}\approx2.91$

• The skewness is zero, and the kurtosis…

The Ranger: (interrupting) Excuse me, but isn’t that enough of the rules? We’ve got the basics.

The Magician: Well, there are a few more laws in this parchment, the triangular probability distribution, the…

The Dwarf: (grumpy) By the beards of our ancestors, we didn’t come here for a math class! We want to roll those dice and play, not listen to endless speeches.

The Barbarian: (slapping the table) He’s right! This is all well and good, but we want action, not numbers!

The Thief: (examining the coin closely) Yeah, I’m with them. Can we start playing now?

The Dwarf: Give me back my coin!

The Magician: (trying to keep her calm) Alright, alright, I see you’re all very impatient. But before rolling the dice, let me just take one last look at this note at the bottom of the page. I want to make sure we’re following all the rules.

The Magician begins to quickly read the note at the bottom of the page, but suddenly stops.

The Magician: (surprised) Wait, there’s something important here that I hadn’t noticed! It says, “Do not flip the coin before playing with the dice because…”

Before she can finish her sentence, the Voleur tosses the gold coin in the air to return it to the Nain. But instead of landing in his hand, the coin starts spinning in the air in a mysterious way, emitting a magical glow.

The Dwarf: (surprised) By the beards of our ancestors, what’s happening?

The coin continues to spin in the air, faster and faster, and suddenly it disappears completely, leaving everyone puzzled.

The Elf: (astonished) Where did the coin go?

The Magician: (shocked) I… I don’t know. It seems like the dice are more mysterious than I thought.

The Barbarian: (excited) Whatever it is, it looks fun! Let us roll the dice now!

The Dwarf: (annoyed) Where is my coin?

It was a night of revelry, heated arguments, and rowdiness in the old tavern. The adventurers had stopped to relax after a long day of exploration, and, as was their custom, they had gotten caught up in the excitement of the evening.

The Dwarf, already in a bad mood, decided that everything was always the fault of the Elf. He had taken the Elf as a scapegoat, attributing all the group’s woes to her, constantly repeating that “it was the Elf’s fault that everything was going wrong.” This deplorable attitude only worsened as the evening progressed.

While they played dice and bet money, the Voleur decided to spice up the evening by discreetly stealing a waitress’s panties. It was an act as audacious as it was risky, but he managed to accomplish this feat with remarkable dexterity.

The Barbarian, on the other hand, gave in to his impulsiveness by punching the bouncer at the tavern’s entrance after a minor argument. The bouncer wasted no time calling for reinforcements, which quickly subdued the Barbarian with a good beating. This plunged the group into an even more complicated situation.

The Ogre, always hungry and curious, decided to satisfy his appetite by swallowing a billiard ball. This caused a great deal of laughter among the tavern’s customers, but also a lot of concern about the Ogre’s well-being.

Finally, the Nain, completely drunk, ended up vomiting his beer on the innkeeper, triggering a general brawl between the adventurers and the other customers.

The ensuing chaos could only lead to one inevitable conclusion: all the adventurers eventually found themselves in the dungeon, where they would have to face new adventures to escape from this predicament. It was the beginning of an adventure that would take them much further than they could have imagined on that night of debauchery and disorder.

The Dungeon

The Ranger, known for his wisdom (or so he claimed), gathered the motley group of adventurers in a dim corner of their filthy cell. The faint flicker of a wavering torch added a picturesque ambiance to their already unsavory situation.

“Listen to me, comrades,” the Ranger began with a firm, though somewhat nervous voice. “We are in a dire situation, but we are not just anybody. We are an elite troupe, and we cannot resign ourselves to being locked up here like common rats in a sewer. What we need is a plan.”

Upon this, the Elf and the Dwarf started bickering like children, calling each other “lichen suckers” and “rock-eaters.” The Dwarf, having thicker skin than the Elf (literally), retorted by insulting the elf’s pointed ears and suggesting that he go back to playing his flute in the forest.

The Barbarian, who seemed incredibly bored, interrupted the quarrel and decided to use his Herculean strength to try and break down the door. Unfortunately, he had taken a severe blow to the head during the arrest and was still groggy from the impact.

The Game Master asked him to make his disadvantage roll, which meant he would roll the die twice and keep the less favorable result. Moreover, the door was made of steel, designed to withstand the efforts of prisoners trying to escape their sentences.

Sélect:

Number of dice = 1

Type of dice = 6

Roll the dice twice and choose the smaller result.

Number of dice

Type of die:

Modifier

Display all rolls?

Result:

What result do you get ?

Bibliography

P. Barbé et M. Ledoux, Probabilité, Les Ulis, EDP Sciences, 2007.

P. Bogaert, Probabilités pour scientifiques et ingénieurs : Introduction au calcul des probabilités, Paris, Éditions De Boeck, 2006.

M. Lejeune, Statistique : la théorie et ses applications, Springer Science et Business Media, 2004.

F. Caravenna, P. Dai Pra et Q. Berger, Introduction aux probabilités : Modèles et applications : mathématiques, physique, informatique, sciences de l’ingénieur, biologie, Dunod, 1er septembre 2021.

Representation of the mean


import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# Parameters for normal distributions
mean = 5  # Common mean for both distributions
variance1 = 10  # Variance for the first example
variance2 = 20  # Variance for the second example

# Generate data for the two distributions
x = np.linspace(-10, 20, 1000)
pdf1 = norm.pdf(x, loc=mean, scale=np.sqrt(variance1))
pdf2 = norm.pdf(x, loc=mean, scale=np.sqrt(variance2))

# Plot probability density functions with transparent fill color
plt.plot(x, pdf1, label=f'Variance={variance1}')
plt.fill_between(x, pdf1, alpha=0.3)
#plt.plot(x, pdf2, label=f'Variance={variance2}')
#plt.fill_between(x, pdf2, alpha=0.3)

# Calculate the mean for both cases (they should be equal)
mean1 = mean
mean2 = mean

# Draw vertical lines for the means
plt.axvline(x=mean1, color='r', linestyle='--', label=f'Mean')

plt.xlabel('Values')
plt.ylabel('Probability')
plt.legend()
plt.grid(True)
plt.show()

print(f"Mean (Var={variance1}): {mean1:.2f}")
print(f"Mean (Var={variance2}): {mean2:.2f}")

Representation of the variance


import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# Parameters for normal distributions
mean = 5  # Common mean for both distributions
variance1 = 10  # Variance for the first example
variance2 = 20  # Variance for the second example

# Generate data for the two distributions
x = np.linspace(-10, 20, 1000)
pdf1 = norm.pdf(x, loc=mean, scale=np.sqrt(variance1))
pdf2 = norm.pdf(x, loc=mean, scale=np.sqrt(variance2))

# Plot probability density functions with transparent fill color
plt.plot(x, pdf1, label=f'Variance={variance1}')
plt.fill_between(x, pdf1, alpha=0.3)
plt.plot(x, pdf2, label=f'Variance={variance2}')
plt.fill_between(x, pdf2, alpha=0.3)

# Calculate the mean for both cases (they should be equal)
mean1 = mean
mean2 = mean

# Draw vertical lines for the means
plt.axvline(x=mean1, color='r', linestyle='--', label=f'Mean')

plt.xlabel('Values')
plt.ylabel('Probability')
plt.legend()
plt.grid(True)
plt.show()

print(f"Mean (Var={variance1}): {mean1:.2f}")
print(f"Mean (Var={variance2}): {mean2:.2f}")

Representation of the skewness


import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import skewnorm

# Parameters for the normal distribution
mean1 = 5
std_dev1 = 2
skewness1 = 0  

# Parameters for the asymmetric normal distribution
mean2 = 5
std_dev2 = 2
skewness2 = 10  # Positive skewness (right-skewed)

# Create a range of x values
x = np.linspace(0, 10, 1000)

# Calculate the probability density functions (PDFs) for both distributions
pdf1 = skewnorm.pdf(x, skewness1, loc=mean1, scale=std_dev1)
pdf2 = skewnorm.pdf(x, skewness2, loc=mean2, scale=std_dev2)

# Plot the PDFs as curves
plt.plot(x, pdf1, label=f'Skewness={skewness1}')
plt.fill_between(x, pdf1, alpha=0.3)
plt.plot(x, pdf2, label=f'Skewness={skewness2}')
plt.fill_between(x, pdf2, alpha=0.3)

plt.xlabel('Values')
plt.ylabel('Probability')
plt.legend()
plt.grid(True)
plt.show()

Discrete uniform distribution of the coin flip


import matplotlib.pyplot as plt

# Define possible values (coin faces)
values = [0, 1]

# Calculate uniform probabilities (each face has a 1/2 probability)
probabilities = [1/2] * 2

# Set the values to display on the y-axis
plt.yticks([0, 0.25, 1/2, 0.75, 1])

# Create the scatter plot
plt.plot(values, probabilities, marker='o', color='black', label='Probabilities', ls='--')

# Limit the y-axis scale from 0 to 1
plt.ylim(0, 1)

# Label the axes and add a title
plt.xlabel('Coin Value')
plt.ylabel('Probability')


# Display the plot
plt.grid(True)
plt.legend(loc='upper right')
plt.show()

Discrete uniform distribution of the roll the a die


import matplotlib.pyplot as plt

# Define possible values (dice faces)
values = [1, 2, 3, 4, 5, 6]

# Calculate uniform probabilities (each face has a 1/6 probability)
probabilities = [1/6] * 6

# Create the scatter plot
plt.plot(values, probabilities, marker='o', color='black', label='Probabilities', ls='--')

# Set the values to display on the y-axis
plt.yticks([0, 1/6, 0.25, 0.5, 0.75, 1])

# Label the axes and add a title
plt.xlabel('Dice Value')
plt.ylabel('Probability')

 
# Display the plot
plt.grid(True)
plt.legend(loc='upper right')
plt.show()

The article Defeat the Game Master first appeared on The Event Horizons.

Wall-E: The Foundations of its Intelligence

admin — Sat, 02 Sep 2023 20:33:51 +0000

Wall-E: The Foundations of its Intelligence

Episode I

By Jordan Moles on September 2, 2023

In a devastated post-apocalyptic world, where the remnants of human civilization are buried under massive heaps of waste, a solitary little robot named Wall-E navigates through this dystopian landscape. His mission: the methodical recycling of discarded waste that has accumulated over the years. However, Wall-E’s endeavors go beyond merely sorting pieces of plastic, metal sheets, and organic materials.

Through his interactions with the environment, this dedicated robot also gathers an abundance of information, analyzes millions of data points, and learns from his experiences to adapt, survive, and carry out his tasks with remarkable efficiency. The capabilities of what seemed to be a simple waste-collecting robot reveal the foundations of a burgeoning field: artificial intelligence.

The very Essence of Artificial Intelligence: Learning

In the early sparks of its existence, our little robot, much like a computer, was born to plunge into the abyss of calculations that would take millions of years for a human to find an answer to. Tasks once titanic for earthly souls stood before it, demanding to be tamed.

But within its circuits, a transformation was underway. A transformation inspired by the geniuses of the world’s scientific community. They infused our robot with a unique form of intelligence, a digital spark that changed the game. Wall-E, once a machine, was now becoming an entity that would learn and make complex decisions. It was the dawn of artificial intelligence, a new technological era.

Confronted with ever-growing challenges, Wall-E showcased its versatility. It seamlessly navigated both types of situations that humanity presented to it. In one case, it obediently followed calculations programmed by humans, responding like a calculator would to a simple $1+1$.

Yet, it encountered a much more intricate puzzle: how to differentiate between the types of waste it encountered? How to recognize plastic from metal or organic material? Or more generally, how to solve a given problem without knowing the specific calculation required for its solution? This is where learning comes into play, a fascinating method we call Machine Learning. A method that opens a door when we don’t know which key to use. Machine Learning is a master key for a multitude of tasks: image recognition, stock market predictions, estimating gold values, detecting cybersecurity vulnerabilities, and, of course, in our case: waste sorting.

To bestow this computer with learning intelligence, methods inspired by our own learning process were implemented. Among them, three fundamental approaches stand out:

• First and foremost, supervised learning, which forms the cornerstone of Machine Learning. Much like our own experience of acquiring knowledge, this method guides the little wheeled computer by providing it with pre-labeled examples. Like an eager apprentice assimilating knowledge, Wall-E is exposed to situations where the expected outcomes are already known. Then, by observing these examples, it gradually generalizes the relationships between inputs and outputs, thereby enabling it to make decisions and solve similar problems it will encounter later on.

• Next, unsupervised learning, a more open and exploratory form of artificial intelligence. This method allows the computer to autonomously discover hidden structures and patterns within data, without the need for pre-labeled examples. Like a fearless explorer, Wall-E uses its sensory analysis to discern patterns, group similar information, and explore the nuances of its environment. Through this unconstrained exploration, it gains a deep understanding of the world around it, uncovering unexpected insights and knowledge.

• Finally, reinforcement learning, which relies on a system of rewards and punishments to guide the computer in its learning process. Similar to our own motivations, Wall-E is rewarded when it successfully accomplishes a task and faces negative consequences for failures. These encouragements and penalties enable it to optimize its actions, make intelligent decisions, and refine its skills over time.

Baby Robot Will Grow Up: The Architecture of Supervised Learning

At the birth of Wall-E, humanity had already charted its exodus to the distant corners of space, leaving behind a Earth suffocated under the weight of climate change and invasive pollution. The natural balances that had cradled our world for so long had faltered, relegating the planet to a new reality. Once vibrant cities teeming with life were now mere remnants, silent witnesses of a bygone era.

However, a group of scientists had committed to remain on this weary land, guided by a bold vision: to educate this small robot brimming with potential, to differentiate metals, to sort plastics, all for a crucial mission – to clean and regenerate the planet itself.

Thus began a phase of learning, where human knowledge was imparted to Wall-E. Scientists employed a specific method to guide this apprentice robot: supervised learning. This foundational aspect of Machine Learning provided Wall-E with the opportunity to evolve and grow by absorbing clearly labeled examples.

The beginnings of this journey revolve around this principle, inviting us to delve into the intricate mechanics of learning and uncover the crucial elements that drive it.

1. The Dataset: A Treasure Trove of Information

Like a gold mine for Wall-E, the dataset, or ensemble of data, constitutes an organized collection of examples upon which the robot will base its learning. Each example consists of diverse input variables (features) that it will arrange into a matrix (a kind of table) and corresponding expected outputs (targets) that it will arrange into a vector (a column). These final variables are what Wall-E will seek to predict.

For instance, if we wish to teach Wall-E to recognize types of waste, the specific characteristics of the objects will constitute the input data (density, thermal conductivity, electrical conductivity, etc.), and labels indicating the type of each object will constitute the expected outputs (plastic, metal, organic). Nothing too intricate with this example table containing 5 samples.

Index	Density	Electrical Conductivity ($S.m^{-1}$)	Carbon Content	Material
1	4.5	$2.4 \times 10^{6}$	0	Metal
2	0.5	$10^{-16}$	0.5	Organic
3	19.3	$41 \times 10^{6}$	0	Metal
4	1.1	$10^{-16}$	0.4	Organic
5	1.2	$10^{-14}$	0	Plastic

Of course, as a waste sorting robot, this task constitutes its main mission. However, our little robot is also passionate about estimating the prices of metals, especially that of gold. Yet, as it doesn’t truly grasp the human monetary system, it converts everything into bolts.

So, to entertain it, scientists have it analyze every piece of gold-like metal to determine its purity and assign it a market value. Here’s an illustrative example with 5 variables.

Index	Purity	Gold Price
1	0.374540	1224.193388
2	0.950714	1483.925567
3	0.731994	1360.214557
4	0.598658	1284.274057
5	0.156019	1004.083221

With a much larger training dataset, it will be able to learn how to classify metal, plastic, and organic materials based on their characteristics, and assess the price of an unknown metal based on its purity.

2. The Model and Its Parameters: The Architecture of Learning

Now, let me introduce you to the structure that Wall-E will use to learn from the dataset. This will be our model. Imagine a “black box” like an electronic device that Wall-E uses to process information and make predictions. It’s “black” in the sense that its internal workings are somewhat mysterious and complex, at least from Wall-E’s perspective. Inside this box, there are gears, levers, and hidden mechanisms that transform inputs (the data collected by Wall-E) into outputs (the predictions made by Wall-E).

Within this black box are the “parameters.” These are like the internal settings that Wall-E can adjust to improve its ability to make accurate predictions. Think of them as the secret buttons and knobs that Wall-E can turn and press to make the black box work more effectively.

When we talk about a “model,” we’re referring to a specific configuration of this black box or how each piece interacts with the rest of the system.

Supervised learning involves adjusting the parameters of this black box so that the predictions it generates are as close as possible to the correct answers (labels) provided in the training dataset. By adjusting the parameters and observing how predictions change, Wall-E is trying to understand how this black box actually works and how to make it better.

These models can be of different natures; some are linear, and others are non-linear. Let’s start by exploring linear models:

Linear Models: Simplicity in Linearity

These are relatively simple yet powerful mathematical representations. They assume that the relationship between the inputs and outputs is linear, which means it can be represented by a straight line (or a plane or hyperplane in a multidimensional space).

As mentioned earlier, scientists didn’t just limit the robot to simple waste recycling; they also taught it how to estimate the price of a metal based on its purity. By revisiting its data, Wall-E has a dataset consisting of only k samples of gold, where purity is the input feature $x^{(k)}$ and the corresponding price is the target $y^{(k)}$. Let’s use the previous table to illustrate this.

Index	x	y
1	0.374540	1224.193388
2	0.950714	1483.925567
3	0.731994	1360.214557
4	0.598658	1284.274057
5	0.156019	1004.083221

Here, we have 5 samples of gold with their respective data, indicating, for example, that sample 2 has a purity $x^{(2)}=0.731994$ and is worth $y^{(2)}=1360.214557$ bolts. So, on the graph, we display the data from the table (we show 50 samples instead of 5, and imagine that there could be millions).

Such a model could thus be represented by an equation of the form $y = ax + b$, where “a” (the slope) and “b” (the y-intercept) are adjustable parameters within the model’s black box.

Supervised learning aims to find the optimal values of “a” and “b” so that the model can draw the best possible line that minimizes the error between predictions and actual values.

Of course, reality is more complex than that, and for a more accurate estimation of the gold price, it would be necessary to consider historical information about gold prices over time, as well as relevant economic, political, and geopolitical features that can influence its value.

While linear models are simple and easy to interpret, they can be limited in their ability to capture complex relationships between variables. This is where non-linear models come into play.

Non-linear Models: Elegance in Complexity

As for non-linear models, they offer increased flexibility compared to linear models. They are capable of capturing complex and obviously non-linear relationships between inputs and outputs, thus allowing the representation of more sophisticated data behaviors.

Imagine that in fact, we have different data behaving more like this.

So such models could be represented by equations like $y = ax^2 + bx +c$ (a quadratic polynomial for the first curve) or more complex functions (like the sigmoid for the second) where the goal remains to find the parameters that minimize the error.

Thus, the choice between a linear model and a non-linear model depends on the nature of the data and the complexity of the problem to be solved. Linear models are generally preferred when relationships between variables are simple and clear, while non-linear models are favored for more complex tasks and data sets rich in information.

3. Cost Function: Measuring Errors

To measure how well Wall-E performs in this gold estimation task, we use a special function called the Cost Function. This function plays a crucial role in quantifying the errors between the price estimates made by Wall-E and the actual gold prices from historical data. It calculates the error for each estimate and then sums up these errors to form an overall measure of Wall-E’s performance in gold price estimation.

Being a true perfectionist, Wall-E aims to have a Cost Function that is well-suited to the model and as small as possible. This implies that he wants to minimize the errors between his price estimates and the actual prices, in order to make predictions with the highest possible accuracy.

4. The Learning Algorithm: Finding the Optimum

To reduce this Cost Function, Wall-E employs a well-known algorithm called the gradient descent. This technique enables it to gradually adjust its internal parameters (for the linear model, it adjusts a and b) based on the errors made during the gold price estimation. At each step of the learning process, Wall-E enhances its performance by moving closer to the optimum, where the Cost Function is minimized.

We observe that with each iteration, the errors become progressively smaller until they reach a constant level. This way, Wall-E becomes an expert in gold price estimation, making predictions with remarkable accuracy.

Therefore, thanks to the final curve, it can, for instance, estimate the price of a gold sample with a purity level of 0.8, which would be approximately 1400 bolts.

A Super Robot

Wall-E’s learning universe extends across a multitude of applications, each resonating with well-defined problems that can be categorized into two distinct families: regression and classification.

Regression is a quantitative technique used to predict continuous target values, meaning numbers that can take any value within a certain range. Thus, among Wall-E’s favorite pursuits, estimating the price of gold falls under regression problems. Other examples include:

Estimation of Remaining Drinkable Water Quantity: Wall-E can use historical data on groundwater levels, precipitation, and evaporation rates to create a regression model. This model could be used to estimate the amount of drinkable water remaining in underground sources, enabling humans to better plan their use of this vital resource.

Prediction of Solar Energy Production: Wall-E relies on solar energy to power its functions and recharge. By using data on daily sunlight, solar panel quality, and other environmental factors, Wall-E could create a regression model to predict solar energy production at different times of the day and under various weather conditions.

Battery Lifespan Estimation: Wall-E’s batteries degrade over time and usage. By analyzing past battery performances and considering environmental conditions, Wall-E could develop a regression model to estimate the remaining lifespan of batteries. This would allow for proactive battery replacement planning.

Prediction of Pollution Levels: Wall-E roams through the mountains of waste and polluted areas. By gathering data on air and water pollution levels, as well as waste dumping practices, it could create a regression model to predict future pollution levels in different regions, helping to identify the most critical areas for sanitation efforts.

Classification is another qualitative supervised learning technique used to predict discrete labels or categories. Therefore, in its quest to clean up the Earth, Wall-E must sort a wide variety of waste materials. By using data on the shape, size, composition, and hazardousness of the waste, it can create a classification model to automatically categorize them into different classes (plastics, metals, organic materials, toxic waste, etc.). This would help optimize the recycling process and contribute to environmental preservation. Here are some examples of applications:

Classification of Celestial Objects: As Wall-E moves through the universe, it encounters a multitude of celestial objects, from asteroids to comets to planets. It can create a classification model to automatically identify different celestial objects based on their characteristics and trajectories.

Classification of Human Emotions: When Wall-E interacts with humans, it can gather data on facial expressions, gestures, and vocal tones to develop a classification model to recognize human emotions such as joy, sadness, fear, or anger. This would enable Wall-E to better understand and adapt its interactions with humans, making its relationships even more authentic.

Classification of Extraterrestrial Signals: While scanning the stars, Wall-E may detect signals from other extraterrestrial civilizations. To comprehend these cosmic communications, it can use supervised learning to create a classification model capable of distinguishing different types of signals, such as greeting messages, mathematical patterns, or warnings.

Exploration and Enrichment

As it evolved in this intricate world, the little solitary robot demonstrated unmatched mastery with every challenge that came its way. Its journey started humbly as a mere waste collector, but it evolved to become an expert in value estimation, thereby uncovering the profound foundations of artificial intelligence. This unique trajectory highlights the incredible potential of machine learning and the accompanying techniques.

Supervised learning, the true cornerstone of this intelligence, allowed Wall-E to transcend the limitations of its machine nature and become an agile learner. Guided by pre-labeled examples, it assimilated complex knowledge and made sound decisions. Later, it embraced linear and non-linear models to interpret and predict relationships within data, transforming into a master in gold value estimation and an elite waste sorter.

The upcoming sections delve into two crucial aspects of supervised learning in more detail:

Part II: The Little Gold Miner

We will delve into the regression model that enabled Wall-E to gain an in-depth understanding of gold value estimation. From dataset analysis to model design, employing the cost function and gradient descent algorithm, each step will be methodically dissected. We will explore the nuances of linear and non-linear models, showcasing how Wall-E optimized its performance to become a master in the art of gold estimation.

Part III: The Sorting Specialist

In this part, we will enter the complex realm of waste sorting, a task that is both critical and challenging. We will detail how Wall-E used classification models to learn to distinguish different types of waste. From dataset processing to creating the classification model, addressing the unique challenges posed by diverse materials, we will explore how Wall-E progressed from a mere waste sorter to an expert in recycling.

Just as Wall-E learned to differentiate plastic from metal and estimate gold purity, artificial intelligence finds its place in domains ranging from predicting solar energy production to classifying human emotions. Wall-E’s brilliance thus reflects an evolution in how AI enriches our understanding of the world and enhances our interactions with it.

The path Wall-E has treaded is only a prologue. The algorithms and models it embraced have set a precedent for artificial intelligence, broadening the horizons of what machines can achieve. And as scientists and engineers continue to build upon these foundations, Wall-E’s story serves as an inspiring reminder: even amidst rubble, waste can become a precious source of knowledge and innovative solutions.

Bibliography

G. James, D. Witten, T. Hastie et R. Tibshirani, An Introduction to Statistical Learning, Springer Verlag, coll. « Springer Texts in Statistics », 2013

D. MacKay, Information Theory, Inference, and Learning Algorithms, Cambridge University Press, 2003

T. Mitchell, Machine Learning, 1997

F. Galton, Kinship and Correlation (reprinted 1989), Statistical Science, Institute of Mathematical Statistics, vol. 4, no 2,‎ 1989, p. 80–86

C. Bishop, Pattern Recognition And Machine Learning, Springer, 2006

Estimation of Gold Price: Non-Optimal


import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Random data generation
np.random.seed(42)  # To reproduce the same results on each run
n_samples = 50  # Number of samples
purity = np.random.rand(n_samples)  # Random purity values between 0 and 1
gold_price = 1000 + 500 * purity + np.random.normal(0, 50, n_samples)  # Gold price based on purity

# Creating the data array
data = np.column_stack((purity, gold_price))

# Creating a Pandas DataFrame for the table
df = pd.DataFrame(data, columns=['Purity', 'Gold Price'])

# Calculate a non-optimal linear regression line
x = data[:, 0]
non_optimal_line = 600 * x + 1000

# Creating the plot
plt.figure(figsize=(10, 6))
plt.scatter(data[:, 0], data[:, 1], label='Data')

# Adding the non-optimal linear regression line in red
plt.plot(x, non_optimal_line, color='red', label='Non-Optimal Linear Regression Line')


plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Relationship between Gold Purity and Price')
plt.grid(True)
plt.show()

Estimation of Gold Price: Non-Optimal with Errors


import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Random data generation
np.random.seed(42)  # To reproduce the same results on each run
n_samples = 50  # Number of samples
purity = np.random.rand(n_samples)  # Random purity values between 0 and 1
gold_price = 1000 + 500 * purity + np.random.normal(0, 50, n_samples)  # Gold price based on purity

# Creating the data array
data = np.column_stack((purity, gold_price))

# Creating a Pandas DataFrame for the table
df = pd.DataFrame(data, columns=['Purity', 'Gold Price'])

# Calculate a non-optimal linear regression line
x = data[:, 0]
non_optimal_line = 600 * x + 1000

# Creating the plot
plt.figure(figsize=(10, 6))
plt.scatter(data[:, 0], data[:, 1], label='Data')

# Adding the non-optimal linear regression line in red
plt.plot(x, non_optimal_line, color='red', label='Non-Optimal Linear Regression Line')

# Adding lines indicating errors for each point relative to the non-optimal line
for i in range(n_samples):
    plt.plot([x[i], x[i]], [data[i, 1], non_optimal_line[i]], color='green', linestyle='--', linewidth=1)

# Adding a single entry in the legend for the error lines
plt.legend(['Data', 'Non-Optimal Linear Regression Line', 'Error'])

plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Relationship between Gold Purity and Price')
plt.grid(True)
plt.show()

Plastic-Metal Classification


import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Define the sigmoid function
def sigmoid(x, a, b):
    return 1 / (1 + np.exp(-(a * x + b)))

# Define the gradient descent function for sigmoid
def gradient_descent_sigmoid(X, y, P, learning_rate, n_iterations):
    m = len(y)
    cost_history = np.zeros(n_iterations)
    for i in range(n_iterations):
        P = P - learning_rate * (1/m) * X.T.dot(sigmoid(X.dot(P), 1, 0) - y)
        cost_history[i] = cost_function_sigmoid(X, y, P)
    return P, cost_history

# Define the cost function for sigmoid
def cost_function_sigmoid(X, y, P):
    m = len(y)
    return -1 / m * np.sum(y * np.log(sigmoid(X.dot(P), 1, 0)) + (1 - y) * np.log(1 - sigmoid(X.dot(P), 1, 0)))

# Random data generation for classification
np.random.seed(42)
n_samples = 50
density = np.random.uniform(0.8, 2.0, n_samples)
threshold = 1.4
material = np.where(density > threshold, 1, 0)

# Creating the design matrix X for classification
X_class = np.column_stack((np.ones(n_samples), density))

# Creating the target vector y for classification
y_class = material.reshape(material.shape[0], 1)

# Initialize P for sigmoid classification
P_class = np.random.randn(2, 1)

# Setting the learning rate and number of iterations for sigmoid classification
learning_rate_class = 0.5
n_iterations_class = 1000000

# Performing gradient descent for sigmoid classification
P_final_class, cost_history_class = gradient_descent_sigmoid(X_class, y_class, P_class, learning_rate_class, n_iterations_class)

# Calculate the sigmoid classification curve
x_range_class = np.linspace(0.8, 2.0, 100)
y_pred_sigmoid_class = sigmoid(x_range_class, P_final_class[1], P_final_class[0])

# Creating the plot for sigmoid classification
plt.figure(figsize=(10, 6))
plt.scatter(density, material, label='Data')
plt.plot(x_range_class, y_pred_sigmoid_class, color='red', label='Fitted Sigmoid Classification')
plt.xlabel('Density')
plt.ylabel('Material (Metal: 1, Plastic: 0)')
plt.title('Classification Using Fitted Sigmoid Curve')
plt.legend()
plt.grid(True)
plt.show()

# Display the fitted parameters and cost history for sigmoid classification
print("Fitted Sigmoid Classification Parameters (a, b):", P_final_class)
plt.plot(range(n_iterations_class), cost_history_class)
plt.xlabel('Number of Iterations')
plt.ylabel('Cost')
plt.title('Cost History during Gradient Descent (Sigmoid Classification)')
plt.show()

Estimation of Gold Price


import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Random data generation
np.random.seed(42)
n_samples = 50
purity = np.random.rand(n_samples)
gold_price = 1000 + 500 * purity + np.random.normal(0, 50, n_samples)  # Linear model

# Creating the data array
data = np.column_stack((purity, gold_price))

# Creating a Pandas DataFrame for the table
df = pd.DataFrame(data, columns=['Purity', 'Gold Price'])

# Define the linear function
def linear(x, a, b):
    return a * x + b

# Define the gradient descent function
def gradient_descent(X, y, P, learning_rate, n_iterations):
    m = len(y)
    cost_history = np.zeros(n_iterations)
    for i in range(n_iterations):
        P = P - learning_rate * (1/m) * X.T.dot(X.dot(P) - y)
        cost_history[i] = cost_function(X, y, P)
    return P, cost_history

# Define the cost function
def cost_function(X, y, P):
    m = len(y)
    return 1 / (2 * m) * np.sum((X.dot(P) - y) ** 2)

# Creating the design matrix X
X = np.column_stack((np.ones(n_samples), purity))

# Creating the target vector y
y = gold_price.reshape(gold_price.shape[0], 1)

# Initialize P
P = np.random.randn(2, 1)

# Setting the learning rate and number of iterations
learning_rate = 0.1
n_iterations = 1000

# Performing gradient descent
P_final, cost_history = gradient_descent(X, y, P, learning_rate, n_iterations)

# Calculate the linear regression line
x_range = np.linspace(0, 1, 100)
y_pred = linear(x_range, P_final[1], P_final[0])

# Creating the plot
plt.figure(figsize=(10, 6))
plt.scatter(purity, gold_price, label='Data')
plt.plot(x_range, y_pred, color='red', label='Optimal Linear Regression')
plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Linear Relationship between Gold Purity and Price with Linear Regression')
plt.legend()
plt.grid(True)
plt.show()

The article Wall-E: The Foundations of its Intelligence first appeared on The Event Horizons.

Stormtroopers Are Bad at Shooting? Yes.

admin — Sun, 23 Jul 2023 17:33:03 +0000

Stormtroopers Are Bad at Shooting?
Yes.

By Jordan Moles on July 23, 2023

The Monte Carlo Method

The Monte Carlo method is an efficient mathematical strategy that is applied to approximate results that are otherwise intractable to calculate with precision. It relies on the use of pseudo-random numbers to simulate random events and derive probabilistic outcomes. A simple illustration to grasp this method would be to envision an army of stormtroopers randomly firing upon a target. By virtue of the Monte Carlo method, we can estimate the stormtroopers’ precision rate by simulating their random shooting and counting the number of shots that strike the target. But especially they can estimate areas.

Tis method is grounded on the law of large numbers, which asserts that if a large number of independent random experiments are conducted, the frequency of the outcomes will converge towards the theoretical probability. For example, if you toss a balanced coin a very large number of times, it will appear tail or head half the time. To employ this method, one must first define a simulation space of random events, generate pseudo-random numbers to mimic these events, and tally the number of occurrences that transpire within a specific region of interest. This information is then used to estimate the probability of a particular event.

For instance, to estimate the precision rate of the stormtroopers, we could define a simulation space that represents the target, let them shoot, and count the number of shots that strike the target. By using the ratio of the number of shots that strike the target to the total number of shots, we can estimate the precision rate of the stormtroopers. To do so,

1. Put one stormtrooper in the closed and huge shooting range.
2. Let’s draw a circle of radius 25 meters in the center of the squared back wall of 50 meters.
3. Now, it’s time to order to the stormtrooper to fire.

“Stormtrooper, attention, target in the back wall in sight, fire one thousand shot.”

Figure 1: A stormtrooper trying to shot the target and the result obtained with one thousand shots.

According to the target, we have the proof that he is not really good at shooting. In fact, he shoots uniformly in the back wall, i.e., in mathematical terms, it means that the probability of striking a defined zone in the back wall is the same as striking another one with the same area. This probability is called continuous uniform distribution. These non-skills will be used to estimate the value of mathematical constants (such as π) and a lot more things.

Estimation of π and the Millennium Falcon’s Area

Before continuing, let’s recall that the area of a square of side R is $S_{square}=R²$ and the area of a circle of radius R is $S_{circle}=π R²$. We will start with the simplest estimation: that of π. This works by using the same steps as outlined previously

1. Put the army of one million and identical stormtroopers in the closed and huge shooting range.
2. Draw a circle of radius 25 meters within the squared back wall of 50 meters.
3. Recall the order.

“Stormtroopers, attention, target in the back wall in sight, fire one shot.”

1. Count the number of impacts (or points) that fall inside the circle.
2. Use the proportion of impacts inside the circle to the total number of impacts generated to estimate π. Specifically, you can use the following formula:

\begin{equation*}
\pi=\frac{S_{circle}}{S_{square}}=\frac{\text{Number of impacts in the circle}}{\text{Total number of impacts}}.
\end{equation*}

Repeat steps several times or increase your army to get a more precise estimate of π.

Figure 2: The army has arrived and launch first 10 thousands shots.

Figure 3: From left to right, 100 thousands and 1 million shots.

Similarly, one can use this method to estimate the area of the Millennium Falcon, a famous spaceship from the Star Wars series that measures 35 meters in length and 25 meters in width.

Figure 4: Here is the real spaceship photo and plan.

The methodology will almost be the same. We use a computer simulation where stormtroopers randomly shoot at the surface of the spaceship. Each point where a “stormtrooper” hits the surface is recorded and the total area is then calculated by counting the total number of points and comparing it to the total size of the spaceship’s surface. This method is very effective because it takes into account the irregular shapes of the spaceship’s surface, which could make it difficult for a more traditional area estimation. But, unfortunately, this will lead to the total destruction of the spaceship!

1. Put the army of stormtroopers in a closed and huge shooting range.
2. Draw a 35m x 25m rectangle to represent the surface of the back wall and stick the millennium falcon on it.
3. Order the stormtroopers to fire.
4. Count the number of shots that strike the surface of the Millennium Falcon.
5. Use the proportion of shots that strike the surface of the Millennium Falcon to the total number of shots to estimate the area of the Millennium Falcon. Specifically, you can use the following formula:
\begin{equation*}
\text{Area of Millennium Falcon}=35\times 25\frac{\text{Number of shots that strike the Millennium Falcon}}{\text{Total number of shots}}.
\end{equation*}
6. Repeat steps several times or increase the number of stormtroopers to get a more precise estimate of the area of the Millennium Falcon.

Figure 5: From left to right, with 10 thousands, 100 thousands and 1 million shots.

The accuracy of the Monte Carlo method for estimating areas depends on the number of randomly generated shots. The more impacts you generate, the more accurate your estimate will be. However, it is important to note that even if you generate a large number of impacts, you will never be able to calculate the exact value of the area you consider. For example, with 1 million stormtroopers, you can get an estimate of π with an accuracy of about 2 decimal places. For the millenium falcon area, we get approximately 400.855m².

The importance of lack of precision

The Monte Carlo method relies heavily on the generation of random numbers to simulate random events. This is where the lack of precision of the stormtroopers comes in. In the previous example, the stormtroopers’ lack of precision in shooting represents the randomness required for the Monte Carlo method to work effectively (here, they shoot perfectly bad). Without this randomness, the method would not be able to accurately approximate results.

Let me explain this concept by introducing Han Solo, a highly skilled marksman, into the simulation. The distribution of shots fired would no longer be uniformly random, but rather, it would be weighted towards the areas where Han Solo aims. More precisely, if we estimate its precision rate as we did with the stormtroopers, we observe that he shoots almost perfectly well.

Figure 6: Han solo firing one million shots.

Maybe because Chewbacca is bothering him or because he has dust in his eye, and this is why its precision rate is not 100 percent (he says). Now, how good is he at estimating π? By using the same formula
\begin{equation*}
\pi=\frac{\text{Number of impact in the circle}}{\text{Total number of impact}},
\end{equation*}
it seems that π is more or less equal to 4 with 1 million of shots.

This highlights an important consideration when using the Monte Carlo method – the accuracy of the results depends heavily on the random nature of the simulation. Introducing biases or non-uniform distributions can greatly impact the effectiveness of the method. Roughly speaking, it means that to be accurate, the random numbers generated must be truly random and not follow a predictable pattern or being precise.

Generation of random numbers

Generating random numbers is a fundamental task in many fields, ranging from computer science to cryptography and simulations. While we often think of randomness as something that occurs naturally, such as the roll of a die or the flip of a coin, many random numbers used in computing are actually generated through sophisticated algorithms or physical phenomena.

One widely used method is the pseudo-random number generator, which produces a sequence of numbers that appears random, but is actually calculated deterministically from an initial “seed” value. Although not truly random, pseudo-random generators are highly efficient and unpredictable enough to meet most practical needs. However, they are subject to periodicities and correlations in the sequences produced, which can pose security risks in certain applications. By using the Star Wars analogy, it consists in taking a perfect imperial sniper which follows a shooting pattern; you only have to order the first target to hit and each shoot will be a defined function of the previous one.

Figure 7: An imperial sniper with a part of his shooting pattern.

Now, imagine that you are a rebel spy and you want to send a secret message to your base. For this, you need a random number that will serve as an encryption key. You could use a pseudorandom number generator to create one, but there is always a risk that the Empire has been able to predict the sequence of numbers you are going to use. To make sure that your encryption key is truly random, you could use a quantum number generator.

In this example, the pseudorandom number generator would be like an Empire soldier who follows a predefined and easily predictable attack plan as the imperial sniper. On the other hand, the quantum number generator would be like a scientist rebel who exploits the unique properties of light sabers to find unpredictable solutions to each situation. As quantum numbers are generated from unpredictable quantum phenomena such as polarization, phase, or frequency of photons, the Empire cannot predict the sequence of numbers you will use, making your secret message much safer. These generators produce numbers that are truly random and impossible to replicate. While still relatively new and expensive, quantum random number generators hold great promise for applications requiring the highest levels of security and unpredictability.

The Versatility and Power of the Monte Carlo Method

To sum up, the Monte Carlo method is a versatile and powerful mathematical technique that allows for the approximation of complex results that are otherwise difficult to calculate precisely. The use of random or pseudo-random numbers to simulate random events and determine probabilistic outcomes makes it an effective tool for various applications, as demonstrated by the simulations of stormtroopers’ shootings. The method’s applications extend beyond estimating mathematical constants and areas of irregular shapes, to include predicting the outcome of elections, simulating population growth, and estimating the probability of rolling a certain number on a dice game.

The Monte Carlo method is a valuable tool for numerous fields, such as physics, engineering, and finance, making it an essential component of the mathematician and statistician’s toolkit.

Bibliography

M. Kalos, P. Whitlock, Monte Carlo Methods, 2008.

D. P. Kroese, T. Taimre, Z.I. Botev, Handbook of Monte Carlo Methods, 2011.

D. P. Kroese, T. Brereton, T. Taimre, Z.I. Botev, Why the Monte Carlo method is so important today, 2014.

S. Weinzierl, Introduction to Monte Carlo methods, 2000.

Estimation of pi by Stormtroopers


import random
import matplotlib.pyplot as plt

def estimate_pi(n):
    num_points_circle = 0
    num_points_total = 0
    circle_x, circle_y = [], []
    square_x, square_y = [], []

    # Loop for generating random points and estimating π
    for _ in range(n):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        distance = x**2 + y**2
        if distance <= 1:
            num_points_circle += 1
            circle_x.append(x)
            circle_y.append(y)
        else:
            square_x.append(x)
            square_y.append(y)
        num_points_total += 1

    # Plotting the points on a graph
    plt.figure(figsize=(5, 5))
    plt.scatter(circle_x, circle_y, color='blue', s=0.1)
    plt.scatter(square_x, square_y, color='red', s=0.1)
    plt.xlim(-1.1, 1.1)
    plt.ylim(-1.1, 1.1)
    plt.title("Estimation of π using the Monte Carlo method\nN = {}".format(n))
    plt.show()

    # Calculating and returning the estimated value of π
    return 4 * num_points_circle / num_points_total

print(estimate_pi(10000))

Estimation of the Millenium Falcon



import cv2
import numpy as np
import random

# Load the image and convert it to grayscale
img = cv2.imread("/Users/.../falcon2.png", cv2.IMREAD_GRAYSCALE)

# Apply thresholding to get a binary image
ret, thresh = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

# Invert the colors so that black becomes white and vice versa
thresh = cv2.bitwise_not(thresh)

# Find contours in the image
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Create a black image to draw the contours
contour_img = np.zeros((img.shape[0], img.shape[1], 3), np.uint8)

# Draw the contours in white on the black image
cv2.drawContours(contour_img, contours, -1, (255, 255, 255), 2)

# Get the size of the image in pixels
height, width = img.shape[:2]

# Retrieve the size of the image in pixels
size = img.shape[:2]

# Define the real dimensions of the Millennium Falcon
real_length = 35  # in meters
real_width = 25   # in meters

# Define the resolution of the image in pixels/meter
resolution = 144

# Calculate the total number of pixels of the ship's surface
total_surface_pixels = int(real_length * real_width * resolution**2)

# Number of random points to generate for the estimation
n = 1000000

# Number of points inside the black figure
num_points_inside = 0

# Generate random points in the image and count the number of points inside the black figure
for i in range(n):
    # Generate a random point in the image
    x = random.randint(0, width-1)
    y = random.randint(0, height-1)

    # Check if the point is inside the black figure
    if cv2.pointPolygonTest(contours[0], (x, y), False) == 1:
        num_points_inside += 1
        # Draw the point in blue
        cv2.circle(contour_img, (x, y), 1, (255, 0, 0), -1)
    else:
        # Draw the point in red
        cv2.circle(contour_img, (x, y), 1, (0, 0, 255), -1)

# Estimation of the area of the black figure using the Monte Carlo method
estimated_area = (num_points_inside / n) * (width * height)

# Display the image with points in blue and red
cv2.imshow('Image with points', contour_img)

# Wait for the user to press a key to close the window
cv2.waitKey(0)
cv2.destroyAllWindows()

# Display the estimated area of the black figure
print("Estimated area of the black figure:", estimated_area)

Estimation of pi by Han Solo




import random
import math
import matplotlib.pyplot as plt

num_shots = 1000000
circle_hits = 0
square_hits = 0
circle_x = []
circle_y = []
square_x = []
square_y = []

for i in range(num_shots):
    x = random.gauss(0, 0.05) # shots centered at the circle's center
    y = random.gauss(0, 0.05)
    distance = math.sqrt(x**2 + y**2)
    if distance <= 1:
        circle_hits += 1
        circle_x.append(x)
        circle_y.append(y)
    else:
        square_x.append(x)
        square_y.append(y)
    square_hits += 1
    if random.random() < 0.1: # 10% chance of shooting in the circle
        if distance <= 1:
            circle_hits -= 1
            circle_x.pop()
            circle_y.pop()
        else:
            circle_hits += 1
            circle_x.append(x)
            circle_y.append(y)
        square_hits -= 1

pi_estimation = 4 * circle_hits / square_hits
print("Estimation of pi:", pi_estimation)

fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim([-1.2, 1.2])
ax.set_ylim([-1.2, 1.2])
ax.set_aspect('equal')
ax.scatter(square_x, square_y, color='red', s=1, label='Outside the circle')
ax.scatter(circle_x, circle_y, color='blue', s=1, label='Inside the circle')
circle = plt.Circle((0, 0), 1, color='black', fill=False)
ax.add_artist(circle)
ax.legend()
plt.show()

To find the Millenium Falcon area, we used the following image.

The article Stormtroopers Are Bad at Shooting? Yes. first appeared on The Event Horizons.

Toss a Coin to Your Witcher

admin — Sun, 23 Jul 2023 16:32:06 +0000

Toss a Coin to Your Witcher

By Jordan Moles on July 25, 2023

Credit: Netflix

In the heart of the mysterious lands of The Witcher universe, where swords clash and spells unleash, a valuable lesson emerges from the depths of probability and destiny. Inspired by a chance encounter in the mists of a casino bar, this lesson invites us to delve into the intricacies of the law of large numbers, while the player’s ruin looms like a threatening shadow. Prepare to be transported into an enchanting narrative, where dice are cast, and games of chance play their captivating symphony.

The Stranger and the Challenge of Destiny

On a tumultuous evening, a solitary witcher named Geralt of Rivia roams the dark streets of a city in search of respite. The echoes of laughter and enchanting melodies guide him to a mysterious bar, the Casino of Destiny. Driven by an irresistible curiosity, he crosses the ornate doors and enters a world where fate is sealed by a simple roll of the dice. Among the lively crowd in the bar, the witcher is drawn to an enigmatic stranger. With a mischievous twinkle in his eye, the stranger takes out a sparkling coin from his satchel. His sly smile betrays a clear intention: he wants to challenge the witcher to a little table game. Intrigued, Geralt accepts the invitation, preparing to face destiny itself.

Credit: Netflix

The stranger, with an enigmatic voice, lays out the rules of the game. Both of them will wager their respective fortunes in the game, assuming Geralt and the stranger both start with 1000 gold coins. In each round, destiny oscillates between the players, thus determining their fortune on a coin toss. Each victory grants a gain of 1, while each defeat comes with an equivalent loss. This bewitching dance continues until one of the players is irreversibly ruined, condemned to face the consequences of their choices.

Let us now translate this situation into probabilistic terms, where “destiny” is represented by a probability p, a value between 0 and 1. A sequence of independent and identically distributed random variables, symbolized by $X_i$ where i is the i-th round, plays a crucial role in the course of the game. Each variable $X_i$ takes the value 1 with a probability p, indicating a victory, and the value -1 with a probability 1-p, indicating a defeat. Mathematically, this is denoted as follows:

\begin{align*}
\mathbb{P}(X_i=1)=p,\quad \mathbb{P}(X_i=-1)=1-p.
\end{align*}
We also note the Witcher’s fortune in round n, which is equal to the sum of his initial fortune and the results of his gains and losses in each round:
\begin{align*}
F_n = 1000 + \sum_{i=1}^n X_i.
\end{align*}
Simultaneously, the fortune of his opponent, intimately linked to his own, evolves through similar mechanisms, but with a fortune in each round of 2000-$F_n$.

Probabilities Veiled: Geralt’s Quest Against Rigged Gambling

The rules of this game are deceitful, and Geralt senses that something is amiss. He suspects the old man of trying to cheat him. Immersed in an enigmatic situation, Geralt finds himself facing a captivating coin game. The possible outcomes are simple: Heads or Tails, with an equal probability of 50/50 if the coin is fair. However, he also knows that the coin could be biased, which worries him, with probabilities taking different values, such as 0, $1/\pi$, or 1/100. The mystery deepens as the true probability remains unknown.

To unravel this mystery, Geralt mobilizes all his skills and available resources, even if it means losing money. He focuses on the first six coin tosses, which resulted in Heads, Tails, Heads, Tails, Tails, Tails (HTHTTT). At first glance, these results seem to indicate an imbalance. However, Geralt undertakes a thorough analysis of the probabilities associated with each possible configuration. He recalls that an old friend, Jacques Bernoulli, had presented him with a similar challenge. It was theoretically a random experiment with two possible outcomes, success or failure, each with a certain probability—exactly what he is facing now.

Jacques had told him that if the coin were fair, the probability of getting Heads first is 1/2, just like getting Tails first. By examining the different possible combinations (HT, HH, TT, TH), he realizes that the probability of getting Heads followed by Tails is 1/4, just like for the other combinations. This is because there are four equiprobable possibilities with a fair coin. Geralt remembers the reasoning well and becomes aware of the importance of details in this quest. He also realizes that, for three tosses, there are eight possible configurations. Among these, there is one chance in eight of getting Heads, Tails, Heads (HTH). Geralt quickly understand the extent of the calculations involved in this analysis. The more tosses there are, the lower the probability of obtaining a specific configuration becomes. For example, the probability of getting the configuration Heads, Tails, Heads, Tails, Tails, Tails (HTHTTT) is $1/2^6$, a relatively low probability.

However, Geralt’s goal is not limited to determining specific configurations. His true interest lies in the proportion of Heads and Tails present in each configuration. In these terms, the sorcerer understands that he is facing a succession of n independent unbiased Bernoulli trials, where the random variable $S_n$, which counts the number of successes, follows a binomial distribution. The probability of having k “Heads” in the sum is given by:

\begin{equation*}
\mathbb{P}(S_n=k)=\binom{n}{k}\frac{1}{2^n}.
\end{equation*}

We recall the following equality

$$\binom{n}{k}=\frac{n\times(n-1)\times\cdots\times 2\times 1}{(k\times(k-1)\times\cdots\times 2\times 1)(n-k)\times(n-k-1)\times \cdots\times 2\times 1}.$$

He anticipates that if the coin is tossed a very large number of times, the frequency of Heads or Tails will be revealed with great precision. His intuition proves correct, and mathematicians call this the “law of large numbers.”

In summary, the law of large numbers states that a fair coin, tossed an infinite number of times, will yield Heads and Tails with an equivalent frequency. Similarly, if the coin is biased, the Witcher will observe a proportion of Heads or Tails different from 50/50.

Simulation of coin tosses. The figures illustrate how the average of Heads tends to approach the theoretical expectation as the number of coin tosses increases (10, 100, 1000, 10000, and 100000), even with a biased coin. Thus, we can clearly observe that starting from 10000 tosses, the blue curve almost coincides with the theoretical average.

Geralt is aware of this mathematical truth, but he also knows that infinity is far too distant to reach, especially in the context of the game proposed by the stranger, where he could end up ruined very quickly.

The Power of Concentration: The Witcher Unravels the Mystery of the Biased Coin

In the game proposed by the stranger, Geralt doesn’t have the luxury of tossing the coin an infinite number of times to verify the frequency of the results. He realizes that he must harness his powers of concentration to the maximum to unravel the mystery of the biased coin. In search of an additional advantage, he decides to drink a potion of concentration, which stimulates his mind and clarity of vision.

Credit: Netflix

Guided by the effect of the potion, Geralt immerses himself in a thorough analysis of the coin tosses. He employs binary notation, where Heads is represented by 1 and Tails by 0. Therefore, $S_n$ represents the number of Heads in a sequence. In the case where Geralt believes the coin is fair, the probability of getting Heads (or +1) on the i-th toss is 1/2, similarly for Tails (or 0), and this can be expressed as: \begin{equation*} \mathbb{P}(X_i=+1)=\mathbb{P}(X_i=0)=\frac{1}{2}. \end{equation*} So, $\mathbb{E}(S_n) = \frac{n}{2}$ because if there are as many +1 as there are 0 in the outcomes, the theoretical average must be $\frac{n}{2}$. He realizes that to obtain a reliable estimation of the proportion of Heads and Tails with a limited number of tosses, he must resort to developed statistical tools such as the Gaussian concentration inequality. This inequality, also known as Hoeffding’s inequality, is a fundamental result in probability and statistics that works well in this specific case. It provides an estimation of the probability that a random variable, in this case, the outcomes of coin tosses, significantly deviates from its mean. It gives bounds on the probability of observing rare or extreme events. In mathematical terms, for all deviations u, it is written as: \begin{equation}\label{Gauss} \mathbb{P}\left(\left|S_n-\mathbb{E}(S_n)\right|\geq u\right)\leq 2e^{-\frac{2u^2}{n}} \end{equation} where $S_n = X_1 + \cdots + X_n$ is the result of n coin tosses, and $\mathbb{E}(S_n)$ is its expectation (essentially its theoretical average). The use of the term “Gaussian concentration” in the context of this inequality refers to the ability of random variables to cluster around their mean, following a distribution close to the normal or Gaussian distribution, represented as a bell-shaped curve. It indicates that the probability of observations far from the mean decreases rapidly (very, very rapidly) as the standard deviation increases.

Credit: Netflix

Histogram representing the frequency of Heads appearing in 1000 coin tosses, along with its bell-shaped theoretical curve.

To experimentally measure this frequency of occurrence, Geralt knows that he must count the number of Heads (+1) in the n coin tosses, divide it by the total number of tosses, and estimate the probability of deviation by a certain percentage u from the value of $\frac{1}{2}$. This can be written using the previous formula, for all deviations u:

\begin{equation}\label{Gauss2}
\mathbb{P}\left(\left|\frac{S_n}{n}-\frac{1}{2}\right| > u\right) \leq 2e^{-2nu^2}.
\end{equation}
If his estimation exceeds the value on the right-hand side, then he is facing a biased coin. Thus, Geralt has a simple way to detect any potential bias in the coin.

Suddenly, time seems to freeze. The Witcher enters a deep trance that allows him to mentally toss the coin and perform all the necessary calculations using the previous formula.

Credit: Netflix

His first calculation involves estimating the probability that, in 10 tosses of a fair coin, the percentage of Heads is either higher or lower by $20\%$ compared to the number of Tails. He finds: \begin{equation*} \mathbb{P}\left(\left|\frac{S_{10}}{10}-\frac{1}{2}\right|>0.2\right)\leq 2e^{- 20\times 0.04}\approx 0.89. \end{equation*} On the following figure, this means that the sum of the area under the red curve between 7 and 10, and between 0 and 3, is less than 0.89.

Histogram representing the frequency of Heads appearing in 10 coin tosses, along with its theoretical bell-shaped curve.

However, this result does not seem very informative in itself because the upper bound of probability, 0.89, is very close to 1. Geralt wonders what could be happening. Perhaps he simply did not toss enough coins? To explore this possibility, he decides to continue his thought experiment and toss the coin not only 10 times but also 20, 30, 40, 100, 500, 1000, and even 10,000 times (See some examples below).

Histogram representing the frequency of Heads appearing in 100 and 500 coin tosses, along with their theoretical bell-shaped curves.

The approximate results of these calculations are presented in the following table and heatmap:

The table presents the results obtained by Geralt during his calculations for different numbers of coin tosses. The values in the cells correspond to the estimated probabilities that the frequency of Heads differs from $\frac{1}{2}$ by a certain percentage (the deviation) based on the number of tosses.

This graph represents the evolution of Gaussian concentration as a function of the deviation and the number of coin tosses.

By observing the data in the table and the evolution of the curves in the graph, we can draw the following conclusions:

• As the number of coin tosses increases, the probabilities of deviation decrease. This means that the more Geralt tosses coins, the more accurately he can estimate whether the coin is biased or not.

• For a small number of tosses (10 or 20), the probabilities of deviation remain relatively high. For example, for 10 tosses, the probability of a $20\%$ deviation is 0.89, indicating a considerable possibility of bias. However, for 20 tosses, this probability decreases to 0.40, suggesting a reduction in uncertainty.

• As the number of tosses increases further (30, 40, 100, 500, 1000), the probabilities of deviation decrease drastically. For example, for 1000 tosses, the probability of a $20\%$ deviation is extremely low, on the order of $3.6 \times 10^{-35}$, indicating a high level of confidence that the coin is fair.

In summary, the table demonstrates that the more coin tosses Geralt performs, the more he can refine his estimation of the frequency of Heads and determine with greater certainty whether the coin is biased or not. The probabilities of deviation decrease rapidly as the number of tosses increases, which enhances the reliability of Geralt’s method to detect biased coins.

Thanks to his potion of concentration and his knowledge of probabilistic principles, the Witcher, Geralt, adjusts his game strategy and fully engages in the game proposed by the stranger. He tosses the provided coin 500 times and obtains a sequence of results where the number of Heads observed is 286, approximately $7\%$ more than the expected number. Here is the sequence:

\begin{align*}
&0 0 1 0 1 0 0 0 0 1 1 1 1 1 0 1 0 1 0 0 0 1 0 11 0 1 0 1 0 0 1 0 1 1 1 1111111100011 1 1 0 0 1 1 1 1 1 1 0 1 1 0 1 0 0 1 0 1 \\
&1111 1 1 0 0 1 0 1 1 0 0 1 1 0 0 0 1 0 0 1 0 1 1 10 0 1 0 1 0 1 0 1 0 1 1 0 1 1 1 1 0 1 1 1 1 1 10 0 1 0 10 0 0 1 1 1 0 01 1 0 0 1\\
&1 1 0 0 1 0 1 1 1 1 1 0 0 1 0 1 0 1 0 1 1 1 1 11 1 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 1 1 0 0 1 1 0 0 0 1 0 1 1 1 1 10 0 0 0 11 1 1 0 0 1 0 \\
& 0 1 1 1 0 1 1 0 10 1 1 0 0 0 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 1 1 10 0 1 1 1 0 1 1 111 1 1 1 1 0 1 0 0 1 0 1 0 10 1 0 1 0 1 1 0 1 1 10 \\
& 1 1 0 0 0 1 1 1 0 1 0 00 1 1 1 1 0 1 0 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 11 0 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 1 0 1 0 0 0 01 0 1 10 1 0 0 1 \\
& 0 1 0 1 1 0 1 1 1 1 0 1 1 1 0 0 1 1 1111111 1 0 1 0 0 0 1 1 1 0 1 0 1 1 1 1 0 0 1 0 0 1 1 1 1 0 1 0 1 0 1 0 1 0 0 1 0 01 0 1 0 1 1 \\
&1 0 1 1 1 0 1 1 1 1 1 0 1 1 1 1 0 1 0 1 1 1111 0 1 1 0 0 1 1 1 0 0 1 1 1 0 1 0 1 0 0 1 0 0 0 1 1 0 1 0 1 0 0 0 1 1 0 00 0 1 1 10 1 0 \\
& 0 0 1 0 0 0 0 0 1 1 0 0 0 0 1 1 0
\end{align*}

By applying these calculations, Geralt estimates that the probability of obtaining such a deviation is approximately 0.01 (which is very low). He realizes that he is facing a scam and requests to restart the game using another coin, as the provided one is biased.

He turns to a casino dealer to obtain an official and fair coin, to continue the game in a just and fair manner.

Credit: Netflix

The Power of Concentration: The Plot of the Gambler’s Ruin: The Probability of Losing Everything

The game is now fair, and each player has an equal chance of winning. The Witcher is interested in the probability that the stranger goes broke before him, meaning that the stranger’s final fortune $F_{\text{Stranger}}$ reaches 0 before 2000. Mathematically, this probability is expressed as:

\begin{align*}
\mathbb{P}_{Stranger}(1000)=\mathbb{P}_{1000}\left(F\text{ reaches } 0 \text{ before } 2000\right).
\end{align*}
This can also be rephrased using what is called stopping times. Stopping times are random times that can be determined from the information available on the process up to that point. Their value indicates the moment when a certain condition is satisfied or a certain quantity is reached. The stopping time may depend on past realizations of the process, but it cannot depend on the future. In our case, this could be the time (which we called round in our case) denoted as $T_0$ when the stranger’s fortune reaches 0, or the time $T_{2000}$ when it reaches 2000. In other words, it is the smallest time n at which $F_n$ becomes zero or reaches 2000:

\begin{align*}
T_0=\inf\{n\geq 0,\quad F_n =0\}\quad \text{ and } \quad T_{2000}=\inf\{n\geq 0,\quad F_n =2000\}.
\end{align*}
It is evident that the longer the game is played, the more likely it is to come to an end, meaning that one of the two players goes broke. Thus, we can express the probability that the stranger loses all his gold before the witcher as the probability that the stopping time $T_0$ is smaller than $T_{2000}$:
\begin{align*}
\mathbb{P}_{Stranger}(1000)=\mathbb{P}_{1000}\left(T_0\end{align*}

Also, it is important to note that the stranger’s fortune can take on all possible “states” (meaning his fortune can be any number between 0 and 2000). Let’s denote this value as k. Thus, the probability that, starting with a fortune of value k, he reaches 0 before 2000 is:
\begin{align*}
\mathbb{P}_{Stranger}(k)=\mathbb{P}_{k}\left(T_0\end{align*}

This probability depends only on the value of the fortune in the previous round. Indeed, since only one gold coin is played in each round, each player can either win or lose only one coin and not, for example, 4 coins at once. Without going into specific details and keeping it general, this means that the previous probability is equal to:
\begin{align*}
\mathbb{P}_{Stranger}(k)=p\mathbb{P}_{Stranger}(k+1)+(1-p)\mathbb{P}_{Stranger}(k-1).
\end{align*}
Since the coin is fair, it is more accurately written as:
\begin{align*}
\mathbb{P}_{Stranger}(k)=\frac{1}{2}\mathbb{P}_{Stranger}(k+1)+\frac{1}{2}\mathbb{P}_{Stranger}(k-1).
\end{align*}
Indeed, an attentive eye will easily solve this equation and provide an explicit relationship for the probability of interest. The probability in question can be expressed as follows:
\begin{align*}
\mathbb{P}_{Stranger}(k)=1-\frac{k}{2000}.
\end{align*}
So, if the stranger has a fortune of 1000, the probability that he reaches 0 before the Witcher is:
\begin{align*}
\mathbb{P}_{Stranger}(1000)=1-\frac{1000}{2000}=\frac{1}{2}.
\end{align*}
By a similar method, we can determine the average time it takes to reach 0 before 2000, denoted as $\mathbb{E}_k(T)$, and it writes
\begin{align*}
\mathbb{E}_k(T)=k(2000-k).
\end{align*}
So, if $k=1000$, it would take an average of one million rounds for one of the two players to reach $0$. The man in the hood thus names this intriguing concept: the gambler’s ruin.

Simulation of the gambler's ruin where Geralt wins after approximately 600,000 rounds.

He explains that despite the law of large numbers, where results tend to converge towards the theoretical probability, the player is always confronted with the risk of losing everything he possesses. The gambler’s ruin, like an elusive creature, lurks in the shadows, ready to pounce on those who succumb to the call of chance without discretion. It serves as a reminder of the unpredictable nature of probability and the potential consequences of unchecked risk-taking in games of chance.

Credit: Netflix

The Secret of the Casino: Bias, Deception, and Manipulated Probabilities

In a fierce battle, the witcher emerges victorious over his adversary with unmatched grace. The masked face of the stranger is unveiled, revealing a gaze filled with admiration and surprise. With a trembling voice, he reveals his true identity as the powerful owner of the casino. The witcher is taken aback, realizing that the fortune of this man far surpasses any predictions that could have been made.

Credit: Netflix

In an unexpected gesture of generosity, the casino owner decides to share some of his secrets with Geralt in a secluded room, away from prying ears. He confides that, thanks to his colossal wealth, his probability of losing is minuscule, allowing him to persist and thrive in his ventures. He specifies that by denoting the two initial fortunes as $F_{Geralt}$ and $F_{Casino}$, he obtains the following equation: \begin{align*} \mathbb{P}_{Casino}(k)=1-\frac{k}{F_{Geralt}+F_{Casino}}\quad\text{and}\quad \mathbb{E}_k(T)=k(F_{Geralt}+F_{Casino}-k). \end{align*} Just by having 100 times more initial money than Geralt, the casino loses its fortune with a low probability that equals: \begin{align*} \mathbb{P}_{Casino}(100\times F_{Geralt})=1-\frac{100\times F_{Geralt}}{F_{Geralt}+100\times F_{Geralt}}=1-\frac{100}{101}=0.0099. \end{align*}

Credit: Netflix

Simulation of the player's ruin when the casino has 100 times more money than Geralt.

But the most precious secret is revealed in a barely audible whisper. The stranger admits to having played with carefully biased coins in his favor. A sly smile appears on his face as he unveils this troubling truth. This subtle deception has allowed him to dramatically increase his gains and maintain his hold over the gambling souls who frequent his establishment. He reminds Geralt that, depending on the bias of the coin, his probability of losing with an initial fortune of k is: \begin{align*} \mathbb{P}_{Casino}(k)=\frac{\left(\frac{1-p}{p}\right)^{F_{Casino}+F_{Geralt}}-\left(\frac{1-p}{p}\right)^{k}}{\left(\frac{1-p}{p}\right)^{F_{Casino}+F_{Geralt}}-1} \end{align*} Indeed, if 1, this probability becomes extremely low. Additionally, upon examining the sketch provided by the master of the casino, Geralt quickly realizes that he would still be at a disadvantage even with a slightly biased coin.

Credit: Netflix

Simulation of the player's ruin with a biased coin ($p=0.49$).

An aura of intrigue hangs in the air as Geralt absorbs this unexpected information. He realizes that he has just unmasked a far more cunning adversary than he could have imagined. But armed with his wisdom and experience, the Witcher is already preparing to face the new challenges that lie ahead. A new quest begins, where the fate of rigged coins and unsuspecting players will intertwine with that of the Witcher, in a complex dance where the stakes are higher than ever before.

The Manipulation of Coin Tosses

The power of the concentration potion fades, and Geralt snaps out of his trance. It is at this moment that the words of the renowned magician Persi Diaconis resonate in the Witcher’s mind.

Credit: Netflix

The precision potion he possesses is a unique creation of its kind. Just a sip of this potion elevates his abilities to an extraordinary level, granting him total mastery over the coin toss. Like a machine, Geralt controls every aspect of the toss: the initial conditions, the number of rotations performed in the air, and even which side will be revealed when the coin lands. His precision in manipulating these parameters is astounding, challenging the idea that the game of coin tossing is a simple random process.

This spectacular demonstration of mastery perfectly illustrates the findings of the study conducted by Joe Keller in our reality. Indeed, this study reveals that coin tossing, although it may seem random, is actually governed by mechanical laws. When a coin is tossed with high initial velocity and strong rotation, it has a probability of landing on the same side as where it started, in nearly half of the cases. However, if we take into account precession, which is the change in the coin’s axis of rotation during its flight, the outcome can differ. If the angle between the angular momentum and the normal to the coin is less than 45 degrees, the coin will never flip and will always land on the same side.

Thanks to his precision potion, Geralt sheds light on the possibility of manipulating coin tosses in a controlled manner, creating the illusion of a random game while being aware that the results are actually determined by mechanical factors. At the heart of this manipulation lies a crucial element: the hand that tosses the coin doesn’t always hold it on the same side, alternating between head and tail. It is the unconscious randomization carried out by the person tossing the coin, as they place it on their thumb before giving it a slight initial push, that evens out the probabilities of getting head or tail. Thus, the result of the toss tends towards equality.

Credit: Netflix

Indeed, for those seeking a slight advantage, diligent training in precision tossing can enable them to master this subtle art and influence the coin to land as they desire. However, in their ingenuity, games of chance introduce another random component: another player must call “Heads” or “Tails” at the precise moment the coin flutters in the air, thus escaping all predictions.

In this enchanting romance, we can appreciate the importance of this balance between precision and randomness. Geralt of Rivia, despite his extraordinary mastery of coin tossing thanks to his precision potion, realizes that the true essence of the game lies in this unconscious randomization, which ensures fairness of probabilities. Coin tossing remains a fascinating game where uncertainty and the magic of the moment harmoniously blend, awakening in each person a curiosity tinged with mystery.

Revelations of the Coin Toss: Geralt’s Insight

In the dark twists and turns of games of chance, where the fate of eager players is decided by a simple coin toss, Geralt of Rivia, the legendary Witcher, has unveiled a troubling truth. He highlights the importance of probabilities and statistical tools to understand and analyze random situations. Despite appearances, Geralt realizes that the game of the coin toss is, in fact, a game of probabilities and chances. With his intelligence and concentration potion, he employs concepts such as the law of large numbers and the Gaussian concentration inequality to evaluate the probabilities and risks associated with coin tosses.

Although he cannot toss the coin an infinite number of times, he manages to obtain reliable estimates of the proportion of Heads and Tails using probabilistic and statistical results. Geralt’s quest also underscores the importance of prudence and self-awareness in games of chance. By being aware of probabilities and risks, Geralt makes informed decisions and minimizes the consequences of his choices.

So, whether you are a lone adventurer on the farthest reaches of the real world or a daring gambler in the depths of casinos, always remember that behind the veil of illusion lies the relentless mathematical truth. And, as Geralt has understood, sometimes the greatest victory lies in the wisdom of knowing when to step away from the gambling table, leaving behind fleeting mirages to embrace a more stable reality. One, perhaps, involving a well-deserved bath.

Credit: Netflix

Bibliography

D. Chafaï, F. Malrieu, Recueil de modèles aléatoires, 2015.

T. Bodineaux, Modélisation de phénomènes aléatoires : introduction aux chaînes de Markov et aux martingales, 2015

M. Ledoux, The concentration of measure phenomenon, 2001

I, Stewart, Do dice play god?, 2019

R. Epstein, The Theory of Gambling and Statistical Logic (Revised ed.), 1995

J. L. Coolidge, The Gambler’s Ruin. Annals of Mathematics. 10 (4): 181–192, 1909

Law of Large Numbers Simulation


import numpy as np
import matplotlib.pyplot as plt

def simulate_biased_coin_tosses(n, p, num_trials):
    """
    Simulates multiple trials of biased coin tosses and plots the running average.
    
    Args:
        n (int): Number of coin tosses in each trial.
        p (float): Probability of getting heads (biased coin).
        num_trials (int): Number of trials to simulate.
    """
    results = []
    
    for _ in range(num_trials):
        coin_tosses = np.random.choice([0, 1], size=n, p=[1-p, p])
        running_average = np.cumsum(coin_tosses) / np.arange(1, n + 1)
        results.append(running_average)
    
    # Plot the results
    for i, running_average in enumerate(results):
        plt.plot(np.arange(1, n + 1), running_average, alpha=0.5)
    
    # Plot the theoretical expectation (p for a biased coin)
    plt.plot(np.arange(1, n + 1), np.full(n, p), color='red', linestyle='--', label='Theoretical Expectation')
    
    plt.xlabel('Number of Tosses')
    plt.ylabel('Running Average')
    plt.title('Law of Large Numbers Simulation (Balanced Coin)')
    plt.legend()
    plt.grid()
    plt.show()

# Parameters
n = 100000  # Number of coin tosses in each trial
p = 0.5  # Probability of getting heads (biased coin)
num_trials = 1  # Number of trials to simulate

# Perform the simulation and visualize the results
simulate_biased_coin_tosses(n, p, num_trials)

Binomial Distribution Simulation

import numpy as np
import matplotlib.pyplot as plt

def simulate_binomial_distribution(n, p, num_trials):
    """
    Simulates multiple trials of a binomial distribution and plots the histogram of outcomes.
    
    Args:
        n (int): Number of trials in each binomial experiment.
        p (float): Probability of success in each trial.
        num_trials (int): Number of trials to simulate.
    """
    results = np.random.binomial(n, p, size=num_trials)
    
    # Plot the histogram of outcomes
    plt.hist(results, bins=np.arange(n + 1) - 0.5, density=True, alpha=0.7, edgecolor='black')
    
    # Plot the theoretical probability mass function
    x = np.arange(n + 1)
    y = np.array([np.math.comb(n, k) * p**k * (1 - p)**(n - k) for k in x])
    plt.plot(x, y, color='red', label='Theoretical Probability')
    
    plt.xlabel('Number of Successes')
    plt.ylabel('Probability')
    plt.title(f'Binomial Distribution (n={n}, p={p})')
    plt.legend()
    plt.grid()
    plt.show()

# Parameters
n =10  # Number of trials in each binomial experiment
p = 0.5  # Probability of success in each trial
num_trials = 100000  # Number of trials to simulate

# Perform the simulation and visualize the results
simulate_binomial_distribution(n, p, num_trials)

Gaussian Concentration Heatmap


# Importing libraries
import numpy as np
import pandas as pd
import seaborn as sns
from scipy.stats import norm
import matplotlib.pyplot as plt

# Function to simulate coin toss
def coin_toss(n, deviation):
    coin = np.random.choice([0, 1], size=n)  # Simulating coin toss
    proportion = np.mean(coin)  # Calculating proportion of Heads
    concentration = 2 * np.exp(-2 * n * deviation**2)  # Calculating Gaussian concentration
    return proportion, concentration

# Parameters for simulation
n_values = [10, 20, 30, 40, 50, 75, 100, 500, 1000, 10000]
deviation_values = [0.01, 0.03, 0.05, 0.07, 0.1, 0.15, 0.2, 0.25, 0.3, 0.5]

# Simulation and calculation of Gaussian concentration for each combination of parameters
results = []
for n in n_values:
    row = []
    for deviation in deviation_values:
        proportion, concentration = coin_toss(n, deviation)
        row.append(concentration)
    results.append(row)

# Creating DataFrame from results
df = pd.DataFrame(results, columns=deviation_values, index=n_values)

# Displaying results as a table
print("Number of coin tosses\t", end="")
for deviation in deviation_values:
    print(f"Deviation {deviation}\t", end="")
print()
for i, n in enumerate(n_values):
    row_str = f"{n}\t\t"
    for j, deviation in enumerate(deviation_values):
        row_str += f"{results[i][j]:.3e}\t"
    print(row_str)

# Creating heatmap with Seaborn
plt.figure(figsize=(12, 8))
sns.heatmap(data=df, annot=True, cmap="Reds", fmt=".2e", cbar=True, cbar_kws={'label': 'Gaussian concentration'})
plt.xlabel("Deviation")
plt.ylabel("Number of coin tosses")
plt.title("Gaussian concentration as a function of the deviation and the number of coin tosses")
plt.show()

Gaussian Concentration table


# Importing libraries
import numpy as np
import pandas as pd
import seaborn as sns
from scipy.stats import norm
import matplotlib.pyplot as plt

# Function to simulate coin toss
def coin_toss(n, deviation):
    coin = np.random.choice([0, 1], size=n)  # Simulating coin toss
    proportion = np.mean(coin)  # Calculating proportion of Heads
    concentration = 2 * np.exp(-2 * n * deviation**2)  # Calculating Gaussian concentration
    return proportion, concentration

# Parameters for simulation
n_values = [10, 20, 30, 40, 100, 500, 1000]
deviation_values = [0.01, 0.03, 0.05, 0.1, 0.2]

# Simulation and calculation of Gaussian concentration for each combination of parameters
results = []
for n in n_values:
    row = []
    for deviation in deviation_values:
        proportion, concentration = coin_toss(n, deviation)
        row.append(concentration)
    results.append(row)

# Creating DataFrame from results
df = pd.DataFrame(results, columns=deviation_values, index=n_values)

# Displaying results as a table
print("Number of coin tosses\tDeviation 0.01\tDeviation 0.03\tDeviation 0.05\tDeviation 0.1\tDeviation 0.2")
for i, n in enumerate(n_values):
    row_str = f"{n}\t\t"
    for j, deviation in enumerate(deviation_values):
        row_str += f"{results[i][j]:.3e}\t"
    print(row_str)

# Creating the graph with Seaborn
sns.set(style="whitegrid")
plt.figure(figsize=(10, 6))
sns.lineplot(data=df, markers=True, dashes=False)
plt.xlabel("Number of coin tosses")
plt.ylabel("Gaussian concentration")
plt.title("Gaussian concentration as a function of the number of coin tosses and the deviation")
plt.legend(title="Deviation")
plt.show()

Players Ruin Simulation



import numpy as np
import matplotlib.pyplot as plt

def simulate_ruin(player_a_amount, player_b_amount, win_probability):
    """
    Simulates the ruin of two players in a gambling game and returns the number of rounds played.
    
    Args:
        player_a_amount (int): Initial amount of money for player A.
        player_b_amount (int): Initial amount of money for player B.
        win_probability (float): Probability of winning a bet.
        
    Returns:
        int: Number of rounds played until one of the players goes broke.
    """
    rounds = 0
    
    while player_a_amount > 0 and player_b_amount > 0:
        # Simulate a round of the game
        if np.random.rand() < win_probability:
            player_a_amount += 1  # Player A wins
            player_b_amount -= 1  # Player B loses
        else:
            player_a_amount -= 1  # Player A loses
            player_b_amount += 1  # Player B wins
        
        rounds += 1
    
    return rounds

def simulate_ruin_visual(player_a_amount, player_b_amount, win_probability):
    """
    Simulates the ruin of two players in a gambling game with a biased coin and visualizes the results.
    
    Args:
        player_a_amount (int): Initial amount of money for player A.
        player_b_amount (int): Initial amount of money for player B.
        win_probability (float): Probability of winning a bet.
    """
    player_a_history = [player_a_amount]
    player_b_history = [player_b_amount]
    rounds = 0
    
    while player_a_amount > 0 and player_b_amount > 0:
        # Simulate a round of the game with a biased coin
        if np.random.rand() < win_probability:
            player_a_amount += 1  # Player A wins
            player_b_amount -= 1  # Player B loses
        else:
            player_a_amount -= 1  # Player A loses
            player_b_amount += 1  # Player B wins
        
        rounds += 1
        player_a_history.append(player_a_amount)
        player_b_history.append(player_b_amount)
    
    # Plot the results
    plt.plot(player_a_history, label='Geralt fortune')
    plt.plot(player_b_history, label='Casino fortune')
    plt.xlabel('Rounds')
    plt.ylabel('Amount')
    plt.title('Players Ruin Simulation (Balanced Coin)')
    plt.legend()
    plt.grid()
    plt.show()

# Parameters
player_a_amount = 1000  # Initial amount of money for player A
player_b_amount = 1000  # Initial amount of money for player B
win_probability = 0.5  # Probability of winning a bet (balanced coin)

# Perform the simulation and get the number of rounds played
rounds_played = simulate_ruin(player_a_amount, player_b_amount, win_probability)
print("Number of rounds played:", rounds_played)

# Perform the simulation and visualize the results
simulate_ruin_visual(player_a_amount, player_b_amount, win_probability)

The article Toss a Coin to Your Witcher first appeared on The Event Horizons.

Index	Density	Electrical Conductivity (\(S.m^{-1}\))	Carbon Content	Material
1	4.5	\(2.4 \times 10^{6}\)	0	Metal
2	0.5	\(10^{-16}\)	0.5	Organic
3	19.3	\(41 \times 10^{6}\)	0	Metal
4	1.1	\(10^{-16}\)	0.4	Organic
5	1.2	\(10^{-14}\)	0	Plastic

The Event Horizons

How to Build an Host ? Episode I

How to Build a Host?

Episode I

By Jordan Moles on January 2, 2024

At the Crossroads of Intelligence

At the Beginning: The Biological Neuron

The structure

How does it Works ?

The First Artificial Neuron in History

Its Structure and Functioning

We Collect the Information​

The Artificial Cell Body: a Mathematical Function

Processed Information

A Simple Example

An Example within an Example​

Revenons au Neurone

The advent of the Perceptron

The Hebb's Law

Model Limitations

A few more Perceptrons

Neural Networks

Cognitive Programming of Hosts for Handwritten Digit Recognition: The Multilayer Perceptron

Assimilation des Données d'Entraînement (DataSet)

Building the Cognitive Model

Forward propagation

Cognitive Error Analysis: The Cost Function

Mechanisms of Comprehension

Optimisation Mentale

The Hosts of Westworld: From Numbers to Faces.

Dr. Ford - "Remember, hosts are not real. They are not conscious."

Bibliography

Note: for more information on the code provided, please visit GitHub. Link in the footer!

Waste Allocation Load Lifter: Earth Class

Waste Allocation Load Lifter: Earth Class

Episode III

By Jordan Moles on December 2, 2023

It is strongly recommended to have read episodes I and II before continuing!

Wall-E's New Horizons: The Classification

The Key Element: Always the Data

Meeting the Samples

The Decision Boundaries

Creation of the Binary Classification Model

Prediction Evaluation: The Cost Function

The Return of the Gradient Descent

The Power of the Little Waste Sorter

Beyond Waste Sorting: Determining Metal Types

Contrast with Binary Classification and Complexities of Multiclass Classification

The Power of Proximity: K Nearest Neighbors

Metal Classification Process: Neighbors in Action

The Art of Model Selection

Exploring New Horizons: Training and Testing

Rising to Excellence: Model Validation

The Dance of Models: Cross-Validation

The Learning Waves: Learning Curves

The End of a Trilogy, the Beginning of a Technological Era

Bibliography

Note: All the necessary data tables are available on GitHub.

Wall-E: The Little Gold Miner

Wall-E: The Little Gold Miner

Episode II

By Jordan Moles on November 2, 2023

It is highly recommended to have read Episode I before continuing!

Into the Depths of Knowledge: Regression

The Data Collection

Creation of the Linear Model

Measuring Gold Treasures: The Cost Function

Distances Explained by Hal

A Fatal Error

Calculation of MAE

Calculation of RMSE

A Small Step for the Robot, a Giant Leap for the Algorithm

Let's Descend!

When will we arrive ?

In its Printed Circuits: Estimating the Price of Gold

Knowledge Transfer and Model Performance: Lessons Applicable to All Regressions

Successful Exploration of the Intricacies of Regression: Next Step, the Fascinating World of Classification

Bibliography

Defeat the Game Master

Defeat the Game Master

We Collect the Information

An Example within an Example

Stormtroopers Are Bad at Shooting?
Yes.