Python est un langage :
C'est un langage dont l'usage est extrêmement répandu dans les milieux académique et industriel.
l = [10,11,12,13,14,15]
l[0]
l.append(16) # ajoute un élément en fin de liste
l.count(14) # compte le nombre d'élements (==14)
l[3:7] #slice entre 3 inclus et 7 exlus
s = 0
for i in l:
s = s + i # une tabulation (ou 4 espaces) à l'intérieur d'une boucle ou d'une fonctions
s
def my_function(x):
if x < 0:
z = 'negatif number'
else:
z = x*10
return z
my_function(-3)
import numpy as np # import la librairie numpy (calcul scientifique)
# Doc : http://docs.scipy.org/doc/numpy/reference/
a = np.arange(5,15)
print(a)
a[0]
a[(a%2==0)] # rend les termes paire
b = np.arange(0,1,0.1)
b
b[[2,3,4]] # rend les élements de positions 2,3 et 4
a + b # somme terme à terme
b * 3
A = np.array([[0,1,2],[3,4,5],[6,7,8]])
print(A)
I = np.eye(3,3)
I
Z = np.zeros((5,2))
O = np.ones((5,2))
R = np.random.rand(5,2)
(Z + 1) * 3
R * Z # produit terme à terme
v = np.array([0,1,10])
print('A =',A)
print('v =',v)
print('A.v =',np.dot(A,v)) #produit matriciel
import matplotlib.pyplot as plt # librairie pour afficher les graphs.
# Doc : http://matplotlib.org/gallery.html, http://matplotlib.org/api/pyplot_api.html
%matplotlib inline
# Affiche dans la fenêtre courante.
x = np.arange(-10,10,0.1)
y = np.cos(x)
plt.plot(x,y)
plt.title('cosinus')
plt.xlabel('abscisses')
plt.ylabel('ordonnées')
x = np.random.rand(100) * 10
y = np.random.rand(100) + 10
plt.scatter(x,y)
plt.scatter(np.mean(x),np.mean(y), c = 'red', s=100)
On rappelle que, pour $ x = (x_1,\ldots,x_n)$ et $y = (y_1,\ldots,y_n)$ dans
$\mathbb{R}^n$, on définit le produit scalaire de $x$ et $y$ par $
Écrire deux fonctions prenant en entrée deux vecteurs (list ou array) :
Tester le temps de calcul de chaque méthode ( %timeit my_function(x,y) )
On désire approximer $\frac{\pi}{4}$ par méthode de Monte-Carlo. Un point tiré uniformément dans $[0, 1] \times [0, 1]$ est dans le quart de disque vérifiant $x^2 + y^2 \leq 1$ avec probabilité $\frac{\pi}{4}$.
a) Écrire une fonction qui :
b) Afficher l'évolution de $\frac{n_1}{N}$ en fonction de $N$. (on peut utiliser la fonction np.linspace(start, end,step))
import sklearn # if not installed : pip install sklearn
X = [[0, 0], [1, 1]]
# X : n_samples x n_features - data
y = [0.0, 1.0]
# y : n_samples - labels
from sklearn import tree
#http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html
clf = tree.DecisionTreeClassifier() # clf : une instance de la classe 'DecisionTreeClassifier'
clf = clf.fit(X, y) # fit : s'entraine sur les données
clf.predict([[2., 2.]]) # predict : prédit le label d'une nouvelle donnée
clf.predict_proba([[0., 0.51]]) # predict_proba : doone la distribution de probabilité
clf.score(X,y) # évalue le score du classifier
# score = list(clf.predict(X) == y).count(True) / len(y)
clf.feature_importances_
# Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(5 * rng.rand(80, 1), axis=0)
y = np.sin(X).ravel()
y[::5] += 3 * (0.5 - rng.rand(16)) # ajout de bruit
from sklearn import tree
clf_1 = tree.DecisionTreeRegressor(max_depth=None)
clf_1.fit(X, y)
score_train = clf_1.score(X,y)
# Predict on test set
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_1 = clf_1.predict(X_test)
# Plot the results
plt.figure()
plt.scatter(X, y, c="k", label="data")
plt.plot(X_test, y_1, c="g", label="", linewidth=2)
plt.xlabel("data")
plt.ylabel("target")
plt.title("Decision Tree Regression. score train = " + str(np.round(score_train,2)) +\
" score test = " + 'not-implemented')
plt.legend()
plt.show()
a) Evaluer le score du modèle sur un jeu de donnée test :
b) Dans une boucle, faire varier le paramètre 'max_depth' et afficher les predictions
c) Afficher sur un même graphe l'évolution du score d'entrainement et du score de test
d) À l'aide d'un ensemble de validation, et sans utiliser l'ensemble de test, estimer la meilleur valeur pour 'max_depth'
# Make data
rng = np.random.RandomState(13)
d1 = np.asarray(((np.arange(10) + rng.rand(10),np.arange(10)+ rng.rand(10)))).T
d2 = np.asarray(((np.arange(3,13)+ rng.rand(10),np.arange(10)+ rng.rand(10)))).T
X = np.vstack((d1,d2))
y = [0] * d1.shape[0] + [1] * d2.shape[0]
plt.scatter(X[:,0],X[:,1], c = y, s = 50)
à l'aide de la fonction "plot_boundary" ci dessous et de la classe "tree.DecisionTreeClassifier", entrainer un classifieur sur les données et afficher les zones de prédictions.
# Ne pas s'attarder sur cette fonction pour le moment.
def plot_boundary(clf, X, y):
# Affiche la carte avec les zones de chaque catégorie
plt.figure()
plot_step = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),
np.arange(y_min, y_max, plot_step))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
cs = plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
plt.scatter(X[:,0],X[:,1], c = y)
plt.title('score = ' + str(clf.score(X,y)))
Générer des données ayant aux moins trois classes et entrainer un un arbre de décision dessus.