Comment construire une matrice de voisinage? Seule la connaissance théorique, la compréhension difficile approfondie de la question.
Dans cet article, nous avons un modèle à titre d'exemple:
\ Tilde {Y} = W \ cdot YY ~ = WY
Où W est une matrice, il peut être défini comme (par exemple):
w_ {ij} = 1wij = 1
Lorsque j dans le plus proche i K, Wij = 1, 0 sinon.
Ci-dessous, nous allons introduire les méthodes en utilisant numpy, scipy et la visualisation de matplotlib pour créer une matrice W en détail.
Pour parvenir à des fins de démonstration, nous avons créé un cube virtuel, la taille des échantillons de formation N = 12, M = 3 échantillons d'essai:
importer numpy comme np
XY_train = np.array (, , , , , , >)
XY_test = np.array (, , , >)
Le regard de déposons sur la distribution de ces points: le point rouge est les données de formation, tandis que Green Point est les données de test.
quartier à la recherche d'outils modernes sont très simples. Ici, nous avons choisi d'utiliser scipy, parce que les autres outils de ce paquet plus tard, mais sklearn ou d'autres paquets peuvent aussi faire le travail. Lors de l'utilisation scipy, d'abord créer un cKDTree en utilisant l'ensemble des données de formation:
de cKDTree d'importation scipy.spatial
arbre = cKDTree (XY_train)
L'arbre se trouve à nouveau:
K = 3
entraîner = tree.query (XY_test, k = K)
Trois ici, nous avons besoin d'échantillons d'essai des éléments de l'échantillon de formation le plus proche voisin. Par défaut, l'indice tree.query de retour et de la distance de corrélation de voisinage. Nous retiendrons les deux.
distances, indices = résultat
l'accent sur Let tableau indexé.
array (, , , >)
Numpy réseau est un index de tableau, comprenant M (nombre d'échantillons testés) rangées et K (le nombre de voisins) colonne. Alors, comment le convertir en une matrice nous en avons besoin? Les exemples sont les suivants:
Voir le quartier sélectionné dans une parcelle dans ce sera intéressant:
matplotlib.pyplot importation comme plt
n = 0 # premier élément dans l'ensemble de données de test
xy_test = XY_test
Index = indices
voisins = XY_train
plt.clf ()
plt.scatter (xy_test , xy_test , color = "red")
plt.scatter (voisins , voisins , color = "blue")
plt.xlabel ( "x")
plt.ylabel ( "y")
plt.xlim (-2, 2)
plt.ylim (-2, 2)
plt.show ()
Bon, alors le quartier et recherche semblait être aussi efficace que prévu! Faites-nous savoir comment convertir un index de tableau de matrice est entièrement disponible, notre objectif devrait être de:
111000000000
000111000000
000000111000
000000000111
Étant donné que le test a été observée 0 (la première ligne) est formé pour observer le voisinage de 0, 1 et 2, de sorte que le test a été observé une (deuxième rangée) dans le voisinage est la formation observée 3, 4 et 5, et ainsi de suite.
Tout d'abord, nous allons créer une telle matrice d'index à l'aide numpy:
importer numpy comme np
a = np.array ()
i =
un
# Array ()
Mais vous trouverez qu'il ne concerne pas les tableaux multidimensionnels.
Nous avons choisi la solution est d'utiliser la matrice clairsemée scipy, ce qui peut créer une liste d'index. Par exemple, pour créer une taille N = 4 dans la matrice diagonale utilisant une matrice creuse peut être exprimée:
de rares d'importation scipy
i_index =
j_index =
values =
matrice = sparse.coo_matrix ((valeurs, (i_index, j_index)), forme = (4, 4))
impression (matrice)
# (0, 0) 1
# (1, 1) 1
# (2, 2) 1
# (3, 3) 1
SciPy Ainsi l'obtention d'un premier élément de réseau i_index j_index et i et j, et le premier élément du tableau de valeurs dans la matrice finale Situation. Ou en d'autres termes, la valeur zéro est de 1 ...... autres éléments non spécifiés ailleurs la valeur de l'élément (0,0) est égal à 1, la valeur de l'élément (1,1).
Si vous préférez la représentation de tableau, vous pouvez saisir le code ci-dessous pour voir les résultats:
matrix.toarray () # transforme la matrice clairsemée dans un tableau numpy juste pour la visualisation
#array (,
# ,
# ,
# >)
Ici vous pouvez voir une matrice diagonale.
Prenons un exemple pour la seconde expliquer plus clairement tout. Maintenant, nous voulons créer est la matrice diagonale inverse:
array (, , , >)
Le code est le suivant:
i_index = # < == c'est le seul changement par rapport à l'exemple précédent!
j_index =
values =
matrice = sparse.coo_matrix ((valeurs, (i_index, j_index)), forme = (4, 4))
Note: Seulement lorsque la matrice est relativement faible pour passer à la représentation clairsemée de la représentation dense, sinon il y aura des problèmes de mémoire (raison de l'existence d'une matrice creuse!)
Pour matrice w, j_index (à savoir "colonne") correspondant à l'index adjacent:
j_index = indices.flatten ()
#ARRAY ()
Ensuite index de ligne i_index correspondant à l'indice de l'échantillon de test, mais requiert des temps répétés K pour correspondre à la j_index triée:
i_index = np.repeat (np.array (plage (M), DTYPE = int), les répétitions = K, axe = 0) .ravel ()
#ARRAY ()
Cela signifie que dans la première rangée (indice de ligne 0) de 0, 1 et 2 auront un indice. Dans la première colonne de la deuxième rangée 3,4,5 (1) il y a un index ...... Si vous regardez la position des échantillons de test / formation (premier chiffre) à nouveau, le résultat est le même!
Nous partons du principe que toute la valeur de « 1 »:
= valeurs np.ones (M * K) # M = nombre d'échantillons de test, K = nombre de voisins
Ou il représente une fonction en fonction de la distance, par exemple:
values = 1. / distances.flatten () ** 2
Enfin, notre matrice ressemble (une valeur de « 1 »):
matrice = sparse.coo_matrix ((valeurs, (i_index, j_index)), forme = (M, N))
# Array (,
# ,
# ,
# >)
Maintenant, nous pouvons calculer le produit scalaire (matrice clairsemée ou dense):
y_tilde = matrix.dot (y) # où y a la forme (N,)
Enfin, le problème est résolu, il!
