Comment utiliser NumPy pour créer rapidement les données dont nous avons besoin?

Que ce soit dans l'apprentissage fragmentaire habituel ou l'apprentissage de cours en ligne, réaliser ou parcourir un algorithme ou un modèle dans le code peut non seulement nous faire comprendre plus profondément, mais aussi renforcer notre mémoire. Par conséquent, il est nécessaire de passer du temps pour apprendre à créer et à organiser les données que nous voulons.

1. Tableau NumPy

Une chose à noter à propos des tableaux NumPy est qu'un tableau est une combinaison d'éléments du même type disposés dans un certain ordre .

2. Méthode de génération de tableau NumPy

Remarque
① Pour générer un tableau général, vous pouvez spécifier le type de données de l'élément de tableau NumPy via le paramètre dtype.
② Généralement, vous pouvez passer un nombre ou une forme en paramètre, ce dernier génère un tableau de taille forme

2.1 Générer un tableau général

• Générer un tableau unidimensionnel: liste entrante
• Générer un tableau de tuples: passer en tuples
• Générer un tableau multidimensionnel: passer dans une liste imbriquée

Code joint:

import numpy as np

arr1 = np.array([1,2,3,4,5])
print(arr1)

arr2 = np.array((1,2,3,4,5))
print(arr2)

arr3 = np.array([[1,2,3],[2,3,4],[4,5,6]])
print(arr3)  ## 这里注意 numpy 数组的打印规则：最内层轴的元素是从左至右，剩下的轴都是从上至下

[1 2 3 4 5]
[1 2 3 4 5]
[[1 2 3]
 [2 3 4]
 [4 5 6]]

2.2 Générer un tableau de type spécial

2.2.1 zéros 、 uns 、 œil

• Générer un tableau avec tous les 0 dans la forme spécifiée (passer un seul nombre ou une seule forme): np.zeros ()
• Génère un tableau de tous les 1 dans la forme spécifiée (passe en un seul nombre ou forme): np.ones ()
• Générer une matrice carrée (passer un seul nombre): np.eye ()

Remarque: passez la forme sous la forme d'un tuple avec des parenthèses

arr4 = np.zeros(3) # 传递单个数字是一维数组
print(arr4)

arr5 = np.ones((3, 3))  # 传递shape 是大小为 shape 的数组
print(arr5)

arr6 = np.eye(3)  # 方阵，至只能传递单个数字
print(arr6)

[0. 0. 0.]
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

2.2.2 Fonction de séquence arithmétique: fonction linspace ()

La fonction linspace () est utilisée pour générer des vecteurs d'espacement linéaire.
Linspace est similaire à l'opérateur deux-points ":", mais peut contrôler directement le nombre de points et toujours inclure les extrémités.
(Le "lin" dans le nom "linspace" indique de générer des valeurs d'espacement linéaire au lieu de la fonction sœur logspace, qui génère des valeurs d'espacement logarithmique.)

arr70 = np.linspace(1, 10, 6)
print(arr70) 

arr71 = np.linspace(1, 10)  # 默认 num=50
print(arr71)

[ 1.   2.8  4.6  6.4  8.2 10. ]
[ 1.          1.18367347  1.36734694  1.55102041  1.73469388  1.91836735
  2.10204082  2.28571429  2.46938776  2.65306122  2.83673469  3.02040816
  3.20408163  3.3877551   3.57142857  3.75510204  3.93877551  4.12244898
  4.30612245  4.48979592  4.67346939  4.85714286  5.04081633  5.2244898
  5.40816327  5.59183673  5.7755102   5.95918367  6.14285714  6.32653061
  6.51020408  6.69387755  6.87755102  7.06122449  7.24489796  7.42857143
  7.6122449   7.79591837  7.97959184  8.16326531  8.34693878  8.53061224
  8.71428571  8.89795918  9.08163265  9.26530612  9.44897959  9.63265306
  9.81632653 10.        ]

2.3 Générer un tableau aléatoire

2.3.1 Fonction arrange ()

organiser()

• Génère un tableau aléatoire unidimensionnel de la longueur spécifiée : np.arange (n)
  (en fait, la valeur par défaut start = 1, stop = n, step = 1)
• Génère un tableau aléatoire de longueur et de longueur d'étape spécifiées : arange ([start,] stop [, step,], dtype = None)

Code

arr7 = np.arange(10) # 其实就是默认的 start =1, stop =n, step=1
print(arr7)

arr8 = np.arange(1, 10, 2)
print(arr8)

[0 1 2 3 4 5 6 7 8 9]
[1 3 5 7 9]

2.3.2 module aléatoire

Utilisez le module aléatoire dans NumPy

