Defis

Avec matplotlib.pyplot :

Reproduire l'image ci-dessous :

Une image plus grande :

Avec une image chargée depuis une base interne :

import matplotlib.pyplot as plt
from PIL import Image

#Prérequis pour charger des images depuis le web :
import urllib.request
import io
from socket import timeout

#Chargement d'une image depuis le web (base interne):
path = "tux1.png"
url = "http://willcoyot.pythonanywhere.com/Defis/static/images/test/tux1.png"
#fd = urllib.request.urlopen(url, timeout=10000)
#image_file = io.BytesIO(fd.read())
#tux = Image.open(image_file)

#=====Passe par javascript fetch :==============
from js import fetch

response = await fetch(url);
js_buffer = await response.arrayBuffer()
tux_url = Image.open(io.BytesIO(js_buffer.to_py()))
tux_url.save("tux.png")
#===========================================

tux = Image.open("tux.png")

w = tux.size[0]
h = tux.size[1]

#Creation d'une image RGB
img = Image.new("RGB",(w,h),(100,0,100))

#On parcourt tous les pixels de l'image:
for x in range(0, w):
    for y in range(0, h):
        if (x - 50)**2 + (y - 30)**2 <= 29**2:
            pix = tux.getpixel((x, y))
            img.putpixel((x, y), pix)

plt.imshow(img)
plt.show()

Un neurone artificiel avec 2 entrées (2D). Recherche de la couleur d'un point :

import matplotlib.pyplot as plt
import random
#=============Données=======================
#Petit dataSet1 3ème valeur : 1 rouge 0 bleu
dataSet1 = [[3, 4, 1], [3, 2, 0], [3, 1, 0], [4, 3, 1], [5, 5, 1], [6, 3, 1], [1, 1, 0]]
#dataSet2 plus grand : Deux centres séparéspour deux paquets de points
centre1 = [4, 2]#modifiable
centre2 = [2, 4]#modifiable
dataSet2 = []
for i in range(100):#On peut mettre plus grand....
    bool = random.randint(0, 1)#0 ou 1
    if bool == 1:
        point = [centre2[0] + random.uniform(-1, 1), centre2[1] + random.uniform(-1, 1), 1]
    else:
        point = [centre1[0] + random.uniform(-1, 1), centre1[1] + random.uniform(-1, 1), 0]
    dataSet2.append(point)

#Le point dont on cherche la couleur
question = [2, 3]

#=============Modelisation d'un neurone ===========

def forward(X, W):
    o = W[0]*X[0] + W[1]*X[1] + W[2] #Forward avec un bice
    if o > 0:
        res = 1
    else:
        res = 0
    return res

def miniDL(D, W, pas):
    for X in D:#Pour chaque point du dadaset :
        res = forward(X, W)
        E = X[2]-res #Erreur
        #Calcul des poids, fonction d'activation :
        #Linear donc pas de fonction d'activition, on conserve la valeur de préactivation
        W[0] += pas*X[0]*E
        W[1] += pas*X[1]*E
        W[2] += pas*E #bice : décommenter cette ligne si vous voulez obtenir une modification du bice

#print(W)
    return W

def prediction(q, W):#Renvoie la couleur du point q après avoir été entrainé
    if forward(q, W) == 1:
        return "Le point est rouge"
    else:
        return "Le point est bleu"

def taux(D, W):#Calcul du taux d'échecs
    echecs = 0
    for X in D:
        if forward(X, W) != X[2]:
            echecs += 1
    return echecs/len(D)

#Droite liée aux poids pour le graphique
def f(x, W):
    return (-W[0]*x - W[2])/W[1]

#================Entrainement====================
D = dataSet2 #1 : petit data set ou 2 : grand data set
pas = 0.1
b = 0 #bice
#W = [0.5, 0.5, b] #Valeurs donnes pour limiter les calculs ?
W = [random.uniform(-1, 1), random.uniform(-1, 1), b] #départ poids aleatoires + bice
print("Valeurs initiales : ", W)

