#Qu'est-ce que Numpy?
#Prise en charge de grands tableaux et matrices multidimensionnels,
#Il fournit une grande bibliothèque de haut niveau de fonctions mathématiques pour les manipuler.
http://rest-term.com/archives/2999/
http://wbhappy.hatenablog.jp/entry/2015/02/06/210000
# ndarray.flags Informations sur la disposition de la mémoire pour les données du tableau
# ndarray.Nombre de dimensions du tableau ndim
# ndarray.nombre d'éléments dans le tableau de taille
# ndarray.forme Nombre d'éléments dans chaque dimension
# ndarray.itemsize Nombre d'octets par élément
# ndarray.foulées Nombre d'octets requis pour passer à l'élément suivant dans chaque dimension
# ndarray.nbytes Nombre d'octets dans le tableau entier
# ndarray.type de données d'élément de tableau dtype(numpy.dtype)
>>> import numpy as np
>>> np.version.full_version
'1.8.0rc1'
>>> a = np.array([0,1,2,3,4,5])
>>> a
array([0, 1, 2, 3, 4, 5])
>>> a.ndim
1
>>> a.shape
(6,)
>>> b = a.reshape((3,2))
>>> b
array([[0, 1],
[2, 3],
[4, 5]])
>>> b.ndim
2
>>> b.shape
(3, 2)
>>> b[1][0] = 77
>>> b
array([[ 0, 1],
[77, 3],
[ 4, 5]])
>>> a
array([ 0, 1, 77, 3, 4, 5])
>>> c = a.reshape((3,2)).copy()
>>> c
array([[ 0, 1],
[77, 3],
[ 4, 5]])
>>> c[0][0] = -99
>>> a
array([ 0, 1, 77, 3, 4, 5])
>>> c
array([[-99, 1],
[ 77, 3],
[ 4, 5]])
>>> a*2
array([ 0, 2, 154, 6, 8, 10])
>>> a**2
array([ 0, 1, 5929, 9, 16, 25])
>>> a[np.array([2,3,4])]
array([77, 3, 4])
>>> a>4
array([False, False, True, False, False, True], dtype=bool)
>>> a[a>4]
array([77, 5])
>>> a[a>4]=4
>>> a
array([0, 1, 4, 3, 4, 4])
>>> a.clip(0,4)
array([0, 1, 4, 3, 4, 4])
>>> c = np.array([1,2,np.NAN, 3,4]) #En supposant une lecture à partir d'un fichier texte
>>> c
array([ 1., 2., nan, 3., 4.])
>>> np.isnan(c) #Remplacer les valeurs manquantes
array([False, False, True, False, False], dtype=bool)
>>> c[~np.isnan(c)]
array([ 1., 2., 3., 4.])
>>> np.mean(c[~np.isnan(c)])
2.5
>>> import timeit
>>> normal_py_sec = timeit.timeit('sum(x*x for x in xrange(1000))',number=10000)
>>> Naive_np_sec = timeit.timeit('sum(na*na)',setup="import numpy as np; na=np.arange(1000)", number=10000)
>>> good_np_sec = timeit.timeit('na.dot(na)',setup="import numpy as np; na=np.arange(1000)", number=10000)
>>> print("Normal Python: %f sec"%normal_py_sec)
Normal Python: 0.836571 sec
>>> print("Naive Numpy: %f sec"%Naive_np_sec)
Naive Numpy: 4.806356 sec
>>> print("Good Numpy: %f sec"%good_np_sec)
Good Numpy: 0.039245 sec
>>> a = np.array([1,2,3])
>>> a.dtype
dtype('int64')
>>> np.array([1, "stringry"])
array(['1', 'stringry'],
dtype='|S8')
>>> np.array([1, "stringy", set([1,2,3])])
array([1, 'stringy', set([1, 2, 3])], dtype=object)
# http://rest-term.com/archives/2999/Que
>>> import numpy as np
>>> a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]]) #Génération de séquence
>>> a
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
>>> a.flags #Informations sur la disposition de la mémoire pour les données de la baie
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
>>> a.ndim #Nombre de dimensions
2
>>> a.size #Nombre d'éléments
12
>>> a.shape #Nombre d'éléments dans chaque dimension(Nombre de lignes,Le nombre de colonnes)
(4, 3)
>>> a.itemsize #Nombre d'octets par élément
8
>>> a.strides #24 octets pour la ligne suivante, 8 octets pour la colonne suivante
(24, 8)
>>> a.nbytes #Nombre d'octets dans le tableau entier
96
>>> a.dtype #Type de données d'élément
dtype('int64')
>>> np.zeros(5)
array([ 0., 0., 0., 0., 0.])
>>> np.ones(5)
array([ 1., 1., 1., 1., 1.])
>>> np.ones([2,3])
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
>>> np.identity(3) #Matrice unitaire
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> np.eye(3) #Matrice d'unité pouvant spécifier le nombre de colonnes
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> np.arange(10) # range()Pareil que
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.araange(1,2,0.2) #point de départ,point final,incrémentale
array([ 1. , 1.2, 1.4, 1.6, 1.8])
>>> np.linspace(1,4,6) #Plage pouvant spécifier le nombre d'éléments()
array([ 1. , 1.6, 2.2, 2.8, 3.4, 4. ])
>>> np.logspace(2,3,4) #Journal
array([ 100. , 215.443469 , 464.15888336, 1000. ])
>>> np.logspace(2,4,4, base=2) #Bas 2
array([ 4. , 6.34960421, 10.0793684 , 16. ])
>>> np.tile([0,1,2,3,4], 2) #Renvoie un tableau d'éléments générés et répétés
array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
>>> a,b = np.meshgrid([1,2,3],[4,5,6,7]) #Un arrangement en forme de grille qui est régulièrement espacé verticalement et horizontalement
>>> a
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
>>> b
array([[4, 4, 4],
[5, 5, 5],
[6, 6, 6],
[7, 7, 7]])
>>> np.tri(3) #Matrice triangulaire
array([[ 1., 0., 0.],
[ 1., 1., 0.],
[ 1., 1., 1.]])
>>> a = np.array([[0,1,2],[3,4,5],[6,7,8]])
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> np.diag(a) #Un tableau d'éléments diagonaux extraits du tableau d'entrée
array([0, 4, 8])
>>> np.empty(5) #Il n'est pas initialisé uniquement en sécurisant la zone
array([ 0.00000000e+000, 4.94065646e-324, 9.88131292e-324,
1.48219694e-323, 1.97626258e-323])
>>> a = np.array([1,2,3])
>>> b = a.copy()
>>> b
array([1, 2, 3])
>>> np.random.randint(0,100,10) #Plage de nombres aléatoires à générer(valeur minimum,Valeur maximum,Nombre d'éléments)Spécifier
array([67, 65, 61, 15, 48, 57, 42, 21, 49, 57])
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a = np.arange(10)
>>> b = a.reshape((2,5)) #Changement de forme du tableau(Dans ce cas à un tableau à deux dimensions)
>>> b
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> a.resize((2,5)) #Passer à un tableau à deux dimensions avec le même nombre d'éléments
>>> a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> a = np.tile(np.arange(3),3) # range(3)Grille à 3 rangées
>>> a
array([0, 1, 2, 0, 1, 2, 0, 1, 2])
>>> np.argmax(a) #Le plus petit index des éléments de valeur maximale
2
>>> np.argmin(a) #Le plus petit indice de l'élément minimum
0
>>> a = np.eye(3) #3 tableaux
>>> a
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> np.nonzero(a) #Renvoie un tableau d'index d'éléments non nuls(Dans ce cas, il s'agit d'un tableau à deux dimensions, donc deux)
(array([0, 1, 2]), array([0, 1, 2]))
>>> a = np.arange(15).reshape((3,5))
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> np.where(a%2==0) #Tableau d'index des éléments qui correspondent aux conditions
(array([0, 0, 0, 1, 1, 2, 2, 2]), array([0, 2, 4, 1, 3, 0, 2, 4]))
>>> a = np.arange(10)
>>> np.select([a<3, a>5],[a, a**2]) #Premier argument de recherche de conditions multiples:Tableau de conditions Deuxième argument:Un tableau de valeurs à définir dans l'index de l'élément qui correspond à la condition
array([ 0, 1, 2, 0, 0, 0, 36, 49, 64, 81])
>>> a = np.arange(9).reshape((3,3))
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> b = np.arange(8,-1,-1).reshape((3,3))
>>> b
array([[8, 7, 6],
[5, 4, 3],
[2, 1, 0]])
>>> np.dstack((a,b)) #Combinez des tableaux bidimensionnels en un tableau tridimensionnel
array([[[0, 8],
[1, 7],
[2, 6]],
[[3, 5],
[4, 4],
[5, 3]],
[[6, 2],
[7, 1],
[8, 0]]])
>>> np.hstack((a,b)) #Joindre dans le sens de la colonne
array([[0, 1, 2, 8, 7, 6],
[3, 4, 5, 5, 4, 3],
[6, 7, 8, 2, 1, 0]])
>>> np.vstack((a,b)) #Rejoindre dans le sens de la ligne
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[8, 7, 6],
[5, 4, 3],
[2, 1, 0]])
>>> a = np.arange(16).reshape(2,2,4)
>>> a
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
>>> np.dsplit(a,2) #Diviser un tableau en trois dimensions
[array([[[ 0, 1],
[ 4, 5]],
[[ 8, 9],
[12, 13]]]), array([[[ 2, 3],
[ 6, 7]],
[[10, 11],
[14, 15]]])]
>>> a = np.arange(16).reshape(4,4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> np.hsplit(a,2) #Fractionner dans la direction de la colonne
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
>>> np.vsplit(a,2) #Fractionner dans le sens de la ligne
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
>>> a = np.array([[1,2],[3,4]])
>>> a
array([[1, 2],
[3, 4]])
>>> np.transpose(a) #Séquence transversale
array([[1, 3],
[2, 4]])
>>> a = np.array([[1,2,3]])
>>> np.swapaxes(a,0,1) #Remplacement de l'arbre
array([[1],
[2],
[3]])
>>> a = np.random.randint(0,500,20)
>>> a
array([444, 97, 324, 492, 275, 95, 157, 336, 51, 249, 363, 409, 299,
432, 41, 469, 201, 308, 85, 455])
>>> np.amax(a) #Valeur maximum
492
>>> np.amin(a) #valeur minimum
41
>>> np.ptp(a) #Gamme de valeurs(Valeur maximum-valeur minimum)
451
>>> np.mean(a) #Moyenne arithmétique
279.10000000000002
>>> np.median(a) #Médian
303.5
>>> np.std(a) #écart-type
146.4031761950539
>>> np.var(a) #Distribué
21433.889999999999
>>> b = np.random.randint(0,500,20)
>>> b
array([375, 207, 495, 320, 472, 481, 491, 133, 279, 480, 232, 261, 492,
183, 168, 424, 95, 236, 176, 332])
>>> np.corrcoef(a,b) #Coefficient de corrélation
array([[ 1. , 0.12452095],
[ 0.12452095, 1. ]])
>>> c = np.random.randint(0,10,20)
>>> c
array([6, 5, 9, 7, 9, 6, 4, 0, 1, 4, 6, 3, 2, 7, 9, 3, 4, 9, 4, 8])
>>> np.histogram(c) #histogramme
(array([1, 1, 1, 2, 4, 1, 3, 2, 1, 4]), array([ 0. , 0.9, 1.8, 2.7, 3.6, 4.5, 5.4, 6.3, 7.2, 8.1, 9. ]))
#Qu'est-ce que SciPy?
#Fournit de nombreux algorithmes
# cluster :Classification hiérarchique/Quantification vectorielle/Méthode de la moyenne K
# constants :Constante mathématique physique
# fftpack :Définition de Fourier
# integrate :L'intégration
# interpolate :interpolation(linéaire,Cubique etc.)
# io :Entrée / sortie de données
# linalg :Routine d'algèbre linéaire avec les bibliothèques BLAS et LAPACK
# maxentropy :Distribution d'entropie
# ndimage :paquet d'images en n dimensions
# odr :Régression de distance orthogonale
# optimize :optimisation
# signal :Traitement de signal
# sparse :Matrice clairsemée
# spatial :Structure des données spatiales et algorithmes
# special :Fonctions spéciales telles que la fonction Vessel et Yakko Bian
# stats :statistiques
>>> import scipy, numpy
>>> scipy.version.full_version
'0.13.0b1'
>>> scipy.dot is numpy.dot
True #Même espace de noms que Numpy
>>> data = sp.genfromtxt("sample/ch01/data/web_traffic.tsv", delimiter='\t')
>>> print(data.shape)
(743, 2)
>>> print(data[:10])
>>> import scipy as sp
>>> data = sp.genfromtxt("./sample/ch01/data/web_traffic.tsv", delimiter="\t") #Lecture des données
>>> print(data[:10])
[ 2.00000000e+00 1.65600000e+03]
[ 3.00000000e+00 1.38600000e+03]
[ 4.00000000e+00 1.36500000e+03]
[ 5.00000000e+00 1.48800000e+03]
[ 6.00000000e+00 1.33700000e+03]
[ 7.00000000e+00 1.88300000e+03]
[ 8.00000000e+00 2.28300000e+03]
[ 9.00000000e+00 1.33500000e+03]
[ 1.00000000e+01 1.02500000e+03]]
>>> print(data.shape)
(743, 2)
>>> x = data[:,0] #temps écoulé(SciPy:Extraire la 0ème dimension)
>>> y = data[:,1] #Nombre d'accès
>>> sp.sum(sp.isnan(y)) #Valeur inappropriée
0
>>> x = x[~sp.isnan(y)] #Débarrassez-vous des valeurs inappropriées
>>> y = y[~sp.isnan(y)] #Débarrassez-vous des valeurs inappropriées
>>> import matplotlib.pyplot as plt #Nuage de points
>>> plt.scatter(x,y)
<matplotlib.collections.PathCollection object at 0x11192e5d0>
>>> plt.title("Web traffic over the last month")
<matplotlib.text.Text object at 0x1118f7c90>
>>> plt.xlabel("Time")
<matplotlib.text.Text object at 0x111636090>
>>> plt.ylabel("Hits/hour")
<matplotlib.text.Text object at 0x111649fd0>
>>> plt.xticks([w*7*24 for w in range(10)], ['week %i' %w for w in range(10)])
([<matplotlib.axis.XTick object at 0x10e349710>, <matplotlib.axis.XTick object at 0x111653450>, <matplotlib.axis.XTick object at 0x11192edd0>, <matplotlib.axis.XTick object at 0x1119514d0>, <matplotlib.axis.XTick object at 0x111951c10>, <matplotlib.axis.XTick object at 0x113505390>, <matplotlib.axis.XTick object at 0x113505ad0>, <matplotlib.axis.XTick object at 0x11350e250>, <matplotlib.axis.XTick object at 0x11350e990>, <matplotlib.axis.XTick object at 0x11351a110>], <a list of 10 Text xticklabel objects>)
>>> plt.autoscale(tight=True)
>>> plt.grid()
>>> plt.show()
#Courbe d'ajustement
# polyfit(x,y,n) :Fonctions utilisées pour l'analyse de régression(Analyse de régression à deux variables avec équation d'ordre n)
#analyse de régression...Une méthode pour obtenir une formule de prédiction (ligne de régression) pour prédire les valeurs futures à partir de l'une des deux variables dont on pense qu'elles ont une corrélation ou une relation causale.
>>> def error(f, x, y): #Erreur en supposant que la fonction de modèle f existe
... return sp.sum((f(x)-y)**2)
>>> fp1, residuals, rank, sv, rcond = sp.polyfit(x, y, 1, full=True) #x avec polyfit,Obtenez le coefficient du modèle qui se rapproche de y au moindre carré
>>> print("Model parameters: %s" % fp1)
Model parameters: [ 2.57152281 1002.10684085]
>>> print(residuals) #Surplus
[ 3.19874315e+08]
>>> print(rank) #Classement de la matrice
2
>>> print(rcond) #L'inverse du nombre de conditions
1.64979141459e-13
référence: http://ktadaki.hatenablog.com/entry/2015/10/29/155340
Je mets des valeurs dans 5 variables, mais je n'utilise que le premier fp1. Le contenu de fp1 ressemble à ceci.
[ 2.59619213 989.02487106]
En d'autres termes, j'ai cette formule.
f(x)=2.59619213x+989.02487106
>>> f1 = sp.poly1d(fp1) #Créer une fonction de modèle
>>> print(error(f1,x,y))
319874314.777
>>> import matplotlib.pyplot as plt #Nuage de points
>>> plt.scatter(x,y)
<matplotlib.collections.PathCollection object at 0x11192e5d0>
>>> plt.title("Web traffic over the last month")
<matplotlib.text.Text object at 0x1118f7c90>
>>> plt.xlabel("Time")
<matplotlib.text.Text object at 0x111636090>
>>> plt.ylabel("Hits/hour")
<matplotlib.text.Text object at 0x111649fd0>
>>> plt.xticks([w*7*24 for w in range(10)], ['week %i' %w for w in range(10)]) #Réécrivez l'échelle de l'axe x. Dans l'argument, spécifiez «où» et «quoi» à afficher dans une liste.
([<matplotlib.axis.XTick object at 0x10e349710>, <matplotlib.axis.XTick object at 0x111653450>, <matplotlib.axis.XTick object at 0x11192edd0>, <matplotlib.axis.XTick object at 0x1119514d0>, <matplotlib.axis.XTick object at 0x111951c10>, <matplotlib.axis.XTick object at 0x113505390>, <matplotlib.axis.XTick object at 0x113505ad0>, <matplotlib.axis.XTick object at 0x11350e250>, <matplotlib.axis.XTick object at 0x11350e990>, <matplotlib.axis.XTick object at 0x11351a110>], <a list of 10 Text xticklabel objects>)
>>> plt.autoscale(tight=True)
<matplotlib.legend.Legend object at 0x10c587ad0>
>>> fx = sp.linspace(0, x[-1], 1000) #Pour le traçage"valeur x"Générer un
>>> plt.plot(fx, f1(fx), linewidth=4) #Dessinez la liste sous forme de graphique
[<matplotlib.lines.Line2D object at 0x10c587850>]
>>> plt.legend(["d=%i" % f1.order], loc="upper left") #Afficher la légende
>>> plt.grid()
>>> plt.show()
>>> f2p = sp.polyfit(x, y, 2)
>>> print(f2p)
[ 1.04688184e-02 -5.21727812e+00 1.96921629e+03]
>>> f2 = sp.poly1d(f2p)
>>> print(error(f2, x, y))
182006476.432
# f(x) = 0.0105322215 * x**2 - 5.26545650 * x + 1974.76802
>>> plt.plot(fx, f2(fx), linewidth=4)
#↑ Incorporer dans le précédent
#Courbe plus précise, mais fonction complexe
#Commande-3,10,Essayé à 100 ans → Superapprentissage
#Je l'ai essayé avec l'ordre 1 → désappris
#3 sur la première ligne droite.Apprendre avec des données datant de plus de 5 semaines,La deuxième ligne droite utilise les données après cela
>>> inflection = 3.5*7*24 #Calculer l'heure du point de changement
>>> xa = x[:inflection] #Point de données avant le point de changement
>>> ya = y[:inflection]
>>> xb = x[:inflection] #Après le point de changement
>>> yb = y[:inflection]
>>> fa = sp.poly1d(sp.polyfit(xa, ya, 1))
>>> fb = sp.poly1d(sp.polyfit(xb, yb, 1))
>>> fa_error = error(fa, xa, ya)
>>> fb_error = error(fb, xb, yb)
>>> print("Error inflection=%f" % (fa_error + fb_error))
Error inflection=218985429.871767
# plt.plot(fx, fa(fx), linewidth=4)
# plt.plot(fx, fb(fx), linewidth=4)Affichez la figure de la même manière
#Calculer l'erreur à l'aide des données de test pour le modèle formé à l'aide des données après le point de changement
>>> frac = 0.3 #Répartition des données utilisées pour le test
>>> split_idx = int(frac * len(xb))
>>> shuffled = sp.random.permutation(list(range(len(xb)))) #30 de toutes les données%Sélectionnez au hasard
>>> test = sorted(shuffled[:split_idx]) #Tableau d'index des données de test
>>> train = sorted(shuffled[split_idx:]) #Tableau d'index de données pour l'entraînement
>>> #Entraînez-vous en utilisant chaque donnée d'entraînement
>>> fbt1 = sp.poly1d(sp.polyfit(xb[train], yb[train], 1))
>>> fbt2 = sp.poly1d(sp.polyfit(xb[train], yb[train], 2))
>>> fbt3 = sp.poly1d(sp.polyfit(xb[train], yb[train], 3))
>>> fbt10 = sp.poly1d(sp.polyfit(xb[train], yb[train], 10))
>>> fbt100 = sp.poly1d(sp.polyfit(xb[train], yb[train], 100))
/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/numpy/lib/polynomial.py:579: RuntimeWarning: overflow encountered in multiply
scale = NX.sqrt((lhs*lhs).sum(axis=0))
/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/numpy/lib/polynomial.py:587: RankWarning: Polyfit may be poorly conditioned
warnings.warn(msg, RankWarning)
>>> #Évaluer à l'aide de chaque donnée d'entraînement
>>> for f in [fbt1, fbt2, fbt3, fbt10, fbt100]:
... print("Error d=%i: %f" % (f.order, error(f, xb[test], yb[test])))
...
Error d=1: 33618254.181783
Error d=2: 31298428.161162
Error d=3: 30849423.817712
Error d=10: 28969336.428648
Error d=55: 28919778.656526
#100 requêtes par heure,Devrait dépasser 000-Trouvez la solution de l'équation quadratique
#100 de polypoly,Soustrayez 000 pour créer un nouveau polypoly et trouver la racine de ce nouveau polypoly
>>> print(fbt2)
2
0.004136 x - 1.662 x + 1677
>>> print(fbt2-100000)
2
0.004136 x - 1.662 x - 9.832e+04
>>> from scipy.optimize import fsolve
>>> reached_max = fsolve(fbt2-100000, 800)/(7*24)
>>> print("100,000 hits/hour expected at week %f" % reached_max[0])
100,000 hits/hour expected at week 30.241873
#Chapitre 2 P27
#Classification/Apprendre avec un enseignant
#Ensemble de données Iris
#Très petite quantité
#Triangle:Setosa Maru:Punition Versucikir:Virginica
>>> from matplotlib import pyplot as plt
>>> from sklearn.datasets import load_iris
>>> import numpy as np
>>> data = load_iris() #charger de sklearn_Charger des données à l'aide de la fonction iris
>>> features = data['data']
>>> feature_names = data['feature_names']
>>> target = data['target']
>>> target_names = data['target_names']
>>> labels = target_names[target] # ?
>>> for t,marker,c in zip(range(3), ">ox","rgb"):
... plt.scatter(features[target == t,0],
... features[target == t,1],
... marker = marker,
... c = c) #Tracer avec des marqueurs de différentes couleurs pour chaque classe
...
<matplotlib.collections.PathCollection object at 0x10a5ec668>
<matplotlib.collections.PathCollection object at 0x10a287208>
<matplotlib.collections.PathCollection object at 0x10a5fa908>
#La "longueur de pétale" est stockée en troisième position dans le tableau.
>>> plength = features[:, 2]
>>> is_setosa = (labels == 'setosa') #Générer un tableau booléen indiquant si setosa ou non
>>> max_setosa = plength[is_setosa].max()
>>> min_non_setosa = plength[~is_setosa].min()
>>> print('Maximum of setosa: {0}.'.format(max_setosa))
Maximum of setosa: 1.9. #Longueur maximale des pétales->1.9
>>> print('Minimum of others: {0}.'.format(min_non_setosa))
Minimum of others: 3.0. #Longueur minimale des pétales->3.0
>>> def apply_model( example ):
... if example[2] < 2:
... print("Iris Setosa")
... else:
... print("Iris Virginica or Itis Versicolor")
#Faites la différence avec les autres iris de la meilleure façon possible
>>> features = features[~is_setosa]
>>> labels = labels[~is_setosa]
>>> virginica = (labels == 'virginica')
>>> best_acc = -1.0
>>> best_fi = -1.0
>>> best_t = -1.0
>>> for fi in range(features.shape[1]): #Générer des candidats de seuil pour chaque très petit montant
... thresh = features[:,fi].copy()
... thresh.sort()
... for t in thresh: #Test à tous les seuils
... pred = (features[:,fi] > t)
... acc = (labels[pred] == 'virginica').mean()
... if acc > best_acc:
... best_acc = acc
... best_fi = fi
... best_t = t
>>> def apply_model( example ):
... if(example[best_fi] > best_t):
... print("virginica")
... else:
... print("virsicolor")
# heldout.Démarrer py
# python3 ./sample/ch02/heldout.py
>>> from threshold import learn_model, apply_model, accuracy
>>> for ei in range(len(features)): #Toutes les données sauf ei th seront utilisées
... training = np.ones(len(features), bool)
... training[ei] = False
... testing = ~training
... model = learn_model(features[training], virginica[training])
... predictions = apply_model(features[testing], virginica[testing], model)
... error += np.sum(predictions != virginica[testing])
Recommended Posts