Introduction
Dans ce laboratoire, nous allons apprendre à modéliser les distributions géographiques des espèces à l'aide d'apprentissage automatique. Il s'agit d'un problème important en biologie de la conservation, car cela nous aide à comprendre la distribution des différentes espèces et à concevoir des stratégies de conservation efficaces. Nous utiliserons un ensemble de données de deux mammifères sud-américains en utilisant des observations passées et 14 variables environnementales. Nous utiliserons l'algorithme OneClassSVM de la bibliothèque scikit-learn pour modéliser la distribution géographique de ces deux espèces.
Conseils sur la VM
Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour passer à l'onglet Notebook pour accéder à Jupyter Notebook pour pratiquer.
Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous réglerons rapidement le problème pour vous.
Importation des bibliothèques
Dans cette étape, nous allons importer les bibliothèques nécessaires à notre analyse. Nous importerons la bibliothèque scikit-learn pour l'apprentissage automatique, numpy pour les calculs numériques et matplotlib pour la visualisation.
from time import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn.utils import Bunch
from sklearn.datasets import fetch_species_distributions
from sklearn import svm, metrics
Chargement des données
Dans cette étape, nous allons charger les données à partir de la bibliothèque scikit-learn. Nous utiliserons la fonction fetch_species_distributions pour charger les données de deux mammifères sud-américains en utilisant des observations passées et 14 variables environnementales.
## Charger les données compressées
data = fetch_species_distributions()
Construire la grille de la carte
Dans cette étape, nous allons construire la grille de la carte à partir de l'objet de données. Nous allons créer une fonction appelée construct_grids qui prend l'objet de données en entrée et renvoie xgrid et ygrid.
def construct_grids(batch):
"""Construire la grille de la carte à partir de l'objet batch
Paramètres
----------
batch : Objet Batch
L'objet renvoyé par fetch_species_distributions
Retours
-------
(xgrid, ygrid) : Tableaux 1-D
La grille correspondant aux valeurs dans batch.coverages
"""
## Coordonnées x,y pour les cellules du coin
xmin = batch.x_left_lower_corner + batch.grid_size
xmax = xmin + (batch.Nx * batch.grid_size)
ymin = batch.y_left_lower_corner + batch.grid_size
ymax = ymin + (batch.Ny * batch.grid_size)
## Coordonnées x des cellules de la grille
xgrid = np.arange(xmin, xmax, batch.grid_size)
## Coordonnées y des cellules de la grille
ygrid = np.arange(ymin, ymax, batch.grid_size)
return (xgrid, ygrid)
## Construire la grille de la carte
xgrid, ygrid = construct_grids(data)
Créer un Bunch d'espèces
Dans cette étape, nous allons créer un bunch avec des informations sur un organisme particulier. Nous allons créer une fonction appelée create_species_bunch qui prend le nom de l'espèce, les ensembles d'entraînement et de test, les couvertures, xgrid et ygrid en entrée et renvoie un objet bunch.
def create_species_bunch(species_name, train, test, coverages, xgrid, ygrid):
"""Créer un bunch avec des informations sur un organisme particulier
Cela utilisera les tableaux d'enregistrements d'entraînement/test pour extraire
les données spécifiques au nom d'espèce donné.
"""
bunch = Bunch(name=" ".join(species_name.split("_")[:2]))
species_name = species_name.encode("ascii")
points = dict(test=test, train=train)
for label, pts in points.items():
## choisir les points associés à l'espèce souhaitée
pts = pts[pts["species"] == species_name]
bunch["pts_%s" % label] = pts
## déterminer les valeurs de couverture pour chacun des points d'entraînement et de test
ix = np.searchsorted(xgrid, pts["dd long"])
iy = np.searchsorted(ygrid, pts["dd lat"])
bunch["cov_%s" % label] = coverages[:, -iy, ix].T
return bunch
## Créer un bunch d'espèces
BV_bunch = create_species_bunch(
"bradypus_variegatus_0", data.train, data.test, data.coverages, xgrid, ygrid
)
MM_bunch = create_species_bunch(
"microryzomys_minutus_0", data.train, data.test, data.coverages, xgrid, ygrid
)
Ajuster OneClassSVM
Dans cette étape, nous allons ajuster le modèle OneClassSVM aux données d'entraînement. Nous allons standardiser les caractéristiques et ajuster le modèle OneClassSVM aux données d'entraînement.
## Standardiser les caractéristiques
mean = BV_bunch.cov_train.mean(axis=0)
std = BV_bunch.cov_train.std(axis=0)
train_cover_std = (BV_bunch.cov_train - mean) / std
## Ajuster OneClassSVM
clf = svm.OneClassSVM(nu=0.1, noyau="rbf", gamma=0.5)
clf.fit(train_cover_std)
Prédire la distribution d'espèces
Dans cette étape, nous allons prédire la distribution d'espèces en utilisant le modèle OneClassSVM. Nous allons prédire la distribution d'espèces en utilisant les données d'entraînement et tracer les résultats.
## Prédire la distribution d'espèces en utilisant les données d'entraînement
Z = np.ones((data.Ny, data.Nx), dtype=np.float64)
## Nous ne prédirons que pour les points terrestres.
idx = np.where(data.coverages[6] > -9999)
coverages_land = data.coverages[:, idx[0], idx[1]].T
pred = clf.decision_function((coverages_land - mean) / std)
Z *= pred.min()
Z[idx[0], idx[1]] = pred
levels = np.linspace(Z.min(), Z.max(), 25)
Z[data.coverages[6] == -9999] = -9999
## tracer les contours de la prédiction
plt.contourf(X, Y, Z, levels=levels, cmap=plt.cm.Reds)
plt.colorbar(format="%.2f")
## disperser les points d'entraînement/test
plt.scatter(
BV_bunch.pts_train["dd long"],
BV_bunch.pts_train["dd lat"],
s=2**2,
c="black",
marqueur="^",
label="train",
)
plt.scatter(
BV_bunch.pts_test["dd long"],
BV_bunch.pts_test["dd lat"],
s=2**2,
c="black",
marqueur="x",
label="test",
)
plt.legend()
plt.title(BV_bunch.name)
plt.axe("égal")
Calculer l'AUC
Dans cette étape, nous allons calculer l'aire sous la courbe ROC (AUC) par rapport aux points d'arrière-plan. Nous allons prédire la distribution d'espèces en utilisant les données de test et les points d'arrière-plan, puis calculer l'AUC.
## Calculer l'AUC par rapport aux points d'arrière-plan
background_points = np.c_[
np.random.randint(low=0, high=data.Ny, size=10000),
np.random.randint(low=0, high=data.Nx, size=10000),
].T
pred_background = Z[background_points[0], background_points[1]]
pred_test = clf.decision_function((BV_bunch.cov_test - mean) / std)
scores = np.r_[pred_test, pred_background]
y = np.r_[np.ones(pred_test.shape), np.zeros(pred_background.shape)]
fpr, tpr, seuils = metrics.roc_curve(y, scores)
roc_auc = metrics.auc(fpr, tpr)
plt.text(-35, -70, "AUC: %.3f" % roc_auc, ha="right")
print("\n Aire sous la courbe ROC : %f" % roc_auc)
Tracer la distribution d'espèces
Dans cette étape, nous allons tracer la distribution d'espèces pour les deux espèces en utilisant les fonctions et les modèles que nous avons créés.
## Tracer la distribution d'espèces
plot_species_distribution()
plt.show()
Sommaire
Dans ce laboratoire, nous avons appris à modéliser les distributions géographiques d'espèces à l'aide d'apprentissage automatique. Nous avons utilisé l'algorithme OneClassSVM de la bibliothèque scikit-learn pour modéliser la distribution géographique de deux mammifères sud-américains à partir d'observations passées et de 14 variables environnementales. Nous avons également appris à tracer la distribution d'espèces et à calculer l'aire sous la courbe ROC pour évaluer les performances de notre modèle.