Outils pour utilisateurs

Outils du site


uneiaen50lignesdecode

Une I.A. en 50 lignes de code

Une intelligence artificielle qui reconnaît les chiffres manuscrits avec un taux de succès de 95%, en 50 lignes de Python seulement, possible ?

(sans tricher avec une librairie comme Tensorflow qui ferait le travail à notre place)

Possible ? Oui!

L'exécution prend 3 minutes environ, et parcourt les 60 000 chiffres manuscrits de la base de données MNIST (provenant de la Poste américaine IIRC) à télécharger auparavant: mnist.npz.

Résultat:

59994
59995
59996
59997
59998
59999
Testing…
Accuracy: 95.5 %

La structure du réseau de neurones est la suivante: 4 couches:

  • couche d'entrée: 784 (=une image 28×28 pixels)
  • couche cachée: 100
  • couche cachée: 100
  • couche de sortie: 10 (la valeur la plus élevée donne le chiffre prédit par l'I.A.)
import numpy as np, cv2
def sigmoid(x): return 1 / (1 + np.exp(-x))
def sigmoid_prime(z): return z * (1 - z)
def relu(x): return np.maximum(0, x)
def relu_prime(z): return np.asarray(z > 0, dtype=np.float32)
layers = [784, 100, 100, 10]
activations, learningrate = [relu, relu, sigmoid], 0.1
if __name__ == "__main__":
    f = np.load('mnist.npz')
    x_train, y_train = f['x_train'], f['y_train']
    x_test, y_test = f['x_test'], f['y_test']
    x_train = x_train.reshape(60000, 784) / 255.0
    x_test = x_test.reshape(10000, 784) / 255.0
    s = np.arange(len(x_train))
    np.random.shuffle(s)
    x_train, y_train = x_train[s], y_train[s]
    Y = np.eye(10, 10)
    activations_prime = [globals()[f.__name__ + '_prime'] for f in activations]
    A = {}
    W = [np.random.randn(layers[k+1], layers[k]) / np.sqrt(layers[k]) for k in range(len(layers)-1)]
    print("Training...")
    cv2.namedWindow('img', cv2.WINDOW_NORMAL)
    for i, (a, d) in enumerate(zip(x_train, y_train)):
        print(i)
        cv2.imshow("img", a.reshape(28,28))
        cv2.waitKey(1)
        a = np.array(a, ndmin=2).T
        A[0] = a
        for k in range(len(layers)-1):
            z = np.dot(W[k], a)
            a = activations[k](z)
            A[k+1] = a
        da = a - Y[:,[d]]
        for k in range(len(layers)-2, -1, -1):           #  la fameuse "backpropagation"
            dz = da * activations_prime[k](A[k+1])
            dW = np.dot(dz, A[k].T)
            da = np.dot(W[k].T, dz)
            W[k] -= learningrate * dW
    print("Testing...")
    S = 0
    for a, d in zip(x_test, y_test):
        for k in range(len(layers)-1):
            a = activations[k](np.dot(W[k], a))
        if np.argmax(a) == d:
            S += 1
    print("Accuracy: %.1f %%" % (100.0 * S / len(x_test)))
    np.save('weights', W)

Comment tester cette I.A. sur votre propre chiffre scanné/photographié/dessiné ?

A venir si ça intéresse des gens :)

uneiaen50lignesdecode.txt · Dernière modification: 2020/10/12 11:41 de serge