• Générer un tableau aléatoire entre (0, 1) : np.random.random () (l'entrée est une forme sous la forme d'un tuple)
• Générer un tableau aléatoire entre (0, 1) : np.random.rand () (l'entrée est un nombre représentant la forme)
• Générer un tableau aléatoire qui satisfait la distribution normale : np.random.randn () (l'entrée est un nombre représentant la forme ou l'entrée est le nombre d'éléments)
• Générer un tableau d' entiers aléatoires : np.random.randint () (l'entrée est le nombre d'éléments ou définir la forme)
• Générer un tableau aléatoire après un ordre aléatoire: np.random.shuffle () (entrée tableau aléatoire x)
• Sélectionnez un tableau aléatoire parmi les tableaux connus : np.radom.choice () (saisir des nombres aléatoires)

rand () et randn ()

rand (d0, d1,…, dn)

randn (d0, d1,…, dn)

arr90 = np.random.rand(5)
print(arr90)   # 这里 n=5 是返回的元素的个数（因为已经默认元素取值为 0-1 之间）
arr91 = np.random.rand(4, 2)  # 这里的参数不需要加（）
print(arr91)

arr101 = np.random.randn(5)
print(arr101)  # 这里 n=5 是返回的元素的个数
arr102 = np.random.randn(2, 3)    # 这里的参数不需要加（）
print(arr102) 

[0.06005572 0.39201155 0.65739602 0.82993779 0.6834849 ]
[[0.22448704 0.46166822]
 [0.1313628  0.81239307]
 [0.82737089 0.08500505]
 [0.48441804 0.86254244]]
[ 0.31277617  2.11994118 -1.67146697 -0.9564838  -1.20713141]
[[ 0.81955507  1.5992909  -0.72949892]
 [-0.40706872 -1.80163208  0.37124959]]

rencontre ()

randint (faible, élevé = Aucun, taille = Aucun, dtype = 'l')

arr11 = np.random.randint(5)
print(arr11)  # 这里 n=5 相当于上限（并不是返回的元素个数），只返回了一个数字
arr12 = np.random.randint(1,5, (2, 3))  # 这里的shape参数需要加（），或者选择 size=(,)
print(arr12)
arr13 = np.random.randint(5, size=(2, 3))
print(arr13)

4
[[2 4 4]
 [2 1 3]]
[[3 2 3]
 [3 2 1]]

Remarque:
① Pour la méthode rand () et la méthode randn (),
si le paramètre d'entrée est un nombre n, n nombres aléatoires seront renvoyés;
si l'entrée est de deux nombres ou plus, un tableau de la taille de ces nombres multiples être retourné ；

② Pour la méthode randint (),
si le paramètre d'entrée est un nombre n, un nombre aléatoire ne dépassant pas n est renvoyé; si un seul nombre n et une forme sont saisis, n est la limite supérieure de l'élément (non prise), et shape
est la taille du tableau généré.

2.4 Changer la forme du tableau

Utilisez la fonction reshape ()

arr14 = np.arange(8).reshape(4,2)
print(arr14)
 
arr15 = np.random.rand(8).reshape(4,2)
print(arr15)

arr16 = np.random.randn(8).reshape(4,2)
print(arr16)

arr17 = np.random.randint(8,size=(2,4)).reshape(4,2)
print(arr17)

[[0 1]
 [2 3]
 [4 5]
 [6 7]]
[[0.74805737 0.4715235 ]
 [0.61835228 0.36544255]
 [0.19811176 0.37036763]
 [0.21455191 0.09242501]]
[[-0.4904222   0.40334254]
 [ 1.06279067  0.8108894 ]
 [-0.62594376  0.79288496]
 [ 1.12483527  0.66219263]]
[[7 4]
 [5 3]
 [1 2]
 [1 6]]

En fait, on peut voir d'après ce qui précède que la méthode d'utilisation de reshape () est très simple et plus pratique que de passer la forme aux paramètres de la fonction!

Une chose à noter: randint () doit d'abord utiliser le paramètre size pour générer un tableau multidimensionnel, puis utiliser reshape ().

[:, par exemple newaxis]

Une méthode courante dans l'apprentissage automatique consiste à utiliser [:, np.newaxis] pour convertir un tableau unidimensionnel en la forme de matrice de caractéristiques que nous voulons.

Remarque: np.newaxis ajoute un axe à numpy.ndarray

import numpy as np

rng = np.random.RandomState(42) 
x = 10* rng.rand(5)
print(x)
print(x.shape)

[3.74540119 9.50714306 7.31993942 5.98658484 1.5601864 ]
(5,)

Une façon consiste à utiliser la méthode reshape () mentionnée précédemment:

X = x.reshape(-1, 1)
print(X)
print(X.shape)

X = x.reshape(-1, 1)
print(X)
print(X.shape)

[[3.74540119]
 [9.50714306]
 [7.31993942]
 [5.98658484]
 [1.5601864 ]]
(5, 1)

Ensuite, il y a cette méthode courante:

X = x[:, np.newaxis]
print(X)
print(X.shape)

[[3.74540119]
 [9.50714306]
 [7.31993942]
 [5.98658484]
 [1.5601864 ]]
(5, 1)

3. Application

Générer des points dispersés (points aléatoires bidimensionnels) couvrant la zone rectangulaire spécifiée

• Module d'importation

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt 
import seaborn as sns; sns.set()

from sklearn.datasets import make_blobs

• Points aléatoires bidimensionnels (zone fixe)

rng = np.random.RandomState(0)
X_new = [-1, -1] + [5, 7] * rng.rand(2000, 2)

plt.scatter(X_new[:, 0], X_new[:, 1], s=10) 

X_new 的 shape ： （2000 ， 2）

Plage couverte par des points aléatoires: X_new Correspondance: coordonnées du coin inférieur gauche + valeur augmentée

• Visualisez les résultats