___¶

Úvod do strojového učení v DPZ¶

MultiLayer Perceptron (MLP) klasifikace snímku Landsat¶

1. Definice¶

Vytvořte klasifikační model pro rozlišení tří tříd (ledovec, suť na ledovci a holá půda/kamení). Porovnejte modely Random Forest a MLP architektury pomocí PyTorchu. Modely validujte.

In [ ]:

import os 
import geopandas as gpd 
import rasterio as rio
from rasterio import features
import numpy as np 
import pandas as pd

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader, TensorDataset
from torch.autograd import Variable

import matplotlib.pyplot as plt 
%matplotlib inline

import os import geopandas as gpd import rasterio as rio from rasterio import features import numpy as np import pandas as pd from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torch.utils.data import Dataset, DataLoader, TensorDataset from torch.autograd import Variable import matplotlib.pyplot as plt %matplotlib inline

2. Průzkum dat¶

In [ ]:

# Landsat 5 ./data/landsat.tif
path = '/Users/lukas/Work/cvut/Strojove_uceni/data/'
raster_filename = 'landsat.tif' 
pass

# Landsat 5 ./data/landsat.tif path = '/Users/lukas/Work/cvut/Strojove_uceni/data/' raster_filename = 'landsat.tif' pass

In [ ]:

# Landsat a metadata 
pass

# Landsat a metadata pass

In [ ]:

# Reference ("labels") pro klasifikaci ./data/rasterized_poly.tif
ref_fn = os.path.join(path, 'rasterized_poly.tif')
pass

# Reference ("labels") pro klasifikaci ./data/rasterized_poly.tif ref_fn = os.path.join(path, 'rasterized_poly.tif') pass

In [4]:

# Unikátní kódy 
pass

# Unikátní kódy pass

In [ ]:

# Vizualizace snímku a reference 
pass

# Vizualizace snímku a reference pass

3. Příprava dat pro klasifikaci¶

In [ ]:

# Vektorizace multispektrálního landsatu z 500, 500, 6 na 4370, 6 což jsou zároveň vybrané pixely 
# pouze refernce

# Vektorizace multispektrálního landsatu z 500, 500, 6 na 4370, 6 což jsou zároveň vybrané pixely # pouze refernce

In [ ]:

# vektorizace a výběr refernce 
# X = vstupni_pole[reference > 0, :]
# y = reference[reference > 0]
pass

# vektorizace a výběr refernce # X = vstupni_pole[reference > 0, :] # y = reference[reference > 0] pass

In [ ]:

# ověřte unikátní kódy tříd klasifikace 
pass

# ověřte unikátní kódy tříd klasifikace pass

In [ ]:

print('Vstup X má rozměr: {sz}'.format(sz=X.shape))
print('Výstup y mározměr: {sz}'.format(sz=y.shape))

print('Vstup X má rozměr: {sz}'.format(sz=X.shape)) print('Výstup y mározměr: {sz}'.format(sz=y.shape))

4. Model 1 (RF sklearn)¶

In [ ]:

# rozdělení na trénovací a testovací data set 
pass

# rozdělení na trénovací a testovací data set pass

In [ ]:

# Inicializace a učení modelu RF modelu 
pass

# Inicializace a učení modelu RF modelu pass

In [ ]:

# Příparava pro predikci - vektorizace matice 
pass

# Příparava pro predikci - vektorizace matice pass

In [ ]:

# nový rozměr dat 
pass

# nový rozměr dat pass

In [ ]:

# Predikce
pass

# Predikce pass

In [ ]:

# dimenze dat 
pass

# dimenze dat pass

In [ ]:

# Návrat do 2D matice
pass

# Návrat do 2D matice pass

In [ ]:

# Visualize výsledku 
    
n = class_prediction.max()
colors = dict((
    (0, (0, 0, 0, 255)),      # Nodata
    (1, (26, 222, 228, 255)), # Ledovec 
    (2, (16, 128, 132, 255)), # Suť 
    (3, (200, 200, 200, 255)) # Skála 
))
#  0 - 255 -> float 0 - 1
for k in colors:
    v = colors[k]
    _v = [_v / 255.0 for _v in v]
    colors[k] = _v
    
