1. Wprowadzenie
Zrobiłeś(-aś) już pierwsze kroki w TensorFlow.js, wypróbowałeś(-aś) nasze gotowe modele, a może nawet stworzyłeś(-aś) własne. Jednak w Pythonie pojawiły się najnowsze badania i zastanawiasz się, czy można je uruchomić w przeglądarce, aby zrealizować swój pomysł i udostępnić go milionom użytkowników. Brzmi znajomo? Jeśli tak, te ćwiczenia są dla Ciebie.
Zespół TensorFlow.js stworzył wygodne narzędzie do konwertowania modeli w formacie SavedModel na TensorFlow.js za pomocą konwertera wiersza poleceń, dzięki czemu możesz korzystać z takich modeli w internecie.
Czego się nauczysz
W tym ćwiczeniu z programowania dowiesz się, jak używać konwertera wiersza poleceń TensorFlow.js do przenoszenia wygenerowanego w Pythonie modelu SavedModel do formatu model.json wymaganego do wykonania po stronie klienta w przeglądarce internetowej.
Więcej szczegółów:
- Jak utworzyć prosty model ML w Pythonie i zapisać go w formacie wymaganym przez konwerter TensorFlow.js.
- Jak zainstalować i używać konwertera TensorFlow.js w przypadku modelu SavedModel wyeksportowanego z Pythona.
- Wykorzystaj pliki wynikowe po konwersji w aplikacji internetowej JS.
- Dowiedz się, co zrobić, gdy coś pójdzie nie tak (nie wszystkie modele zostaną przekonwertowane) i jakie masz opcje.
Wyobraź sobie, że możesz wziąć najnowsze wyniki badań i udostępnić model milionom programistów JS na całym świecie. Możesz też wykorzystać go we własnym projekcie, z którego będzie mógł korzystać każdy na świecie, jeśli tylko będzie działał w przeglądarce internetowej, ponieważ nie wymaga złożonych zależności ani konfiguracji środowiska. Chcesz zacząć hakowanie? Zaczynamy!
Podziel się z nami tym, co udało Ci się przekonwertować.
Dzięki temu, czego się dziś nauczysz, możesz spróbować przekonwertować niektóre z ulubionych modeli z Pythona. Jeśli Ci się to uda i utworzysz działającą witrynę demonstracyjną z modelem w akcji, oznacz nas w mediach społecznościowych hashtagiem #MadeWithTFJS, aby mieć szansę na wyróżnienie Twojego projektu na naszym blogu TensorFlow lub podczas przyszłych prezentacji. Chcielibyśmy, aby więcej niesamowitych badań było przenoszonych do internetu, co umożliwiłoby większej liczbie osób korzystanie z takich modeli w innowacyjny lub kreatywny sposób, tak jak w tym świetnym przykładzie.
2. Czym jest TensorFlow.js?
TensorFlow.js to biblioteka uczenia maszynowego typu open source, która może działać wszędzie tam, gdzie JavaScript. Jest ona oparta na oryginalnej bibliotece TensorFlow napisanej w Pythonie i ma na celu odtworzenie środowiska deweloperskiego i zestawu interfejsów API dla ekosystemu JavaScript.
Gdzie można jej używać?
Dzięki przenośności JavaScript możesz teraz pisać w 1 języku i z łatwością korzystać z uczenia maszynowego na wszystkich tych platformach:
- Po stronie klienta w przeglądarce przy użyciu czystego JavaScriptu.
- po stronie serwera, a nawet na urządzeniach IoT, takich jak Raspberry Pi, przy użyciu Node.js;
- Aplikacje na komputery korzystające z Electrona
- natywnych aplikacji mobilnych korzystających z React Native,
TensorFlow.js obsługuje też wiele backendów w każdym z tych środowisk (rzeczywiste środowiska sprzętowe, w których może działać, np. procesor lub WebGL). „Backend” w tym kontekście nie oznacza środowiska po stronie serwera – backend do wykonywania może być np. po stronie klienta w WebGL, aby zapewnić zgodność i szybkie działanie. Obecnie TensorFlow.js obsługuje:
- Wykonywanie WebGL na karcie graficznej urządzenia (GPU) – to najszybszy sposób wykonywania większych modeli (o rozmiarze powyżej 3 MB) z akceleracją GPU.
- Wykonywanie kodu Web Assembly (WASM) na procesorze – aby zwiększyć wydajność procesora na różnych urządzeniach, np. na starszych telefonach komórkowych. Jest to lepsze rozwiązanie w przypadku mniejszych modeli (o rozmiarze poniżej 3 MB), które mogą działać szybciej na procesorze z użyciem WASM niż z użyciem WebGL ze względu na narzut związany z przesyłaniem treści do procesora graficznego.
- Wykonywanie na procesorze – to rozwiązanie rezerwowe, gdy żadne inne środowisko nie jest dostępne. Jest to najwolniejsza z tych 3 metod, ale zawsze dostępna.
Uwaga: jeśli wiesz, na jakim urządzeniu będzie wykonywany kod, możesz wymusić użycie jednego z tych backendów. Jeśli tego nie zrobisz, TensorFlow.js sam podejmie decyzję.
Supermoce po stronie klienta
Uruchamianie TensorFlow.js w przeglądarce na komputerze klienckim może przynieść kilka korzyści, które warto wziąć pod uwagę.
Prywatność
Możesz trenować i klasyfikować dane na urządzeniu klienta bez wysyłania ich na serwer WWW strony trzeciej. Może to być wymagane w celu zachowania zgodności z lokalnymi przepisami, np. z RODO, lub podczas przetwarzania danych, które użytkownik chce przechowywać na swoim urządzeniu i nie wysyłać do osób trzecich.
Szybkość
Nie musisz wysyłać danych na serwer zdalny, więc wnioskowanie (czyli klasyfikowanie danych) może być szybsze. Co więcej, jeśli użytkownik przyzna Ci dostęp, będziesz mieć bezpośredni dostęp do czujników urządzenia, takich jak aparat, mikrofon, GPS, akcelerometr i inne.
Zasięg i skala
Każda osoba na świecie może jednym kliknięciem otworzyć wysłany przez Ciebie link, otworzyć stronę internetową w przeglądarce i skorzystać z Twojej pracy. Nie musisz przeprowadzać złożonej konfiguracji serwera z systemem Linux, sterownikami CUDA i wieloma innymi elementami, aby korzystać z systemu uczenia maszynowego.
Koszt
Brak serwerów oznacza, że musisz płacić tylko za CDN do hostowania plików HTML, CSS, JS i modeli. Koszt sieci CDN jest znacznie niższy niż utrzymywanie serwera (potencjalnie z dołączoną kartą graficzną) działającego przez całą dobę.
Funkcje po stronie serwera
Korzystanie z implementacji TensorFlow.js w Node.js umożliwia korzystanie z tych funkcji:
Pełna obsługa CUDA
Po stronie serwera, aby przyspieszyć działanie karty graficznej, musisz zainstalować sterowniki NVIDIA CUDA, aby umożliwić TensorFlow współpracę z kartą graficzną (w przeciwieństwie do przeglądarki, która korzysta z WebGL – nie wymaga instalacji). Pełna obsługa CUDA pozwala jednak w pełni wykorzystać możliwości karty graficznej na niższym poziomie, co przekłada się na krótszy czas trenowania i wnioskowania. Wydajność jest porównywalna z implementacją TensorFlow w Pythonie, ponieważ obie korzystają z tego samego backendu w C++.
Rozmiar modelu
W przypadku najnowocześniejszych modeli z badań możesz pracować z bardzo dużymi modelami, które mogą mieć rozmiar nawet kilku gigabajtów. Obecnie nie można uruchamiać tych modeli w przeglądarce ze względu na ograniczenia dotyczące wykorzystania pamięci na kartę przeglądarki. Aby uruchamiać te większe modele, możesz używać Node.js na własnym serwerze o specyfikacji sprzętowej, która umożliwia wydajne działanie takiego modelu.
IOT
Node.js jest obsługiwany na popularnych komputerach jednopłytkowych, takich jak Raspberry Pi, co oznacza, że możesz na nich uruchamiać modele TensorFlow.js.
Szybkość
Node.js jest napisany w JavaScript, co oznacza, że korzysta z kompilacji JIT. Oznacza to, że w przypadku korzystania z Node.js często można zauważyć wzrost wydajności, ponieważ jest on optymalizowany w czasie działania, zwłaszcza w przypadku wstępnego przetwarzania. Świetny przykład tego można znaleźć w tym studium przypadku, które pokazuje, jak Hugging Face wykorzystał Node.js, aby dwukrotnie zwiększyć wydajność swojego modelu przetwarzania języka naturalnego.
Znasz już podstawy TensorFlow.js, wiesz, gdzie można go używać i jakie są jego zalety. Zacznijmy więc robić z jego pomocą przydatne rzeczy.
3. Konfigurowanie systemu
W tym samouczku będziemy używać Ubuntu – popularnej dystrybucji systemu Linux, z której korzysta wiele osób. Jest ona dostępna w Compute Engine w Google Cloud jako obraz podstawowy, jeśli chcesz wykonać te czynności na maszynie wirtualnej w chmurze.
W momencie pisania tego artykułu możemy wybrać obraz Ubuntu 18.04.4 LTS podczas tworzenia nowej instancji Compute Engine, z której będziemy korzystać. Możesz oczywiście użyć własnego komputera lub innego systemu operacyjnego, ale instrukcje instalacji i zależności mogą się różnić w zależności od systemu.
Instalowanie TensorFlow (wersja w Pythonie)
Jeśli chcesz przekonwertować istniejący model oparty na Pythonie, który został znaleziony lub zostanie napisany, musisz najpierw skonfigurować wersję Pythona TensorFlow na swojej instancji, zanim będziesz mieć możliwość wyeksportowania pliku „SavedModel” z Pythona (jeśli plik „SavedModel” nie jest jeszcze dostępny do pobrania).
Połącz się przez SSH z utworzoną powyżej maszyną w chmurze, a następnie wpisz w oknie terminala to polecenie:
Okno terminala:
sudo apt update
sudo apt-get install python3
Dzięki temu będziemy mieć na komputerze zainstalowaną wersję Pythona 3. Aby korzystać z TensorFlow, musisz mieć zainstalowany język Python w wersji 3.4 lub nowszej.
Aby sprawdzić, czy zainstalowana jest prawidłowa wersja, wpisz:
Okno terminala:
python3 --version
Powinny się wyświetlić dane wyjściowe wskazujące numer wersji, np. Python 3.6.9. Jeśli widzisz, że wartość jest wydrukowana prawidłowo i jest wyższa niż 3,4, możesz przejść dalej.
Następnie zainstalujemy PIP dla Pythona 3, czyli menedżera pakietów Pythona, a potem go zaktualizujemy. Typ:
Okno terminala:
sudo apt install python3-pip
pip3 install --upgrade pip
Instalację pip3 możemy ponownie zweryfikować za pomocą tego polecenia:
Okno terminala:
pip3 --version
W momencie pisania tego artykułu po wykonaniu tego polecenia w terminalu wyświetla się pip 20.2.3.
Zanim zainstalujemy TensorFlow, musimy mieć pakiet Pythona „setuptools” w wersji 41.0.0 lub nowszej. Aby mieć pewność, że jest ona zaktualizowana do najnowszej wersji, uruchom to polecenie:
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ż proces się zakończy.
Sprawdźmy, czy TensorFlow został prawidłowo zainstalowany. Utwórz w bieżącym katalogu plik Pythona o nazwie test.py:
Okno terminala:
nano test.py
Po otwarciu edytora nano możemy napisać kod w Pythonie, aby wydrukować 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 wyjść z edytora nano.
Teraz możemy uruchomić ten plik Pythona, aby zobaczyć wersję TensorFlow wyświetlaną na ekranie:
Okno terminala:
python3 test.py
W momencie pisania tego artykułu w konsoli wyświetla się 2.3.1 w przypadku zainstalowanej wersji TensorFlow Python.
4. Tworzenie modelu w Pythonie
W kolejnym kroku tych ćwiczeń z programowania utworzymy prosty model w Pythonie, aby pokazać, jak zapisać wytrenowany model w formacie „SavedModel”, a następnie użyć go z konwerterem wiersza poleceń TensorFlow.js. Zasada działania będzie podobna w przypadku każdego modelu Pythona, który chcesz przekonwertować, ale uprościmy ten kod, aby był zrozumiały dla wszystkich.
Otwórz do edycji plik test.py utworzony w pierwszej sekcji i zaktualizuj kod w ten 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ę szacować zależność między podanymi wartościami x (danymi wejściowymi) i y (danymi wyjściowymi). Następnie zapiszemy wytrenowany model na dysku. Więcej informacji o tym, co robi każda linia, znajdziesz w komentarzach w kodzie.
Jeśli po uruchomieniu tego programu sprawdzimy nasz katalog (wywołując python3 test.py), powinniśmy zobaczyć w nim nowe pliki i foldery:
- test.py
- saved_model.pb
- zasoby
- zmienne,
Wygenerowaliśmy już pliki, których potrzebuje konwerter TensorFlow.js, aby przekonwertować ten model do uruchamiania w przeglądarce.
5. Konwertowanie modelu SavedModel do formatu TensorFlow.js
Instalowanie konwertera TensorFlow.js
Aby zainstalować konwerter, uruchom to polecenie:
Okno terminala:
pip3 install tensorflowjs
To było proste.
Załóżmy, że używamy konwertera wiersza poleceń (tensorflowjs_converter), a nie wersji kreatora pokazanej powyżej. Aby przekonwertować zapisany model, który właśnie utworzyliśmy, i jawnie przekazać parametry do konwertera, możemy wywołać to polecenie:
Okno terminala:
tensorflowjs_converter \
--input_format=keras_saved_model \
./ \
./predict_houses_tfjs
Co się tu dzieje? Najpierw wywołujemy zainstalowany przed chwilą plik binarny tensorflowjs_converter i określamy, że próbujemy przekonwertować zapisany model Keras.
W przykładzie kodu powyżej widać, że zaimportowaliśmy bibliotekę Keras i użyliśmy jej interfejsów API warstw wyższego poziomu do utworzenia modelu. Jeśli w kodzie Pythona nie używasz biblioteki Keras, możesz użyć innego formatu danych wejściowych:
- keras – wczytuje format keras (typ pliku HDF5);
- tf_saved_model – do wczytywania modelu, który korzysta z interfejsów API TensorFlow Core zamiast Keras.
- tf_frozen_model – do wczytywania modelu zawierającego zamrożone wagi.
- tf_hub – do wczytywania modelu wygenerowanego w TensorFlow Hub.
Więcej informacji o tych formatach znajdziesz tutaj
Kolejne 2 parametry określają, w którym folderze znajduje się zapisany model. W naszym przykładzie powyżej wskazujemy bieżący katalog, a następnie określamy, do którego katalogu chcemy wyeksportować konwersję. W naszym przykładzie jest to folder o nazwie „predict_houses_tfjs” w bieżącym katalogu.
Uruchomienie powyższego polecenia spowoduje utworzenie w bieżącym katalogu nowego folderu o nazwie predict_houses_tfjs, który będzie zawierać:
- model.json
- Group1-shard1of1.bin
Są to pliki potrzebne do uruchomienia modelu w przeglądarce. Zapisz te pliki, ponieważ użyjemy ich w następnej sekcji.
6. Korzystanie z przekonwertowanego modelu w przeglądarce
Hostowanie przekonwertowanych plików
Najpierw musimy umieścić wygenerowane pliki model.json i *.bin na serwerze WWW, aby mieć do nich dostęp za pomocą strony internetowej. Na potrzeby tej prezentacji użyjemy Glitch.com, aby ułatwić Ci śledzenie naszych działań. Jeśli jednak masz doświadczenie w inżynierii internetowej, możesz zamiast tego uruchomić prosty serwer HTTP na bieżącej instancji serwera Ubuntu. Wybór należy do Ciebie.
Przesyłanie plików do Glitcha
- Zaloguj się na Glitch.com.
- Użyj tego linku, aby sklonować nasz projekt TensorFlow.js. Zawiera on szkielet plików HTML, CSS i JS, które importują bibliotekę TensorFlow.js, gotową do użycia.
- W panelu po lewej stronie kliknij folder „Komponenty”.
- Kliknij „Prześlij komponent” i wybierz
group1-shard1of1.bin, aby przesłać go do tego folderu. Po przesłaniu powinien wyglądać tak:
- Jeśli klikniesz
group1-shard1of1.binprzesłany plik, możesz skopiować adres URL do jego lokalizacji. Skopiuj teraz tę ścieżkę w sposób pokazany poniżej:
- Teraz edytuj plik
model.jsonw ulubionym edytorze tekstu na komputerze lokalnym i wyszukaj (za pomocą CTRL+F) plikgroup1-shard1of1.bin, który będzie gdzieś w nim wymieniony.
Zastąp tę nazwę pliku adresem URL skopiowanym w kroku 5, ale usuń początkowy znak https://cdn.glitch.com/, który jest generowany przez błąd w skopiowanej ścieżce.
Po edycji powinien wyglądać mniej więcej tak (zwróć uwagę, że początkowa ścieżka serwera została usunięta, więc zachowana została tylko nazwa przesłanego pliku): 
7. Teraz zapisz i prześlij ten zmodyfikowany plik model.json do Glitch, klikając kolejno „assets” (zasoby) i przycisk „upload an asset” (prześlij zasób) (ważne). Jeśli nie użyjesz fizycznego przycisku, a zamiast tego przeciągniesz i upuścisz plik, zostanie on przesłany jako plik z możliwością edycji, a nie do sieci CDN. Nie będzie się on znajdować w tym samym folderze, a TensorFlow.js będzie zakładać ścieżkę względną podczas próby pobrania plików binarnych dla danego modelu. Jeśli wszystko zostało wykonane prawidłowo, w folderze assets powinny się znajdować 2 pliki: 
Świetnie. Możemy teraz używać zapisanych plików z rzeczywistym kodem w przeglądarce.
Wczytywanie modelu
Po hostowaniu przekonwertowanych plików możemy napisać prostą stronę internetową, aby je wczytać i użyć do prognozowania. Otwórz plik script.js w folderze projektu Glitch i zastąp jego zawartość poniższym kodem po zmianie const MODEL_URL na wygenerowany link Glitch.com do pliku model.json przesłanego do 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 tak, aby wskazywała ścieżkę model.json, spowoduje wyświetlenie danych wyjściowych pokazanych poniżej.
Jeśli sprawdzimy konsolę przeglądarki (naciśnij F12, aby otworzyć narzędzia deweloperskie), zobaczymy też opis wczytanego modelu:
Porównując to z kodem w Pythonie na początku tego laboratorium, możemy potwierdzić, że jest to ta sama sieć, którą utworzyliśmy z 1 gęstym wejściem i 1 gęstą warstwą z 1 węzłem.
Gratulacje! Właśnie udało Ci się uruchomić przekonwertowany wytrenowany model Pythona w przeglądarce.
7. Modele, które nie są konwertowane
Czasami bardziej złożone modele, które są kompilowane w celu używania mniej popularnych operacji, nie będą obsługiwane w przypadku konwersji. Wersja TensorFlow.js oparta na przeglądarce jest całkowicie nową wersją TensorFlow, dlatego obecnie nie obsługujemy wszystkich operacji niskiego poziomu, które są dostępne w interfejsie TensorFlow C++ API (jest ich tysiące). Z czasem będziemy dodawać kolejne operacje, w miarę jak będziemy się rozwijać i gdy podstawowe operacje staną się bardziej stabilne.
W momencie pisania tego artykułu jedną z takich funkcji w TensorFlow Python, która po wyeksportowaniu jako zapisany model generuje nieobsługiwaną operację, jest funkcja linalg.diag. Jeśli spróbujemy przekonwertować zapisany model, który używa tego w Pythonie (który obsługuje wynikowe operacje), zobaczymy błąd podobny do tego poniżej:
Na czerwono widać, że wywołanie linalg.diag zostało skompilowane do operacji o nazwie MatrixDiagV3, która w momencie pisania tego samouczka nie była obsługiwana przez TensorFlow.js w przeglądarce internetowej.
Co należy zrobić?
Masz dwie opcje do wyboru.
- Zaimplementuj brakującą operację w TensorFlow.js – jesteśmy projektem open source i mile widziane są wszelkie działania, np. dodawanie nowych operacji. Zapoznaj się z tym przewodnikiem dotyczącym pisania nowych operacji w TensorFlow.js. Jeśli Ci się to uda, możesz użyć flagi
Skip_op_checkw naszym konwerterze wiersza poleceń, aby zignorować ten błąd i kontynuować konwersję (zakładając, że ta operacja jest dostępna w nowej wersji TensorFlow.js, którą utworzono i która obsługuje brakującą operację). - Określ, która część kodu Pythona spowodowała nieobsługiwaną operację w wyeksportowanym pliku
savedmodel. W przypadku małego zestawu kodu może to być łatwe do zlokalizowania, ale w bardziej złożonych modelach może wymagać dość szczegółowej analizy zagrożeń, ponieważ obecnie nie ma metody identyfikowania wywołania funkcji Pythona wysokiego poziomu, które wygenerowało daną operację w formacie plikusavedmodel. Po zlokalizowaniu możesz zmienić tę metodę na inną obsługiwaną.
8. Gratulacje
Gratulacje! Zrobiliśmy pierwsze kroki w zakresie korzystania z modelu Pythona za pomocą TensorFlow.js w przeglądarce.
Podsumowanie
W tym module nauczyliśmy się, jak:
- Skonfiguruj środowisko Linuksa, aby zainstalować TensorFlow oparte na Pythonie
- Eksportowanie modelu „SavedModel” w Pythonie
- Instalowanie konwertera TensorFlow.js w wierszu poleceń
- Użyj konwertera wiersza poleceń TensorFlow.js, aby utworzyć wymagane pliki po stronie klienta.
- Używanie wygenerowanych plików w prawdziwej aplikacji internetowej
- Określ modele, które nie zostaną przekonwertowane, i wskaż, co należy wdrożyć, aby umożliwić ich przekonwertowanie w przyszłości.
Co dalej?
Pamiętaj, aby oznaczać nas w swoich projektach za pomocą hashtaga #MadeWithTFJS. Dzięki temu możesz zostać wyróżniony(-a) w mediach społecznościowych lub podczas przyszłych wydarzeń związanych z TensorFlow. Chętnie zobaczymy, co udało Ci się przekonwertować i wykorzystać po stronie klienta w przeglądarce.
Więcej ćwiczeń z TensorFlow.js
- Pisanie sieci neuronowej od podstaw w TensorFlow.js
- Tworzenie inteligentnej kamery internetowej, która może wykrywać obiekty
- Niestandardowa klasyfikacja obrazów z wykorzystaniem uczenia transferowego w TensorFlow.js