====== Une I.A. en 50 lignes de code ======
<WRAP center round box 60% centeralign>
**{{tagpage>ia|Intelligence Artificielle}}**     **[[http://translate.google.com/translate?hl=&sl=auto&tl=en&u=https%3A%2F%2Fressources.labomedia.org%2Funeiaen50lignesdecode|English Version]]**
</WRAP>
<WRAP center round box 60% centeralign>
**[[les_pages_intelligence_artificielle_en_details|Les Pages Intelligence Artificielle en détails]]**
</WRAP>

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 [[https://en.wikipedia.org/wiki/MNIST_database|MNIST]] (provenant de la Poste américaine IIRC) à télécharger auparavant: [[http://gget.it/in1c/mnist.npz|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 28x28 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.)

<code python main.py>
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)
</code>

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


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

{{tag> digitrecognition ia joseph numpy opensource python }}