Cours 5 - Calculs Numériques

Calculatrice

Un ordinateur n’est au final qu’une grosse calculatrice avec plusieurs avantages:

Meilleur clavier
Meilleur écran
Plus de puissance

Il est extrêmement commun pour un ingénieur d’utiliser un ordinateur pour effectuer des calculs. L’utilisation de Python dans ce domaine est très répandue dans le monde professionnel.

Mode interactif

Le mode interactif de Python peut être utilisé comme calculatrice dans le terminal

> python
Python 3.X.X ...
Type "help", "copyright", "credits" or "license" for more
information.

>>> 1 + 1
2

>>> exit

Trigonometrie

import math

print(math.cos(math.pi))
print(math.sin(math.pi/2))
print(math.tan(math.pi/4))
print(math.acos(0))         # arc cosinus
print(math.asin(1))         # arc sinus
print(math.atan(1))         # arc tangente

Le module math contient bien d’autres fonctions mathématiques

Nombre complexes

import cmath

# racine carrée de nombres négatifs
print(cmath.sqrt(-1))

# définir un nombre complex
x = 1+2j
x = complex(1, 2)
print(x)

# parties réelles et imaginaires
print(x.real)
print(x.imag)

# modules et arguments
print(cmath.phase(x))           # argument
print(abs(x))                   # module
print(cmath.polar(x))           # module et argument

# définition d'1 nb complex à partir du module et argument
print(cmath.rect(1, cmath.pi))

# opérations
print(x+x)
print(x*x)
print(cmath.exp(x))             # exponentielle

Fonctions récursives

Une fonction peut s’appeler elle-même.

Exemple: la factorielle.

def fact(n):
  result = 1
  while n > 0:
      result *= n
      n -= 1
  return result

En récursif:

def fact(n):
  if n == 1:
      return 1
  return fact(n - 1) * n

Fonctions récursives

Attention aux boucles d’appels infinies !
Il faut toujours prévoir un cas de base.

def fact(n):
    if n == 1:               # cas de base
        return 1
    return fact(n - 1) * n   # cas récursif

Calcul numérique

Différent du calcul symbolique
Méthodes de résolution itératives Série de valeurs qui s’approchent de la solution
Solution numérique approchée Souvent aussi proche que l’on veut

Calcul numérique: racine d’une fonction

Recherche d’une racine d’une fonction entre deux bornes
Exemple de fonction:

from math import cos

def fun(x):
  return cos(x) + cos(3 * x + 1) / 2 + cos(5 * x - 1) / 3

Graphique de fun(x) — Graphique de `fun(x)`

Racine d’une fonction: Recherche dichotomique

Dans l’intervalle [-2, 0]
Si le signe de fun() à gauche et à droite de l’intervalle sont différents, il y a au moins une solution dans l’intervalle Si la fonction est continue

Racine d’une fonction: Recherche dichotomique

Dans l’intervalle [-2, 0]
Si le signe de fun() à gauche et à droite de l’intervalle sont différents, il y a au moins une solution dans l’intervalle Si la fonction est continue

Racine d’une fonction: Recherche dichotomique

Dans l’intervalle [-2, 0]
Si le signe de fun() à gauche et à droite de l’intervalle sont différents, il y a au moins une solution dans l’intervalle Si la fonction est continue

Racine d’une fonction

def root(fun, min, max, eps=1e-8):
    if fun(min) * fun(max) > 0:
        return None

    mid = (min + max) / 2

    if max - min < eps:
        return mid

    res = root(fun, min, mid, eps)

    if res is not None:
        return res

    return root(fun, mid, max, eps)

print(root(fun, -2, 0))

-1.2646564356982708

Optimisation: minimum d’une fonction

Le gradient indique la direction dans laquelle une fonction augmente le plus rapidement.
Pour une fonction à une variable, le gradient se limite à une valeur dont le signe indique la direction de la croissance.
Pour trouver un minimum:
1. On part d’une valeur de x.
2. On calcule le gradient de la fonction pour cette valeur de x.
3. On déplace x d’un décalage proportionnel à l’opposé du gradient.
4. On recommence à l’étape 2.
On appelle cette procédure la descente de gradient.

Descente de gradient

Le gradient est positif, on se déplace vers les x négatifs

Descente de gradient

Le gradient est positif, on se déplace vers les x négatifs

Descente de gradient

Le gradient est presque nul, on a trouvé un minimum

Approximation de la dérivée

Mathématiquement, on peut définir la dérivée comme suit:

$\frac{df}{dx}(x) = \lim_{h \to 0} \frac{f(x+h) - f(x-h)}{2 \cdot h}$

En Python, on approximera en choisissant un h très petit:

def diff(fun, x, h=1e-8):
    return (fun(x + h) - fun(x - h)) / (2 * h)

Minimum d’une fonction

