Démystifier les concepts mathématiques pour le deep learning

La data science est un domaine interdisciplinaire qui s’appuie sur les mathématiques et les statistiques avancées pour faire des prédictions. Tous les algorithmes de data science mobilisent, directement ou indirectement, des concepts mathématiques. Une solide maîtrise des maths vous aidera à concevoir des solutions innovantes en data science, comme un système de recommandation. Si vous êtes à l’aise en mathématiques, votre transition vers la data science sera plus fluide. En tant que data scientist, vous devez exploiter les concepts fondamentaux des mathématiques pour résoudre des problèmes.

Au-delà des mathématiques, vous aurez aussi besoin de connaissances métier, de compétences en programmation, d’un sens du business, de capacités d’analyse et d’un état d’esprit curieux. Impossible d’échapper aux maths pour un data scientist. Vous devez assimiler et vous enseigner les bases des mathématiques et des statistiques pour le devenir.

Scalaire et vecteur

• Scalaires : Un scalaire est un nombre unique qui interagit avec un vecteur dans l’espace via la multiplication scalaire.

• Vecteurs : Un vecteur V est un ensemble ordonné d’éléments. Un vecteur est un tableau de nombres, en ligne ou en colonne. Les vecteurs peuvent s’additionner et être multipliés par un nombre réel, appelé scalaire.

Source de l’image

# Import numpy module
import numpy as np

# creating a vector
v = np.array([1, 2, 3, 4, 5])
print(v)
Propulsé par

[1 2 3 4 5]
Propulsé par

# Vector Operations
# Import numpy module
import numpy as np

# Create two vector
a = np.array([1, 2, 3, 4, 5])
b = np.array([1, 2, 3, 4, 5])

# adding two vectors
add = a + b
print("Addition:",add)

# Vector Subtraction
sub = a - b
print("Subtraction:",sub)

# Vector Multiplication
mul = a * b
print("Multiplication:",mul)

# Vector Division
div = a / b
print("division",div)
Propulsé par

Addition: [ 2  4  6  8 10]
Subtraction: [0 0 0 0 0]
Multiplication: [ 1  4  9 16 25]
division [1. 1. 1. 1. 1.]
Propulsé par

Matrice et tenseur

• Matrices : Une matrice est un tableau N-D de nombres qui représente des transformations. Vous pouvez voir une matrice comme une transformation telle que « mise à l’échelle », « rotation », « cisaillement » ou « symétrie ». Elle transforme un point de l’espace en un autre.

# Import numpy module
import numpy as np

# create 2*2 matrix
a1=np.array([[1, 2], [3, 4]])
a2=np.array([[1, 2], [3, 4]])

# Dot Product
dot_product = np.dot(a1,a2)
print("Dot Product: \n",dot_product)

# Cross Product
cross_product = np.cross(a1,a2)
print("Cross Product: \n", cross_product)
Propulsé par

Dot Product:
 [[ 7 10]
 [15 22]]
Cross Product:
 [0 0]
Propulsé par

Le produit scalaire de deux vecteurs représente la projection de l’un sur l’autre, tandis que le produit vectoriel permet d’identifier le plan sur lequel les deux vecteurs peuvent se situer.

• Tenseur : Il arrive que l’on ait besoin d’un tableau à plus de deux dimensions, avec pour chaque axe une dimension possiblement différente : c’est un tenseur, organisé en grille. La dimension d’un tenseur s’appelle son rang. Les scalaires et les vecteurs sont aussi des tenseurs : les tenseurs d’ordre zéro sont des scalaires, et ceux d’ordre un sont des vecteurs.

Source de l’image

Déterminant

Le déterminant est une valeur scalaire qui exprime, pour une matrice, le facteur par lequel des longueurs (en 1D), des aires (en 2D) ou des volumes (en 3D) sont dilatés. Si le déterminant vaut 2, le volume (en 3D) est doublé ; s’il vaut 1, le volume est inchangé. Si le déterminant est nul, la matrice n’a pas d’inverse, car zéro multiplié par quoi que ce soit donne zéro.

