Lab 11 - Supervised Classification

Introduction

Supervised classification uses a training dataset with known labels representing the spectral characteristics of each land cover class of interest to "supervise" the classification. The overall approach in Earth Engine follows these steps:

1. Get a satellite scene

Lab Instructions

1. Part 1 - Load the Satellite Image

   We will begin by loading a clear Landsat 8 image. We'll use a point in Milan, Italy, as the center of our study area.

   // Create an Earth Engine Point object over Milan.
   var pt = ee.Geometry.Point([9.453, 45.424]);
   
   // Filter the Landsat 8 collection and select the least cloudy image.
   var Landsat = ee.ImageCollection('LANDSAT/LC08/C02/T1_L2')
       .filterBounds(pt)
       .filterDate('2019-01-01', '2020-01-01')
       .sort('CLOUD_COVER')
       .first();
   
   // Center the map on that image.
   Map.centerObject(Landsat, 8);
   
   // Add Landsat image to the map.
   var visParams = {
       bands: ['SR_B4', 'SR_B3', 'SR_B2'],
       min: 7000,
       max: 12000
   };
   Map.addLayer(Landsat, visParams, 'Landsat 8 image');

   Understanding the code:

   • .sort('CLOUD_COVER') - Orders images by cloud cover percentage
   • .first() - Takes the least cloudy image (first after sorting)
   • The visParams display a true-color composite (Red-Green-Blue)

   

2. Part 2 - Define Your Land Cover Classes

   Before collecting training points, define the classes you want to map. For this exercise, we'll use four classes:

   Class Name	Class Code	Hex Color	Description
   Forest	0	#589400	Trees and dense vegetation
   Developed	1	#FF0000	Urban areas, buildings, roads
   Water	2	#1A11FF	Rivers, lakes, sea
   Herbaceous	3	#D0741E	Crops, grassland, bare fields

   Why numeric codes? Classifiers work with numbers, not text. The palette in your visualization will map these codes back to meaningful colors.

3. Part 3 - Collect Training Points

   Now we'll use the Geometry Tools to create points on the Landsat image representing each land cover class.

   Step 3a: Create the First Feature Collection

   1. In the Geometry Tools, click on the marker (point) option
   2. A geometry import named "geometry" will appear. Click the gear icon to configure it

   

   Step 3b: Configure the Feature Collection

   1. Name the import forest
   2. Change the import type to FeatureCollection
   3. Click + Property
   4. Name the property class and set its value to 0
   5. Set the color to #589400 (dark green)
   6. Click OK

   

   About Hexadecimal Colors: Hex colors use six digits (0-9, A-F) in pairs for Red, Green, and Blue. For example, #589400 has 58 red, 94 green, and 00 blue - creating a dark green. #FF0000 is pure red.

   Step 3c: Collect Forest Points

   1. Click on forest in the Geometry Imports to activate drawing mode
   2. Click on forested areas in your Landsat image
   3. Collect at least 25 points
   4. Click Exit when finished

   

   Step 3d: Repeat for Other Classes

   Create new layers for each remaining class. For each one:

   • Developed: class = 1, color = #FF0000, collect over urban areas
   • Water: class = 2, color = #1A11FF, collect over the sea and rivers
   • Herbaceous: class = 3, color = #D0741E, collect over agricultural fields

   

   

   Try It

   Use the satellite basemap to help identify land cover types, but base your point placement on how areas appear in the Landsat image itself. The classifier will learn from Landsat spectral values, not the basemap!

4. Part 4 - Combine Training Data

   Merge all four FeatureCollections into one combined training dataset:

   // Combine training feature collections.
   var trainingFeatures = ee.FeatureCollection([
       forest, developed, water, herbaceous
   ]).flatten();
   
   print('Training features:', trainingFeatures);

   Understanding the code:

   • ee.FeatureCollection([...]) - Creates a collection of collections
   • .flatten() - Converts nested collections into one flat FeatureCollection

   Verify in the Console that each feature has a class property with values 0-3.

5. Part 5 - Extract Spectral Information

   Sample the Landsat band values at each training point location:

   // Define prediction bands.
   var predictionBands = [
       'SR_B1', 'SR_B2', 'SR_B3', 'SR_B4', 'SR_B5', 'SR_B6', 'SR_B7',
       'ST_B10'
   ];
   
   // Sample training points.
   var classifierTraining = Landsat.select(predictionBands)
       .sampleRegions({
           collection: trainingFeatures,
           properties: ['class'],
           scale: 30
       });
   
   print('Sampled training data:', classifierTraining);

   Understanding the code:

   • predictionBands - The spectral bands the classifier will use to learn patterns
   • .sampleRegions() - Extracts pixel values at each point location
   • properties: ['class'] - Keeps the class label with each sample
   • scale: 30 - Matches Landsat's 30-meter resolution

   

6. Part 6 - Train a CART Classifier

   CART (Classification and Regression Tree) is a decision tree algorithm that creates rules based on band values:

   

   //////////////// CART Classifier ///////////////////
   
   // Train a CART Classifier.
   var classifier = ee.Classifier.smileCart().train({
       features: classifierTraining,
       classProperty: 'class',
       inputProperties: predictionBands
   });
   
   // View the decision rules
   print('CART decision tree:', classifier.explain());

   

7. Part 7 - Classify the Image

   Apply the trained classifier to classify every pixel in the Landsat image:

   // Classify the Landsat image.
   var classified = Landsat.select(predictionBands).classify(classifier);
   
   // Define classification image visualization parameters.
   var classificationVis = {
       min: 0,
       max: 3,
       palette: ['589400', 'ff0000', '1a11ff', 'd0741e']
   };
   
   // Add the classified image to the map.
   Map.addLayer(classified, classificationVis, 'CART classified');

   Understanding the palette: The colors correspond to class values 0–3 in order: Forest (green), Developed (red), Water (blue), Herbaceous (orange).

   

   Try It

   Toggle between the classified image and the original Landsat layer. Use the layer transparency slider to compare. Look for areas where the classification seems wrong.

8. Part 8 - Train a Random Forest Classifier

   Random Forest builds many decision trees and uses voting to improve accuracy:

   

   /////////////// Random Forest Classifier /////////////////////
   
   // Train RF classifier.
   var RFclassifier = ee.Classifier.smileRandomForest(50).train({
       features: classifierTraining,
       classProperty: 'class',
       inputProperties: predictionBands
   });
   
   // Classify Landsat image.
   var RFclassified = Landsat.select(predictionBands).classify(RFclassifier);
   
   // Add classified image to the map.
   Map.addLayer(RFclassified, classificationVis, 'RF classified');

   Understanding the code:

   • smileRandomForest(50) - Creates a Random Forest with 50 decision trees
   • More trees generally = better accuracy, but longer computation
   • The seed parameter (optional) makes results reproducible

   

9. Part 9 - Compare and Analyze Results

   Inspect both classifications and consider these questions:

   • Which classifier produces smoother results?
   • Where do you see obvious misclassifications?
   • Which classes are most often confused with each other?

   Ways to Improve Classification:

   1. Collect more training data: More points = better learning
   2. Tune hyperparameters: Adjust the number of trees or tree depth
   3. Try other classifiers: SVM, Gradient Tree Boost, etc.
   4. Distribute samples spatially: Cover the entire study area
   5. Add spectral indices: NDVI, NDWI can help separate vegetation from urban