Jouez des nombres manuscrits avec Python Partie 1

Afficher les données numériques manuscrites sous forme d'image

Tout d'abord, préparez des données numériques manuscrites. Cette fois, de la tâche de Digital Recognizer de Kaggle, les données de l'enseignant nommées train Je souhaite le télécharger et l'utiliser.

Si toutes ces données sont utilisées, il s'agit d'une quantité considérable de données de 73 Mo. Par souci de clarté, 20 pièces de chaque nombre de 0 à 9 sont ramassées et utilisées, pour un total de 200 pièces. Veuillez télécharger les données récupérées depuis ici.

Ces données numériques manuscrites sont un fichier CSV

8, 0, 0, 0, 128, ... , 54, 23, 0, 0

```Le premier chiffre est une étiquette indiquant quel numéro a été écrit, et les chiffres suivants sont 28x28.=Les données numériques pour 784 pixels suivent.

 Tout d'abord, importez les bibliothèques requises.

```py
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm

Ensuite, il lit les données, les stocke dans un tableau et les trie dans l'ordre des étiquettes.

size = 28
raw_data= np.loadtxt('train_small.csv',delimiter=',',skiprows=1)

digit_data = []
for i in range(len(raw_data)):
    digit_data.append((raw_data[i,0],raw_data[i,1:785]))

digit_data.sort(key=lambda x: x[0]) # sort array by label

Tout d'abord, affichons le type d'image des données lues (avec le graphe pcolor de matplotlib).

# draw digit images
plt.figure(figsize=(15, 15))

for i in range(len(digit_data)):
    X, Y = np.meshgrid(range(size),range(size))
    Z = digit_data[i][1].reshape(size,size)   # convert from vector to 28x28 matrix
    Z = Z[::-1,:]             # flip vertical
    plt.subplot(10, 20, i+1)  # layout 200 cells
    plt.xlim(0,27)
    plt.ylim(0,27)
    plt.pcolor(X, Y, Z)
    plt.flag()
    plt.gray()
    plt.tick_params(labelbottom="off")
    plt.tick_params(labelleft="off")
    
plt.show()

La 8ème donnée de "2" est étonnante, il n'y a pas de vestige de "2" (rires) Si on ne dit pas que c'est "2", il ne sera peut-être pas possible pour les humains de le distinguer ... Il s'agit de l'ensemble de données utilisé cette fois.

Essayez de corréler chaque donnée

Tracez la matrice de corrélation

Faisons une matrice de corrélation de ces données d'image 28x28 = 784 pixels avec chaque élément en tant que densité d'échelle de gris avec un vecteur de 784 dimensions. La question est de savoir dans quelle mesure il est logique de simplement corréler, mais j'estime qu'une méthode simple peut exprimer dans une certaine mesure la proximité des images. Comme il s'agit d'une matrice 200x200, je ne peux pas la comprendre même si c'est un nombre, donc je vais la montrer dans un graphique pour obtenir une image.

C'est un graphique assez spectaculaire (rires)

Les composantes diagonales complètes ont les mêmes données, donc la corrélation est de 1. En y regardant légèrement, j'ai l'impression que les blocs diagonaux (coefficient de corrélation entre les mêmes nombres) sont un peu sombres. «1» est certainement fortement corrélé.

Le calcul en python se fait comme suit.

data_mat = []

# convert list to ndarray
for i in range(len(digit_data)):
    label = digit_data[i][0]
    data_mat.append(digit_data[i][1])

A = np.array(data_mat)
Z = np.corrcoef(A)      # generate correlation matrix

area_size = len(digit_data)
X, Y = np.meshgrid(range(area_size),range(area_size)) 

Définissez un seuil pour faciliter la lecture

Pour le rendre un peu plus facile à voir, définissons un seuil et représentons ceux dont le coefficient de corrélation est supérieur à 0 et ceux dont le coefficient de corrélation est inférieur à 1. J'ai choisi 0,5 et 0,6 comme seuil, mais ils sont arbitraires, et j'en ai essayé plusieurs et j'ai choisi ceux dont les composantes diagonales ont commencé à émerger. En regardant le 0.6, il semble qu'il y ait une grande différence entre le bloc diagonal et les autres. Il semble également indiquer que «9» et «7» sont similaires. On peut voir que "2" a une corrélation particulièrement faible entre "2".

plt.clf()
plt.figure(figsize=(10, 10))
plt.xlim(0,area_size-1)
plt.ylim(0,area_size-1)
plt.title("Correlation matrix of digit charcter vector. (corr>0.5)")

thresh = .5 
Z1 = Z.copy()
Z1[Z1 > thresh] = 1
Z1[Z1 <= thresh] = 0

plt.pcolor(X, Y, Z1, cmap=cm.get_cmap('Blues'),alpha=0.6)
plt.xticks([(i * 20) for i in range(10)],range(10))
plt.yticks([(i * 20) for i in range(10)],range(10))
plt.grid(color='deeppink',linestyle='--')
plt.show()

Valeur moyenne par bloc

Enfin, montrons la valeur moyenne de chaque bloc dans un graphique 10x10.

summary_Z = np.zeros(100).reshape(10,10)

for i in range(10):
    for j in range(10):
        i1 = i * 20
        j1 = j * 20
        #print "[%d:%d,%d:%d]" % (i1,i1+20,j1,j1+20)
        if i==j:
            #Puisque la composante diagonale est fixée à 1, prenez la moyenne en l'excluant pour éviter que la valeur ne dépasse.
            summary_Z[i,j] = (np.sum(Z[i1:i1+20,j1:j1+20])-20)/380
        else:
            summary_Z[i,j] = np.sum(Z[i1:i1+20,j1:j1+20])/400

# average of each digit's grid
plt.clf()
plt.figure(figsize=(10, 10))
plt.xlim(0,10)
plt.ylim(0,10)

sX, sY = np.meshgrid(range(11),range(11))
plt.title("Correlation matrix of summuation of each digit's cell")
plt.xticks(range(10),range(10))
plt.yticks(range(10),range(10))
plt.pcolor(sX, sY, summary_Z, cmap=cm.get_cmap('Blues'),alpha=0.6)
plt.show()            

### pour la prochaine étape

Cette fois, j'ai essayé une analyse grossière dans le sens où les données d'image sont considérées comme un vecteur de 784 dimensions et la corrélation est prise telle quelle entre les vecteurs, mais comme les données d'image sont à l'origine bidimensionnelles, les pixels voisins tels que le haut, le bas, la gauche et la droite Je pense qu'il est possible d'exprimer une proximité plus plausible entre les images en considérant la proximité considérant la valeur. C'est encore avant l'apprentissage automatique à ce stade. Cependant, les composantes diagonales étaient correctement affichées. J'écrirai une chose un peu plus sérieuse comme prochaine étape dans Article suivant.