Używaj jednostek Coral Edge TPU do uruchamiania modeli TFlite w Node.js z TensorFlow.js

1. Wprowadzenie

Ostatnia aktualizacja: 11.04.2022

Z tego ćwiczenia w Codelabs dowiesz się, jak wytrenować model klasyfikacji obrazów za pomocą Teachable Machine i uruchomić go z akceleracją sprzętową Coral przy użyciu TensorFlow.js, zaawansowanej i elastycznej biblioteki uczenia maszynowego w JavaScript. Tworzysz aplikację Electron, która wyświetla obrazy z kamery internetowej i klasyfikuje je za pomocą urządzenia Coral Edge TPU. W pełni działająca wersja tego ćwiczenia jest dostępna w repozytorium GitHub sig-tfjs.

Czy potrzebuję urządzenia Coral?

Nie. Możesz wypróbować to ćwiczenie bez urządzenia Coral i uzyskać dobrą wydajność na komputerze stacjonarnym, korzystając zamiast tego z akceleratora WebNN.

Co utworzysz

W tym ćwiczeniu utworzysz aplikację Electron, która klasyfikuje obrazy. Twoja aplikacja:

• Klasyfikuje obrazy z kamery internetowej w kategoriach zdefiniowanych w wytrenowanym modelu.
• Korzysta z akceleratora Coral, aby zwiększyć wydajność, jeśli jest dostępny.
• Wykorzystuje WebNN do zwiększania wydajności, jeśli jest obsługiwany na Twojej platformie.

Czego się nauczysz

• Jak zainstalować i skonfigurować pakiet NPM tfjs-tflite-node, aby uruchamiać modele TFLite w Node.js.
• Jak zainstalować bibliotekę środowiska wykonawczego Edge TPU, aby uruchamiać modele na urządzeniu Coral.
• Jak przyspieszyć wnioskowanie modelu za pomocą Coral Edge TPU.
• Jak przyspieszyć wnioskowanie modelu za pomocą WebNN.

To ćwiczenie koncentruje się na TFLite w Node.js. Nieistotne koncepcje i bloki kodu zostały pominięte. Można je po prostu skopiować i wkleić.

Czego potrzebujesz

Aby ukończyć to ćwiczenie, potrzebujesz:

• komputer z kamerą internetową,
• W przypadku Coral zalecamy używanie Raspberry Pi z systemem Raspberry Pi OS (64-bit) z interfejsem.
• W przypadku WebNN zalecamy komputer Intel x86-64 z systemem Ubuntu 20.04 lub Windows 10.
• Wersja Node.js musi być co najmniej 12.
• Znajomość języka JavaScript.
• (Zalecane) akcelerator USB Coral, który przyspiesza działanie modelu.

2. Konfiguracja

Pobierz kod

Cały kod potrzebny do tego projektu umieściliśmy w repozytorium Git. Aby rozpocząć, pobierz kod i otwórz go w ulubionym środowisku programistycznym. W tym ćwiczeniu zalecamy użycie Raspberry Pi z systemem Raspberry Pi OS (64-bit) z interfejsem graficznym. Ułatwia to podłączenie akceleratora Coral.

Zdecydowanie zalecane: użyj Gita, aby sklonować repozytorium na Raspberry Pi

Aby uzyskać kod, otwórz nowe okno terminala i sklonuj repozytorium:

git clone https://github.com/tensorflow/sig-tfjs.git

Wszystkie pliki, które musisz edytować w ramach tego ćwiczenia w Codelabs, znajdują się w katalogu tfjs-tflite-node-codelab (w katalogu sig-tfjs). W tym katalogu znajdziesz podkatalogi o nazwach starter_code, cpu_inference_working, coral_inference_working i webnn_inference_working. Są to punkty kontrolne poszczególnych kroków tego ćwiczenia.

W repozytorium znajdują się też pakiety NPM, od których zależy tfjs-tflite-node-codelab. Nie musisz edytować tych plików, ale musisz uruchomić niektóre z nich, aby mieć pewność, że środowisko jest skonfigurowane poprawnie.

Instalowanie biblioteki środowiska wykonawczego Edge TPU

Przed użyciem urządzeń Coral musisz zainstalować bibliotekę środowiska wykonawczego Edge TPU. Zainstaluj go, postępując zgodnie z instrukcjami dotyczącymi Twojej platformy.

W systemie Linux / Raspberry Pi

W systemie Linux biblioteka jest dostępna w repozytorium PPA Google jako pakiet Debiana libedgetpu1-std dla architektur x86-64 i Armv8 (64-bitowej). Jeśli Twój procesor korzysta z innej architektury, musisz skompilować go ze źródła.

Uruchom to polecenie, aby dodać PPA Coral od Google i zainstalować bibliotekę środowiska wykonawczego Edge TPU.