Propriétés :

• Le déterminant d’un produit de matrices est le produit de leurs déterminants : det(M1M2) = det(M1) det(M2).

• Le déterminant d’une matrice est égal au produit de ses valeurs propres.

• Si vous multipliez une matrice par une constante, le déterminant varie selon det(cM) = c^N det(M), où N est la dimension de la matrice.

Si votre matrice représente un jouet élastique, alors son déterminant indique à quel point vous l’avez étiré.

# Import numpy module
import numpy as np

# Create 2*2 matrix
arr=np.array([[1,2],[3,4]])

# Compute Determinant of a matrix
arr_det=np.linalg.det(arr)

# Print the Computed Determinant
print("Determinant:",arr_det)
Propulsé par

Determinant: -2.0000000000000004
Propulsé par

Valeurs propres et vecteurs propres

Un vecteur propre d’une matrice carrée A est un vecteur non nul dont la multiplication par A ne change que l’échelle.

Source de l’image

Le vecteur propre est aussi appelé vecteur caractéristique. C’est un vecteur non nul qui ne varie que par un facteur scalaire lorsqu’une transformation linéaire lui est appliquée.

Les vecteurs propres définissent les axes de rotation de la transformation linéaire. Ces directions sont fixes, et la valeur propre est le facteur d’échelle par lequel la matrice étire ou contracte. Les valeurs propres sont aussi appelées valeurs ou racines caractéristiques. Autrement dit, les valeurs propres quantifient la distorsion induite par la transformation le long de ces directions privilégiées.

Le déterminant indique l’aire ou le volume après mise à l’échelle par la transformation linéaire. C’est pourquoi le produit des valeurs propres est égal au déterminant.

# Import numpy module
import numpy as np

# Create 2*2 matrix
arr=np.array([[1,2],[3,4]])

# Find eigenvalues and eigenvectors
eigenvalues, eigenvectors = np.linalg.eig(arr)

# print the eigenvalues and eigenvectors
print("Eigen Values: \n",eigenvalues)
print("Eigen Vectors:\n", eigenvectors)
Propulsé par

Eigen Values:
 [-0.37228132  5.37228132]
Eigen Vectors:
 [[-0.82456484 -0.41597356]
 [ 0.56576746 -0.90937671]]
Propulsé par

Fonction NORM

Il est parfois utile de mesurer la « taille » d’un vecteur. La fonction de norme permet de le faire : elle associe une longueur strictement positive à un vecteur d’un espace vectoriel, sauf pour le vecteur nul. Elle inclut la norme L^p. Elle envoie les vecteurs vers des valeurs non négatives. Pour un vecteur (et certaines matrices), elle correspond à la distance euclidienne. Elle est égale à la plus grande valeur singulière.

# import numpy module
import numpy as np

# Create 3*3 Matrix
a = np.array([[1,2,3],[4,5,6],[7,8,9]])

# Compute norm
a_norm = np.linalg.norm(a)

# print the norm of function
print(a_norm)
Propulsé par

16.881943016134134
Propulsé par

Factorisation de matrices

La factorisation de matrices, ou décomposition de matrices, consiste à scinder une matrice en ses composantes. Elle est à la matrice ce que la factorisation est aux nombres (par exemple 10 = 2 × 5). On l’utilise notamment pour résoudre des systèmes linéaires.

Parmi les techniques de factorisation :

• Décomposition LU : pour les matrices carrées, décompose en composantes L et U.

• Décomposition QR : pour les matrices m × n (pas limitée aux matrices carrées), décompose en composantes Q et R. Contrairement à LU, elle s’applique aussi aux matrices non carrées.

• Décomposition de Cholesky : utilisée pour les moindres carrés en régression linéaire, ainsi qu’en simulation et en optimisation.

• Décomposition en valeurs singulières présentée dans la section suivante.

