Uncomment the following line to install geemap if needed.

In [1]:

# !pip install geemap

# !pip install geemap

Machine Learning with Earth Engine - Accuracy Assessment¶

Supervised classification algorithms available in Earth Engine¶

Source: https://developers.google.com/earth-engine/classification

The Classifier package handles supervised classification by traditional ML algorithms running in Earth Engine. These classifiers include CART, RandomForest, NaiveBayes and SVM. The general workflow for classification is:

1. Collect training data. Assemble features which have a property that stores the known class label and properties storing numeric values for the predictors.
2. Instantiate a classifier. Set its parameters if necessary.
3. Train the classifier using the training data.
4. Classify an image or feature collection.
5. Estimate classification error with independent validation data.

The training data is a FeatureCollection with a property storing the class label and properties storing predictor variables. Class labels should be consecutive, integers starting from 0. If necessary, use remap() to convert class values to consecutive integers. The predictors should be numeric.

To assess the accuracy of a classifier, use a ConfusionMatrix. The sample() method generates two random samples from the input data: one for training and one for validation. The training sample is used to train the classifier. You can get resubstitution accuracy on the training data from classifier.confusionMatrix(). To get validation accuracy, classify the validation data. This adds a classification property to the validation FeatureCollection. Call errorMatrix() on the classified FeatureCollection to get a confusion matrix representing validation (expected) accuracy.

Step-by-step tutorial¶

Import libraries¶

In [2]:

import ee
import geemap

import ee import geemap

Create an interactive map¶

In [3]:

Map = geemap.Map()
Map

Map = geemap.Map() Map

Out[3]:

Make this Notebook Trusted to load map: File -> Trust Notebook

Add data to the map¶

Let's add the USGS National Land Cover Database, which can be used to create training data with class labels.

In [4]:

NLCD2016 = ee.Image('USGS/NLCD/NLCD2016').select('landcover')
Map.addLayer(NLCD2016, {}, 'NLCD 2016')

NLCD2016 = ee.Image('USGS/NLCD/NLCD2016').select('landcover') Map.addLayer(NLCD2016, {}, 'NLCD 2016')

Load the NLCD metadata to find out the Landsat image IDs used to generate the land cover data.

In [5]:

NLCD_metadata = ee.FeatureCollection("users/giswqs/landcover/NLCD2016_metadata")
Map.addLayer(NLCD_metadata, {}, 'NLCD Metadata')

NLCD_metadata = ee.FeatureCollection("users/giswqs/landcover/NLCD2016_metadata") Map.addLayer(NLCD_metadata, {}, 'NLCD Metadata')

In [6]:

# point = ee.Geometry.Point([-122.4439, 37.7538])  # Sanfrancisco, CA
# point = ee.Geometry.Point([-83.9293, 36.0526])   # Knoxville, TN
point = ee.Geometry.Point([-88.3070, 41.7471])  # Chicago, IL

# point = ee.Geometry.Point([-122.4439, 37.7538]) # Sanfrancisco, CA # point = ee.Geometry.Point([-83.9293, 36.0526]) # Knoxville, TN point = ee.Geometry.Point([-88.3070, 41.7471]) # Chicago, IL

In [7]:

metadata = NLCD_metadata.filterBounds(point).first()
region = metadata.geometry()

metadata = NLCD_metadata.filterBounds(point).first() region = metadata.geometry()

In [8]:

metadata.get('2016on_bas').getInfo()

metadata.get('2016on_bas').getInfo()

Out[8]:

'LC08_2016256'

In [9]:

doy = metadata.get('2016on_bas').getInfo().replace('LC08_', '')
doy

doy = metadata.get('2016on_bas').getInfo().replace('LC08_', '') doy

Out[9]:

'2016256'

In [10]:

ee.Date.parse('YYYYDDD', doy).format('YYYY-MM-dd').getInfo()

ee.Date.parse('YYYYDDD', doy).format('YYYY-MM-dd').getInfo()

Out[10]:

'2016-09-12'

In [11]:

start_date = ee.Date.parse('YYYYDDD', doy)
end_date = start_date.advance(1, 'day')

start_date = ee.Date.parse('YYYYDDD', doy) end_date = start_date.advance(1, 'day')

In [12]:

image = (
    ee.ImageCollection('LANDSAT/LC08/C01/T1_SR')
    .filterBounds(point)
    .filterDate(start_date, end_date)
    .first()
    .select('B[1-7]')
    .clip(region)
)

vis_params = {'min': 0, 'max': 3000, 'bands': ['B5', 'B4', 'B3']}

