1. Wprowadzenie
Ostatnia aktualizacja: 11.04.2022 r.
Z tego ćwiczenia z programowania dowiesz się, jak wytrenować model klasyfikacji obrazów za pomocą Teachable Machine oraz uruchomić go z akceleracją sprzętową Coral za pomocą TensorFlow.js – zaawansowanej i elastycznej biblioteki systemów uczących się dla JavaScriptu. Tworzysz aplikację Electron, która wyświetla obrazy z kamery internetowej i klasyfikuje je za pomocą TPU. W pełni działająca wersja tego ćwiczenia z programowania jest dostępna w repozytorium sig-tfjs na GitHubie.
Czy potrzebuję urządzenia Coral?
Nie. Możesz wykonać te ćwiczenia z programowania bez urządzenia Coral, a mimo to uzyskać dobrą wydajność na komputerze, używając akceleratora WebNN.
Co utworzysz
W ramach tego ćwiczenia w Codelabs tworzysz aplikację Electron, która klasyfikuje obrazy. Twoja aplikacja:
- Klasyfikuje obrazy z kamery internetowej do kategorii zdefiniowanych w wytrenowanym modelu.
- Wykorzystuje akcelerator Coral, który zwiększa wydajność (jeśli jest dostępny).
- Wykorzystuje WebNN, aby zwiększyć wydajność, jeśli jest obsługiwana na Twojej platformie.
Czego się nauczysz
- Dowiedz 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 modeli za pomocą Coral Edge TPU.
- Jak przyspieszyć wnioskowanie przez model przy użyciu WebNN.
To ćwiczenia z programowania koncentrują się na TFLite w środowisku Node.js. Nieistotne koncepcje i bloki kodu zostały zamaskowane. Można je po prostu skopiować i wkleić.
Czego potrzebujesz
Do ukończenia ćwiczenia z programowania potrzebne będą:
- Komputer z kamerą internetową.
- W przypadku produktów Coral zalecamy korzystanie z Raspberry Pi z systemem operacyjnym Raspberry Pi (64-bitowym) z komputerem.
- W przypadku WebNN zalecamy komputer z procesorem Intel x86-64 z systemem Ubuntu 20.04 lub Windows 10.
- Node.js w wersji >= 12.
- Znajomość języka JavaScript.
- (Zalecane) Akcelerator USB Coral, który przyspieszy model.
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. Na potrzeby tych ćwiczeń w Codelabs zalecamy korzystanie z Raspberry Pi z systemem operacyjnym Raspberry Pi (64-bitowym) na komputerze. 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 skopiuj repozytorium:
git clone https://github.com/tensorflow/sig-tfjs.git
Wszystkie pliki, które musisz edytować w ramach ćwiczeń z programowania, znajdują się w katalogu tfjs-tflite-node-codelab (wewnątrz sig-tfjs). W tym katalogu znajdują się podkatalogi o nazwach starter_code, cpu_inference_working, coral_inference_working i webnn_inference_working. To są punkty kontrolne poszczególnych kroków tego ćwiczenia z programowania.
Wśród innych plików w repozytorium znajdują się pakiety NPM, od których zależy funkcja tfjs-tflite-node-codelab. Nie musisz edytować żadnego z tych plików, ale konieczne będzie przeprowadzenie przez nich testów, aby upewnić się, że środowisko jest prawidłowo skonfigurowane.
Instalowanie biblioteki środowiska wykonawczego Edge TPU
Urządzenia Coral wymagają zainstalowania biblioteki środowiska wykonawczego Edge TPU przed użyciem. Zainstaluj ją, postępując zgodnie z instrukcjami dotyczącymi Twojej platformy.
W systemie Linux / Raspberry Pi
W systemie Linux biblioteka jest dostępna w PPA Google w postaci pakietu Debiana libedgetpu1-std dla architektur x86-64 i Armv8 (64-bitowych). Jeśli Twój procesor używa innej architektury, musisz skompilować go ze źródła.
Uruchom to polecenie, aby dodać platformę Google Coral PPA 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 w innym systemie operacyjnym
Wstępnie skompilowane pliki binarne są dostępne na systemy x86-64 w systemach macOS i Windows. Można je zainstalować, uruchamiając skrypt install.sh lub install.bat z archiwum po pobraniu.
Ponowne uruchamianie urządzenia
Po zainstalowaniu środowiska wykonawczego Edge TPU uruchom ponownie urządzenie, aby aktywować nową regułę Coral Udev dodaną przez instalatora.
Sprawdzanie, czy urządzenie Coral zostało wykryte
Aby sprawdzić, czy urządzenie Coral zostało wykryte i działa, uruchom testy integracji 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
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 się martwić instalowaniem @tensorflow/tfjs-node,, jak opisano w logach, ponieważ będzie on uruchamiany w TFLite.
Jeśli zamiast tego dane wyjściowe zawierają ciąg Encountered unresolved custom op: edgetpu-custom-op, urządzenie Coral nie zostało wykryte. Upewnij się, że masz zainstalowaną bibliotekę środowiska wykonawczego Edge TPU i podłączone urządzenie Coral do komputera. Aby przetestować wersję wiązań Coral w języku Python, możesz też skorzystać z przewodnika dla początkujących użytkowników Coral. Jeśli wersja Pythona działa, ale testy nadal kończą się niepowodzeniem, poinformuj nas o tym, przesyłając raport o błędzie.
Uruchamianie kodu startowego
Teraz możesz uruchomić kod startowy. Aby rozpocząć, wykonaj następujące czynności:
- Przejdź do katalogu
starter_codew katalogutfjs-tflite-node-codelab. - Uruchom program
npm install, aby zainstalować zależności. - Uruchom
npm start, aby uruchomić projekt. Powinna otworzyć się aplikacja, która wyświetla obraz z kamery internetowej na komputerze.
Od czego zacząć?
Na początek stworzyliśmy podstawową aplikację z aparatem Electron stworzoną na potrzeby tego ćwiczenia z programowania. Kod został uproszczony, aby pokazać koncepcje przedstawione w ćwiczeniach z programowania, i nie wymaga dużej obsługi błędów. Jeśli zdecydujesz się na ponowne użycie któregoś z kodu w produkcyjnej aplikacji, pamiętaj, by sprawdzić, czy nie występują błędy, i w pełni przetestować cały kod.
Poznaj kod startowy
W tym kodzie startowym znajduje się wiele plików, ale musisz edytować tylko jeden z nich to renderer.js. Kontroluje to, co ma się wyświetlać na stronie, w tym plik danych wideo i elementy HTML. To miejsce, w którym dodajesz do aplikacji model systemów uczących się. Wśród pozostałych plików znajduje się plik index.html, ale zawiera on jedynie plik renderer.js. Jest też plik main.js, który jest punktem wejścia dla Electron. Kontroluje cykl życia aplikacji, w tym, co ma się wyświetlać po otwarciu i co robić, gdy jest zamknięta. Nie musisz jednak wprowadzać w niej żadnych zmian.
Otwórz debuger
W trakcie wykonywania tego ćwiczenia z programowania może być konieczne debugowanie aplikacji. Ta aplikacja jest oparta na modelu Electron, dlatego ma wbudowany debuger Chrome. Na większości platform możesz go otworzyć, naciskając Ctrl + Shift + I. Kliknij kartę Konsola, aby wyświetlić logi i komunikaty o błędach z aplikacji.
Nie zobaczysz nic więcej, więc zajmijmy się trenowaniem klasyfikatora obrazów.
3. Wytrenuj klasyfikator obrazów
W tej sekcji wytrenujesz model klasyfikacji obrazów w wersjach TFLite i Coral.
Wytrenuj klasyfikator
Klasyfikator obrazów pobiera obrazy wejściowe i przypisuje do nich etykiety. W ramach tego ćwiczenia w programie do wytrenowania modelu w przeglądarce używasz Teachable Machine. Aby przyspieszyć trenowanie w tej sekcji, możesz użyć komputera stacjonarnego lub laptopa zamiast Raspberry Pi, ale musisz skopiować pliki wynikowe do Pi.
Teraz możesz wytrenować model. Jeśli nie masz pewności, jakiego rodzaju model należy wytrenować, z łatwością będzie można wytrenować model wykrywający osoby, który po prostu wykrywa, czy dana osoba znajduje się w kadrze.
- W nowej karcie otwórz stronę trenowania Teachable Machine.
- Kliknij kolejno Image Project i Standardowy model obrazów.
- Dodaj przykłady obrazów do każdych zajęć. Najłatwiej to zrobić, używając kamery internetowej. Możesz też zmienić nazwy zajęć.
- Gdy zbierzesz wystarczającą ilość danych dla poszczególnych zajęć (wystarczy 50 próbek), kliknij Tren model (Wytrenuj model).
Gdy zakończy się trenowanie modelu, powinien wyświetlić się podgląd danych wyjściowych modelu.
Podaj modelowi inne dane wejściowe. Jeśli znajdziesz dane wejściowe, które są nieprawidłowo sklasyfikowane, dodaj je do danych treningowych i ponownie wytrenuj model.
- Jeśli uznasz, że dokładność modelu jest zadowalająca, kliknij Eksportuj model. Musisz pobrać 2 osobne wersje modelu.
- Wyeksportuj model jako model zmiennoprzecinkowy Tensorflow Lite. Spowoduje to pobranie pliku o nazwie
converted_tflite.zip. który działa na procesorze. - Wyeksportuj model jako model Tensorflow Lite EdgeTPU. Spowoduje to pobranie pliku o nazwie
converted_edgetpu.zip, który działa na karcie Coral Edge TPU.
4. Uruchamianie modelu procesora w aplikacji
Po wytrenowaniu modelu możesz dodać go do swojej aplikacji. Po zakończeniu tej sekcji aplikacja będzie mogła uruchamiać Twój model, korzystając z procesora urządzenia.
Dodaj plik modelu do aplikacji
Rozpakuj plik z modelem converted_tflite.zip pobrany podczas trenowania klasyfikatora. W archiwum są 2 pliki. model_uquant.tflite to zapisany model TFLite, w tym wykres modelu i wagi. labels.txt zawiera czytelne dla człowieka etykiety klas, które prognozuje model. Umieść oba pliki w katalogu modeldirectory.
Zainstaluj zależności
Załadowanie modelu i wstępne przetwarzanie danych wejściowych wymaga kilku zależności od TensorFlow.js:
tfjs-tflite-node: pakiet TensorFlow.js do uruchamiania modeli TFLite w Node.js.@tensorflow/tfjs: główny pakiet TensorFlow.js.
Rozszerzenie @tensorflow/tfjs jest już zainstalowane, ale musisz zainstalować 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. Zaimportuj plik tfjs-tflite-node.
const {loadTFLiteModel} = require('tfjs-tflite-node');
Wczytywanie modelu
Teraz możesz wczytać model. W tym celu tfjs-tflite-node udostępnia funkcję loadTFLiteModel. Może ładować modele ze ścieżki pliku albo adresu URL SlateBuffer lub TFHub. Aby wczytać model i jego wagi, dodaj do funkcji main ten fragment:
CODELAB, część 1. Wczytaj model tutaj.
const modelPath = './model/model_unquant.tflite';
const model = await loadTFLiteModel(modelPath);
const labels = fs.readFileSync('./model/labels.txt', 'utf8')
.split('\n');
Uruchamianie modelu
Uruchamianie modelu składa się z 3 etapów. Najpierw pobierasz i wstępnie przetwarzasz klatkę wejściową z kamery internetowej. Następnie uruchamiasz model w tej ramce i otrzymujesz prognozę. Gdy to zrobisz, wyświetli się ona na stronie.
Wstępne przetwarzanie danych wejściowych z kamery internetowej
W tej chwili kamera internetowa to tylko element HTML, a klatki, które wyświetla, nie są dostępne dla pliku JavaScript renderer.js. Do pobierania klatek z kamery internetowej TensorFlow.js udostępnia funkcję tf.data.webcam, która jest łatwą w użyciu metodą capture() do rejestrowania klatek z kamery.
Aby go użyć, dodaj do main() ten kod konfiguracji:
CODELAB, część 1. Tutaj skonfiguruj kamerę tf.data.webcam.
const tensorCam = await tf.data.webcam(webcam);
Następnie, aby zarejestrować obraz w każdej klatce, dodaj do run() ten element:
CODELAB, część 1. Możesz tutaj rejestrować klatki z kamery internetowej.
const image = await tensorCam.capture();
Musisz też wstępnie przetworzyć każdą klatkę, by była zgodna z modelem. Model używany w tym ćwiczeniu w Codelabs ma dane wejściowe o kształcie [1, 224, 224, 3], więc oczekuje obrazu RGB o wymiarach 224 x 224 piksele. Funkcja tensorCam.capture() daje kształt [224, 224, 3], więc za pomocą tf.expandDims musisz dodać dodatkowy wymiar z przodu tensora. Dodatkowo model procesora oczekuje danych wejściowych typu Float32 z zakresu od -1 do 1, ale kamera internetowa rejestruje wartości z zakresu od 0 do 255. Możesz podzielić tensor wejściowy przez 127, aby zmienić jego zakres od [0, 255] do [0, ~2], a następnie odjąć 1, aby otrzymać wymagany zakres [-1, ~1]. Aby to zrobić, dodaj te wiersze do polecenia tf.tidy() w funkcji run():
CODELAB, część 1: wstępnie przetwórz klatki z kamery internetowej.
const expanded = tf.expandDims(image, 0);
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));
Ważne jest, aby po użyciu tensorów pozbyć się ich. Funkcja tf.tidy() wykonuje tę czynność 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, część 1: pozbądź się ramek kamery internetowej.
image.dispose();
Uruchamianie modelu i wyświetlanie wyników
Aby uruchomić model na wstępnie przetworzonych danych wejściowych, wywołaj model.predict() na tensorze znormalizowanym. Zwraca tensor jednowymiarowy zawierający przewidywane prawdopodobieństwo dla każdej etykiety. Pomnóż to prawdopodobieństwo przez 100, aby otrzymać procentowe prawdopodobieństwo dla każdej etykiety, i użyj funkcji showPrediction zawartej w kodzie inicjującym, aby wyświetlić prognozę modelu na ekranie.
Ten kod wykorzystuje również kod stats.js do określenia czasu potrzebnego na prognozowanie. W tym celu wywołuje funkcje stats.begin i stats.end około model.predict.
CODELAB, część 1. Uruchom model i wyświetl tutaj wyniki.
stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);
Uruchom aplikację jeszcze raz przy użyciu funkcji yarn start – powinny pojawić się klasyfikacje Twojego modelu.
Wydajność
Zgodnie z obecnymi ustawieniami model działa na CPU. Jest to odpowiednie w przypadku komputerów stacjonarnych i większości laptopów, ale może nie być korzystne, jeśli używasz Raspberry Pi lub innego urządzenia o małej mocy. W przypadku Raspberry Pi 4 prędkość wynosi około 10 FPS, co może być niewystarczające w niektórych aplikacjach. Aby uzyskać lepszą wydajność bez konieczności używania szybszej maszyny, możesz wykorzystać krzem dla konkretnej aplikacji w postaci Coral Edge TPU.
5. Uruchom model Coral w swojej aplikacji
Jeśli nie masz urządzenia Coral, możesz pominąć tę sekcję.
Ten krok ćwiczenia w Codelabs opiera się na kodzie napisanym w poprzedniej sekcji, ale jeśli chcesz zacząć od „czystej planszy”, możesz użyć punktu kontrolnego cpu_inference_working.
Kroki uruchamiania modelu Coral są prawie takie same jak kroki uruchamiania modelu procesora. Główną różnicą jest format modelu. Model Coral obsługuje tylko tensory uint8, więc model jest kwantyzowany. Ma to wpływ na tensory wejściowe przekazywane do modelu oraz te tensory wyjściowe, które zwraca. Kolejną różnicą jest to, że do uruchomienia na Coral TPU modele muszą być kompilowane za pomocą kompilatora Edge TPU. TeachableMachine ma już za sobą ten krok. Instrukcje, jak to zrobić w przypadku innych modeli, znajdziesz w dokumentacji Coral.
Dodaj plik modelu koralowego do aplikacji
Rozpakuj plik z modelem converted_edgetpu.zip pobrany podczas trenowania klasyfikatora. Archiwum zawiera 2 pliki. model_edgetpu.tflite to zapisany model TFLite, w tym wykres modelu i wagi. labels.txt zawiera czytelne dla człowieka etykiety klas, które prognozuje model. Umieść plik z modelem w katalogu coral_model.
Zainstaluj zależności
Uruchamianie modeli Coral wymaga biblioteki środowiska wykonawczego Edge TPU. Zanim przejdziesz dalej, upewnij się, że został zainstalowany. W tym celu postępuj zgodnie z instrukcjami konfiguracji.
Dostęp do urządzeń Coral uzyskuje przedstawiciel TFLite. Aby uzyskać do nich dostęp za pomocą JavaScriptu, zainstaluj pakiet coral-tflite-delegate:
npm install --save coral-tflite-delegate
Następnie zaimportuj przedstawiciela, dodając ten wiersz na początku pliku renderer.js:
CODELAB, część 2. Tutaj zaimportuj przedstawiciela.
const {CoralDelegate} = require('coral-tflite-delegate');
Wczytywanie modelu
Teraz możesz wczytać model koralowy. Należy to zrobić tak samo jak w przypadku modelu procesora, z tą różnicą, że teraz przekazujesz do funkcji loadTFLiteModel opcje umożliwiające wczytanie delegata Coral.
CODELAB, część 2. Wczytaj model delegata.
const coralModelPath = './coral_model/model_edgetpu.tflite';
const options = {delegates: [new CoralDelegate()]};
const coralModel = await loadTFLiteModel(coralModelPath, options);
Nie musisz ładować etykiet, ponieważ są takie same jak w przypadku modelu procesora.
Dodaj przycisk przełączania między procesorami CPU i Coral
Model Koral dodaj razem z modelem procesora dodanym w ostatniej sekcji. Jednoczesne korzystanie z nich utrudnia dostrzeżenie różnic w wydajności, dlatego przycisk przełączania może przełączać się między wykonywaniem na procesorze Coral a wykonywaniem procesora.
Dodaj przycisk z tym kodem:
CODELAB, część 2. Utwórz tutaj przycisk przekazywania dostępu.
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 w funkcji run(). Jeśli zasada useCoralDelegate ma wartość fałsz, powinna uruchamiać wersję procesora. Jeśli tego nie zrobisz, będzie działać w wersji Coral (na razie nic się nie zmieni). Dodaj kod uruchamiający model procesora w instrukcji if. Zwróć uwagę, że tensor expanded jest pomijany w instrukcji if, ponieważ model Coral go używa.
CODELAB, część 2. Sprawdź, czy chcesz użyć przedstawiciela.
// 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 Coral modelu wymaga tensorów uint8 w zakresie od 0 do 255, dlatego jej dane wejściowe nie muszą być znormalizowane. Dane wyjściowe są jednak także tensorem uint8 w zakresie od 0 do 255. Przed wyświetleniem musi zostać przekonwertowana na liczbę zmiennoprzecinkową od 0 do 100.
CODELAB, część 2. Uruchom tutaj prognozę Coral. (To jest 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 aplikację jeszcze raz za pomocą polecenia yarn start – powinna wyświetlić się klasyfikacje z akceleratora Coral.
Aby przełączać się między trybem Coral a wnioskowaniem na podstawie procesora, naciśnij przycisk. Możesz zauważyć, że rankingi ufności modelu Coral są mniej dokładne niż rankingi modelu procesora i zwykle kończą się równomierną liczbą miejsc po przecinku. Ta utrata precyzji wynika z kompromisu uruchomienia kwantowego modelu na platformie Coral. W praktyce nie ma to znaczenia, ale trzeba o tym pamiętać.
Uwaga dotycząca skuteczności
Liczba klatek, którą widzisz, obejmuje wstępne i końcowe przetwarzanie, więc nie jest reprezentatywna dla możliwości sprzętu Coral. Aby uzyskać pełniejsze informacje o wydajności, kliknij miernik klatek na sekundę, aż wyświetli się czas oczekiwania (w milisekundach), który mierzy tylko wywołanie funkcji model.predict. Mimo to wciąż obejmuje to czas potrzebny na przeniesienie Tensors do natywnych wiązań TFLite C, a następnie na urządzenie Coral, nie jest to więc doskonały pomiar. Więcej dokładnych testów porównawczych wydajności zapisanych w języku C++ znajdziesz na stronie testów porównawczych EdgeTPU.
Warto też pamiętać, że film został nagrany na laptopie, a nie Raspberry Pi, więc liczba klatek na sekundę może być inna.
Przyspieszenie wstępnego przetwarzania danych Coral
W niektórych przypadkach możesz przyspieszyć wstępne przetwarzanie, przełączając backendy TFJS. Domyślny backend to WebGL, który sprawdza się w przypadku dużych operacji, które można równolegle zrobić, ale ta aplikacja nie robi z tego zbyt wiele na etapie wstępnego przetwarzania danych (jedyne używane przez niego działanie to expandDims, który nie działa równolegle). Możesz przełączyć się na backend procesora, aby uniknąć dodatkowych opóźnień związanych z przenoszeniem tensorów do i z GPU. Aby to zrobić, dodaj ten wiersz po zaimportowaniu na początku pliku.
tf.setBackend(‘cpu');
Ma to również wpływ na wstępne przetwarzanie modelu procesora TFLite, który jest równoległy, dlatego po tej zmianie model działa znacznie wolniej.
6. Przyspiesz model procesora przy użyciu WebNN
Jeśli nie masz akceleratora Coral lub chcesz wypróbować inny sposób przyspieszenia modelu, możesz użyć przedstawiciela WebNN TFLite. Ten delegat używa sprzętu systemów uczących się wbudowanego w procesory Intel, aby przyspieszyć wnioskowanie modeli za pomocą zestawu narzędzi OpenVINO. W związku z tym wiąże się z tym dodatkowe wymagania, których nie omówiliśmy w sekcji „Konfiguracja” tego ćwiczenia z programowania. Konieczne jest zainstalowanie pakietu narzędzi OpenVINO. Zanim przejdziesz dalej, sprawdź swoją konfigurację pod kątem obsługiwanych platform systemowych. Pamiętaj jednak, że delegacja WebNN nie obsługuje jeszcze systemu macOS.
Zainstaluj pakiet narzędzi OpenVINO
Zestaw narzędzi OpenVINO wykorzystuje sprzęt z systemami uczącymi się wbudowany w procesory Intela, aby przyspieszyć modele. Możesz pobrać wstępnie skompilowaną wersję z platformy Intel lub skompilować ją ze źródła. Można zainstalować OpenVINO na kilka sposobów, ale na potrzeby tego ćwiczenia z programowania zalecamy użycie skryptu instalatora systemu Windows lub Linux. Pamiętaj o zainstalowaniu wersji środowiska wykonawczego LTS 2021.4.2, ponieważ inne wersje mogą być niezgodne. Po uruchomieniu instalatora skonfiguruj zmienne środowiskowe powłoki zgodnie z opisem w instrukcjach instalacji dla Linux lub Windowsa ( rozwiązanie trwałe) albo uruchom polecenie setupvars.sh (Linux) lub setupvars.bat (Windows) znajdujące się w katalogu webnn-tflite-delegate.
Sprawdzanie, czy przedstawiciel WebNN działa
Aby sprawdzić, czy delegat WebNN działa prawidłowo, uruchom testy integracji pakietu webnn-tflite-delegate, który znajduje się w katalogu głównym repozytorium. Aby uruchomić testy integracji, uruchom te polecenia w katalogu pakietu:
# 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 takie dane wyjściowe, oznacza to, że wystąpił 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.
Te dane wyjściowe najprawdopodobniej oznaczają, że zmienne środowiskowe OpenVINO nie zostały ustawione. Na razie możesz je ustawić za pomocą polecenia setupvars.sh (Linux) lub setupvars.bat (Windows), ale możesz też ustawić je na stałe, postępując zgodnie z instrukcjami dotyczącymi rozwiązań stałych dla Linux lub Windows. Jeśli używasz systemu Windows,
setupvars.bat
Polecenie nie obsługuje Git bash, więc pamiętaj, aby je uruchomić wraz z innymi poleceniami z tego ćwiczenia z programowania z poziomu wiersza poleceń systemu Windows.
Instalowanie przedstawiciela WebNN
Po zainstalowaniu OpenVINO możesz przyspieszyć model procesora za pomocą WebNN. Ta sekcja ćwiczeń w Codelabs opiera się na kodzie napisanym w sekcji „Uruchamianie modelu procesora w aplikacji”. . Możesz użyć kodu napisanego w tym kroku, ale jeśli masz już za sobą część sekcji Coral, użyj punktu kontrolnego cpu_inference_working, aby zacząć od „czystej planszy”.
Część Node.js delegata WebNN jest rozpowszechniana w npmjs. Aby ją zainstalować, uruchom to polecenie:
npm install --save webnn-tflite-delegate
Następnie zaimportuj przedstawiciela, dodając ten wiersz na początku pliku renderer.js:
CODELAB, część 2. Tutaj zaimportuj przedstawiciela.
const {WebNNDelegate, WebNNDevice} = require('webnn-tflite-delegate');
Delegat WebNN obsługuje działanie na CPU lub GPU. WebNNDevice pozwala wybrać, która z nich ma być używana.
Wczytywanie modelu
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 go włączyć, dodaj WebNNDelegate do listy przedstawicieli przekazanych do modelu:
CODELAB, część 2. Wczytaj model delegata.
let webnnModel = await loadTFLiteModel(modelPath, {
delegates: [new WebNNDelegate({webnnDevice: WebNNDevice.DEFAULT})],
});
Nie musisz ponownie wczytywać etykiet, ponieważ to ten sam model.
Dodaj przycisk przełączania między CPU TfLite i WebNN
Gdy wersja modelu WebNN jest gotowa, dodaj przycisk umożliwiający przełączanie między wnioskowaniem przez procesory WebNN i TfLite. Jednoczesne korzystanie z nich utrudnia dostrzeżenie różnic pod względem skuteczności.
Dodaj przycisk z tym kodem (pamiętaj, że nie spowoduje on jeszcze zmiany modeli):
CODELAB, część 2. Utwórz tutaj przycisk przekazywania dostępu.
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 należy użyć do skonfigurowania ustawień WebNN w następnej sekcji.
Dodawanie menu umożliwiającego przełączanie się między urządzeniami WebNN
WebNN obsługuje procesory CPU i GPU, więc aby przełączać się między nimi, dodaj menu. 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 uruchomisz aplikację, zobaczysz menu z listą Domyślne, GPU i CPU. Wybranie jednego z nich nie spowoduje żadnych działań, ponieważ menu nie zostało jeszcze połączone. 
Zmienianie urządzenia w menu
Aby podłączyć menu w taki sposób, aby zmieniało używane urządzenie WebNN, dodaj detektor do zdarzenia change w elemencie selektora menu. Gdy wybrana wartość się zmieni, odtwórz model WebNN z odpowiednim urządzeniem WebNN wybranym w opcjach przekazywania.
Dodaj ten kod po kodzie, który dodał menu:
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 po każdej zmianie tworzy nowy model z prawidłowymi ustawieniami. Teraz czas podłączyć model WebNN i wykorzystać go do wnioskowania.
Uruchamianie modelu WebNN
Model WebNN jest gotowy do użycia, ale przycisk przełączania między CPU WebNN a TfLite nie powoduje jeszcze zmiany modelu. Aby zmienić model, musisz najpierw zmienić nazwę zmiennej model w stosunku do nazwy wyświetlanej po załadowaniu modelu procesora TfLite w pierwszej sekcji ćwiczenia w Codelabs.
Zmień następujący wiersz...
const model = await loadTFLiteModel(modelPath);
...aby był zgodny z tym wierszem.
const cpuModel = await loadTFLiteModel(modelPath);
Jeśli zmienna model ma nazwę cpuModel, dodaj to do funkcji run, by wybrać właściwy model na podstawie stanu przycisku:
CODELAB, część 2. Sprawdź, czy chcesz użyć przedstawiciela.
let model;
if (useWebNNDelegate) {
model = webnnModel;
} else {
model = cpuModel;
}
Teraz po uruchomieniu aplikacji przycisk przełącza się między procesorem TfLite a WebNN. 
Jeśli masz zintegrowany procesor graficzny Intel, możesz też przełączać się między wnioskowaniem z procesora WebNN i GPU.
Uwaga dotycząca skuteczności
Liczba klatek, którą widzisz, obejmuje wstępne i końcowe przetwarzanie, więc dane nie są reprezentatywne dla funkcji WebNN. Aby uzyskać pełniejsze informacje o wydajności, kliknij miernik klatek na sekundę, aż wyświetli się czas oczekiwania (w milisekundach), który mierzy tylko wywołanie funkcji model.predict. Mimo to wciąż uwzględnia to czas potrzebny na przeniesienie Tensors do natywnych wiązań C TFLite, dlatego nie jest to doskonały pomiar.
7. Gratulacje
Gratulacje! Właśnie udało Ci się ukończyć swój pierwszy projekt Coral / WebNN z wykorzystaniem tfjs-tflite-node w Electron.
Wypróbuj go i przetestuj na różnych obrazach. Możesz też wytrenować nowy model w TeachableMachine, aby sklasyfikować coś zupełnie innego.
Podsumowanie
Dzięki temu ćwiczeniu w programowaniu udało Ci się dowiedzieć:
- Jak zainstalować i skonfigurować pakiet npm tfjs-tflite-node do uruchamiania modeli TFLite w Node.js.
- Jak zainstalować bibliotekę środowiska wykonawczego Edge TPU, aby uruchamiać modele na urządzeniu Coral.
- Jak przyspieszyć wnioskowanie modeli za pomocą Coral Edge TPU.
- Jak przyspieszyć wnioskowanie modeli za pomocą WebNN.
Co dalej?
Skoro masz już bazę do pracy, od której możesz zacząć. Jakie pomysły możesz wpaść, aby wykorzystać ten model do zastosowania w praktyce w praktyce? Może uda Ci się zrewolucjonizować branżę, w której pracujesz, korzystając z szybkiego i niedrogiego wnioskowania, albo zmodyfikować toster tak, aby przestał wznieść toast, gdy chleb będzie odpowiedni. Możliwości są nieograniczone.
Aby dowiedzieć się więcej o tym, jak usługa TeachableMachine wytrenowała używany przez Ciebie model, zapoznaj się z ćwiczeniami z programowania dotyczącymi Transfer Learning. Jeśli szukasz innych modeli, które współpracują z Coralem, takich jak rozpoznawanie mowy czy szacowanie pozycji, zajrzyj na stronę coral.ai/models. Wersje procesora tych modeli i wielu innych znajdziesz w TensorFlow Hub.
Podziel się z nami tym, co udało Ci się stworzyć
Możesz z łatwością wykorzystać swoje dzisiejsze materiały również w innych kreatywnych celach, więc zachęcamy do kreatywnego myślenia i dalszego hakowania.
Pamiętaj, aby oznaczyć nas w mediach społecznościowych hashtagiem #MadeWithTFJS, aby mieć szansę na zaprezentowanie Twojego projektu na blogu TensorFlow lub nawet na przyszłych wydarzeniach. Chętnie zobaczymy, co stworzysz.