# None of this is needed on Coral boards
# This repo is needed for almost all packages below
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
# This repo is needed for only python3-coral-cloudiot and python3-coral-enviro
echo "deb https://packages.cloud.google.com/apt coral-cloud-stable main" | sudo tee /etc/apt/sources.list.d/coral-cloud.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update
sudo apt-get install libedgetpu1-std

W systemie Windows lub innym systemie operacyjnym

Wstępnie skompilowane pliki binarne są dostępne w wersjach x86-64 systemów MacOS i Windows. Po pobraniu można je zainstalować, uruchamiając skrypt install.sh lub install.bat w archiwum.

Ponownie uruchom urządzenie

Po zainstalowaniu środowiska wykonawczego Edge TPU uruchom ponownie urządzenie, aby aktywować nową regułę Coral Udev dodaną przez instalator.

Sprawdź, czy urządzenie Coral jest wykrywane

Aby sprawdzić, czy urządzenie Coral jest wykrywane i działa, uruchom testy integracyjne dla pakietu coral-tflite-delegate. Ten pakiet znajduje się w katalogu głównym repozytorium. Aby uruchomić testy integracji, podłącz akcelerator Coral i uruchom te polecenia w katalogu pakietu:

npx yarn
npx yarn build-deps
npx yarn test-integration

Uwaga: jeśli symbol npx jest niedostępny, sprawdź, czy masz zainstalowany Node.js. Aby zainstalować Node, postępuj zgodnie z instrukcjami na stronie nodejs.org. Zainstaluj wersję co najmniej 12. Uruchomienie polecenia apt install nodejs może spowodować zainstalowanie Node 10, którego nie należy używać w tym ćwiczeniu.

Powinny się wyświetlić dane wyjściowe podobne do tych:

yarn run v1.22.17
$ yarn build && yarn test-integration-dev
$ tsc
$ jasmine --config=jasmine-integration.json
Platform node has already been set. Overwriting the platform with node.
Randomized with seed 78904
Started

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
WARNING: converting 'int32' to 'uint8'
.


1 spec, 0 failures
Finished in 2.777 seconds
Randomized with seed 78904 (jasmine --random=true --seed=78904)
Done in 6.36s.

Nie musisz instalować @tensorflow/tfjs-node,, o którym mowa w logach, ponieważ model będzie uruchamiany w TFLite.

Jeśli dane wyjściowe zawierają Encountered unresolved custom op: edgetpu-custom-op, oznacza to, że urządzenie Coral nie zostało wykryte. Upewnij się, że masz zainstalowaną bibliotekę środowiska wykonawczego Edge TPU i że urządzenie Coral jest podłączone do komputera. Możesz też skorzystać z przewodnika Coral dla początkujących, aby przetestować wersję Python wiązań Coral. Jeśli wersja w Pythonie działa, ale te testy nadal się nie powiodły, zgłoś błąd.

Uruchamianie kodu startowego

Teraz możesz uruchomić kod startowy. Aby rozpocząć, wykonaj te czynności.

1. Przejdź do katalogu starter_code w katalogu tfjs-tflite-node-codelab.
2. uruchom npm install, aby zainstalować zależności.
3. Uruchom npm start, aby otworzyć projekt. Powinna otworzyć się aplikacja wyświetlająca obraz z kamery internetowej komputera.

Uwaga: jeśli używasz płytki deweloperskiej Coral i npm install zgłasza błąd ENOMEM, uruchom polecenie npm rebuild && npm install, aby ponownie skompilować uszkodzone pakiety.

Jaki jest nasz punkt początkowy?

Punktem początkowym jest podstawowa aplikacja aparatu Electron zaprojektowana na potrzeby tego ćwiczenia. Kod został uproszczony, aby przedstawić koncepcje w tym ćwiczeniu, i zawiera niewiele mechanizmów obsługi błędów. Jeśli zdecydujesz się ponownie użyć kodu w aplikacji produkcyjnej, upewnij się, że obsługujesz wszystkie błędy i dokładnie przetestuj cały kod.

Zapoznaj się z kodem startowym

W tym kodzie startowym jest wiele plików, ale musisz edytować tylko plik renderer.js. Określa, co ma się wyświetlać na stronie, w tym kanał wideo i elementy HTML, oraz umożliwia dodanie do aplikacji modelu uczenia maszynowego. Wśród innych plików znajduje się plik index.html, ale jego jedynym zadaniem jest wczytywanie pliku renderer.js. Jest też plik main.js, który jest punktem wejścia dla Electrona. Kontroluje ona cykl życia aplikacji, w tym to, co ma się wyświetlać po jej otwarciu i co ma się dziać po jej zamknięciu, ale nie musisz w niej niczego zmieniać.

Otwórz debuger

Podczas wykonywania tego ćwiczenia możesz potrzebować debugowania aplikacji. Ta aplikacja jest oparta na Electronie, więc ma wbudowany debugger Chrome. Na większości platform możesz otworzyć je za pomocą kombinacji klawiszy Ctrl + Shift + I. Kliknij kartę Konsola, aby wyświetlić logi i komunikaty o błędach z aplikacji.