Décomposition en valeurs singulières

Dans la section précédente, nous avons vu l’éigen-décomposition d’une matrice en vecteurs et valeurs propres. La décomposition en valeurs singulières (SVD) est une autre forme de factorisation, en vecteurs singuliers et valeurs singulières. Elle offre de nombreuses applications en traitement du signal, psychologie, sociologie, climatologie, sciences de l’atmosphère, statistiques et astronomie.

• M est une matrice m × m
• U est une matrice singulière gauche m × n
• Σ est une matrice diagonale n × n à éléments réels non négatifs
• V est une matrice singulière droite m × n
• V* est une matrice n × m, la transposée conjugée de V.

# Import numpy module
import numpy as np

# Create 3*3 matrix
a = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]])

# Decomposition of matrix using SVD
U, s, Vh = np.linalg.svd(a, full_matrices=False)

U,s,Vh
Propulsé par

(array([[-0.27067357, -0.61678044,  0.69789573],
        [-0.65939972, -0.2937857 , -0.62152182],
        [-0.20244298, -0.3480035 , -0.06765408],
        [-0.67152413,  0.64200111,  0.34939247]]),
 array([18.0376394 ,  2.34360292,  0.38870323]),
 array([[-0.46961711, -0.51018039, -0.72053851],
        [ 0.87911451, -0.19502274, -0.43488368],
        [-0.08134773,  0.83766467, -0.54009299]]))
Propulsé par

# Generate the initial matrix
new_a = np.dot(U, np.dot(np.diag(s), Vh))

# Print original matrix
print(new_a)
Propulsé par

[[1. 3. 4.]
 [5. 6. 9.]
 [1. 2. 3.]
 [7. 6. 8.]]
Propulsé par

Pseudo-inverse de Moore-Penrose

La pseudo-inverse d’une matrice généralise la notion d’inverse. Elle est utilisée pour calculer des solutions aux moindres carrés. L’inverse de Moore-Penrose est la forme de pseudo-inverse la plus répandue.

# Import numpy module
import numpy as np

# Create 3*3 matrix
a = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]])

# Compute the (Moore-Penrose) pseudo-inverse of a matrix.
inv=np.linalg.pinv(a)

# Print pseudo-inverse of a matrix.
print(inv)
Propulsé par

[[-0.37037037  0.03703704 -0.11111111  0.18518519]
 [ 1.56296296 -1.2962963  -0.11111111  0.71851852]
 [-0.84444444  0.94444444  0.16666667 -0.57777778]]
Propulsé par

Produit de Hadamard

Le produit de Hadamard, ou produit de Schur, est le produit élément par élément de deux matrices de mêmes dimensions. Plus simple que le produit matriciel classique, il est utilisé notamment dans les algorithmes de compression avec perte JPEG. Le produit de Hadamard est commutatif, associatif et distributif. Il facilite l’obtention de l’inverse et simplifie le calcul des puissances de matrices.

Le produit de Hadamard intervient dans de nombreux domaines : correction de codes en transmissions satellitaires, théorie de l’information, cryptographie, reconnaissance de formes, réseaux de neurones, estimation du maximum de vraisemblance, compression JPEG avec perte, analyse statistique multivariée et modélisation linéaire.

# Import numpy module
import numpy as np

# Create 2*2 matrix a1 and a2
a1=np.array([[1, 2], [3, 4]])
a2=np.array([[1, 2], [3, 4]])

# Element wise multiplication
hadamard_product = np.multiply(a1,a2)

# Print hadamard distance
print("Hadamard Product: \n", hadamard_product)
Propulsé par

Hadamard Product:
 [[ 1  4]
 [ 9 16]]
Propulsé par

Entropie

