Deep Learning

IA : Vers le Deep Learning

Exemple simplifié de modélisation 2D, et 3D d'un neurone artificiel

2D : Voici un code complet ainsi qu'une représentation en 2D des données et de la droite de séparation après 20 tours d'entraînement

import random
import matplotlib.pyplot as plt

data = [[4.2, 2.6, 1], [4.4, 3.25, 1], [3.8, 3.3, 1], [4.7, 2.8, 1], [4.6, 3.45, 1], [3.5, 3.8, 1], [4.5, 3.2, 1],
        [3.9, 3.15, 1], [4.7, 2.9, 1], [4.1, 2.9, 1], [4.9, 3.0, 1], [4.1, 3.35, 1], [4.1, 2.7, 1], [4.3, 3.35, 1],
        [3.8, 3.35, 1], [4.6, 2.85, 1], [3.75, 3.0, 1], [4.5, 2.55, 1], [3.9, 2.65, 1], [4.5, 1.4, 1], [3.2, 2.9, 0],
        [3.1, 3.5, 0], [3.0, 2.9, 0], [3.1, 2.25, 0], [3.8, 1.8, 0], [3.1, 2.85, 0], [3.6, 2.6, 0], [3.0, 2.3, 0],
        [3.1, 2.4, 0], [3.7, 2.2, 0], [3.0, 2.4, 0], [3.2, 3.3, 0], [3, 3.9, 0], [3.1, 2.85, 0], [3.2, 2.2, 0],
        [3.4, 2.4, 0], [3.4, 2.65, 0], [3.1, 2.05, 0], [3.5, 2.55, 0], [3.5, 2.35, 0]]

#Le point dont on cherche la couleur
question = [3.5, 3.2]

# Calcul pour prediction (à compléter):
def prediction(X, Y, w1, w2, b):
    #A compléter...

return 0

# Ajustement des poids en fonction de l'erreur (à compléter):
def ajust(pas, X, Y, w1, w2, b, E):
    #A compléter...

return w1, w2, b

#taux d'échec :
def taux(data, w1, w2, b):
    nb_echecs = 0
    for carte in data:
        X = carte[0]
        Y = carte[1]
        p = prediction(X, Y, w1, w2, b)
        if p != carte[2]:
            nb_echecs += 1
    print("Taux d'échecs : ", nb_echecs/len(data))

#Initialisation du pas et des poids :
pas = 0.1
w1 = 5
w2 = 2
b = -14

# Selection de 20 cartes au hasard
select = random.sample(data, 20)

# On parcourt les 20 cartes de la selection:
for carte in select:
    X = carte[0]
    Y = carte[1]
    color = carte[2]
    predict = prediction(X, Y, w1, w2, b)
    #Calcul de l'erreur:
    E = color-predict
    w1, w2, b = ajust(pas, X, Y, w1, w2, b, E)
    print(taux(data, w1, w2, b))

print(w1, w2, b)

#======================Plot 2D=============================

#Pour afficher les data
x_rouge = []
y_rouge = []
x_bleu = []
y_bleu = []
for i in range(len(data)):
    if data[i][2] == 1:
        x_rouge.append(data[i][0])
        y_rouge.append(data[i][1])
    else:
        x_bleu.append(data[i][0])
        y_bleu.append(data[i][1])

#Droite liée aux poids
def f(x, w1, w2, b):
    return (-w1*x - b)/w2

plt.scatter(x_rouge, y_rouge, c = 'red')
plt.scatter(x_bleu, y_bleu, c = 'blue')
#Une étoile noire pour la fleur dont on cherche la couleur
plt.scatter(3.5, 3.2, c = 'black', marker = '*', s = 100)
plt.plot([f(x, w1, w2, b) for x in range(8)])
plt.show()

3D : Voici un code complet ainsi qu'une représentation en 3D des données et du plan de séparation après 20 tours d'entraînement

import random