def minimize(fun, x0, step=1e-2, eps=1e-8):
    x = x0
    d = diff(fun, x)
    while abs(d) > eps:
        x = x - step * d
        d = diff(fun, x)
    return x

print(minimize(fun, -1))

-1.6677608168359495

Fonctionnement basique d’un LLM

“Notre nouveau modèle de 100 milliards de paramètres prend en charge un contexte de 1 million de tokens”

Tokens ?
Contexte ?
Modèle ?
Paramètres ?

Tokens

Un LLM est un programme et un programme travaille plus facilement avec des nombres.
Un token est un morceau de mot portant un numéro.
Avant d’être traité par un LLM, un texte est tokenisé:

text = "Te considères-tu comme vivant ?"

parts = [
  "Te", " ", "cons", "id", "è", "res", "-", "tu", " ", "comme", " vivant", " ?"
]

ids = [977, 220, 9375, 2634, 293, 12, 259, 2238, 220, 12548, 5633, 30]

Modèle

$Y = F(X)$

Un modèle est une fonction
Son but est de fournir une prédiction La sortie du modèle $Y$
Il calcule la prédiction sur base de valeurs d’entrée $X$

Contexte

Un LLM est un modèle particulier
Les valeurs d’entrée son appelée contexte Les $n$ derniers tokens
La prédiction est le prochain token probabilités pour chaque token d’être le suivant

context = [977, 220, 9375, 2634, 293, 12, 259, 2238, 220, 12548, 5633, 30]

next = F(context) # 1212, "Non"
context.append(next)

context.append(F(context)) # 11, ","
context.append(F(context)) # 2005, " je"
context.append(F(context)) # 299, " ne"
context.append(F(context)) # 579, " suis"
context.append(F(context)) # 1049, " pas"
context.append(F(context)) # 5633, " vivant"
context.append(F(context)) # 13, "."

Paramètres

Partons d’un modèle très simple, le modèle linéaire $y = m \cdot x + p$
```
def F(x):
  return m*x+p
```
L’entrée est x et les paramètres sont m et p
Pour utiliser ce modèle sur une relation linéaire particulière il faut choisir les bons m et p.

L’entrainement

Entrainer un modèle c’est:

Sur base de de données connues des x pour lesquels on connait y
Trouver les valeurs des paramètres
Qui donnent de bonnes prédictions des F(x) proches des y connus

Exemple, modèle linéaire: Les données

`x`	`y`
6.5114	11.1892
7.2440	12.5194
5.7117	9.7893
1.5392	2.9398
6.1776	10.3582
0.0031	0.8437
9.1037	15.2448
3.8121	6.8719
4.9725	8.5677
2.3354	4.6341
1.8208	3.7831
8.1167	13.9252
7.9584	13.2268
2.7410	4.8576
3.4728	6.0295
4.7317	8.4290
5.6237	9.7783
2.6557	4.7825
7.7711	13.2674
9.1899	15.6054

x = [6.5114, 7.244, 5.7117, 1.5392, 6.1776, 0.0031, 9.1037, 3.8121, 4.9725, 2.3354, 1.8208, 8.1167, 7.9584, 2.741, 3.4728, 4.7317, 5.6237, 2.6557, 7.7711, 9.1899]
y = [11.1892, 12.5194, 9.7893, 2.9398, 10.3582, 0.8437, 15.2448, 6.8719, 8.5677, 4.6341, 3.7831, 13.9252, 13.2268, 4.8576, 6.0295, 8.429, 9.7783, 4.7825, 13.2674, 15.6054]

La fonction de coût

Pour trouver m et p on minimise la distance entre les prédictions et les y connus

# Modèle paramétrique
def F(m, p, x):
  return m * x + p

# Moyenne des carrés des distances
def cost(m, p):
  res = 0
  for i in range(len(x)):
    prediction = F(m, p, x[i])
    res += (prediction - y[i])**2
  return res/len(x)

Trouver m et p consiste à minimiser la fonction cost()

Minimisation à 2 variables

def diff(fun, x1, x2, h=1e-8):
    return (
      (fun(x1 + h, x2) - fun(x1 - h, x2)) / (2 * h),
      (fun(x1, x2 + h) - fun(x1, x2 - h)) / (2 * h),
    )

# Remplace `abs()` pour le gradient à 2 composantes
def norm(a, b):
    return (a**2 + b**2)**(0.5)

def minimize(fun, x1_0, x2_0, step=1e-2, eps=1e-8):
    x1 = x1_0
    x2 = x2_0
    d1, d2 = diff(fun, x1, x2)
    while norm(d1, d2) > eps:
        x1 = x1 - step * d1
        x2 = x2 - step * d2
        d1, d2 = diff(fun, x1, x2)
    return x1, x2

Entrainement du modèle linéaire

m, p = minimize(cost, 0, 0)
print(m, p)

1.6126216510967022 0.648694847983633