Nie ma tu już nic więcej do odkrycia, więc przejdźmy od razu do trenowania klasyfikatora obrazów.

3. Trenowanie klasyfikatora obrazów

W tej sekcji wytrenujesz wersje TFLite i Coral niestandardowego modelu klasyfikacji obrazów.

Trenowanie klasyfikatora

Klasyfikator obrazów przyjmuje obrazy wejściowe i przypisuje im etykiety. W tym ćwiczeniu użyjesz Teachable Machine do wytrenowania modelu w przeglądarce. Aby przyspieszyć trenowanie w tej sekcji, możesz użyć komputera lub laptopa zamiast Raspberry Pi, ale musisz skopiować uzyskane pliki na Raspberry Pi.

Możesz już wytrenować model. Jeśli nie wiesz, jaki model wytrenować, możesz zacząć od prostego modelu wykrywającego osoby, który po prostu sprawdza, czy w kadrze znajduje się człowiek.

1. Otwórz stronę szkoleniową Teachable Machine w nowej karcie.
2. Wybierz Projekt obrazu, a następnie Standardowy model obrazu.
3. Dodaj przykłady obrazów dla każdej klasy. Najłatwiej to zrobić, korzystając z kamery internetowej. Możesz też zmienić nazwy zajęć.
4. Gdy zbierzesz wystarczającą ilość danych dla każdej klasy (zwykle wystarczy 50 próbek), kliknij Train Model (Trenuj model).

Po zakończeniu trenowania modelu powinna pojawić się jego wersja podglądowa.

Spróbuj podać modelowi inne dane wejściowe. Jeśli znajdziesz dane wejściowe, które zostały nieprawidłowo sklasyfikowane, dodaj je do danych treningowych i ponownie wytrenuj model.

5. Gdy będziesz zadowolony(-a) z dokładności modelu, kliknij Eksportuj model. Musisz pobrać 2 osobne wersje modelu.
6. Wyeksportuj model jako model zmiennoprzecinkowy TensorFlow Lite. Spowoduje to pobranie pliku o nazwie converted_tflite.zip. który działa na procesorze.
7. Wyeksportuj model jako model Tensorflow Lite EdgeTPU. Zostanie pobrany plik o nazwie converted_edgetpu.zip, który działa na Coral Edge TPU.

Wskazówka: aby zwiększyć dokładność, używaj w próbkach obrazów różnych rotacji, pozycji i teł. Jeśli masz laptopa, użyj go, aby łatwiej zebrać te próbki.

4. Uruchamianie modelu procesora w aplikacji

Masz już wytrenowany model, czas więc dodać go do aplikacji. Po ukończeniu tej sekcji aplikacja będzie mogła uruchamiać model za pomocą procesora urządzenia.

Dodawanie pliku modelu do aplikacji

Rozpakuj pobrany podczas trenowania klasyfikatora plik modelu converted_tflite.zip. Archiwum zawiera 2 pliki. model_uquant.tflite to zapisany model TFLite, w tym wykres modelu i wagi. labels.txt zawiera zrozumiałe dla człowieka etykiety klas, które model prognozuje. Umieść oba pliki w modeldirectory.

Instalowanie zależności

Wczytywanie modelu i przetwarzanie wstępne danych wejściowych wymaga kilku zależności z TensorFlow.js:

• tfjs-tflite-node: pakiet TensorFlow.js do uruchamiania modeli TFLite w Node.js.
• @tensorflow/tfjs: główny pakiet TensorFlow.js.

Pakiet @tensorflow/tfjs jest już zainstalowany, ale musisz zainstalować pakiet tfjs-tflite-node za pomocą tego polecenia:

npm install --save tfjs-tflite-node

Po zainstalowaniu dodaj go do aplikacji u góry pliku renderer.js:

CODELAB, część 1. Importowanie tfjs-tflite-node.

const {loadTFLiteModel} = require('tfjs-tflite-node');

Wczytaj model

Teraz możesz wczytać model. tfjs-tflite-node udostępnia w tym celu funkcję loadTFLiteModel. Może wczytywać modele ze ścieżki pliku, ArrayBuffer lub adresu URL TFHub. Aby wczytać model i jego wagi, dodaj to do funkcji main:

CODELAB part 1: Load the model here.

const modelPath = './model/model_unquant.tflite';
const model = await loadTFLiteModel(modelPath);
const labels = fs.readFileSync('./model/labels.txt', 'utf8')
      .split('\n');

Uruchamianie modelu

Uruchomienie modelu wymaga wykonania 3 kroków. Najpierw pobierasz i przetwarzasz wstępnie klatkę wejściową z kamery internetowej. Następnie uruchamiasz model na tej klatce i uzyskujesz prognozę. Następnie wyświetl prognozę na stronie.

Wstępne przetwarzanie danych z kamery internetowej

Obecnie kamera internetowa jest tylko elementem HTML, a wyświetlane przez nią klatki nie są dostępne dla pliku JavaScript renderer.js. Aby pobierać klatki z kamery internetowej, TensorFlow.js udostępnia funkcję tf.data.webcam, która zawiera łatwą w użyciu metodę capture() do przechwytywania klatek z kamery.

Aby go użyć, dodaj ten kod konfiguracji do main():

CODELAB part 1: Set up tf.data.webcam here.

const tensorCam = await tf.data.webcam(webcam);

Następnie, aby rejestrować obraz w każdej klatce, dodaj do run() ten kod:

CODELAB part 1: Capture webcam frames here.

const image = await tensorCam.capture();

Musisz też wstępnie przetworzyć każdą klatkę, aby była zgodna z modelem. Model używany w tym ćwiczeniu ma kształt wejściowy [1, 224, 224, 3], więc oczekuje obrazu RGB o rozmiarze 224 x 224 piksele. Funkcja tensorCam.capture()zwraca kształt [224, 224, 3], więc musisz dodać dodatkowy wymiar na początku tensora za pomocą funkcji tf.expandDims. Dodatkowo model procesora oczekuje danych wejściowych Float32 z zakresu od -1 do 1, ale kamera internetowa rejestruje wartości od 0 do 255. Możesz podzielić tensor wejściowy przez 127, aby zmienić jego zakres z [0, 255] na [0, ~2], a następnie odjąć 1, aby uzyskać żądany zakres [−1, ~1]. Aby to zrobić, dodaj te wiersze do tf.tidy() w funkcji run():

CODELAB part 1: Preprocess webcam frames here.

const expanded = tf.expandDims(image, 0);
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));

Po użyciu tensorów należy je usunąć. tf.tidy() robi to automatycznie w przypadku kodu zawartego w wywołaniu zwrotnym, ale nie obsługuje funkcji asynchronicznych. Musisz ręcznie usunąć utworzony wcześniej tensor obrazu, wywołując jego metodę dispose().

CODELAB part 1: Dispose webcam frames here.

image.dispose();

Uruchamianie modelu i wyświetlanie wyników

Aby uruchomić model na wstępnie przetworzonych danych wejściowych, wywołaj funkcję model.predict() na znormalizowanym tensorze. Zwraca tensor jednowymiarowy zawierający przewidywane prawdopodobieństwo każdej etykiety. Pomnóż to prawdopodobieństwo przez 100, aby uzyskać procentowe prawdopodobieństwo każdej etykiety, i użyj funkcji showPrediction dołączonej do kodu startowego, aby wyświetlić na ekranie prognozę modelu.

Ten kod używa też biblioteki stats.js do pomiaru czasu trwania prognozy przez umieszczanie wywołań funkcji stats.begin i stats.end wokół funkcji model.predict.

CODELAB part 1: Run the model and display the results here.

stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);

Ponownie uruchom aplikację za pomocą yarn start. Powinny się wyświetlić klasyfikacje z Twojego modelu.

Wydajność

Obecnie model jest skonfigurowany tak, aby działał na procesorze. Jest to odpowiednie rozwiązanie w przypadku komputerów stacjonarnych i większości laptopów, ale może nie być pożądane, jeśli stosujesz je na Raspberry Pi lub innym urządzeniu o niskim poborze mocy. Na Raspberry Pi 4 prawdopodobnie zobaczysz około 10 klatek na sekundę, co może nie być wystarczająco szybkie w przypadku niektórych aplikacji. Aby uzyskać lepszą wydajność bez używania szybszego urządzenia, możesz użyć krzemu przeznaczonego do konkretnych zastosowań w postaci Coral Edge TPU.

5. Uruchamianie modelu Coral w aplikacji

Jeśli nie masz urządzenia Coral, możesz pominąć tę sekcję.

Ten etap ćwiczenia opiera się na kodzie napisanym w ostatniej sekcji, ale jeśli chcesz zacząć od początku, możesz użyć punktu kontrolnego cpu_inference_working.

Czynności związane z uruchamianiem modelu Coral są prawie identyczne jak w przypadku modelu procesora. Główna różnica polega na formacie modelu. Ponieważ Coral obsługuje tylko tensory uint8, model jest skwantyzowany. Ma to wpływ na tensory wejściowe przekazywane do modelu i tensory wyjściowe, które zwraca. Kolejną różnicą jest to, że modele muszą być kompilowane za pomocą kompilatora Edge TPU, aby można było je uruchamiać na Coral TPU. Teachable Machine wykonało już ten krok, ale więcej informacji o tym, jak to zrobić w przypadku innych modeli, znajdziesz w dokumentacji Coral.

Dodawanie pliku modelu Coral do aplikacji