for i in range(20):
    #Devons nous parcourir toutes les données du dataSet ? si > 20 oui sinon, on en choisi 20:
    if len(D) > 20:
        Dselect = random.sample(D, 20)
    else :
        Dselect = D
    W = miniDL(Dselect, W, pas)
    print("Taux d'échecs : ", taux(D, W))

print("Valeurs finales : ", W)
#Prédiction pour la question
print(prediction(question, W))

#============Représentation graphique====================

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

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

Un neurone artificiel avec 3 entrées (3D). Recherche de la couleur d'un point :

# -*- coding: utf-8 -*-

#Pour Chrome :
#import sys
#sys.setrecursionlimit(650)

import csv #Pour l'export de données
import random
#=============Données=======================
#Petit dataSet1 3ème valeur : 1 rouge 0 bleu
dataSet1 = [[3, 4, 1], [3, 2, 0], [3, 1, 0], [4, 3, 1], [5, 5, 1], [6, 3, 1], [1, 1, 0]]
#dataSet2 plus grand : Deux centres séparés pour deux paquets de points
centre1 = [3, 2, 1]#modifiable
centre2 = [5, 4, 3]#modifiable
#Création de data
dataSet2 = []
for i in range(50):#On peut mettre plus grand....
    bool = random.randint(0, 1)#0 ou 1
    if bool == 1:
        point = [centre2[0] + random.uniform(-1, 1), centre2[1] + random.uniform(-1, 1), centre2[2] + random.uniform(-1, 1), 1]
    else:
        point = [centre1[0] + random.uniform(-1, 1), centre1[1] + random.uniform(-1, 1), centre1[2] + random.uniform(-1, 1), 0]
    dataSet2.append(point)

#Le point dont on cherche la couleur
question = [2, 3, 1.5]

#=============Modelisation d'un neurone ===========

def forward(X, W):
    o = W[0]*X[0] + W[1]*X[1] + W[2]*X[2] + W[3] #Forward avec un bice
    if o > 0:
        res = 1
    else:
        res = 0
    return res

def miniDL(D, W, pas):
    for X in D:#Pour chaque point du dadaset :
        res = forward(X, W)
        E = X[3]-res #Erreur
        #Calcul des poids, fonction d'activation :
        #Linear donc pas de fonction d'activition, on conserve la valeur de préactivation
        #Ou alors il faut considérer que c'est une heaviside ?
        W[0] += pas*X[0]*E
        W[1] += pas*X[1]*E
        W[2] += pas*X[2]*E
        W[3] += pas*E #bice : décommenter cette ligne si vous voulez obtenir une modification du bice

return W

def prediction(q, W):#Renvoie la couleur du point q après avoir été entrainé
    if forward(q, W) == 1:
        return "Le point est rouge"
    else:
        return "Le point est bleu"

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

#================Entrainement====================
D = dataSet2 #1 : petit data set ou 2 : grand data set
pas = 0.1
b = 2 #bice
iter = 100 #Nombre d'iterations
#W = [0.5, 0.5, 0.5, b] #Valeurs donnes pour limiter les calculs ?
W = [random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1), b] #départ poids aleatoires + bice
print("Valeurs initiales : ", W)

for i in range(iter):
    #Devons nous parcourir toutes les données du dataSet ? si > 20 oui sinon, on en choisi 20:
    if len(D) > 20:
        Dselect = random.sample(D, 20)
    else :
        Dselect = D
    W = miniDL(Dselect, W, pas)
    print("Taux d'échecs : ", taux(D, W))

print("Valeurs finales : ")
print("w1 = " + str(W[0]))
print("w2 = " + str(W[1]))
print("w3 = " + str(W[2]))
print("b = " + str(W[3]))
#Prédiction pour la question
print(prediction(question, W))

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

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

for X in D:
    if X[3] == 1:
        ax.scatter(X[0], X[1], X[2], marker='o', color=(1, 0, 0))
    else:
        ax.scatter(X[0], X[1], X[2], marker='o', color=(0, 0, 1))

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

#Plan:
X = np.arange(0, 7, 0.25)
Y = np.arange(0, 7, 0.25)
X, Y = np.meshgrid(X, Y)
Z = (W[0]*X + W[1]*Y + W[3])/(-W[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()

Les images numériques

Créer une simple image