« L’entropie d’une variable aléatoire est une fonction qui tente de caractériser son imprévisibilité. » (Entropy and Mutual Information) Elle est utilisée pour construire automatiquement des arbres de décision : à chaque étape de construction de l’arbre, la sélection des variables s’appuie sur un critère d’entropie. La sélection de modèles suit souvent le principe de l’entropie maximale : parmi des modèles concurrents, celui avec l’entropie la plus élevée est préférable.

« Si une variable aléatoire X prend ses valeurs dans un ensemble χ={x1, x2,..., xn}, et est définie par une loi de probabilité P(X), alors on écrit l’entropie de la variable aléatoire : » (Entropy and Mutual Information)

« Si le logarithme de la formule ci-dessus est en base 2, l’entropie s’exprime en bits. S’il s’agit du logarithme népérien, l’entropie s’exprime en nats. Le plus souvent, on l’exprime en bits. » (Entropy and Mutual Information)

# Import scipy and numpy module
import scipy.stats
import numpy as np

# Create an array
a=np.array([1,1,2,3,1,3,4,2,5,6,3,2,4,3])


# Compute probability distribution
a_pdf=scipy.stats.norm.pdf(a)

# Calculate the entropy of a distribution for given probability values.
entropy = scipy.stats.entropy(a_pdf) # get entropy from probability values
print("Entropy: ",entropy)
Propulsé par

Entropy:  1.6688066853941022
Propulsé par

Divergence de Kullback-Leibler

La divergence de Kullback–Leibler est l’entropie relative entre deux lois de probabilité. Elle mesure l’écart (similarité ou dissimilarité) d’une distribution par rapport à une distribution de référence. Une valeur nulle de la divergence de Kullback–Leibler indique des distributions identiques. Elle s’exprime ainsi :

Elle ressemble à une mesure de distance, mais n’en est pas une : elle est asymétrique, donc non commutative. En général, on a D(p, q) ≠ D(q, p). La divergence KL est fréquemment utilisée dans la méthode d’apprentissage non supervisé « Variational Autoencoders ».

# Import scipy.stats and numpy module
import scipy.stats
import numpy as np

# Create numpy arrays
a=np.array([1,1,2,3,1,3,4,2,5,6,3,2,4,3])
b=np.array([1,1,3,4,2,4,5,2,5,6,3,2,4,3])

# Compute probability distribution
a_pdf=scipy.stats.norm.pdf(a)
b_pdf=scipy.stats.norm.pdf(b)

# compute relative entropy or KL Divergence
kl_div=scipy.stats.entropy(a_pdf,b_pdf)

print("KL Divergence: ",kl_div)
Propulsé par

KL Divergence:  0.26732496641464365
Propulsé par

Descente de gradient

La descente de gradient est l’un des algorithmes les plus connus pour optimiser coefficients et biais en régression linéaire, régression logistique et réseaux de neurones. C’est un processus itératif qui cherche le minimum d’une fonction donnée.

Source de l’image

Source de l’image

On distingue trois variantes : batch complet, stochastique et mini-batch. La descente de gradient en batch complet utilise l’ensemble du jeu de données pour calculer le gradient, tandis que la descente stochastique s’appuie sur un échantillon. La version mini-batch combine les deux : l’ensemble d’apprentissage est découpé en petits lots (batches) qui calculent la perte successivement, puis on moyenne le résultat final.

Conclusion

Félicitations, vous êtes arrivé au bout de ce tutoriel !

Vous avez découvert des notions mathématiques essentielles pour le deep learning : scalaire, vecteur, matrice, tenseur, déterminant, valeurs propres, vecteurs propres, fonction NORM, décomposition en valeurs singulières (SVD), pseudo-inverse de Moore-Penrose, produit de Hadamard, entropie, divergence de Kullback-Leibler et descente de gradient.

Au passage, vous avez pratiqué ces concepts en Python avec NumPy et SciPy.

Pour aller plus loin avec Python, suivez ces cours DataCamp :

• Clustering Methods with SciPy
• Unsupervised Learning in Python
• Statistical Thinking in Python (Part 1)
• Statistical Simulation in Python