data = [[4.1, 3.85, 2.2, 1], [3.7, 3.4, 2.2, 1], [4.7, 2.8, 1.7, 1], [4.5, 3.25, 2.4, 1], [4.4, 3.25, 2.5, 1], [4.8, 2.75, 1.4, 1], [4.0, 3.7, 2.3, 1], [5.0, 2.2, 2.0, 1], [4.5, 3.65, 2.3, 1], [5.1, 3.25, 2.4, 1], [4.3, 3.65, 2.7, 1], [5.1, 3.35, 2.3, 1], [5.3, 3.4, 2.2, 1], [4.9, 3.5, 2.8, 1], [4.3, 2.75, 2.6, 1], [4.1, 2.5, 1.3, 1], [4.5, 3.65, 1.8, 1], [4.8, 3.3, 2.0, 1], [4.5, 3.6, 2.0, 1], [5.1, 2.05, 1.4, 1], [3.6, 2.3, 1.1, 0], [3.5, 2.1, 2.8, 0], [3.9, 2.8, 1.3, 0], [3.4, 2.8, 1.1, 0], [3.9, 2.5, 2.7, 0], [3.9, 2.9, 2.3, 0], [3.5, 2.2, 2.2, 0], [3.5, 2.7, 2.8, 0], [3.1, 2.3, 1.2, 0], [3.2, 2.2, 2.8, 0], [3.1, 2.9, 2.0, 0], [3.2, 2.3, 2.4, 0], [3.5, 2.7, 2.0, 0], [3.5, 2.1, 2.1, 0], [3.1, 2.5, 2.3, 0], [3.3, 2.5, 2.7, 0], [3.7, 2.5, 2.4, 0], [3.7, 2.7, 2.0, 0], [3.5, 2.9, 1.4, 0], [3.1, 2.5, 1.4, 0]]

#Le point dont on cherche la couleur
question = [3.5, 3.2, 2.2]

def prediction(carte, W):
    o = W[0]*carte[0] + W[1]*carte[1] + W[2]*carte[2] + W[3]
    if o > 0:
        predict = 1
    else:
        predict = 0
    return predict

def ajust(pas, carte, W, E):
    W[0] = W[0] + pas*carte[0]*E
    W[1] = W[1] + pas*carte[1]*E
    W[2] = W[2] + pas*carte[2]*E
    W[3] = W[3] + pas*E
    return W

def taux(data, W):#Calcul du taux d'échecs
    echecs = 0
    for carte in data:
        if prediction(carte, W) != carte[3]:
            echecs += 1
    return echecs/len(data)

#====Initialisation:====
pas = 0.1
poids = [5, 3, 1, -15]
#====Entrainement:====

#Sélection de 20 cartes au hasard:
select = random.sample(data, 20)

for carte in select:
    predict = prediction(carte, poids)
    #Calcul de l'erreur:
    E = carte[3]-predict
    poids = ajust(pas, carte, poids, E)
    print(taux(data, poids))

print(poids)

#======================Plot 3D=============================
import matplotlib.pyplot as plt
from matplotlib import cm
import mpl_toolkits.mplot3d
import numpy as np

#Possibilité de tester certains poids trouvés
#poids = [2.9, 1.5, -0.1, -15.6]

fig = plt.figure()
ax = fig.add_subplot(projection='3d')

#Les données :
for carte in data:
    if carte[3] == 1:
        ax.scatter(carte[0], carte[1], carte[2], marker='o', color=(1, 0, 0))
    else:
        ax.scatter(carte[0], carte[1], carte[2], marker='o', color=(0, 0, 1))

#ax.scatter(question[0], question[1], question[2], marker='*', color=(0, 1, 0))

#Le plan de séparation :
X = np.arange(2, 5, 0.5)
Y = np.arange(2, 5, 0.5)
X, Y = np.meshgrid(X, Y)
Z = (poids[0]*X + poids[1]*Y + poids[3])/(-poids[2])
ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0, antialiased=False)

ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.show()

Cours1 : Déplacer la tortue Cours2 : Répéter Cours3 : Procédures Cours4 : On mélange tout