Rappels : NumPy, scikit-learn, Matplotlib

Année: 2026-2027

Ce notebook n’est pas à rendre. Il rappelle les bibliothèques utilisées dans les TP et le projet.

Installation des paquets¶

Installez d’abord les paquets numpy, scikit-learn et matplotlib

!pip install numpy scikit-learn matplotlib

Nombres complexes¶

Un nombre complexe $z$ s’écrit $z = x + j* y$ , où $x$ et $y$ sont des nombres réels.

c1 = complex(0, 0)

print(c1)

x = 2
y = 3
c2 = complex(x, y)

print(c2)

Module¶

Le module d’un nombre complexe $z = x + j* y$ est donné par la formule $\sqrt {(x^2 + y^2)}$

from math import sqrt

absc2 = sqrt(x**2 + y**2)
print(absc2)

On peut aussi utiliser la fonction $abs()$ .

absc2 = abs(c2)
print(absc2)

absc1 = abs(c1)
print(absc1)

Nombres régulièrement espacés¶

import numpy as np

np.linspace(1.0, 5.0, num=5)

import numpy as np

np.linspace(1.0, 5.0, num=10)

Moyennes¶

Moyenne arithmétique¶

Si $a_1, a_2, \ldots, a_n$ sont des nombres, la moyenne arithmétique est :

A=\frac{1}{n}\sum_{i=1}^n a_i=\frac{a_1+a_2+\cdots+a_n}{n}

(1)

num = np.linspace(1.0, 100.0, num=100)

a = np.mean(num)
print(a)

Moyenne géométrique¶

from scipy.stats import gmean

g = gmean(num)
print(g)

Si $a_1, a_2, \ldots, a_n$ sont des nombres, la moyenne géométrique est :

\left(\prod_{i=1}^n a_i\right)^\frac{1}{n} = \sqrt[n]{a_1 a_2 \cdots a_n}

(2)

Si $a_1, a_2, \ldots, a_n$ sont des nombres, la moyenne harmonique est :

H = \frac{n}{\frac1{a_1} + \frac1{a_2} + \cdots + \frac1{a_n}} = \frac{n}{\sum\limits_{i=1}^n \frac1{a_i}} = \left(\frac{\sum\limits_{i=1}^n a_i^{-1}}{n}\right)^{-1}.

(3)

Moyenne harmonique¶

from scipy.stats import hmean

h = hmean(num)
print(h)

Classification¶

Comprendre le jeu de données IRIS¶

from sklearn.datasets import load_iris

data = load_iris()

# Target Classes and Names
for target, name in enumerate(data.target_names):
    print(target, name)

# Features
for feature in data.feature_names:
    print(feature)

X = data.data
Y = data.target

print(f"Data size: {len(X)}")

# Printing the data

for x, y in zip(X, Y):
    print(f" {x}: {y} ({data.target_names[y]})")

from sklearn.model_selection import train_test_split

# Random state ensures reproducibility
X_train, X_test, Y_train, Y_test = train_test_split(
    X, Y, test_size=0.33, random_state=42
)

print(f"Training data size: {len(X_train)}")
print(f"Test data size: {len(X_test)}")

from sklearn.metrics import ConfusionMatrixDisplay
import matplotlib.pyplot as plot


def display_confusion_matrix(classifier, title):
    disp = ConfusionMatrixDisplay.from_estimator(
        classifier,
        X_test,
        Y_test,
        display_labels=data.target_names,
        cmap=plot.cm.Blues,
        normalize="true",
    )
    disp.ax_.set_title(title)
    plot.show()

## Classifier
from sklearn import svm, metrics

for kernel in ["linear", "rbf", "poly"]:
    print("")
    classifier = svm.SVC(kernel=kernel, gamma=10)
    classifier.fit(X_train, Y_train)

    predicted_values = classifier.predict(X_test.reshape((X_test.shape[0], -1)))

    # classification report
    title = "SVM classifier with" + kernel + " kernel"
    print(metrics.classification_report(Y_test, predicted_values))
    display_confusion_matrix(classifier, title)

Importation des paquets¶

Nous importons les paquets nécessaires

import numpy as np
from sklearn.linear_model import Perceptron
from sklearn import datasets, metrics
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plot
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

Chargement du jeu de données¶

Nous chargeons le jeu de données IRIS.

iris = datasets.load_iris()

Description du jeu de données¶

Caractéristiques d’entrée¶

iris.feature_names

Variable cible¶

iris.target_names

Vérification du nombre d’enregistrements¶

print(f"Number of Input Records: {len(iris.data)}")
print(f"Number of Target Records: {len(iris.target)}")

Visualisation du jeu de données¶

x = iris.data
y = iris.target

plot.scatter(x[:, 0], x[:, 1], c=y, cmap=plot.cm.Set1, edgecolor="k")
plot.xlabel(iris.feature_names[0])
plot.ylabel(iris.feature_names[1])
plot.show()

plot.scatter(x[:, 2], x[:, 3], c=y, cmap=plot.cm.Set1, edgecolor="k")
plot.xlabel(iris.feature_names[2])
plot.ylabel(iris.feature_names[3])
plot.show()

fig = plot.figure(figsize=(6, 6))
ax = fig.add_subplot(projection="3d")

ax.scatter(x[:, 1], x[:, 2], x[:, 3], c=y, cmap=plot.cm.Set1, edgecolor="k")
ax.set_xlabel(iris.feature_names[1])
ax.set_ylabel(iris.feature_names[2])
ax.set_zlabel(iris.feature_names[3])
plot.show()

fig = plot.figure(figsize=(6, 6))
ax = fig.add_subplot(projection="3d")

ax.scatter(x[:, 0], x[:, 2], x[:, 3], c=y, cmap=plot.cm.Set1, edgecolor="k")
ax.set_xlabel(iris.feature_names[0])
ax.set_ylabel(iris.feature_names[2])
ax.set_zlabel(iris.feature_names[3])
plot.show()

Entraînement¶

x = iris.data
y = iris.target

x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.7, random_state=12, stratify=y
)

print(f"Number of Training Records (input): {len(x_train)}")
print(f"Number of Training Records (target): {len(y_train)}")

print(f"Number of Test Records (input): {len(x_test)}")
print(f"Number of Test Records (input): {len(x_test)}")

Standardisation des caractéristiques¶

sc = StandardScaler()
sc.fit(x_train)
print(f"Mean: {sc.mean_} \nVariance={sc.var_}")

x_train_std = sc.transform(x_train)
x_test_std = sc.transform(x_test)

classifier = Perceptron(max_iter=100, eta0=0.1, random_state=12)

# training
classifier.fit(x_train_std, y_train)

Rapport de classification¶

predicted_target = classifier.predict(x_test_std)

# classification report
print(metrics.classification_report(y_test, predicted_target))

Matrice de confusion¶

cm = confusion_matrix(y_test, predicted_target, normalize="pred")
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=iris.target_names)
disp.plot(cmap=plot.cm.Blues)

cm = confusion_matrix(y_test, predicted_target, normalize="true")
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=iris.target_names)
disp.plot(cmap=plot.cm.Blues)