Map.centerObject(point, 8)
Map.addLayer(image, vis_params, "Landsat-8")
Map

image = ( ee.ImageCollection('LANDSAT/LC08/C01/T1_SR') .filterBounds(point) .filterDate(start_date, end_date) .first() .select('B[1-7]') .clip(region) ) vis_params = {'min': 0, 'max': 3000, 'bands': ['B5', 'B4', 'B3']} Map.centerObject(point, 8) Map.addLayer(image, vis_params, "Landsat-8") Map

Out[12]:

Make this Notebook Trusted to load map: File -> Trust Notebook

In [13]:

nlcd_raw = NLCD2016.clip(region)
Map.addLayer(nlcd_raw, {}, 'NLCD')

nlcd_raw = NLCD2016.clip(region) Map.addLayer(nlcd_raw, {}, 'NLCD')

Prepare for consecutive class labels¶

In this example, we are going to use the USGS National Land Cover Database (NLCD) to create label dataset for training.

First, we need to use the remap() function to turn class labels into consecutive integers.

In [14]:

raw_class_values = nlcd_raw.get('landcover_class_values').getInfo()
print(raw_class_values)

raw_class_values = nlcd_raw.get('landcover_class_values').getInfo() print(raw_class_values)

[11, 12, 21, 22, 23, 24, 31, 41, 42, 43, 51, 52, 71, 72, 73, 74, 81, 82, 90, 95]

In [15]:

n_classes = len(raw_class_values)
new_class_values = list(range(0, n_classes))
new_class_values

n_classes = len(raw_class_values) new_class_values = list(range(0, n_classes)) new_class_values

Out[15]:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

In [16]:

class_palette = nlcd_raw.get('landcover_class_palette').getInfo()
print(class_palette)

class_palette = nlcd_raw.get('landcover_class_palette').getInfo() print(class_palette)

['476ba1', 'd1defa', 'decaca', 'd99482', 'ee0000', 'ab0000', 'b3aea3', '68ab63', '1c6330', 'b5ca8f', 'a68c30', 'ccba7d', 'e3e3c2', 'caca78', '99c247', '78ae94', 'dcd93d', 'ab7028', 'bad9eb', '70a3ba']

In [17]:

nlcd = nlcd_raw.remap(raw_class_values, new_class_values).select(
    ['remapped'], ['landcover']
)
nlcd = nlcd.set('landcover_class_values', new_class_values)
nlcd = nlcd.set('landcover_class_palette', class_palette)

nlcd = nlcd_raw.remap(raw_class_values, new_class_values).select( ['remapped'], ['landcover'] ) nlcd = nlcd.set('landcover_class_values', new_class_values) nlcd = nlcd.set('landcover_class_palette', class_palette)

In [18]:

Map.addLayer(nlcd, {}, 'NLCD')
Map

Map.addLayer(nlcd, {}, 'NLCD') Map

Out[18]:

Make this Notebook Trusted to load map: File -> Trust Notebook

Make training data¶

In [19]:

# Make the training dataset.
points = nlcd.sample(
    **{
        'region': region,
        'scale': 30,
        'numPixels': 5000,
        'seed': 0,
        'geometries': True,  # Set this to False to ignore geometries
    }
)

Map.addLayer(points, {}, 'training', False)

# Make the training dataset. points = nlcd.sample( **{ 'region': region, 'scale': 30, 'numPixels': 5000, 'seed': 0, 'geometries': True, # Set this to False to ignore geometries } ) Map.addLayer(points, {}, 'training', False)

In [20]:

print(points.size().getInfo())

print(points.size().getInfo())

5000

In [21]:

print(points.first().getInfo())

print(points.first().getInfo())

{'type': 'Feature', 'geometry': {'type': 'Point', 'coordinates': [-88.56212124700772, 42.210469414463425]}, 'id': '0', 'properties': {'landcover': 17}}

Split training and testing¶

In [22]:

# Use these bands for prediction.
bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7']

# This property of the table stores the land cover labels.
label = 'landcover'

# Overlay the points on the imagery to get training.
sample = image.select(bands).sampleRegions(
    **{'collection': points, 'properties': [label], 'scale': 30}
)

# Adds a column of deterministic pseudorandom numbers.
sample = sample.randomColumn()

split = 0.7

training = sample.filter(ee.Filter.lt('random', split))
validation = sample.filter(ee.Filter.gte('random', split))