index_colors = [colors[key] if key in colors else 
                (255, 255, 255, 0) for key in range(1, n + 1)]
cmap = plt.matplotlib.colors.ListedColormap(index_colors, 'Klasifikace', n)

# Visualize výsledku n = class_prediction.max() colors = dict(( (0, (0, 0, 0, 255)), # Nodata (1, (26, 222, 228, 255)), # Ledovec (2, (16, 128, 132, 255)), # Suť (3, (200, 200, 200, 255)) # Skála )) # 0 - 255 -> float 0 - 1 for k in colors: v = colors[k] _v = [_v / 255.0 for _v in v] colors[k] = _v index_colors = [colors[key] if key in colors else (255, 255, 255, 0) for key in range(1, n + 1)] cmap = plt.matplotlib.colors.ListedColormap(index_colors, 'Klasifikace', n)

In [ ]:

# Mapa klasifikace 
plt.subplot(121)
plt.imshow(image_arr[:, :, 1], cmap=plt.cm.Greys_r, interpolation='none')
plt.colorbar(shrink=0.4)
plt.title('Landsat')
plt.subplot(122)
plt.imshow(class_prediction, cmap=cmap, interpolation='none')
plt.title('Klasifikace')
#  ['ice', 'debris', 'bare']
plt.colorbar(cmap=cmap, ticks=np.unique(y), format='%1i', shrink=0.4)
plt.tight_layout()

# Mapa klasifikace plt.subplot(121) plt.imshow(image_arr[:, :, 1], cmap=plt.cm.Greys_r, interpolation='none') plt.colorbar(shrink=0.4) plt.title('Landsat') plt.subplot(122) plt.imshow(class_prediction, cmap=cmap, interpolation='none') plt.title('Klasifikace') # ['ice', 'debris', 'bare'] plt.colorbar(cmap=cmap, ticks=np.unique(y), format='%1i', shrink=0.4) plt.tight_layout()

4. Model 2 (MLP PyTorch)¶

In [5]:

# Příznky X - dimenze 
pass

# Příznky X - dimenze pass

In [ ]:

# Reference musí být kódovány od 0!!! 
y_torch = y - 1
np.unique(y_torch)

# Reference musí být kódovány od 0!!! y_torch = y - 1 np.unique(y_torch)

In [ ]:

# Hyperparametry
input_features = 6  # Počet kanálů Landsat-5 
hidden_size = 8     # skryté jednotky 
output_classes = 3  # Třídy klasifikace 
batch_size = 32     # Velikost dávky pro klasifikaci 
learning_rate = 0.001 # Rychlost učení 
num_epochs = 30     # Počet epoch

# Hyperparametry input_features = 6 # Počet kanálů Landsat-5 hidden_size = 8 # skryté jednotky output_classes = 3 # Třídy klasifikace batch_size = 32 # Velikost dávky pro klasifikaci learning_rate = 0.001 # Rychlost učení num_epochs = 30 # Počet epoch

Definice třídy vstupních dat¶

In [ ]:

# Třída Dataset pro Landsat-5 data
# vstupní příznaky torch.float32
# reference (labels) torch.long 
class LandsatDataset(Dataset):
    def __init__(self, features, labels):
        """
        Args:
            features: numpy pole (n_samples, n_features)
            labels: numpy pole (n_samples,)
        """
        self.features = torch.tensor(features, dtype=torch.float32)
        self.labels = torch.tensor(labels, dtype=torch.long)

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        return self.features[idx], self.labels[idx]

# Třída Dataset pro Landsat-5 data # vstupní příznaky torch.float32 # reference (labels) torch.long class LandsatDataset(Dataset): def __init__(self, features, labels): """ Args: features: numpy pole (n_samples, n_features) labels: numpy pole (n_samples,) """ self.features = torch.tensor(features, dtype=torch.float32) self.labels = torch.tensor(labels, dtype=torch.long) def __len__(self): return len(self.labels) def __getitem__(self, idx): return self.features[idx], self.labels[idx]

