Przykładowy przepływ pracy deep learning przy użyciu vGPU i EO-DATA na NSIS
W tym artykule przedstawiono wykorzystanie narzędzi deep learning (TensorFlow/Keras) do wykonywania niestandardowej klasyfikacji obrazów na vGPU w chmurze.
Wykorzystanie (v)GPU przyspieszy obliczenia związane z deep learningiem. W tym przykładzie skróci to czas przetwarzania z kilku godzin do kilku minut.
Model opisany w tym artykule można również zainstalować w środowisku Docker i używać go w nim. Informacje o instalacji zawiera artykuł /cuttingedge/Install-TensorFlow-on-Docker-Running-on-NSIS-vGPU-Virtual-Machine/, a informacje o jego użyciu zawiera artykuł Przykładowy przepływ pracy deep learning wykorzystujący TensorFlow uruchomiony w środowisku Docker na maszynie wirtualnej NSIS vGPU.
Zadanie, do którego zastosujesz TensorFlow, polega na rozpoznaniu, które zestawy obrazów są przycięte, a które nie. W dwóch zestawach obrazów pokazanych poniżej, obrazy po lewej stronie nie są przycięte, a te po prawej są. Model, który opracujesz w tym artykule, będzie w stanie wyciągnąć (mniej więcej) takie same wnioski, jak ludzie dla tego samego zestawu zdjęć.
Ostrzeżenie
Przetwarzanie obrazów satelitarnych to odrębna dyscyplina wykorzystująca różne techniki. Ten artykuł koncentruje się na absolutnych podstawach, aby zademonstrować koncepcję i możliwy przepływ pracy podczas korzystania z deep learningu na maszynie vGPU.
Opracowany tutaj model jest tylko przykładem. Wykorzystanie go w produkcji wymagałoby dalszych testów. Model nie jest deterministyczny i przy każdym treningu będzie dawał inne wyniki.
Co zamierzamy zrobić?
Wyjaśnić szczegółowo kod w języku Python używany w tym procesie.
Pobrać dane do testowania i treningu
Skopiować dane i kodu w języku Python na maszynę wirtualną z obsługą GPU
Zainstalować zależności wymagane przez aplikację (pandas i numpy).
Wytrenować i uruchomić model w oparciu o dane pobrane z tego artykułu.
Przeanalizować wyniki
Wykonać testy porównawcze modelu na wariantach (flavor) vm.a6000.1 i vm.a6000.8 i wykazać, że na drugim z nich proces jest nawet pięć razy szybszy
Wymagania wstępne
Nr 1 Konto
Jest wymagane konto hostingowe NSIS z dostępem do interfejsu Horizon: https://horizon.cloudferro.com.
Nr 2 Utworzenie nowej maszyny wirtualnej z systemem Linux z wirtualnym procesorem graficznym NVIDIA
Jest wymagana maszyna obsługująca vGPU w chmurze: Jak utworzyć nową maszynę wirtualną Linux z NVIDIA Virtual GPU w Dashboardzie OpenStack Horizon na NSIS Cloud
Nr 3 Dodanie floating IP do maszyny wirtualnej
Jak dodać lub usunąć Floating IP maszyny wirtualnej w NSIS.
Teraz będzie można używać tego floating IP w przykładach opisanych w niniejszym artykule.
Nr 4 Zainstalowany TensorFlow
Konieczne jest również zainstalowanie TensorFlow. Instrukcje, jak to zrobić, można znaleźć w artykule: Instalacja TensorFlow na maszynie wirtualnej z włączoną obsługą vGPU na NSIS Cloud. Ten artykuł jest jego bezpośrednią kontynuacją.
Nr 5 Ubuntu 20.04 na komputerze lokalnym
W tym artykule założono, że na lokalnym komputerze jest zainstalowany system Ubuntu 20.04 LTS. Można jednak uruchomić ten model z dowolnego innego systemu operacyjnego, pod warunkiem że będą używane odpowiednie polecenia umożliwiające operacje na plikach, dostęp SSH itp.
Objaśnienie kodu
Ta sekcja zawiera szczegółowe wyjaśnienie tego procesu i wykorzystywanego w nim kodu w języku Python. Aby zapoznać się z praktycznymi krokami umożliwiającymi odtworzenie tego procesu, należy rozpocząć od sekcji Praktyczny przepływ pracy (patrz poniżej). Nie będzie konieczne musiał samodzielne kopiowanie kodu w języku Python, zawarty plik jest dostępny do pobrania.
Krok 1: Przygotowanie danych
Przygotowanie danych jest podstawowym (i zwykle najbardziej czasochłonnym) krokiem w każdym projekcie związanym z Data Science. Aby nasz model deep learningu mógł się uczyć, będziemy postępować zgodnie z typową sekwencją czynności (uczenie nadzorowane):
Przygotuj wystarczająco dużą próbkę danych (w tym przykładzie jest to próbka zdjęć satelitarnych Sentinel-2).
Oznacz te dane ręcznie (tę czynność wykonuje człowiek). W naszym przykładzie ręcznie rozdzieliliśmy obrazy na kategorie „edges” i „noedges”, reprezentujące odpowiednio obrazy przycięte i nieprzycięte.
Wydziel część tych danych jako podzbiór Train(+Validation), który zostanie użyty do uczenia modelu.
Wydziel kolejny podzbiór Test. Jest to podzbiór kontrolny, którego model nigdy nie widzi podczas fazy uczenia się, będzie on używany do oceny jakości modelu.
Plik .zip do pobrania znajdujący się w dalszej części tego artykułu jest już przygotowany (zgodnie z tymi krokami) zbiorem danych. Zawiera on
592 pliki zestawu Train/Validate (po połowie obrazów przyciętych/nieprzyciętych)
148 plików zestawu testowego (również po połowie przyciętych/nieprzyciętych).
Na podstawie nazw katalogów i podkatalogów z tego zbioru danych Keras automatycznie przypisze etykiety, więc ważne jest, aby zachować strukturę folderów bez zmian.
Ostatnim krokiem jest wykonanie niezbędnych operacji na danych, tak aby stanowiły one odpowiednie dane wejściowe dla modelu. TensorFlow wykona dużą część tej pracy za nas. Przykładowo, za pomocą funkcji image_dataset_from_directory, każdy obraz jest automatycznie etykietowany i konwertowany na wektory / macierz liczb: wysokość x szerokość x głębokość (warstwa RGB).
W przypadku konkretnego przypadku użycia może być konieczne wykonanie na tym etapie różnych optymalizacji danych.
import numpy as np
import tensorflow as tf
from tensorflow import keras
import pandas as pd
# DATA INGESTION
# -------------------------------------------------------------------------------------
# Ingest the Training, Validation and Test datasets from image folders.
# The labels (edges vs. noedges) are automatically inferred based on folder names.
train_ds = keras.utils.image_dataset_from_directory(
directory='./data/train',
labels='inferred',
label_mode='categorical',
validation_split=0.2,
subset='training',
image_size=(343, 343),
seed=123,
batch_size=8)
val_ds = keras.utils.image_dataset_from_directory(
directory='./data/train',
labels='inferred',
label_mode='categorical',
validation_split=0.2,
subset='validation',
image_size=(343, 343),
seed=123,
batch_size=8)
test_ds = keras.utils.image_dataset_from_directory(
directory='./data/test',
labels='inferred',
label_mode='categorical',
image_size=(343, 343),
shuffle = False,
batch_size=1)
Krok 2: Definiowanie i szkolenie modelu
Definiowanie optymalnego modelu jest sztuką i nauką Data Science. To, co tutaj pokazujemy, to tylko prosty przykładowy model i należy przeczytać więcej z innych źródeł na temat tworzenia modeli dla rzeczywistych scenariuszy.
Po zdefiniowaniu modelu jest on kompilowany i rozpoczyna się jego szkolenie. Każda epoka to kolejna iteracja dostrajania modelu. Te epoki są złożonymi i intensywnymi operacjami obliczeniowymi. Korzystanie z vGPU ma fundamentalne znaczenie dla aplikacji deep learningu, ponieważ umożliwia rozdzielenie mikrozadań na setki czy tysiące rdzeni, co znacznie przyspiesza proces.
Po dopasowaniu modelu zapiszemy go i ponownie wykorzystamy do generowania prognoz.
# TRAINING
# -------------------------------------------------------------------------------------
# Build, compile and fit the Deep Learning model
model = keras.applications.Xception(
weights=None, input_shape=(343, 343, 3), classes=2)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics='accuracy')
model.fit(train_ds, epochs=5, validation_data=val_ds)
model.save('model_save.h5')
# to reuse the model later:
#model = keras.models.load_model('model_save.h5')
Krok 3: Generowanie prognoz dla danych testowych
Po wytrenowaniu modelu generowanie prognoz jest prostą i znacznie szybszą operacją. W naszym przypadku użyjemy modelu do wygenerowania prognoz dla danych testowych, jak opisano wcześniej.
# GENERATE PREDICTIONS on previously unseen data
# -------------------------------------------------------------------------------------
predictions_raw = model.predict(test_ds)
Krok 4: Podsumowanie wyników
W tym kroku bierzemy rzeczywiste etykiety („edges” i „noedges”, które reprezentują odpowiednio obrazy „przycięte” i „nieprzycięte”) i porównujemy je z etykietami, które przewidział nasz model.
Podsumowujemy wyniki w ramce danych zapisanej jako plik CSV, co umożliwia interpretację rzeczywistych wyników w zestawie testowym w porównaniu z przewidywaniami dostarczonymi przez model.
Przykład danych wyjściowych w formacie CSV:
# SUMMARIZE RESULTS (convenience, alterantive approaches are available)
# -------------------------------------------------------------------------------------
# initialize pandas dataframe with file paths
df = pd.DataFrame(data = {"file_path": test_ds.file_paths})
class_names = test_ds.class_names # ["edges","noedges"]
# add actual labels column
def get_actual_label(label_vector):
for index, value in enumerate(label_vector):
if (value == 1):
return class_names[index]
actual_label_vectors = np.concatenate([label for data, label in test_ds], axis=0).tolist() # returns array of label vectors [[0,1],[1,0],...] representing category (edges/noedges)
actual_labels = list(map(lambda alv: get_actual_label(alv), actual_label_vectors))
df["actual_label"] = actual_labels
# add predicted labels column
predictions_binary = np.argmax(predictions_raw, axis=1) # flatten to 0-1 recommendation
predictions_labeled = list(map(lambda x: class_names[0] if x == 0 else class_names[1],list(predictions_binary)))
df["predicted_label"] = predictions_labeled
df.to_csv("results.csv", index=False)
Praktyczny przepływ pracy
Ta sekcja zawiera praktyczne kroki, które umożliwiają samodzielne wykonanie tego przepływu pracy. Jest to tylko przykład i można samodzielnie utworzyć inny przepływ pracy.
Przed wykonaniem poniższych czynności praktycznych zapoznaj się ponownie z sekcją Wymagania wstępne.
Krok 1: Ładowanie i formatowanie danych
Jeśli jeszcze tego nie zrobiłeś(-aś), rozłącz się z maszyną wirtualną za pomocą następującego polecenia:
exit
Otwórz przeglądarkę internetową i pobierz potrzebne pliki:
Krok 2: Skopiowanie pobranych plików na maszynę wirtualną
Na potrzeby tego artykułu założymy, że przeglądarka pobrała wyżej wymienione pliki do katalogu Downloads w katalogu domowym. Jeśli przeglądarka jest skonfigurowana inaczej, należy odpowiednio zmodyfikować poniższe instrukcje.
Otwórz terminal na komputerze lokalnym i ustaw katalog Downloads jako bieżący katalog roboczy:
cd Downloads
Użyj polecenia scp, aby skopiować pliki na maszynę wirtualną (zastąp 64.225.129.70 floating IP swojej maszyny):
scp ./data.zip ./deeplearning.py [email protected]:/home/eouser/
Krok 3: Instalacja wymaganych pakietów dodatkowych
Połącz się ponownie z maszyną wirtualną za pomocą SSH (zastąp 64.225.129.70 floating IP swojej maszyny):
Ponownie przejdź do wirtualnego środowiska Python (tego, które zostało utworzonew poprzednim artykule Instalacja TensorFlow na maszynie wirtualnej z włączoną obsługą vGPU na NSIS Cloud).
source tensorflowenv/bin/activate
Teraz zainstaluj wymagane biblioteki:
pip install numpy
pip install pandas
Krok 4: Przygotowanie plików
Utwórz katalog, w którym umieścisz pliki wymagane do procesu głębokiego uczenia - na potrzeby tego artykułu zostanie on nazwany deeplearning:
mkdir deeplearning
Przenieś wymagane pliki do tego katalogu:
mv deeplearning.py data.zip deeplearning
Ustaw katalog deeplearning jako bieżący katalog roboczy:
cd deeplearning
Rozpakuj plik zawierający dane i usuń go:
unzip data.zip
Możesz teraz usunąć oryginalne archiwum zip:
rm data.zip
Użyj polecenia ls, aby sprawdzić, czy katalog deeplearning zawiera następujące pliki:
katalog data (zawartość powyższego archiwum ZIP)
plik tekstowy deeplearning.py
Krok 5: Wykonanie pliku z kodem w języku Python
Teraz wykonaj plik tekstowy z kodem w języku Python za pomocą następującego polecenia:
python3 deeplearning.py
Po zakończeniu operacji w bieżącym katalogu roboczym powinien pojawić się plik tekstowy results.csv (zawierający wyniki) oraz plik model_save.h5 (zawierający właśnie wytrenowany model) – sprawdź, czy istnieją za pomocą polecenia ls.
Krok 6: Pobranie wyników i wytrenowanego modelu na komputer lokalny
Aby przenieść te pliki na komputer lokalny, należy najpierw odłączyć się od maszyny wirtualnej za pomocą następującego polecenia:
exit
Teraz ustaw katalog, do którego chcesz pobrać ten plik, jako bieżący katalog roboczy i upewnij się, że nie ma w nim żadnego pliku o nazwie results.csv lub model_save.h5. Możesz teraz pobrać pliki za pomocą następującego polecenia (zastąp 64.225.129.70 floating IP swojej maszyny wirtualnej):
scp [email protected]:/home/eouser/deeplearning/results.csv [email protected]:/home/eouser/deeplearning/model_save.h5 .
Pliki powinny teraz znajdować się na komputerze lokalnym:
Porównanie wydajności
Ten artykuł zakłada, że TensforFlow jest zainstalowany bezpośrednio w chmurze. Istnieje równoległy artykuł z tym samym przykładem w środowisku Docker (Przykładowy przepływ pracy deep learning wykorzystujący TensorFlow uruchomiony w środowisku Docker na maszynie wirtualnej NSIS vGPU). Teraz zamierzamy porównać czasy działania w tych środowisk, używając najmniejszych i największych wersji obrazów (flavor) dla vGPU, vm.a6000.1 i vm.a6000.8.
Poniższa tabela zawiera czas potrzebny do zakończenia wykonywania kodu w języku Python. Został on zmierzony przy użyciu polecenia time („wartość rzeczywista”). Wszystkie testy zostały przeprowadzone w chmurze NSIS.
+---------------------+-------------+-----------------+
| | vm.a6000.1 | vm.a6000.8 |
| Docker used | 5m50.449s | 1m14.446s |
| Docker not not used | 5m0.276s | 0m55.547s |
Cały proces zajął około 5 razy mniej czasu na wersji instancji (flavor) vm.a6000.8 niż na wersji vm.a6000.1. W przypadku korzystania z Dockera występuje niewielkie zmniejszenie wydajności, ale jest to oczekiwane.
Informacja
Ten test porównawczy uwzględnia wszystkie fazy wykonywania kodu w języku Python i nie wszystkie z nich mogą w takim samym stopniu wykorzystywać lepszy sprzęt.
Co można dalej zrobić
Ten przepływ pracy można również wykonać, instalując środowisko bezpośrednio w chmurze NSIS. Jeśli chcesz to zrobić, zapoznaj się z następującym artykułem: Przykładowy przepływ pracy deep learning wykorzystujący TensorFlow uruchomiony w środowisku Docker na maszynie wirtualnej NSIS vGPU.
Ostrzeżenie
Przykłady w tym artykule mogą być niereprezentatywne, a ich przebieg może się różnić. Użyj tego kodu i całego artykułu jako punktu wyjścia do przeprowadzenia własnych badań.