Rozpakuj pobrany podczas trenowania klasyfikatora plik modelu converted_edgetpu.zip. Archiwum zawiera 2 pliki. model_edgetpu.tflite to zapisany model TFLite, w tym wykres modelu i wagi. labels.txt zawiera zrozumiałe dla człowieka etykiety klas, które model prognozuje. Umieść plik modelu w katalogu coral_model.

Instalowanie zależności

Uruchamianie modeli Coral wymaga biblioteki środowiska wykonawczego Edge TPU. Zanim przejdziesz dalej, upewnij się, że aplikacja została zainstalowana zgodnie z instrukcjami konfiguracji.

Urządzenia Coral są dostępne jako delegaty TFLite. Aby uzyskać do nich dostęp z JavaScriptu, zainstaluj pakiet coral-tflite-delegate:

npm install --save coral-tflite-delegate

Następnie zaimportuj delegata, dodając ten wiersz na początku pliku renderer.js:

CODELAB part 2: Import the delegate here.

const {CoralDelegate} = require('coral-tflite-delegate');

Wczytaj model

Teraz możesz wczytać model Coral. Robisz to w taki sam sposób jak w przypadku modelu CPU, z tym że teraz przekazujesz opcje do funkcji loadTFLiteModel, aby załadować delegata Coral.

CODELAB part 2: Load the delegate model here.

const coralModelPath = './coral_model/model_edgetpu.tflite';
const options = {delegates: [new CoralDelegate()]};
const coralModel = await loadTFLiteModel(coralModelPath, options);

Nie musisz wczytywać etykiet, ponieważ są one takie same jak w przypadku modelu CPU.

Dodawanie przycisku przełączania między procesorem a Coral

Dodaj model Coral obok modelu procesora dodanego w ostatniej sekcji. Uruchamianie ich jednocześnie utrudnia dostrzeganie różnic w wydajności, dlatego przycisk przełączania umożliwia przełączanie między wykonywaniem na Coral a wykonywaniem na procesorze.

Dodaj przycisk za pomocą tego kodu:

CODELAB part 2: Create the delegate button here.

let useCoralDelegate = false;
const toggleCoralButton = document.createElement('button');
function toggleCoral() {
  useCoralDelegate = !useCoralDelegate;
  toggleCoralButton.innerText = useCoralDelegate
      ? 'Using Coral. Press to switch to CPU.'
      : 'Using CPU. Press to switch to Coral.';
}
toggleCoralButton.addEventListener('click', toggleCoral);
toggleCoral();
document.body.appendChild(toggleCoralButton);

Połączmy ten warunek z funkcją run(). Gdy wartość useCoralDelegate jest fałszywa, powinna być uruchamiana wersja na procesor. W przeciwnym razie uruchamia wersję Coral (ale na razie nic nie robi). Owiń kod uruchamiający model procesora instrukcją warunkową. Zwróć uwagę, że tensor expanded został pominięty w instrukcji if, ponieważ jest używany przez model Coral.

CODELAB part 2: Check whether to use the delegate here.

// NOTE: Don't just copy-paste this code into the app.
// You'll need to edit the code from the CPU section.
const expanded = tf.expandDims(image, 0);
if (useCoralDelegate) {
  // CODELAB part 2: Run Coral prediction here.
} else {
  const divided = tf.div(expanded, tf.scalar(127));
  const normalized = tf.sub(divided, tf.scalar(1));
  stats.begin();
  const prediction = model.predict(normalized);
  stats.end();
  const percentage = tf.mul(prediction, tf.scalar(100));
  showPrediction(percentage.dataSync(), labels);
}

Uruchamianie modelu

Wersja modelu Coral oczekuje tensorów uint8 z zakresu od 0 do 255, więc nie wymaga normalizacji danych wejściowych. Dane wyjściowe to jednak też tensor uint8 z zakresu od 0 do 255. Zanim zostanie wyświetlona, musi zostać przekonwertowana na liczbę zmiennoprzecinkową z zakresu od 0 do 100.

CODELAB part 2: Run Coral prediction here. (To część fragmentu kodu powyżej)

stats.begin();
const prediction = coralModel.predict(expanded);
stats.end();
const percentage = tf.div(tf.mul(prediction, tf.scalar(100)), tf.scalar(255));
showPrediction(percentage.dataSync(), labels);

Uruchom ponownie aplikację z parametrem yarn start. Powinna ona wyświetlać klasyfikacje z akceleratora Coral.

Możesz przełączać się między wnioskowaniem na urządzeniu Coral a wnioskowaniem na procesorze, naciskając przycisk. Możesz zauważyć, że rankingi ufności modelu Coral są mniej precyzyjne niż w przypadku modelu CPU i zwykle kończą się parzystym miejscem po przecinku. Ta utrata precyzji jest kompromisem związanym z uruchamianiem skwantyzowanego modelu na urządzeniu Coral. W praktyce zwykle nie ma to znaczenia, ale warto o tym pamiętać.