In [ ]:

# rozdělení na trénovací a testovací, 20% testování 
pass

# rozdělení na trénovací a testovací, 20% testování pass

In [ ]:

# Vytvořte PyTorch data set pro trénování a testování LandsatDataset() 
train_dataset = LandsatDataset(X_train, y_train)
test_dataset = pass

# Vytvořte PyTorch data set pro trénování a testování LandsatDataset() train_dataset = LandsatDataset(X_train, y_train) test_dataset = pass

In [ ]:

# Vytvořte PyTorch DataLoader (iterátor) z obou data setů DataLoader() 
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = pass

# Vytvořte PyTorch DataLoader (iterátor) z obou data setů DataLoader() train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) test_loader = pass

Definice modelu¶

In [ ]:

# MLP model (input_size, hidden_size, num_classes), ReLU 

class MLPClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(MLPClassifier, self).__init__()
        pass 

    def forward(self, x):
        pass 
    
        return x

# MLP model (input_size, hidden_size, num_classes), ReLU class MLPClassifier(nn.Module): def __init__(self, input_size, hidden_size, num_classes): super(MLPClassifier, self).__init__() pass def forward(self, x): pass return x

In [ ]:

# Inicalizujte model, ztrátovou funice pro klasifikaci a optimalizátor
model = pass 
criterion = # nn.CrossEntropyLoss()
optimizer = # optim.Adam() nebo optim SGD() .. model.parameters() l= ...

# Inicalizujte model, ztrátovou funice pro klasifikaci a optimalizátor model = pass criterion = # nn.CrossEntropyLoss() optimizer = # optim.Adam() nebo optim SGD() .. model.parameters() l= ...

In [ ]:

model

model

5. Učení modelu¶

In [ ]:

# Proces učení 
loss_epoch = []
for epoch in range(num_epochs):
    # přepnutí modelu do procesu učení model.train() 
    model.train()
    # vynulování celkové ztráty 
    total_loss = 0
    # cyklus přes dávky trénovacích dat
    for features, labels in train_loader:
        # Predikce (dopředný chod )
        outputs = pass 
        # ztráta 
        loss = pass 
        
        # vynulování gradientu z optimlaizátoru 
        optimizer.zero_grad()
        # zpětný chod (backpropagation) 
        pass 
        # aktualizace vah 
        pass 
        # aktualizace celkové ztráty 
        total_loss += loss.item()
        # ulož ztrátu 
        loss_epoch.append(total_loss)

    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {total_loss/len(train_loader):.4f}")

# Proces učení loss_epoch = [] for epoch in range(num_epochs): # přepnutí modelu do procesu učení model.train() model.train() # vynulování celkové ztráty total_loss = 0 # cyklus přes dávky trénovacích dat for features, labels in train_loader: # Predikce (dopředný chod ) outputs = pass # ztráta loss = pass # vynulování gradientu z optimlaizátoru optimizer.zero_grad() # zpětný chod (backpropagation) pass # aktualizace vah pass # aktualizace celkové ztráty total_loss += loss.item() # ulož ztrátu loss_epoch.append(total_loss) print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {total_loss/len(train_loader):.4f}")

In [ ]:

# Vyzualizuj proce učení 
pass

# Vyzualizuj proce učení pass

Testování přesnosti¶

In [ ]:

# Testování modelu 

# přepnutí modlu do procesu evaluace (testování)
model.eval()

correct = 0
total = 0
with torch.no_grad():
    for features, labels in test_loader:
        outputs = model(features)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = correct / total
print(f"Celková přesnost testování: {accuracy:.2f}")

# Testování modelu # přepnutí modlu do procesu evaluace (testování) model.eval() correct = 0 total = 0 with torch.no_grad(): for features, labels in test_loader: outputs = model(features) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = correct / total print(f"Celková přesnost testování: {accuracy:.2f}")

6. Predikce¶

In [ ]:

pass

pass

Vizualizace výsledku¶

In [ ]:

pass

pass

In [ ]: