Utilisez Numpy

introduction

Décrit comment utiliser Numpy.

Données de base (ndarray)

La structure de données de base dans Numpy est ndarray. Représente un tableau à N dimensions.

Décrit comment créer un ndarray.

Méthode utilisant arange

>>> from numpy  import *

# range()Créez un tableau unidimensionnel avec la même sensation que.
>>> a = arange(10);a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

#Tableau bidimensionnel avec remodelage(2 lignes 5 colonnes)À
>>> a = arange(10).reshape(2,5);a
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])

#Matrice 3D(Deux matrices 3 par 4)
>>> a = arange(24).reshape(2,3,4);a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

Méthode utilisant un tableau

#Créez un tableau à une dimension. Spécifiez des données spécifiques.
>>> a = array([1,2,3]);a
array([1, 2, 3])

#Créez un tableau à deux dimensions.
>>> a = array([(1,2,3), (4,5,6)]);a
array([[1, 2, 3],
       [4, 5, 6]])

Méthode utilisant des zéros, des uns, des yeux, des vides

zeros crée un tableau avec tous les éléments nuls. ones crée un tableau avec les 1 éléments. eye crée un tableau avec 1 élément diagonal. empty crée un tableau non initialisé.

>>> a = zeros((2,3));a
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])

>>> a = ones((2,3));a
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

>>> a = eye(3,3);a
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

#La valeur de l'élément n'est pas définie car il n'est pas initialisé.
>>> a = empty((2,3));a
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])

Méthode utilisant linspace

Créez un tableau unidimensionnel en spécifiant la valeur de début, la valeur de fin et le nombre de données. Utile lors de la création de graphiques de fonctions.

>>> x = linspace(0, 2*pi, 10);x
array([ 0.        ,  0.6981317 ,  1.3962634 ,  2.0943951 ,  2.7925268 ,
        3.4906585 ,  4.1887902 ,  4.88692191,  5.58505361,  6.28318531])

>>> sin(x)
array([  0.00000000e+00,   6.42787610e-01,   9.84807753e-01,
         8.66025404e-01,   3.42020143e-01,  -3.42020143e-01,
        -8.66025404e-01,  -9.84807753e-01,  -6.42787610e-01,
        -2.44929360e-16])

Méthode utilisant aléatoire

Créez un tableau avec des nombres aléatoires uniformes et des nombres aléatoires normaux comme éléments.

# [0,1)Créez un nombre aléatoire uniforme pour.
>>> a = random.random(10);a
array([ 0.55089503,  0.45425945,  0.57639104,  0.65731385,  0.06515141,
        0.75809653,  0.98538432,  0.14194245,  0.81874444,  0.77024755])

#Valeur moyenne mu,Créez un nombre aléatoire normal avec un écart type de sigma.
>>> mu = 100; sigma=10
>>> a = random.normal(mu, sigma, 10).reshape(2,5);a
array([[  83.5821915 ,   82.34512541,  102.4633897 ,   72.53721859,
          96.21639407],
       [  91.54337302,   96.03740307,   82.04488924,  109.00803432,
         101.72208762]])

Calcul

Quatre règles

>>> a = random.random(6).reshape(2,3);a
array([[ 0.52638479,  0.39144147,  0.75575996],
       [ 0.1557081 ,  0.11812827,  0.84377568]])
>>> b = random.random(6).reshape(2,3);b
array([[ 0.28797541,  0.60331924,  0.81078013],
       [ 0.83825199,  0.41031302,  0.64098045]])
>>> a + b
array([[ 0.8143602 ,  0.9947607 ,  1.56654009],
       [ 0.9939601 ,  0.52844128,  1.48475613]])
>>> a - b
array([[ 0.23840938, -0.21187777, -0.05502018],
       [-0.68254389, -0.29218475,  0.20279523]])
>>> a * b
array([[ 0.15158588,  0.23616417,  0.61275516],
       [ 0.13052263,  0.04846957,  0.54084371]])
>>> a / b
array([[ 1.82788103,  0.64881317,  0.93213921],
       [ 0.18575334,  0.28789793,  1.31638287]])

queue

>>> a = random.random(6).reshape(2,3);a
array([[ 0.26511097,  0.7092039 ,  0.78596957],
       [ 0.52916934,  0.00993958,  0.30160079]])
>>> b = random.random(6).reshape(3,2);b
array([[ 0.68708518,  0.77809895],
       [ 0.32463964,  0.35987488],
       [ 0.13998871,  0.65494372]])

#Produit matriciel(dot)
>>> dot(a,b)
array([[ 0.52241638,  0.97627307],
       [ 0.4090319 ,  0.61285465]])

#Matrice de translocation(T)
>>> a.T
array([[ 0.26511097,  0.52916934],
       [ 0.7092039 ,  0.00993958],
       [ 0.78596957,  0.30160079]])

#Matrice inverse(linalg.inv)
>>> linalg.inv(dot(a,b))
array([[ -7.74182569,  12.33267281],
       [  5.16705495,  -6.59937322]])

#Formule matricielle(linalg.det)
>>> linalg.det(dot(a,b))
-0.079161515267537994

#valeur propre(w), Vecteur unique(v) linalg.eig
>>> w, v = linalg.eig(dot(a,b))
>>> w
array([-0.06590343,  1.20117446])
>>> v
array([[-0.85650205, -0.8210583 ],
       [ 0.51614363, -0.57084434]])

vecteur

>>> a = random.random(3);a
array([ 0.52541688,  0.12396039,  0.31534285])
>>> b = random.random(3);b
array([ 0.62372191,  0.00251833,  0.41029588])

#produit intérieur
>>> inner(a,b)
0.45741006789576372

#Produit extérieur(Produit croisé)
>>> cross(a,b)
array([ 0.0500663 , -0.01889014, -0.07599364])

#Produit direct
>>> outer(a,b)
array([[  3.27714024e-01,   1.32317300e-03,   2.15576381e-01],
       [  7.73168097e-02,   3.12173138e-04,   5.08604357e-02],
       [  1.96686245e-01,   7.94137296e-04,   1.29383871e-01]])

Opération logique

Détermine si les éléments du tableau répondent aux critères.

>>> a = random.random(9).reshape(3,3);a
array([[ 0.07562832,  0.37995414,  0.80141031],
       [ 0.31946711,  0.54688344,  0.27916878],
       [ 0.64425661,  0.50601982,  0.55279281]])

#Pour chaque élément un< 0.Juger 5.
>>> a < 0.5
array([[ True,  True, False],
       [ True, False,  True],
       [False, False, False]], dtype=bool)

#Élément par élément(0.2 < a) & (a < 0.4)Est jugé.
>>> (0.2 < a) & (a < 0.4)
array([[False,  True, False],
       [ True, False,  True],
       [False, False, False]], dtype=bool)

# any():Est au moins un vrai?
>>> a = [True,False]
>>> any(a)
True
>>> a = [False,False]
>>> any(a)
False

# all():Sont tous vrais?
>>> a = [True,False]
>>> all(a)
False
>>> a = [True,True]
>>> all(a)
True

Calcul statistique

>>> a = random.random(5);a
array([ 0.81006955,  0.54988884,  0.3000227 ,  0.68326733,  0.01710223])

#total
>>> a.sum()
2.3603506492918598
#moyenne
>>> a.mean()
0.47207012985837193
#maximum
>>> a.max()
0.81006955003900494
#le minimum
>>> a.min()
0.017102231221299058
#maximum-le minimum
>>> a.ptp()
0.79296731881770588
#Le diviseur de l'écart type est N
>>> a.std()
0.28337244927937266
#Le diviseur de l'écart type est N-1
>>> a.std(ddof=1)
0.31682002976226714
#Le diviseur distribué est N
>>> a.var()
0.080299945006851087
#Index du tableau de valeurs maximales
>>> a.argmax()
0
#Index du tableau de valeurs minimales
>>> a.argmin()
4
#Valeur cumulée
>>> a.cumsum()
array([ 0.81006955,  1.35995839,  1.65998109,  2.34324842,  2.36035065])

Effectue des calculs statistiques le long d'un axe pour un tableau à N dimensions. Il s'agit d'une image calculée en se déplaçant uniquement dans la direction de l'axe spécifié. L'axe est spécifié par l'axe des arguments.

#3 lignes 4 colonnes*Créez un tableau de 2.
>>> a = random.random(24).reshape(2,3,4);a
array([[[ 0.70106649,  0.84600927,  0.96988224,  0.06242455],
        [ 0.90827331,  0.65320237,  0.41143149,  0.73883318],
        [ 0.03434408,  0.40834032,  0.16037719,  0.66273333]],

       [[ 0.33596355,  0.77672752,  0.26468854,  0.83723116],
        [ 0.9966073 ,  0.29452339,  0.26186954,  0.33732824],
        [ 0.76577634,  0.20663298,  0.33442575,  0.3477926 ]]])

#J'expliquerai en utilisant la somme comme exemple, mais d'autres statistiques peuvent être calculées de la même manière.
# axis=Somme le long de 0.
>>> a.sum(axis=0)
array([[ 1.03703004,  1.62273679,  1.23457077,  0.89965571],
       [ 1.90488061,  0.94772576,  0.67330104,  1.07616143],
       [ 0.80012042,  0.6149733 ,  0.49480294,  1.01052593]])

# axis=Additionnez 1.
>>> a.sum(axis=1)
array([[ 1.64368387,  1.90755197,  1.54169092,  1.46399106],
       [ 2.09834719,  1.27788389,  0.86098384,  1.52235201]])

# axis=Additionnez 2.
>>> a.sum(axis=2)
array([[ 2.57938255,  2.71174035,  1.26579492],
       [ 2.21461077,  1.89032848,  1.65462767]])