Uwaga dotycząca wydajności

Liczba klatek na sekundę, którą widzisz, obejmuje przetwarzanie wstępne i postprocessing, więc nie odzwierciedla możliwości sprzętu Coral. Aby lepiej poznać wydajność, klikaj miernik FPS, aż wyświetli się opóźnienie (w milisekundach), które mierzy tylko wywołanie funkcji model.predict. Obejmuje to jednak czas potrzebny na przeniesienie tensorów do natywnych powiązań C TFLite, a następnie na urządzenie Coral, więc nie jest to idealny pomiar. Bardziej precyzyjne testy wydajności napisane w C++ znajdziesz na stronie testów porównawczych EdgeTPU.

Warto też zauważyć, że film został nagrany na laptopie, a nie na Raspberry Pi, więc możesz zobaczyć inną liczbę klatek na sekundę.

Przyspieszanie przetwarzania wstępnego na urządzeniach Coral

W niektórych przypadkach możesz przyspieszyć przetwarzanie wstępne, przełączając backendy TFJS. Domyślny backend to WebGL, który sprawdza się w przypadku dużych operacji, które można wykonywać równolegle, ale ta aplikacja nie wykonuje wielu takich operacji w fazie wstępnego przetwarzania (używa tylko operacji expandDims, która nie jest wykonywana równolegle). Aby uniknąć dodatkowego opóźnienia związanego z przenoszeniem tensorów na procesor graficzny i z niego, możesz przełączyć się na backend procesora, dodając ten wiersz po importach u góry pliku.

