ee.Classifier.smileKNN

Crea un clasificador k-NN vacío.

El algoritmo de k-vecinos más cercanos (k-NN) es un método para clasificar objetos por votación mayoritaria de sus vecinos, en el que el objeto se asigna a la clase más común entre sus k vecinos más cercanos (k es un número entero positivo, por lo general, pequeño y, a menudo, impar).

UsoMuestra
ee.Classifier.smileKNN(k, searchMethod, metric)Clasificador
ArgumentoTipoDetalles
kNúmero entero, valor predeterminado: 1Cantidad de vecinos para la clasificación.
searchMethodCadena. El valor predeterminado es "AUTO".Es el método de búsqueda. Los siguientes son válidos [AUTO, LINEAR_SEARCH, KD_TREE, COVER_TREE]:

  • `AUTO`: Elige entre KD_TREE y COVER_TREE según el recuento de dimensiones. Si los atributos tienen menos de 10 dimensiones, se usa KD_TREE.
  • `LINEAR_SEARCH`: Es más eficiente que los enfoques de partición del espacio (como los árboles KD) en espacios de mayor dimensión.
  • `KD_TREE`: Método de búsqueda de vecinos más cercanos que usa una estructura de conjunto de datos de partición de espacio para organizar puntos en un espacio k-dimensional. Los KD-trees no son adecuados para encontrar de manera eficiente el vecino más cercano en espacios de alta dimensión. Como regla general, si la dimensionalidad es D, la cantidad de puntos en el conjunto de datos, N, debe ser N >> 2^D.
  • `COVER_TREE`: El árbol de cobertura es una estructura de datos para la búsqueda genérica de vecinos más cercanos, que es especialmente eficiente en espacios con una dimensión intrínseca pequeña.

Los resultados pueden variar entre los diferentes métodos de búsqueda para las vinculaciones de distancia y los valores de probabilidad. Dado que el rendimiento y los resultados pueden variar, consulta la documentación de SMILE y otros materiales.

metricCadena. El valor predeterminado es "EUCLIDEAN".Es la métrica de distancia que se usará. NOTA: KD_TREE (y AUTO para dimensiones bajas) no usarán la métrica seleccionada. Las opciones son las siguientes:
  • `EUCLIDEAN`: Distancia euclidiana.
  • `MAHALANOBIS`: Distancia de Mahalanobis.
  • `MANHATTAN`: Distancia de Manhattan.
  • `BRAYCURTIS`: Distancia de Bray-Curtis.

Ejemplos

Editor de código (JavaScript)

// Cloud masking for Landsat 8.
function maskL8sr(image) {
  var qaMask = image.select('QA_PIXEL').bitwiseAnd(parseInt('11111', 2)).eq(0);
  var saturationMask = image.select('QA_RADSAT').eq(0);

  // Apply the scaling factors to the appropriate bands.
  var opticalBands = image.select('SR_B.').multiply(0.0000275).add(-0.2);
  var thermalBands = image.select('ST_B.*').multiply(0.00341802).add(149.0);

  // Replace the original bands with the scaled ones and apply the masks.
  return image.addBands(opticalBands, null, true)
      .addBands(thermalBands, null, true)
      .updateMask(qaMask)
      .updateMask(saturationMask);
}

// Map the function over one year of data.
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
                     .filterDate('2020-01-01', '2021-01-01')
                     .map(maskL8sr);

// Make a median composite.
var composite = collection.median();

// Demonstration labels.
var labels = ee.FeatureCollection('projects/google/demo_landcover_labels')

// Use these bands for classification.
var bands = ['SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6', 'SR_B7'];
// The name of the property on the points storing the class label.
var classProperty = 'landcover';

// Sample the composite to generate training data.  Note that the
// class label is stored in the 'landcover' property.
var training = composite.select(bands).sampleRegions(
    {collection: labels, properties: [classProperty], scale: 30});

// Train a kNN classifier.
var classifier = ee.Classifier.smileKNN(5).train({
  features: training,
  classProperty: classProperty,
});

// Classify the composite.
var classified = composite.classify(classifier);
Map.setCenter(-122.184, 37.796, 12);
Map.addLayer(classified, {min: 0, max: 2, palette: ['red', 'green', 'blue']});

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

Colab (Python)

# Cloud masking for Landsat 8.
def mask_l8_sr(image):
  qa_mask = image.select('QA_PIXEL').bitwiseAnd(int('11111', 2)).eq(0)
  saturation_mask = image.select('QA_RADSAT').eq(0)

  # Apply the scaling factors to the appropriate bands.
  optical_bands = image.select('SR_B.').multiply(0.0000275).add(-0.2)
  thermal_bands = image.select('ST_B.*').multiply(0.00341802).add(149.0)

  # Replace the original bands with the scaled ones and apply the masks.
  return (
      image.addBands(optical_bands, None, True)
      .addBands(thermal_bands, None, True)
      .updateMask(qa_mask)
      .updateMask(saturation_mask)
  )


# Map the function over one year of data.
collection = (
    ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
    .filterDate('2020-01-01', '2021-01-01')
    .map(mask_l8_sr)
)

# Make a median composite.
composite = collection.median()

# Demonstration labels.
labels = ee.FeatureCollection('projects/google/demo_landcover_labels')

# Use these bands for classification.
bands = ['SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6', 'SR_B7']
# The name of the property on the points storing the class label.
class_property = 'landcover'

# Sample the composite to generate training data.  Note that the
# class label is stored in the 'landcover' property.
training = composite.select(bands).sampleRegions(
    collection=labels, properties=[class_property], scale=30
)

# Train a kNN classifier.
classifier = ee.Classifier.smileKNN(5).train(
    features=training, classProperty=class_property
)

# Classify the composite.
classified = composite.classify(classifier)

m = geemap.Map()
m.set_center(-122.184, 37.796, 12)
m.add_layer(
    classified, {'min': 0, 'max': 2, 'palette': ['red', 'green', 'blue']}
)
m