Einführung
In diesem Lab werden wir lernen, wie man die geografischen Verbreitungen von Arten mit maschinellem Lernen modelliert. Dies ist ein wichtiges Problem in der Naturschutzbiologie, da es uns hilft, die Verbreitung verschiedener Arten zu verstehen und effektive Naturschutzstrategien zu entwickeln. Wir werden einen Datensatz von zwei südamerikanischen Säugetieren mit früheren Beobachtungen und 14 Umweltvariablen verwenden. Wir werden den OneClassSVM-Algorithmus aus der scikit-learn-Bibliothek verwenden, um die geografische Verbreitung dieser beiden Arten zu modellieren.
Tipps für die VM
Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.
Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.
Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.
Bibliotheken importieren
In diesem Schritt werden wir die erforderlichen Bibliotheken für unsere Analyse importieren. Wir werden die scikit-learn-Bibliothek für maschinelles Lernen, numpy für numerische Berechnungen und matplotlib für die Visualisierung importieren.
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
Daten laden
In diesem Schritt werden wir die Daten aus der scikit-learn-Bibliothek laden. Wir werden die Funktion fetch_species_distributions verwenden, um die Daten von zwei südamerikanischen Säugetieren mit früheren Beobachtungen und 14 Umweltvariablen zu laden.
## Load the compressed data
data = fetch_species_distributions()
Karteigitter erstellen
In diesem Schritt werden wir das Karteigitter aus dem Datenobjekt erstellen. Wir werden eine Funktion namens construct_grids erstellen, die das Datenobjekt als Eingabe nimmt und das xgrid und ygrid zurückgibt.
def construct_grids(batch):
"""Erstelle das Karteigitter aus dem Batch-Objekt
Parameter
----------
batch : Batch-Objekt
Das Objekt, das von fetch_species_distributions zurückgegeben wird
Rückgabe
-------
(xgrid, ygrid) : 1-D Arrays
Das Gitter, das den Werten in batch.coverages entspricht
"""
## x,y-Koordinaten für die Eckzellen
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)
## x-Koordinaten der Gitterzellen
xgrid = np.arange(xmin, xmax, batch.grid_size)
## y-Koordinaten der Gitterzellen
ygrid = np.arange(ymin, ymax, batch.grid_size)
return (xgrid, ygrid)
## Erstelle das Karteigitter
xgrid, ygrid = construct_grids(data)
Arten-Bunch erstellen
In diesem Schritt werden wir ein Bunch mit Informationen über ein bestimmtes Organismus erstellen. Wir werden eine Funktion namens create_species_bunch erstellen, die den Artenamen, train, test, coverages, xgrid und ygrid als Eingabe nimmt und ein Bunch-Objekt zurückgibt.
def create_species_bunch(species_name, train, test, coverages, xgrid, ygrid):
"""Erstelle ein Bunch mit Informationen über ein bestimmtes Organismus
Dies wird die Test-/Trainings-Aufzeichnungsmengen verwenden, um die
Daten für den angegebenen Artenamen zu extrahieren.
"""
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():
## wähle die Punkte, die mit der gewünschten Art assoziiert sind
pts = pts[pts["species"] == species_name]
bunch["pts_%s" % label] = pts
## bestimme die Coverage-Werte für jeden der Trainings- und Testpunkte
ix = np.searchsorted(xgrid, pts["dd long"])
iy = np.searchsorted(ygrid, pts["dd lat"])
bunch["cov_%s" % label] = coverages[:, -iy, ix].T
return bunch
## Erstelle Arten-Bunch
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
)
OneClassSVM anpassen
In diesem Schritt werden wir das OneClassSVM-Modell an die Trainingsdaten anpassen. Wir werden die Merkmale standardisieren und das OneClassSVM-Modell an die Trainingsdaten anpassen.
## Standardize features
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
## Fit OneClassSVM
clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.5)
clf.fit(train_cover_std)
Artenverteilung vorhersagen
In diesem Schritt werden wir die Artenverteilung mit dem OneClassSVM-Modell vorhersagen. Wir werden die Artenverteilung mit den Trainingsdaten vorhersagen und die Ergebnisse darstellen.
## Predict species distribution using the training data
Z = np.ones((data.Ny, data.Nx), dtype=np.float64)
## Wir werden nur für die Landpunkte vorhersagen.
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
## Zeichne die Konturlinien der Vorhersage
plt.contourf(X, Y, Z, levels=levels, cmap=plt.cm.Reds)
plt.colorbar(format="%.2f")
## Streue die Trainings-/Testpunkte
plt.scatter(
BV_bunch.pts_train["dd long"],
BV_bunch.pts_train["dd lat"],
s=2**2,
c="black",
marker="^",
label="train",
)
plt.scatter(
BV_bunch.pts_test["dd long"],
BV_bunch.pts_test["dd lat"],
s=2**2,
c="black",
marker="x",
label="test",
)
plt.legend()
plt.title(BV_bunch.name)
plt.axis("equal")
AUC berechnen
In diesem Schritt werden wir die Fläche unter der ROC-Kurve (AUC) in Bezug auf Hintergrundpunkte berechnen. Wir werden die Artenverteilung mit den Testdaten und den Hintergrundpunkten vorhersagen und die AUC berechnen.
## Compute AUC with regards to background points
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, thresholds = metrics.roc_curve(y, scores)
roc_auc = metrics.auc(fpr, tpr)
plt.text(-35, -70, "AUC: %.3f" % roc_auc, ha="right")
print("\n Area under the ROC curve : %f" % roc_auc)
Artenverteilung darstellen
In diesem Schritt werden wir die Artenverteilung für beide Arten mit den von uns erstellten Funktionen und Modellen darstellen.
## Plot species distribution
plot_species_distribution()
plt.show()
Zusammenfassung
In diesem Lab haben wir gelernt, wie man die geografischen Verteilungen von Arten mit maschinellem Lernen modelliert. Wir haben das OneClassSVM-Algorithmus aus der scikit-learn-Bibliothek verwendet, um die geografische Verteilung von zwei südamerikanischen Säugetieren anhand von vergangenen Beobachtungen und 14 Umweltvariablen zu modellieren. Wir haben auch gelernt, wie man die Artenverteilung darstellt und die Fläche unter der ROC-Kurve berechnet, um die Leistung unseres Modells zu bewerten.