Estimation de la densité de noyau des distributions d'espèces

Introduction

Ce laboratoire démontre un exemple d'une requête basée sur les voisins (en particulier une estimation de la densité de noyau) sur des données géospatiales, en utilisant un Ball Tree construit sur la métrique de distance de Haversine - c'est-à-dire les distances entre des points en latitude/longitude. L'ensemble de données est fourni par Phillips et al. (2006). L'exemple utilise la bibliothèque basemap pour tracer les côtes et les frontières nationales de l'Amérique du Sud.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

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ésoudrons rapidement le problème pour vous.

Importation des bibliothèques requises

La première étape consiste à importer les bibliothèques requises pour ce laboratoire. Dans ce laboratoire, nous utiliserons les bibliothèques numpy, matplotlib, fetch_species_distributions et KernelDensity.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_species_distributions
from sklearn.neighbors import KernelDensity

Chargement des données

L'étape suivante consiste à charger les données fournies par Phillips et al. (2006). L'ensemble de données contient deux espèces que nous utiliserons pour démontrer l'estimation de la densité de noyau.

data = fetch_species_distributions()
species_names = ["Bradypus Variegatus", "Microryzomys Minutus"]

Préparer les données

Nous allons maintenant préparer les données pour l'estimation de la densité de noyau. Nous allons extraire les informations de latitude et de longitude à partir de l'ensemble de données et les convertir en radians.

Xtrain = np.vstack([data["train"]["dd lat"], data["train"]["dd long"]]).T
ytrain = np.array(
    [d.decode("ascii").startswith("micro") for d in data["train"]["species"]],
    dtype="int",
)
Xtrain *= np.pi / 180.0  ## Convert lat/long to radians

Construire des grilles

Nous allons maintenant construire la grille de la carte à partir de l'objet batch. Nous utiliserons la fonction construct_grids pour y parvenir.

def construct_grids(batch):
    """Construire la grille de la carte à partir de l'objet batch

    Paramètres
    ----------
    batch : Objet Batch
        L'objet renvoyé par :func:`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)

## Appeler la fonction et stocker les résultats dans xgrid et ygrid
xgrid, ygrid = construct_grids(data)

Préparer la grille de données

Nous allons configurer la grille de données pour le tracé de courbes de niveau. Nous utiliserons la fonction construct_grids pour y parvenir.

X, Y = np.meshgrid(xgrid[::5], ygrid[::5][::-1])
land_reference = data.coverages[6][::5, ::5]
land_mask = (land_reference > -9999).ravel()

xy = np.vstack([Y.ravel(), X.ravel()]).T
xy = xy[land_mask]
xy *= np.pi / 180.0

Tracer la carte de l'Amérique du Sud

Nous allons maintenant tracer la carte de l'Amérique du Sud avec les distributions de chaque espèce.

fig = plt.figure()
fig.subplots_adjust(left=0.05, right=0.95, wspace=0.05)

for i in range(2):
    plt.subplot(1, 2, i + 1)

    print(" - calcul de la KDE dans les coordonnées sphériques")
    kde = KernelDensity(
        bandwidth=0.04, metric="haversine", kernel="gaussian", algorithm="ball_tree"
    )
    kde.fit(Xtrain[ytrain == i])

    Z = np.full(land_mask.shape[0], -9999, dtype="int")
    Z[land_mask] = np.exp(kde.score_samples(xy))
    Z = Z.reshape(X.shape)

    levels = np.linspace(0, Z.max(), 25)
    plt.contourf(X, Y, Z, levels=levels, cmap=plt.cm.Reds)

    if basemap:
        print(" - tracer les côtes en utilisant basemap")
        m = Basemap(
            projection="cyl",
            llcrnrlat=Y.min(),
            urcrnrlat=Y.max(),
            llcrnrlon=X.min(),
            urcrnrlon=X.max(),
            resolution="c",
        )
        m.drawcoastlines()
        m.drawcountries()
    else:
        print(" - tracer les côtes à partir de la couverture")
        plt.contour(
            X, Y, land_reference, levels=[-9998], colors="k", linestyles="solid"
        )
        plt.xticks([])
        plt.yticks([])

    plt.title(species_names[i])

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à effectuer une estimation de la densité de noyau sur des données géospatiales. Nous avons utilisé l'ensemble de données de Phillips et al. (2006) pour démontrer cette technique. Nous avons également appris à tracer la carte de l'Amérique du Sud avec les distributions de chaque espèce en utilisant la bibliothèque basemap.