1. Wprowadzenie
Masz już za sobą pierwsze kroki z użyciem TensorFlow.js, wypróbowywanie naszych gotowych modeli, a może nawet stworzenie własnych, ale udało Ci się opracować nowatorskie badania w Pythonie i chcesz sprawdzić, czy zostanie on uruchomiony w przeglądarce i urzeczywistni Twój pomysłowy pomysł w skalowalny sposób. Brzmi znajomo? Jeśli tak, to moduł CodeLab dla Ciebie.
Zespół TensorFlow.js przygotował wygodne narzędzie do konwertowania modeli w formacie SavedModel na TensorFlow.js za pomocą konwertera wiersza poleceń. Dzięki temu możesz korzystać z takich modeli na dużą skalę w sieci.
Czego się nauczysz
Z tego modułu dotyczącego kodu dowiesz się, jak za pomocą konwertera wiersza poleceń TensorFlow.js przenieść zapisany model SavedModel w języku Python do formatu model.json wymaganego do wykonania po stronie klienta w przeglądarce.
Oto najważniejsze kwestie:
- Jak utworzyć prosty model ML w języku Python i zapisać go w wymaganym formacie wymaganym przez konwerter TensorFlow.js.
- Jak zainstalować konwerter TensorFlow.js w modelu SavedModel wyeksportowanego z Pythona i jak z niego korzystać.
- Pobierz powstałe pliki z konwersji i wykorzystaj je w aplikacji internetowej JS.
- Dowiedz się, co zrobić, gdy coś pójdzie nie tak (nie wszystkie modele wygenerują konwersję) i jakie masz możliwości.
Wyobraź sobie, że jesteś w stanie wziąć udział w nowo opublikowanych badaniach i udostępnić ten model milionom programistów JS na całym świecie. A może użyjesz tego narzędzia samodzielnie we własnym projekcie, z czego każdy na świecie będzie mógł się zapoznać, jeśli uruchomi się w przeglądarce, ponieważ nie są wymagane żadne złożone zależności ani konfiguracja środowiska. Czas na hakowanie? Do dzieła!
Podziel się z nami informacjami o konwersjach.
Możesz wykorzystać to, czego się dziś nauczymy, aby spróbować przekonwertować niektóre ze swoich ulubionych modeli z języka Python. Jeśli uda Ci się to i stworzysz działającą witrynę demonstracyjną pokazującą model w akcji, otaguj nas w mediach społecznościowych hashtagiem #MadeWithTFJS, a Twój projekt zostanie zaprezentowany na naszym blogu TensorFlow, a nawet podczas przyszłych wydarzeń z programu pokazów i opowiedzi. Chcielibyśmy zobaczyć w internecie więcej niesamowitych badań i umożliwić większej liczbie osób wykorzystanie takich modeli w innowacyjny lub kreatywny sposób, tak jak w tym świetnym przykładzie.
2. Co to jest TensorFlow.js?
TensorFlow.js to biblioteka systemów uczących się typu open source, która umożliwia uruchamianie JavaScriptu wszędzie. Opiera się on na pierwotnej bibliotece TensorFlow napisanej w języku Python i ma na celu odtworzenie tego środowiska programistycznego oraz zestawu interfejsów API w ekosystemie JavaScriptu.
Gdzie można korzystać z tej funkcji?
JavaScript jest łatwy w obsłudze, dlatego możesz teraz z łatwością pisać w jednym języku i wykonywać uczenie maszynowe na wszystkich poniższych platformach:
- Po stronie klienta w przeglądarce używamy wbudowanego JavaScriptu
- Po stronie serwera, a nawet urządzenia IoT, takie jak Raspberry Pi, korzystające z Node.js
- Aplikacje komputerowe wykorzystujące technologię Electron
- natywne aplikacje mobilne wykorzystujące komponent React Native,
TensorFlow.js obsługuje też wiele backendów w każdym z tych środowisk (rzeczywistych środowisk sprzętowych, w których można go uruchamiać, np. CPU lub WebGL. „backend” w tym kontekście nie oznacza to środowiska po stronie serwera – backend do wykonywania może na przykład znajdować się po stronie klienta w WebGL), aby zapewnić zgodność i jednocześnie zapewnić szybkie działanie. Obecnie TensorFlow.js obsługuje:
- Wykonanie WebGL na karcie graficznej urządzenia (GPU) – to najszybszy sposób na uruchamianie większych modeli (o rozmiarach powyżej 3 MB) z akceleracją GPU.
- Wykonywanie narzędzi Web Assembly (WASM) na CPU – w celu poprawy wydajności procesora na różnych urządzeniach, na przykład na telefonach komórkowych starszej generacji. Sprawdza się to lepiej w mniejszych modelach (poniżej 3 MB), które w WASM działają szybciej na procesorach niż w WebGL ze względu na wymagania związane z przesyłaniem materiałów do procesora graficznego.
- Wykonanie procesora – środowisko zastępcze nie powinno być dostępne. To najwolniejszy z trzech, ale zawsze gotowy.
Uwaga: możesz wymusić stosowanie jednego z tych backendów, jeśli wiesz, na którym urządzeniu będzie wykonywane działanie. Jeśli nie określisz tego, możesz po prostu pozwolić TensorFlow.js zdecydować za Ciebie.
Supermocy po stronie klienta
Uruchomienie kodu TensorFlow.js w przeglądarce na komputerze klienckim może przynieść szereg korzyści, które warto rozważyć.
Prywatność
Możesz trenować i klasyfikować dane na komputerze klienckim bez konieczności wysyłania ich na serwer internetowy firmy zewnętrznej. W niektórych przypadkach może to być wymagane w celu zachowania zgodności z przepisami obowiązującymi w danym kraju, np. RODO, lub w przypadku przetwarzania danych, które użytkownik chce zachować na swoim komputerze, a nie wysyłać do innych firm.
Szybkość
Dzięki temu, że nie trzeba wysyłać danych na serwer zdalny, wnioskowanie (czynność klasyfikowania danych) może być szybsze. Co więcej, po przyznaniu dostępu przez użytkownika będziesz mieć bezpośredni dostęp do czujników urządzenia, takich jak aparat, mikrofon, GPS, akcelerometr i inne.
Zasięg i skala
Wystarczy jedno kliknięcie, aby każdy na całym świecie mógł kliknąć wysłany przez Ciebie link, otworzyć stronę internetową w przeglądarce i wykorzystać to, co udało Ci się osiągnąć. Użycie systemu uczącego się nie wymaga skomplikowanej konfiguracji systemu Linux po stronie serwera ze sterownikami CUDA i nie tylko.
Koszt
Brak serwerów oznacza, że jedyną rzeczą, za którą musisz zapłacić, jest sieć CDN do przechowywania plików HTML, CSS, JS i modeli. Koszt sieci CDN jest znacznie wyższy niż w przypadku serwera (potencjalnie z podłączoną kartą graficzną) działającym przez całą dobę.
Funkcje po stronie serwera
Poniższe funkcje są dostępne dzięki wdrożeniu TensorFlow.js w Node.js.
Pełna obsługa CUDA
Aby włączyć akcelerację karty graficznej, po stronie serwera musisz zainstalować sterowniki NVIDIA CUDA, aby umożliwić TensorFlow współpracę z kartą graficzną (inaczej niż w przeglądarce, która używa WebGL – nie trzeba instalować). Pełna obsługa technologii CUDA pozwala jednak w pełni wykorzystać możliwości karty graficznej niższego poziomu, co pozwala skrócić czas trenowania i wnioskowania. Wydajność jest porównywalna z implementacją TensorFlow w języku Python, ponieważ obie korzystają z tego samego backendu w C++.
Rozmiar modelu
Aby tworzyć najbardziej zaawansowane modele na podstawie badań, możesz pracować z bardzo dużymi modelami, nawet o wielkości gigabajtów. Tych modeli nie można obecnie uruchamiać w przeglądarce ze względu na ograniczenia wykorzystania pamięci przez poszczególne karty przeglądarki. Aby móc uruchamiać te większe modele, możesz użyć środowiska Node.js na własnym serwerze ze specyfikacjami sprzętowymi, które są wymagane do wydajnego działania takiego modelu.
IOT
Node.js jest obsługiwany na popularnych komputerach jednopłytkowych, takich jak Raspberry Pi, co z kolei oznacza, że na takich urządzeniach możesz uruchamiać modele TensorFlow.js.
Szybkość
Node.js jest napisany w języku JavaScript, co oznacza, że korzysta z kompilacji w odpowiednim momencie. Oznacza to, że gdy korzystasz z Node.js, możesz często zauważyć wzrost wydajności, ponieważ jest on optymalizowany w czasie działania, a zwłaszcza w przypadku wstępnego przetwarzania danych. Świetnym przykładem tego jest to studium przypadku, które pokazuje, jak firma Hugging Face wykorzystała środowisko Node.js, aby dwukrotnie zwiększyć wydajność modelu przetwarzania języka naturalnego.
Znasz już podstawy środowiska TensorFlow.js, wiesz, gdzie może on działać i jakie są jego zalety, więc teraz możesz zacząć robić z nim przydatne rzeczy.
3. Konfigurowanie systemu
W tym samouczku użyjemy Ubuntu – popularnej dystrybucji systemu Linux, z której korzysta wielu użytkowników i dostępnej w Google Cloud Compute Engine jako obrazu podstawowego – jeśli zdecydujesz się wykorzystać ją w maszynie wirtualnej działającej w chmurze.
Podczas tworzenia nowej instancji Compute Engine możemy wybrać obraz Ubuntu 18.04.4 LTS, którego użyjemy. Oczywiście możesz użyć własnego komputera, a nawet innego systemu operacyjnego, ale instrukcje instalacji i zależności mogą się różnić w zależności od systemu.
Instalowanie TensorFlow (wersja Pythona)
Teraz, ponieważ prawdopodobnie próbujesz przekonwertować istniejący model oparty na Pythonie, który został znaleziony lub zostanie zapisany, zanim będziemy mogli wyeksportować model „SavedModel” z Pythona, musisz mieć w instancji skonfigurowaną wersję TensorFlow w Pythonie, jeśli obiekt „SavedModel” nie jest jeszcze dostępny do pobrania.
Połącz się przez SSH z komputerem w chmurze utworzonym powyżej i wpisz w oknie terminala to polecenie:
Okno terminala:
sudo apt update
sudo apt-get install python3
Dzięki temu będziemy mieć pewność, że na komputerze zainstalowany jest język Python 3. Aby używać TensorFlow, musisz zainstalować Pythona w wersji 3.4 lub nowszej.
Aby sprawdzić, czy zainstalowana jest prawidłowa wersja, wpisz:
Okno terminala:
python3 --version
Powinny wyświetlić się dane wyjściowe wskazujące numer wersji, na przykład Python 3.6.9. Jeśli okaże się, że jest on wydrukowany poprawnie, a ma wersję wyższą niż 3.4, możemy kontynuować.
Następnie zainstalujemy PIP dla języka Python 3, który jest menedżerem pakietów Pythona, i zaktualizujemy go. Typ:
Okno terminala:
sudo apt install python3-pip
pip3 install --upgrade pip
Ponownie możemy zweryfikować instalację pip3 za pomocą:
Okno terminala:
pip3 --version
W momencie pisania w terminalu po wykonaniu tego polecenia widoczna jest informacja pip 20.2.3.
Do zainstalowania TensorFlow jest pakiet Pythona „setuptools” być w wersji 41.0.0 lub nowszej. Uruchom to polecenie, aby się upewnić, że aktualizacja jest do najnowszej wersji:
Okno terminala:
pip3 install -U setuptools
Na koniec możemy zainstalować TensorFlow dla Pythona:
Okno terminala:
pip3 install tensorflow
Może to zająć trochę czasu, więc poczekaj, aż się zakończy.
Sprawdźmy, czy TensorFlow został poprawnie zainstalowany. Utwórz w bieżącym katalogu plik Pythona o nazwie test.py:
Okno terminala:
nano test.py
Po otwarciu nano możemy napisać kod Pythona, by wyświetlić zainstalowaną wersję TensorFlow:
test.py:
import tensorflow as tf
print(tf.__version__)
Naciśnij CTRL + O, aby zapisać zmiany na dysku, a następnie CTRL + X, aby zamknąć edytor nano.
Teraz możemy uruchomić ten plik Pythona, aby wyświetlić wersję TensorFlow drukowaną na ekranie:
Okno terminala:
python3 test.py
W momencie tworzenia wiadomości w konsoli wyświetla się 2.3.1 dla naszej zainstalowanej wersji TensorFlow Pythona.
4. Tworzenie modelu w Pythonie
W następnym kroku tego ćwiczenia w Codelabs dowiesz się, jak utworzyć prosty model Pythona, aby pokazać, jak można zapisać wynikowy wytrenowany model w obiekcie „SavedModel”. w formacie TensorFlow.js z konwerterem wiersza poleceń TensorFlow.js. Zasada jest podobna w przypadku każdego modelu Pythona, który próbujesz przekonwertować, ale kod powinien być prosty, aby wszyscy mogli go zrozumieć.
Zmodyfikujmy plik test.py utworzony w pierwszej sekcji i zaktualizujmy kod w następujący sposób:
test.py:
import tensorflow as tf
print(tf.__version__)
# Import NumPy - package for working with arrays in Python.
import numpy as np
# Import useful keras functions - this is similar to the
# TensorFlow.js Layers API functionality.
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
# Create a new dense layer with 1 unit, and input shape of [1].
layer0 = Dense(units=1, input_shape=[1])
model = Sequential([layer0])
# Compile the model using stochastic gradient descent as optimiser
# and the mean squared error loss function.
model.compile(optimizer='sgd', loss='mean_absolute_error')
# Provide some training data! Here we are using some fictional data
# for house square footage and house price (which is simply 1000x the
# square footage) which our model must learn for itself.
xs = np.array([800.0, 850.0, 900.0, 950.0, 980.0, 1000.0, 1050.0, 1075.0, 1100.0, 1150.0, 1200.0, 1250.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0, 2000.0], dtype=float)
ys = np.array([800000.0, 850000.0, 900000.0, 950000.0, 980000.0, 1000000.0, 1050000.0, 1075000.0, 1100000.0, 1150000.0, 1200000.0, 1250000.0, 1300000.0, 1400000.0, 1500000.0, 1600000.0, 1700000.0, 1800000.0, 1900000.0, 2000000.0], dtype=float)
# Train the model for 500 epochs.
model.fit(xs, ys, epochs=500, verbose=0)
# Test the trained model on a test input value
print(model.predict([1200.0]))
# Save the model we just trained to the "SavedModel" format to the
# same directory our test.py file is located.
tf.saved_model.save(model, './')
Ten kod wytrenuje bardzo prostą regresję liniową, aby nauczyć się oszacować zależność między danymi wejściowymi x (danymi wejściowymi) a danymi wyjściowymi y. Następnie zapiszemy wynikowy wytrenowany model na dysku. Szczegółowe informacje o działaniu poszczególnych wierszy znajdziesz w komentarzach.
Jeśli po uruchomieniu tego programu sprawdzimy katalog (wywołując python3 test.py), powinniśmy zobaczyć nowe pliki i foldery utworzone w bieżącym katalogu:
- test.py
- saved_model.pb
- zasoby
- zmienne
Wygenerowano pliki, których potrzebuje konwerter TensorFlow.js do przekonwertowania tego modelu na działanie w przeglądarce.
5. Konwertowanie obiektu SavedModel na format TensorFlow.js
Zainstaluj konwerter TensorFlow.js
Aby zainstalować konwerter, uruchom następujące polecenie:
Okno terminala:
pip3 install tensorflowjs
To było proste.
Zakładając, że użyliśmy konwertera wiersza poleceń (tensorflowjs_converter), a nie wersji kreatora widocznej powyżej, możemy wywołać poniższe polecenie, by przekonwertować właśnie utworzony zapisany model i bezpośrednio przekazać parametry do konwertera:
Okno terminala:
tensorflowjs_converter \
--input_format=keras_saved_model \
./ \
./predict_houses_tfjs
Co się tutaj dzieje? Najpierw wywołujemy zainstalowany właśnie plik binarny Tensorflowjs_converter i określamy, że próbujemy przekonwertować zapisany model keras.
W przykładowym kodzie powyżej zauważysz, że zaimportowaliśmy keras i użyliśmy interfejsów API warstw wyższego poziomu do utworzenia naszego modelu. Jeśli w kodzie Pythona nie używasz keras, możesz użyć innego formatu danych wejściowych:
- keras – aby wczytać format keras (typ pliku HDF5)
- tf_saved_model – aby wczytać model, który korzysta z podstawowych interfejsów API Tensorflow zamiast Kera.
- tf_frozen_model – aby wczytać model zawierający zablokowane wagi.
- tf_hub – aby wczytać model wygenerowany z centrum Tensorflow.
Więcej informacji o tych innych formatach znajdziesz tutaj
Następne 2 parametry określają folder, w którym znajduje się zapisany model – w naszym przykładzie powyżej określamy bieżący katalog, a następnie określamy katalog, do którego mamy kierować konwersję (który określamy powyżej jako folder „predict_houses_tfjs”). w bieżącym katalogu.
Uruchomienie tego polecenia spowoduje utworzenie w bieżącym katalogu nowego folderu o nazwie predict_houses_tfjs, który zawiera:
- model.json
- Grupa1-fragment1z1.bin
Te pliki są nam potrzebne do uruchomienia modelu w przeglądarce. Zapisz te pliki, ponieważ wykorzystamy je w następnej sekcji.
6. Za pomocą przekonwertowanego modelu w przeglądarce
Przechowywanie przekonwertowanych plików na serwerze
Najpierw musimy umieścić wygenerowane na serwerze WWW pliki model.json i *.bin, aby można było uzyskiwać do nich dostęp na naszej stronie internetowej. W tej wersji demonstracyjnej skorzystamy z witryny Glitch.com, aby ułatwić Ci zapoznanie się z nią. Jeśli jednak zajmujesz się inżynierią sieciową, możesz uruchomić w bieżącej instancji serwera Ubuntu prosty serwer http. Wybór należy do Ciebie.
Przesyłanie plików do Glitch
- Zaloguj się na Glitch.com.
- Użyj tego linku, aby sklonować nasz stały projekt TensorFlow.js. Zawiera on szkieletowe pliki html, css i js, które importują do nas gotową bibliotekę TensorFlow.js.
- Kliknij „Zasoby”. w panelu po lewej stronie.
- Kliknij „Prześlij zasób”. i wybierz
group1-shard1of1.bin, które chcesz przesłać do tego folderu. Po przesłaniu plik powinien wyglądać tak:
- Jeśli klikniesz przesłany przed chwilą plik
group1-shard1of1.bin, możesz skopiować adres URL do jego lokalizacji. Skopiuj teraz tę ścieżkę – tak jak pokazano poniżej:
- Teraz edytuj
model.jsonw ulubionym edytorze tekstu na komputerze lokalnym i wyszukaj (kombinacją CTRL+F) plikgroup1-shard1of1.bin, który pojawi się gdzieś w nim.
Zastąp tę nazwę pliku adresem URL skopiowanym w kroku 5 i usuń początkowy https://cdn.glitch.com/ wygenerowany przez błąd ze skopiowanej ścieżki.
Po wprowadzeniu zmian powinien on wyglądać mniej więcej tak (zwróć uwagę, że wiodąca ścieżka serwera została usunięta, dzięki czemu zachowana jest tylko nazwa przesłanego pliku): 
7. Teraz zapisz i prześlij wyedytowany model.json plik, aby przestał działać. Wystarczy, że klikniesz komponenty, a potem „Prześlij zasób” przycisk (ważne). Jeśli nie użyjesz fizycznego przycisku i przeciągnij go i upuść, zostanie on przesłany jako plik edytowalny, a nie do sieci CDN, które nie będą znajdować się w tym samym folderze, a przy próbie pobrania plików binarnych przez TensorFlow.js przyjmuje się, że przy próbie pobrania plików binarnych dla danego modelu zakładana jest ścieżka względna. Jeśli zrobisz to prawidłowo, w folderze assets powinny pojawić się 2 pliki podobne do tego: 
Świetnie. Teraz możemy używać zapisanych plików z jakimś kodem w przeglądarce.
Wczytywanie modelu
Skoro już przechowujemy przekonwertowane pliki, możemy napisać prostą stronę internetową, która je załaduje i użyje do wygenerowania prognozy. Otwórz script.js w folderze projektu Glitch i zastąp zawartość tego pliku taką jak poniżej po zmianie elementu const MODEL_URL tak, by wskazywał wygenerowany link Glitch.com dotyczący pliku model.json przesłanego w Glitch:
script.js:
// Grab a reference to our status text element on the web page.
// Initially we print out the loaded version of TFJS.
const status = document.getElementById('status');
status.innerText = 'Loaded TensorFlow.js - version: ' + tf.version.tfjs;
// Specify location of our Model.json file we uploaded to the Glitch.com CDN.
const MODEL_URL = ‘YOUR MODEL.JSON URL HERE! CHANGE THIS!';
// Specify a test value we wish to use in our prediction.
// Here we use 950, so we expect the result to be close to 950,000.
const TEST_VALUE = 950.0
// Create an asynchronous function.
async function run() {
// Load the model from the CDN.
const model = await tf.loadLayersModel(MODEL_URL);
// Print out the architecture of the loaded model.
// This is useful to see that it matches what we built in Python.
console.log(model.summary());
// Create a 1 dimensional tensor with our test value.
const input = tf.tensor1d([TEST_VALUE]);
// Actually make the prediction.
const result = model.predict(input);
// Grab the result of prediction using dataSync method
// which ensures we do this synchronously.
status.innerText = 'Input of ' + TEST_VALUE +
'sqft predicted as $' + result.dataSync()[0];
}
// Call our function to start the prediction!
run();
Uruchomienie powyższego kodu po zmianie stałej MODEL_URL w taki sposób, aby wskazywała ścieżkę model.json, spowoduje wyświetlenie pokazanych poniżej danych wyjściowych.
Jeśli sprawdzimy konsolę przeglądarki (naciśnij klawisz F12, aby wyświetlić narzędzia dla programistów w przeglądarce), zobaczymy również opis modelu, który jest drukowany:
Dzięki porównaniu tego z naszym kodem w Pythonie na początku tego ćwiczenia z programowania możemy potwierdzić, że jest to ta sama sieć, którą utworzyliśmy z 1 gęstymi danymi wejściowymi i 1 gęstą warstwą z 1 węzłem.
Gratulacje! Właśnie udało Ci się uruchomić w przeglądarce przekonwertowany model wytrenowany w języku Python.
7. Modele bez konwersji
Może się zdarzyć, że bardziej złożone modele, które są kompilowane w celu zastosowania mniej typowych operacji, nie będą obsługiwane w przypadku konwersji. Oparta w przeglądarce wersja TensorFlow.js to całkowita przeredagowanie TensorFlow. W związku z tym obecnie nie obsługujemy wszystkich operacji niskiego poziomu interfejsu TensorFlow C++ API (jest ich tysiąc) – choć z czasem w miarę rozwoju cały czas się rozwijamy i w miarę jak główne działania stają się bardziej stabilne.
W momencie pisania skryptu jedna z takich funkcji w TensorFlow Python, która generuje nieobsługiwaną operację przy wyeksportowaniu jako zapisany model, to linalg.diag. Jeśli spróbujemy przekonwertować zapisany model, który go używa w Pythonie (który obsługuje generowane operacje), pojawi się błąd podobny do tego poniżej:
Widzimy tu zaznaczone na czerwono, że wywołanie linalg.diag zostało skompilowane w celu wygenerowania operacji o nazwie MatrixDiagV3, która nie była obsługiwana przez TensorFlow.js w przeglądarce w momencie pisania tego ćwiczenia z programowania.
Co zrobić?
Masz dwie opcje do wyboru.
- Wdróż tę brakującą operację w TensorFlow.js – jest to projekt open source i jesteśmy mile widziani w przypadku nowych działań. Zapoznaj się z tym przewodnikiem dotyczącym tworzenia nowych operacji dla TensorFlow.js. Jeśli sobie z tym poradzisz, możesz użyć flagi
Skip_op_checkw naszym konwerterze wiersza poleceń, aby zignorować ten błąd i kontynuować konwersję (zakładamy, że ta funkcja jest dostępna w nowej kompilacji TensorFlow.js, która ma obsługiwaną brakującą opcję). - Ustal, która część kodu Pythona spowodowała nieobsługiwaną operację w wyeksportowanym pliku
savedmodel. W niewielkim zestawie kodu może to być łatwe do zlokalizowania, ale w bardziej złożonych modelach może to wymagać pewnych analiz, ponieważ obecnie nie ma metody identyfikacji wysokiego poziomu wywołania funkcji Pythona, które spowodowało wyświetlenie danej operacji w formacie plikusavedmodel. Po jego znalezieniu możesz go jednak zmienić, korzystając z innej obsługiwanej metody.
8. Gratulacje
Gratulacje. Pierwsze kroki przy użyciu modelu Pythona za pomocą TensorFlow.js w przeglądarce masz już za sobą.
Podsumowanie
Z tego modułu dotyczącego kodu nauczyliśmy się, jak:
- Skonfiguruj nasze środowisko Linux, aby zainstalować TensorFlow w Pythonie
- Eksportowanie modelu Pythona „SavedModel”
- Instalowanie konwertera wiersza poleceń TensorFlow.js
- Użyj konwertera wiersza poleceń TensorFlow.js, aby utworzyć wymagane pliki po stronie klienta
- Używanie wygenerowanych plików w rzeczywistej aplikacji internetowej
- Zidentyfikuj modele, które nie będą konwertowane, i sprawdź, co trzeba wdrożyć, aby umożliwić im takie konwersje w przyszłości.
Co dalej?
Pamiętaj, aby oznaczyć nas tagiem #MadeWithTFJS we wszystkich swoich materiałach, abyśmy mogli pojawić się w mediach społecznościowych lub zaprezentować podczas przyszłych wydarzeń TensorFlow. Chętnie zobaczymy, co konwertujesz i jakie dane wykorzystasz w przeglądarce.
Dowiedz się więcej o programie TensorFlow.js w języku angielskim
- Tworzenie sieci neuronowej od zera w TensorFlow.js
- Tworzenie inteligentnej kamery internetowej z możliwością wykrywania obiektów
- Niestandardowa klasyfikacja obrazów za pomocą uczenia maszynowego w TensorFlow.js