Fichier

>>> a
array([[[ 0.69633633,  0.60467738,  0.46174455,  0.24528887],
        [ 0.03127559,  0.66646753,  0.93620592,  0.39435246],
        [ 0.59428005,  0.05191262,  0.94079899,  0.1217417 ]],

       [[ 0.6436789 ,  0.41509296,  0.38650686,  0.41877047],
        [ 0.87710361,  0.34266031,  0.58358085,  0.72265266],
        [ 0.57560748,  0.2277301 ,  0.12321634,  0.49292207]]])

#Enregistrez en tant que fichier binaire.
>>> a.tofile("test.dat")

#Lire à partir d'un fichier binaire. Les informations d'axe telles que les lignes et les colonnes ont disparu.
>>> fromfile("test.dat")
array([ 0.69633633,  0.60467738,  0.46174455,  0.24528887,  0.03127559,
        0.66646753,  0.93620592,  0.39435246,  0.59428005,  0.05191262,
        0.94079899,  0.1217417 ,  0.6436789 ,  0.41509296,  0.38650686,
        0.41877047,  0.87710361,  0.34266031,  0.58358085,  0.72265266,
        0.57560748,  0.2277301 ,  0.12321634,  0.49292207])

#Enregistrez au format npy.
>>> save("test", a)

#Les informations d'axe restent également.
>>> load("test.npy")
array([[[ 0.69633633,  0.60467738,  0.46174455,  0.24528887],
        [ 0.03127559,  0.66646753,  0.93620592,  0.39435246],
        [ 0.59428005,  0.05191262,  0.94079899,  0.1217417 ]],

       [[ 0.6436789 ,  0.41509296,  0.38650686,  0.41877047],
        [ 0.87710361,  0.34266031,  0.58358085,  0.72265266],
        [ 0.57560748,  0.2277301 ,  0.12321634,  0.49292207]]])

#Enregistrez au format npz.
>>> savez("test", a=a)

#Parcourez le tableau avec des mots-clés.
>>> npz = load("test.npz")
>>> npz["a"]
array([[[ 0.69633633,  0.60467738,  0.46174455,  0.24528887],
        [ 0.03127559,  0.66646753,  0.93620592,  0.39435246],
        [ 0.59428005,  0.05191262,  0.94079899,  0.1217417 ]],

       [[ 0.6436789 ,  0.41509296,  0.38650686,  0.41877047],
        [ 0.87710361,  0.34266031,  0.58358085,  0.72265266],
        [ 0.57560748,  0.2277301 ,  0.12321634,  0.49292207]]])

#Version compressée de Savez_Il est également compressé. Même usage que savez.

#Si vous ne le fermez pas, le fichier restera ouvert.
>>> npz.close()

>>> x = random.random(6).reshape(2,3);x
array([[ 0.56246598,  0.19331716,  0.2826291 ],
       [ 0.81149981,  0.32680372,  0.90326888]])

#Savetxt est utile pour les tableaux à 2 dimensions. C'est du texte donc c'est facile à lire.
>>> savetxt("x.txt", x, delimiter="\t")
>>> loadtxt("x.txt")
array([[ 0.56246598,  0.19331716,  0.2826291 ],
       [ 0.81149981,  0.32680372,  0.90326888]])

#Une erreur se produira s'il s'agit de 3D.
>>> savetxt("a.txt", a) #Une erreur se produira.

Recommended Posts

Utilisez Numpy
Utilisez OpenBLAS avec numpy, scipy
pratique numpy 1
Utilisez Numpy, Scipy, scikit-learn avec Heroku
numpy partie 1
Principes de base de NumPy
Mémorandum Numpy _ Matrice
Utilisez DeepLabCut
Utiliser pycscope
Utilisez des collections.
Utilisation: Django-MySQL
Utilisez Pygments.rb
Axe NumPy
Utilisez pandas-ply
numpy partie 2
Utilisez GitPython
Utiliser Miniconda
Utilisez Numpy, Scipy, scikit-learn sur Amazon Linux
Utilisez BLAS / LAPACK multi-thread avec numpy / scipy
Mon Numpy (Python)
Utiliser le TSC invariant
où de numpy
[C] Utilisez qsort ()
test unitaire numpy
Fonctionnement du tableau NumPy (3)
list et numpy
Fonction universelle NumPy
mémorandum numpy 1 / np.pad
Les bases de #Python (#Numpy 1/2)
Utiliser l'API JIRA
Utilisez des références faibles
Utiliser django-debug-toolbar de manière non locale
recherche d'index numpy
[Numpy] Shuffle ndarray
Utiliser l'optimisation des combinaisons
Principes de base de Python #Numpy
technique non basique de numpy
À propos de la diffusion Numpy
[PyTorch] Exemple ① ~ NUMPY ~
python: utilisez votre propre classe pour numpy ndarray
Installation de Numpy + Atlas
[Python] Mémo Numpy