Artenverteilungsmodellierung

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.

Skills Graph

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.