tf.setBackend(‘cpu');

Ma to też wpływ na przetwarzanie wstępne w przypadku modelu TFLite CPU, które jest wykonywane równolegle, więc po wprowadzeniu tej zmiany model działa znacznie wolniej.

6. Przyspieszanie modelu CPU za pomocą WebNN

Jeśli nie masz akceleratora Coral lub chcesz wypróbować inny sposób na przyspieszenie działania modelu, możesz użyć delegata WebNN TFLite. Ten delegat korzysta ze sprzętu do uczenia maszynowego wbudowanego w procesory Intel, aby przyspieszyć wnioskowanie modelu za pomocą zestawu narzędzi OpenVINO. W związku z tym ma dodatkowe wymagania, które nie zostały omówione w sekcji konfiguracji tego ćwiczenia, i musisz zainstalować zestaw narzędzi OpenVINO. Zanim przejdziesz dalej, sprawdź, czy Twoja konfiguracja jest zgodna z obsługiwanymi platformami systemu docelowego. Pamiętaj jednak, że delegat WebNN nie obsługuje jeszcze systemu macOS.

Instalowanie pakietu narzędzi OpenVINO

Zestaw narzędzi OpenVINO wykorzystuje sprzęt do uczenia maszynowego wbudowany w procesory Intel, aby przyspieszać działanie modeli. Możesz pobrać wstępnie skompilowaną wersję od firmy Intel lub skompilować ją ze źródła. OpenVINO można zainstalować na kilka sposobów, ale na potrzeby tego ćwiczenia zalecamy użycie skryptu instalatora dla Windowsa lub Linux. Zainstaluj środowisko wykonawcze LTS w wersji 2021.4.2, ponieważ inne wersje mogą być niezgodne. Po uruchomieniu instalatora skonfiguruj zmienne środowiskowe powłoki zgodnie z instrukcjami instalacji dla systemu Linux lub Windows ( trwałe rozwiązanie) albo uruchamiając polecenie setupvars.sh (Linux) lub setupvars.bat (Windows) znajdujące się w katalogu webnn-tflite-delegate.

Uwaga dotycząca systemu Windows: polecenie setupvars.bat nie obsługuje powłoki Bash, więc uruchamiaj je i inne polecenia z tego ćwiczenia w wierszu poleceń systemu Windows.

Sprawdzanie działania delegata WebNN

Aby sprawdzić, czy delegat WebNN działa prawidłowo, uruchom testy integracyjne pakietu webnn-tflite-delegate znajdujące się w katalogu głównym repozytorium. Aby uruchomić testy integracji, w katalogu pakietu uruchom te polecenia:

# In webnn-tflite-delegate/
npx yarn
npx yarn test-integration

Powinny się wyświetlić dane wyjściowe podobne do tych:

WebNN delegate: WebNN device set to 0.
INFO: Created TensorFlow Lite WebNN delegate for device Default and power Default.

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
label: wine bottle
score:  0.934505045413971
.


1 spec, 0 failures
Finished in 0.446 seconds
Randomized with seed 58441 (jasmine --random=true --seed=58441)
Done in 8.07s.

Jeśli zobaczysz dane wyjściowe podobne do tych, oznacza to błąd konfiguracji:

Platform node has already been set. Overwriting the platform with node.
Randomized with seed 05938
Started
error Command failed with exit code 3221225477.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

Ten wynik najprawdopodobniej oznacza, że nie masz ustawionych zmiennych środowiskowych OpenVINO. Na razie możesz je ustawić, uruchamiając polecenie setupvars.sh (Linux) lub setupvars.bat (Windows), ale możesz też ustawić je na stałe, postępując zgodnie z instrukcjami dotyczącymi Linux lub Windowsa ( trwałe rozwiązanie). Jeśli używasz systemu Windows, kliknij

setupvars.bat

nie obsługuje Git Basha, więc uruchom to i inne polecenia z tego samouczka w wierszu poleceń systemu Windows.

Instalowanie delegata WebNN

Po zainstalowaniu OpenVINO możesz przyspieszyć działanie modelu CPU za pomocą WebNN. Ta sekcja samouczka opiera się na kodzie napisanym w sekcji „Uruchamianie modelu na procesorze w aplikacji”. Możesz użyć kodu napisanego w tym kroku, ale jeśli masz już za sobą sekcję dotyczącą Coral, użyj punktu kontrolnego cpu_inference_working, aby zacząć od początku.

Część delegata WebNN w Node.js jest rozpowszechniana w npm. Aby go zainstalować, uruchom to polecenie:

npm install --save webnn-tflite-delegate

Następnie zaimportuj delegata, dodając ten wiersz na początku pliku renderer.js:

CODELAB part 2: Import the delegate here.

const {WebNNDelegate, WebNNDevice} = require('webnn-tflite-delegate');

Delegat WebNN obsługuje uruchamianie na procesorze lub GPU. WebNNDevice umożliwia wybór, którego z nich chcesz użyć.

Wczytaj model

Teraz możesz wczytać model z włączonym delegatem WebNN. W przypadku Coral trzeba było wczytać inny plik modelu, ale WebNN obsługuje ten sam format modelu co TFLite. Aby włączyć delegata WebNNDelegate, dodaj go do listy delegatów przekazywanych do modelu:

CODELAB part 2: Load the delegate model here.

let webnnModel = await loadTFLiteModel(modelPath, {
  delegates: [new WebNNDelegate({webnnDevice: WebNNDevice.DEFAULT})],
});

Nie musisz ponownie wczytywać etykiet, ponieważ jest to ten sam model.

Dodawanie przycisku do przełączania między TfLite CPU a WebNN

Gdy wersja modelu WebNN będzie gotowa, dodaj przycisk, który umożliwi przełączanie się między wnioskowaniem WebNN a TfLite CPU. Uruchamianie ich w tym samym czasie utrudnia dostrzeganie różnic w skuteczności.

Dodaj przycisk za pomocą tego kodu (pamiętaj, że nie będzie on jeszcze przełączać modeli):

CODELAB part 2: Create the delegate button here.

let useWebNNDelegate = false;
const divElem = document.createElement('div');
const toggleWebNNButton = document.createElement('button');
function toggleWebNN() {
  useWebNNDelegate = !useWebNNDelegate;
  toggleWebNNButton.innerHTML = useWebNNDelegate
      ? 'Using WebNN. Press to switch to TFLite CPU.'
      : 'Using TFLite CPU. Press to switch to WebNN.';
  divElem.hidden = useWebNNDelegate ? false : true;
}

toggleWebNNButton.addEventListener('click', toggleWebNN);
toggleWebNN();
document.body.appendChild(toggleWebNNButton);
document.body.appendChild(divElem);

Ten kod dodaje też element div, którego użyjesz do skonfigurowania ustawień WebNN w następnej sekcji.

Dodawanie menu, aby przełączać się między urządzeniami WebNN

WebNN obsługuje uruchamianie na procesorze i GPU, więc dodaj menu, aby można było się między nimi przełączać. Dodaj ten kod po kodzie, który tworzy przycisk:

// Create elements for WebNN device selection
divElem.innerHTML = '<br/>WebNN Device: ';
const selectElem = document.createElement('select');
divElem.appendChild(selectElem);

const webnnDevices = ['Default', 'GPU', 'CPU'];
// append the options
for (let i = 0; i < webnnDevices.length; i++) {
  var optionElem = document.createElement('option');
  optionElem.value = i;
  optionElem.text = webnnDevices[i];
  selectElem.appendChild(optionElem);
}

Jeśli teraz uruchomisz aplikację, zobaczysz menu z opcjami Domyślny, GPU i CPU. Wybranie jednej z nich nie spowoduje teraz żadnej zmiany, ponieważ menu nie zostało jeszcze podłączone.

Zmienianie urządzenia za pomocą menu

Aby połączyć menu tak, aby zmieniało używane urządzenie WebNN, dodaj detektor do zdarzenia change elementu selektora menu. Gdy wybrana wartość się zmieni, ponownie utwórz model WebNN z odpowiednim urządzeniem WebNN wybranym w opcjach delegowania.

Po kodzie, który dodał menu, dodaj ten kod:

selectElem.addEventListener('change', async () => {
  let webnnDevice;
  switch(selectElem.value) {
    case '1':
      webnnDevice = WebNNDevice.GPU;
      break;
    case '2':
      webnnDevice = WebNNDevice.CPU;
      break;
    default:
      webnnDevice = WebNNDevice.DEFAULT;
      break;
  }
  webnnModel = await loadTFLiteModel(modelPath, {
    delegates: [new WebNNDelegate({webnnDevice})],
  });
});

Dzięki tej zmianie menu będzie za każdym razem tworzyć nowy model z prawidłowymi ustawieniami. Teraz czas podłączyć model WebNN i użyć go do wnioskowania.

Uruchamianie modelu WebNN

Model WebNN jest gotowy do użycia, ale przycisk przełączania między WebNN a TfLite CPU nie przełącza jeszcze modelu. Aby przełączyć model, musisz najpierw zmienić nazwę zmiennej model z pierwszej sekcji tego samouczka, w której wczytano model TfLite CPU.

Zmień następny wiersz...

const model = await loadTFLiteModel(modelPath);

...aby pasował do tego wiersza.

const cpuModel = await loadTFLiteModel(modelPath);

Zmień nazwę zmiennej model na cpuModel i dodaj ją do funkcji run, aby wybrać odpowiedni model na podstawie stanu przycisku:

CODELAB part 2: Check whether to use the delegate here.

let model;
if (useWebNNDelegate) {
  model = webnnModel;
} else {
  model = cpuModel;
}

Teraz, gdy uruchomisz aplikację, przycisk będzie się przełączać między TfLite CPU a WebNN.

Możesz też przełączać się między wnioskowaniem WebNN na CPU i GPU, jeśli masz zintegrowany układ GPU Intela.

Uwaga dotycząca wydajności

Liczba klatek na sekundę, którą widzisz, obejmuje przetwarzanie wstępne i postprocessing, więc nie odzwierciedla możliwości WebNN. Aby lepiej poznać wydajność, klikaj miernik FPS, aż wyświetli się opóźnienie (w milisekundach), które mierzy tylko wywołanie funkcji model.predict. Obejmuje to jednak czas potrzebny na przeniesienie tensorów do natywnych powiązań C TFLite, więc nie jest to idealny pomiar.

7. Gratulacje

Gratulacje! Właśnie udało Ci się ukończyć pierwszy projekt Coral / WebNN z użyciem tfjs-tflite-node w Electronie.

Wypróbuj tę funkcję na różnych obrazach. Możesz też wytrenować nowy model w Teachable Machine, aby klasyfikować coś zupełnie innego.

Podsumowanie

Z tego ćwiczenia dowiedziałeś(-aś) się:

• Jak zainstalować i skonfigurować pakiet npm tfjs-tflite-node, aby uruchamiać modele TFLite w Node.js.
• Jak zainstalować bibliotekę środowiska wykonawczego Edge TPU, aby uruchamiać modele na urządzeniu Coral.
• Jak przyspieszyć wnioskowanie modelu za pomocą Coral Edge TPU.
• Jak przyspieszyć wnioskowanie modelu za pomocą WebNN.

Co dalej?

Masz już działającą bazę, od której możesz zacząć. Jakie kreatywne pomysły możesz wykorzystać, aby rozszerzyć ten moduł uruchamiający model uczenia maszynowego i zastosować go w praktyce w przypadku użycia, nad którym pracujesz? Możesz zrewolucjonizować branżę, w której pracujesz, dzięki szybkim i niedrogim wnioskowaniom, albo zmodyfikować toster, aby przestawał opiekać pieczywo, gdy będzie ono odpowiednio przyrumienione. Możliwości są nieograniczone.

Aby dowiedzieć się więcej o tym, jak Teachable Machine wytrenowało użyty przez Ciebie model, zapoznaj się z naszym ćwiczeniem dotyczącym uczenia transferowego. Jeśli szukasz innych modeli, które działają z Coral, np. do rozpoznawania mowy i szacowania pozycji, zajrzyj na coral.ai/models. Wersje tych modeli na procesor i wiele innych znajdziesz też w TensorFlow Hub.

Udostępnianie nam swoich treści

Możesz łatwo rozszerzyć to, co udało Ci się dziś stworzyć, na inne kreatywne zastosowania. Zachęcamy Cię do nieszablonowego myślenia i dalszego eksperymentowania.

Nie zapomnij oznaczyć nas w mediach społecznościowych, używając hashtagu #MadeWithTFJS. Dzięki temu Twój projekt może zostać zaprezentowany na naszym blogu TensorFlow lub podczas przyszłych wydarzeń. Chętnie zobaczymy, co stworzysz.

Witryny, które warto sprawdzić

• Oficjalna strona TensorFlow.js
• Gotowe modele TensorFlow.js
• Interfejs API TensorFlow.js
• TensorFlow.js Show & Tell