# Use these bands for prediction. bands = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7'] # This property of the table stores the land cover labels. label = 'landcover' # Overlay the points on the imagery to get training. sample = image.select(bands).sampleRegions( **{'collection': points, 'properties': [label], 'scale': 30} ) # Adds a column of deterministic pseudorandom numbers. sample = sample.randomColumn() split = 0.7 training = sample.filter(ee.Filter.lt('random', split)) validation = sample.filter(ee.Filter.gte('random', split))

In [23]:

training.first().getInfo()

training.first().getInfo()

Out[23]:

{'type': 'Feature',
 'geometry': None,
 'id': '2_0',
 'properties': {'B1': 72,
  'B2': 215,
  'B3': 579,
  'B4': 543,
  'B5': 2558,
  'B6': 1782,
  'B7': 1103,
  'landcover': 3,
  'random': 0.18158720869622524}}

In [24]:

validation.first().getInfo()

validation.first().getInfo()

Out[24]:

{'type': 'Feature',
 'geometry': None,
 'id': '0_0',
 'properties': {'B1': 174,
  'B2': 223,
  'B3': 614,
  'B4': 368,
  'B5': 4221,
  'B6': 1737,
  'B7': 766,
  'landcover': 17,
  'random': 0.889822614157854}}

Train the classifier¶

In this examples, we will use random forest classification.

In [25]:

classifier = ee.Classifier.smileRandomForest(10).train(training, label, bands)

classifier = ee.Classifier.smileRandomForest(10).train(training, label, bands)

Classify the image¶

In [26]:

# Classify the image with the same bands used for training.
result = image.select(bands).classify(classifier)

# # Display the clusters with random colors.
Map.addLayer(result.randomVisualizer(), {}, 'classfied')
Map

# Classify the image with the same bands used for training. result = image.select(bands).classify(classifier) # # Display the clusters with random colors. Map.addLayer(result.randomVisualizer(), {}, 'classfied') Map

Out[26]:

Make this Notebook Trusted to load map: File -> Trust Notebook

Render categorical map¶

To render a categorical map, we can set two image properties: classification_class_values and classification_class_palette. We can use the same style as the NLCD so that it is easy to compare the two maps.

In [27]:

class_values = nlcd.get('landcover_class_values').getInfo()
print(class_values)

class_values = nlcd.get('landcover_class_values').getInfo() print(class_values)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

In [28]:

class_palette = nlcd.get('landcover_class_palette').getInfo()
print(class_palette)

class_palette = nlcd.get('landcover_class_palette').getInfo() print(class_palette)

['476ba1', 'd1defa', 'decaca', 'd99482', 'ee0000', 'ab0000', 'b3aea3', '68ab63', '1c6330', 'b5ca8f', 'a68c30', 'ccba7d', 'e3e3c2', 'caca78', '99c247', '78ae94', 'dcd93d', 'ab7028', 'bad9eb', '70a3ba']

In [29]:

landcover = result.set('classification_class_values', class_values)
landcover = landcover.set('classification_class_palette', class_palette)

landcover = result.set('classification_class_values', class_values) landcover = landcover.set('classification_class_palette', class_palette)

In [30]:

Map.addLayer(landcover, {}, 'Land cover')
Map

Map.addLayer(landcover, {}, 'Land cover') Map

Out[30]:

Make this Notebook Trusted to load map: File -> Trust Notebook

Visualize the result¶

In [31]:

print('Change layer opacity:')
cluster_layer = Map.layers[-1]
cluster_layer.interact(opacity=(0, 1, 0.1))

print('Change layer opacity:') cluster_layer = Map.layers[-1] cluster_layer.interact(opacity=(0, 1, 0.1))

Change layer opacity:

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [31], in <cell line: 2>()
      1 print('Change layer opacity:')
----> 2 cluster_layer = Map.layers[-1]
      3 cluster_layer.interact(opacity=(0, 1, 0.1))

AttributeError: 'Map' object has no attribute 'layers'

Add a legend to the map¶

In [32]:

Map.add_legend(builtin_legend='NLCD')
Map

Map.add_legend(builtin_legend='NLCD') Map

Out[32]:

Make this Notebook Trusted to load map: File -> Trust Notebook

Accuracy assessment¶

Training dataset¶

confusionMatrix() computes a 2D confusion matrix for a classifier based on its training data (ie: resubstitution error). Axis 0 of the matrix correspond to the input classes (i.e., reference data), and axis 1 to the output classes (i.e., classification data). The rows and columns start at class 0 and increase sequentially up to the maximum class value

In [33]:

train_accuracy = classifier.confusionMatrix()

train_accuracy = classifier.confusionMatrix()

In [34]:

train_accuracy.getInfo()

train_accuracy.getInfo()

Out[34]:

[[272, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [2, 0, 183, 6, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0],
 [0, 0, 1, 421, 1, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0],
 [1, 0, 1, 15, 171, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 3, 8, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0],
 [0, 0, 2, 2, 0, 0, 0, 212, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0],
 [0, 0, 1, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 2, 0, 13, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 32, 0, 0, 0, 0, 4, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [1, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 14, 0, 0],
 [1, 0, 1, 4, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1730, 0, 0],
 [0, 0, 1, 1, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 56, 0],
 [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10]]

Overall Accuracy essentially tells us out of all of the reference sites what proportion were mapped correctly. The overall accuracy is usually expressed as a percent, with 100% accuracy being a perfect classification where all reference site were classified correctly. Overall accuracy is the easiest to calculate and understand but ultimately only provides the map user and producer with basic accuracy information.

In [35]:

train_accuracy.accuracy().getInfo()

train_accuracy.accuracy().getInfo()

Out[35]:

0.9562445667922341

The Kappa Coefficient is generated from a statistical test to evaluate the accuracy of a classification. Kappa essentially evaluates how well the classification performed as compared to just randomly assigning values, i.e. did the classification do better than random. The Kappa Coefficient can range from -1 t0 1. A value of 0 indicated that the classification is no better than a random classification. A negative number indicates the classification is significantly worse than random. A value close to 1 indicates that the classification is significantly better than random.

In [36]:

train_accuracy.kappa().getInfo()

train_accuracy.kappa().getInfo()

Out[36]:

0.9376575979043613

Producer's Accuracy is the map accuracy from the point of view of the map maker (the producer). This is how often are real features on the ground correctly shown on the classified map or the probability that a certain land cover of an area on the ground is classified as such. The Producer's Accuracy is complement of the Omission Error, Producer's Accuracy = 100%-Omission Error. It is also the number of reference sites classified accurately divided by the total number of reference sites for that class.

In [37]:

train_accuracy.producersAccuracy().getInfo()

train_accuracy.producersAccuracy().getInfo()

Out[37]:

[[1],
 [0],
 [0.8632075471698113],
 [0.958997722095672],
 [0.8814432989690721],
 [0.897196261682243],
 [0.8666666666666667],
 [0.9636363636363636],
 [0.5],
 [0.8125],
 [0],
 [0.5],
 [0.8421052631578947],
 [0],
 [0],
 [0],
 [0.8148148148148148],
 [0.9936817920735209],
 [0.8115942028985508],
 [0.7142857142857143]]

The Consumer's Accuracy is the accuracy from the point of view of a map user, not the map maker. the User's accuracy essentially tells use how often the class on the map will actually be present on the ground. This is referred to as reliability. The User's Accuracy is complement of the Commission Error, User's Accuracy = 100%-Commission Error. The User's Accuracy is calculating by taking the total number of correct classifications for a particular class and dividing it by the row total.

In [38]:

train_accuracy.consumersAccuracy().getInfo()

train_accuracy.consumersAccuracy().getInfo()

Out[38]:

[[0.9819494584837545,
  0,
  0.9581151832460733,
  0.9172113289760349,
  0.95,
  0.9320388349514563,
  0.9285714285714286,
  0.925764192139738,
  1,
  1,
  0,
  1,
  1,
  0,
  0,
  0,
  0.9777777777777777,
  0.9648633575013943,
  0.9824561403508771,
  1]]

Validation dataset¶

In [39]:

validated = validation.classify(classifier)

validated = validation.classify(classifier)

In [40]:

validated.first().getInfo()

validated.first().getInfo()

Out[40]:

{'type': 'Feature',
 'geometry': None,
 'id': '0_0',
 'properties': {'B1': 174,
  'B2': 223,
  'B3': 614,
  'B4': 368,
  'B5': 4221,
  'B6': 1737,
  'B7': 766,
  'classification': 17,
  'landcover': 17,
  'random': 0.889822614157854}}

errorMatrix computes a 2D error matrix for a collection by comparing two columns of a collection: one containing the actual values, and one containing predicted values.

In [41]:

test_accuracy = validated.errorMatrix('landcover', 'classification')

test_accuracy = validated.errorMatrix('landcover', 'classification')

In [42]:

test_accuracy.getInfo()

test_accuracy.getInfo()

Out[42]:

[[145, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [2, 0, 13, 18, 2, 0, 0, 15, 0, 0, 0, 0, 1, 0, 0, 0, 2, 54, 1, 0],
 [2, 0, 8, 113, 20, 2, 1, 7, 0, 0, 0, 0, 1, 0, 0, 0, 3, 33, 3, 0],
 [1, 0, 1, 27, 34, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 1, 0],
 [0, 0, 1, 2, 18, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0],
 [0, 0, 0, 3, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
 [0, 0, 12, 6, 1, 0, 0, 54, 0, 0, 0, 0, 0, 0, 0, 0, 1, 14, 5, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 1, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 10, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 7, 10, 2, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 2, 25, 0, 0],
 [0, 0, 11, 37, 2, 4, 0, 10, 0, 0, 0, 0, 1, 0, 0, 0, 4, 708, 0, 0],
 [0, 0, 4, 7, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0],
 [0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5, 0, 0]]

In [43]:

test_accuracy.accuracy().getInfo()

test_accuracy.accuracy().getInfo()

Out[43]:

0.7023886378308586

In [44]:

test_accuracy.kappa().getInfo()

test_accuracy.kappa().getInfo()

Out[44]:

0.5639057934062713

In [45]:

test_accuracy.producersAccuracy().getInfo()

test_accuracy.producersAccuracy().getInfo()

Out[45]:

[[0.9797297297297297],
 [0],
 [0.12037037037037036],
 [0.5854922279792746],
 [0.4594594594594595],
 [0.425],
 [0],
 [0.5806451612903226],
 [0],
 [0],
 [0],
 [0],
 [0],
 [0],
 [0],
 [0],
 [0.04],
 [0.9111969111969112],
 [0.07142857142857142],
 [0]]

In [46]:

test_accuracy.consumersAccuracy().getInfo()

test_accuracy.consumersAccuracy().getInfo()

Out[46]:

[[0.9666666666666667,
  0,
  0.21666666666666667,
  0.4977973568281938,
  0.41975308641975306,
  0.5483870967741935,
  0,
  0.5142857142857142,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0.14285714285714285,
  0.8194444444444444,
  0.15384615384615385,
  0]]

Download confusion matrix¶

In [47]:

import csv
import os

out_dir = os.path.join(os.path.expanduser('~'), 'Downloads')
training_csv = os.path.join(out_dir, 'train_accuracy.csv')
testing_csv = os.path.join(out_dir, 'test_accuracy.csv')

with open(training_csv, "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(train_accuracy.getInfo())

with open(testing_csv, "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(test_accuracy.getInfo())

import csv import os out_dir = os.path.join(os.path.expanduser('~'), 'Downloads') training_csv = os.path.join(out_dir, 'train_accuracy.csv') testing_csv = os.path.join(out_dir, 'test_accuracy.csv') with open(training_csv, "w", newline="") as f: writer = csv.writer(f) writer.writerows(train_accuracy.getInfo()) with open(testing_csv, "w", newline="") as f: writer = csv.writer(f) writer.writerows(test_accuracy.getInfo())

Reclassify land cover map¶

In [48]:

landcover = landcover.remap(new_class_values, raw_class_values).select(
    ['remapped'], ['classification']
)

landcover = landcover.remap(new_class_values, raw_class_values).select( ['remapped'], ['classification'] )

In [49]:

landcover = landcover.set('classification_class_values', raw_class_values)
landcover = landcover.set('classification_class_palette', class_palette)

landcover = landcover.set('classification_class_values', raw_class_values) landcover = landcover.set('classification_class_palette', class_palette)

In [50]:

Map.addLayer(landcover, {}, 'Final land cover')
Map

Map.addLayer(landcover, {}, 'Final land cover') Map

Out[50]:

Make this Notebook Trusted to load map: File -> Trust Notebook

Export the result¶

Export the result directly to your computer:

In [51]:

import os

out_dir = os.path.join(os.path.expanduser('~'), 'Downloads')
out_file = os.path.join(out_dir, 'landcover.tif')

import os out_dir = os.path.join(os.path.expanduser('~'), 'Downloads') out_file = os.path.join(out_dir, 'landcover.tif')

In [52]:

geemap.ee_export_image(landcover, filename=out_file, scale=900)

geemap.ee_export_image(landcover, filename=out_file, scale=900)

Generating URL ...
Downloading data from https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/thumbnails/d994d3a3f05a1501eb943e006b2a6b39-26292a72b5d2942b01aeb6df83a6c971:getPixels
Please wait ...
Data downloaded to /home/runner/Downloads/landcover.tif

Export the result to Google Drive:

In [53]:

geemap.ee_export_image_to_drive(
    landcover, description='landcover', folder='export', scale=900
)

geemap.ee_export_image_to_drive( landcover, description='landcover', folder='export', scale=900 )

Exporting landcover ...

---

Last update: 2022-03-14