Apache MXNet - szybki przewodnik

W tym rozdziale przedstawiono funkcje Apache MXNet i omówiono najnowszą wersję tej platformy oprogramowania do głębokiego uczenia.

Co to jest MXNet?

Apache MXNet to potężny instrument ramowy do głębokiego uczenia się typu open source, pomagający programistom w tworzeniu, szkoleniu i wdrażaniu modeli Deep Learning. W ciągu ostatnich kilku lat, od opieki zdrowotnej, przez transport, po produkcję, a właściwie w każdym aspekcie naszego codziennego życia, wpływ głębokiego uczenia się był powszechny. Obecnie firmy poszukują głębokiego uczenia się, aby rozwiązać niektóre trudne problemy, takie jak rozpoznawanie twarzy, wykrywanie obiektów, optyczne rozpoznawanie znaków (OCR), rozpoznawanie mowy i tłumaczenie maszynowe.

Z tego powodu Apache MXNet jest obsługiwany przez:

• Niektóre duże firmy, takie jak Intel, Baidu, Microsoft, Wolfram Research itp.

• Dostawcy chmury publicznej, w tym Amazon Web Services (AWS) i Microsoft Azure

• Niektóre duże instytuty badawcze, takie jak Carnegie Mellon, MIT, University of Washington i Hong Kong University of Science & Technology.

Dlaczego Apache MXNet?

Istnieją różne platformy uczenia głębokiego, takie jak Torch7, Caffe, Theano, TensorFlow, Keras, Microsoft Cognitive Toolkit itp., Więc możesz się zastanawiać, dlaczego Apache MXNet? Sprawdźmy niektóre z powodów:

• Apache MXNet rozwiązuje jeden z największych problemów istniejących platform uczenia głębokiego. Problem polega na tym, że aby korzystać z platform głębokiego uczenia się, trzeba nauczyć się innego systemu dla innego smaku programowania.

• Z pomocą Apache MXNet programiści mogą wykorzystać pełne możliwości GPU, a także przetwarzania w chmurze.

• Apache MXNet może przyspieszyć wszelkie obliczenia numeryczne i kładzie szczególny nacisk na przyspieszenie rozwoju i wdrażania wielkoskalowych DNN (głębokich sieci neuronowych).

• Zapewnia użytkownikom możliwości programowania imperatywnego i symbolicznego.

Różne funkcje

Jeśli szukasz elastycznej biblioteki do głębokiego uczenia się, aby szybko opracować najnowocześniejsze badania głębokiego uczenia się lub solidnej platformy do przyspieszenia obciążenia produkcyjnego, Twoje wyszukiwanie kończy się na Apache MXNet. Wynika to z następujących cech:

Rozproszone szkolenie

Niezależnie od tego, czy jest to szkolenie z wieloma procesorami graficznymi, czy z wieloma hostami z niemal liniową wydajnością skalowania, Apache MXNet umożliwia programistom maksymalne wykorzystanie ich sprzętu. MXNet obsługuje również integrację z Horovod, który jest platformą do rozproszonego uczenia głębokiego typu open source stworzoną w Uber.

Na potrzeby tej integracji poniżej przedstawiono niektóre typowe rozproszone interfejsy API zdefiniowane w Horovod:

• horovod.broadcast()

• horovod.allgather()

• horovod.allgather()

W związku z tym MXNet oferuje nam następujące możliwości:

• Device Placement - Z pomocą MXNet możemy łatwo określić każdą strukturę danych (DS).

• Automatic Differentiation - Apache MXNet automatyzuje różnicowanie, czyli obliczenia pochodne.

• Multi-GPU training - MXNet pozwala nam osiągnąć wydajność skalowania z liczbą dostępnych GPU.

• Optimized Predefined Layers - Możemy kodować nasze własne warstwy w MXNet, a także zoptymalizować wstępnie zdefiniowane warstwy pod kątem szybkości.

Hybrydyzacja

Apache MXNet zapewnia swoim użytkownikom hybrydowy front-end. Z pomocą Gluon Python API może wypełnić lukę między swoimi imperatywnymi i symbolicznymi możliwościami. Można to zrobić, nazywając funkcjonalność hybrydyzacji.

Szybsze obliczenia

Operacje liniowe, takie jak dziesiątki lub setki mnożenia macierzy, są wąskim gardłem obliczeniowym dla głębokich sieci neuronowych. Aby rozwiązać ten problem, MXNet zapewnia -

• Zoptymalizowane obliczenia numeryczne dla procesorów graficznych

• Zoptymalizowane obliczenia numeryczne dla rozproszonych ekosystemów

• Automatyzacja typowych przepływów pracy, za pomocą których można krótko przedstawić standardowy NN.

Wiązania językowe

MXNet ma głęboką integrację z językami wysokiego poziomu, takimi jak Python i R. Zapewnia również obsługę innych języków programowania, takich jak

• Scala

• Julia

• Clojure

• Java

• C/C++

• Perl

Nie musimy uczyć się żadnego nowego języka programowania, zamiast tego MXNet w połączeniu z funkcją hybrydyzacji pozwala na wyjątkowo płynne przejście z Pythona do wdrożenia w wybranym przez nas języku programowania.

Najnowsza wersja MXNet 1.6.0

Apache Software Foundation (ASF) wydała stabilną wersję 1.6.0 Apache MXNet 21 lutego 2020 roku na licencji Apache License 2.0. To ostatnia wersja MXNet obsługująca Python 2, ponieważ społeczność MXNet głosowała za zaprzestaniem obsługi Pythona 2 w kolejnych wydaniach. Zapoznajmy się z niektórymi nowymi funkcjami, które ta wersja oferuje użytkownikom.

Interfejs kompatybilny z NumPy

Ze względu na swoją elastyczność i ogólność NumPy jest szeroko stosowany przez praktyków uczenia maszynowego, naukowców i studentów. Ale jak wiemy, dzisiejsze akceleratory sprzętowe, takie jak graficzne jednostki przetwarzania (GPU), są coraz bardziej asymilowane w różnych zestawach narzędzi do uczenia maszynowego (ML), użytkownicy NumPy, aby skorzystać z szybkości procesorów graficznych, muszą przejść na nowe ramy z inną składnią.

Dzięki MXNet 1.6.0 Apache MXNet zmierza w kierunku programowania zgodnego z NumPy. Nowy interfejs zapewnia równoważną użyteczność i ekspresję dla praktyków znających składnię NumPy. Oprócz tego MXNet 1.6.0 umożliwia także istniejącemu systemowi Numpy wykorzystanie akceleratorów sprzętowych, takich jak GPU, do przyspieszenia obliczeń na dużą skalę.

Integracja z Apache TVM

Apache TVM, kompleksowy zestaw kompilatorów do głębokiego uczenia się typu open source dla zaplecza sprzętowego, takiego jak procesory, procesory graficzne i wyspecjalizowane akceleratory, ma na celu wypełnienie luki między strukturami uczenia głębokiego skupiającego się na produktywności a zapleczem sprzętowym zorientowanym na wydajność . Dzięki najnowszej wersji MXNet 1.6.0 użytkownicy mogą wykorzystać Apache (inkubujący) program TVM do implementacji wydajnych jąder operatorów w języku programowania Python. Dwie główne zalety tej nowej funkcji to -

• Upraszcza poprzedni proces programowania oparty na C ++.

• Umożliwia udostępnianie tej samej implementacji w wielu zapleczach sprzętowych, takich jak procesory, układy GPU itp.

Ulepszenia istniejących funkcji

Oprócz wyżej wymienionych funkcji MXNet 1.6.0 zapewnia również pewne ulepszenia w stosunku do istniejących funkcji. Ulepszenia są następujące -

Grupowanie operacji według elementów dla GPU

Jak wiemy, wydajność operacji opartych na elementach zależy od przepustowości pamięci i jest to powód, dla którego tworzenie takich operacji może zmniejszyć ogólną wydajność. Apache MXNet 1.6.0 wykonuje fuzję operacji w oparciu o elementy, która w rzeczywistości generuje połączone operacje w czasie, gdy jest to możliwe. Takie pod względem elementów połączenie operacji zmniejsza również zapotrzebowanie na pamięć i poprawia ogólną wydajność.

Upraszczanie typowych wyrażeń

MXNet 1.6.0 eliminuje nadmiarowe wyrażenia i upraszcza typowe wyrażenia. Takie ulepszenie poprawia również użycie pamięci i całkowity czas wykonywania.

Optymalizacje

MXNet 1.6.0 zapewnia również różne optymalizacje istniejących funkcji i operatorów, które są następujące:

• Automatyczna precyzja mieszana

• Gluon Fit API

• MKL-DNN

• Duży wspornik tensora

• TensorRT integracja

• Obsługa gradientu wyższego rzędu

• Operators

• Profiler wydajności operatora

• Import / eksport ONNX

• Ulepszenia API Gluon

• Ulepszenia API symboli

• Ponad 100 poprawek błędów

Aby rozpocząć pracę z MXNet, pierwszą rzeczą, którą musimy zrobić, jest zainstalowanie go na naszym komputerze. Apache MXNet działa na prawie wszystkich dostępnych platformach, w tym Windows, Mac i Linux.

System operacyjny Linux

Możemy zainstalować MXNet w systemie Linux na następujące sposoby -

Graficzna jednostka przetwarzania (GPU)

Tutaj użyjemy różnych metod, a mianowicie Pip, Docker i Source, aby zainstalować MXNet, gdy używamy GPU do przetwarzania -

Korzystając z metody Pip

Możesz użyć następującego polecenia, aby zainstalować MXNet w swoim Linus OS -

pip install mxnet

Apache MXNet oferuje również pakiety pip MKL, które są znacznie szybsze na sprzęcie Intel. Tutaj na przykładmxnet-cu101mkl oznacza, że ​​-

• Pakiet jest zbudowany z CUDA / cuDNN

• Pakiet obsługuje MKL-DNN

• Wersja CUDA to 10.1

Aby uzyskać informacje o innej opcji, możesz również zapoznać się z https://pypi.org/project/mxnet/.

Korzystając z Docker

Obrazy dockera z MXNet można znaleźć w witrynie DockerHub, która jest dostępna pod adresem https://hub.docker.com/u/mxnet Sprawdźmy poniższe kroki, aby zainstalować MXNet za pomocą Dockera z GPU -

Step 1- Najpierw postępuj zgodnie z instrukcjami instalacji platformy Docker, które są dostępne pod adresem https://docs.docker.com/engine/install/ubuntu/. Musimy zainstalować Dockera na naszym komputerze.

Step 2- Aby umożliwić korzystanie z procesorów graficznych z kontenerów docker, musimy zainstalować wtyczkę nvidia-docker-plugin. Możesz postępować zgodnie z instrukcjami instalacji podanymi na stroniehttps://github.com/NVIDIA/nvidia-docker/wiki.

Step 3- Używając następującego polecenia, możesz pobrać obraz dokowany MXNet -

$ sudo docker pull mxnet/python:gpu

Teraz, aby sprawdzić, czy ściągnięcie obrazu dockera mxnet / python powiodło się, możemy wyświetlić obrazy docker w następujący sposób -

$ sudo docker images

Aby uzyskać najszybsze prędkości wnioskowania z MXNet, zaleca się używanie najnowszego MXNet z Intel MKL-DNN. Sprawdź poniższe polecenia -

$ sudo docker pull mxnet/python:1.3.0_cpu_mkl $ sudo docker images

Ze źródła

Aby zbudować bibliotekę współdzieloną MXNet ze źródła za pomocą GPU, najpierw musimy skonfigurować środowisko dla CUDA i cuDNN w następujący sposób:

• Pobierz i zainstaluj zestaw narzędzi CUDA, tutaj zalecany jest CUDA 9.2.

• Następnie pobierz cuDNN 7.1.4.

• Teraz musimy rozpakować plik. Wymagane jest również przejście do katalogu głównego cuDNN. Przenieś także nagłówek i biblioteki do lokalnego folderu CUDA Toolkit w następujący sposób -

tar xvzf cudnn-9.2-linux-x64-v7.1
sudo cp -P cuda/include/cudnn.h /usr/local/cuda/include
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64
sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*
sudo ldconfig

Po skonfigurowaniu środowiska dla CUDA i cuDNN wykonaj poniższe kroki, aby zbudować bibliotekę współdzieloną MXNet ze źródła -

Step 1- Najpierw musimy zainstalować wstępnie wymagane pakiety. Te zależności są wymagane w systemie Ubuntu w wersji 16.04 lub nowszej.

sudo apt-get update
sudo apt-get install -y build-essential git ninja-build ccache libopenblas-dev 
libopencv-dev cmake

Step 2- W tym kroku pobierzemy źródło MXNet i skonfigurujemy. Najpierw sklonujmy repozytorium za pomocą następującego polecenia -

git clone –recursive https://github.com/apache/incubator-mxnet.git mxnet
cd mxnet
cp config/linux_gpu.cmake #for build with CUDA

Step 3- Używając następujących poleceń, możesz zbudować współdzieloną bibliotekę MXNet core

rm -rf build
mkdir -p build && cd build
cmake -GNinja ..
cmake --build .

Two important points regarding the above step is as follows−

Jeśli chcesz zbudować wersję debugowania, określ następująco:

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Aby ustawić liczbę równoległych zadań kompilacji, określ następujące parametry -

cmake --build . --parallel N

Po pomyślnym zbudowaniu podstawowej biblioteki współdzielonej MXNet w build folder w twoim MXNet project root, znajdziesz libmxnet.so który jest wymagany do zainstalowania powiązań językowych (opcjonalnie).

Centralna jednostka przetwarzania (CPU)

Tutaj użyjemy różnych metod, a mianowicie Pip, Docker i Source, aby zainstalować MXNet, gdy używamy procesora do przetwarzania -

Korzystając z metody Pip

Możesz użyć następującego polecenia, aby zainstalować MXNet na swoim Linus OS−

pip install mxnet

Apache MXNet oferuje również pakiety pip obsługujące MKL-DNN, które są znacznie szybsze na sprzęcie Intel.

pip install mxnet-mkl

Korzystając z Docker

Obrazy dockera z MXNet można znaleźć w witrynie DockerHub, która jest dostępna pod adresem https://hub.docker.com/u/mxnet. Sprawdźmy poniższe kroki, aby zainstalować MXNet za pomocą Dockera z procesorem -

Step 1- Najpierw postępuj zgodnie z instrukcjami instalacji platformy Docker, które są dostępne pod adresem https://docs.docker.com/engine/install/ubuntu/. Musimy zainstalować Dockera na naszym komputerze.

Step 2- Używając następującego polecenia, możesz pobrać obraz dokera MXNet:

$ sudo docker pull mxnet/python

Teraz, aby sprawdzić, czy ściągnięcie obrazu dockera mxnet / python powiodło się, możemy wyświetlić obrazy docker w następujący sposób -

$ sudo docker images

Aby uzyskać najszybsze prędkości wnioskowania z MXNet, zaleca się używanie najnowszego MXNet z Intel MKL-DNN.

Sprawdź poniższe polecenia -

$ sudo docker pull mxnet/python:1.3.0_cpu_mkl $ sudo docker images

Ze źródła

Aby zbudować bibliotekę współdzieloną MXNet ze źródła z procesorem, wykonaj poniższe czynności -

Step 1- Najpierw musimy zainstalować wstępnie wymagane pakiety. Te zależności są wymagane w systemie Ubuntu w wersji 16.04 lub nowszej.

sudo apt-get update

sudo apt-get install -y build-essential git ninja-build ccache libopenblas-dev libopencv-dev cmake

Step 2- W tym kroku pobierzemy źródło MXNet i skonfigurujemy. Najpierw sklonujmy repozytorium za pomocą następującego polecenia:

git clone –recursive https://github.com/apache/incubator-mxnet.git mxnet

cd mxnet
cp config/linux.cmake config.cmake

Step 3- Używając następujących poleceń, możesz zbudować współdzieloną bibliotekę MXNet core:

rm -rf build
mkdir -p build && cd build
cmake -GNinja ..
cmake --build .

Two important points regarding the above step is as follows−

Jeśli chcesz zbudować wersję debugowania, określ następujące elementy:

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Aby ustawić liczbę równoległych zadań kompilacji, podaj następujące:

cmake --build . --parallel N

Po pomyślnym zbudowaniu podstawowej biblioteki współdzielonej MXNet w build folder w katalogu głównym projektu MXNet, znajdziesz libmxnet.so, które jest wymagane do zainstalowania powiązań językowych (opcjonalnie).

System operacyjny Mac

Możemy zainstalować MXNet na MacOS w następujący sposób:

Graficzna jednostka przetwarzania (GPU)

Jeśli planujesz zbudować MXNet na MacOS z GPU, nie ma dostępnej metody Pip i Docker. Jedyną metodą w tym przypadku jest zbudowanie go ze źródła.

Ze źródła

Aby zbudować bibliotekę współdzieloną MXNet ze źródła za pomocą GPU, najpierw musimy skonfigurować środowisko dla CUDA i cuDNN. Musisz postępować zgodnie zNVIDIA CUDA Installation Guide który jest dostępny pod adresem https://docs.nvidia.com i cuDNN Installation Guide, który jest dostępny pod adresem https://docs.nvidia.com/deeplearning dla systemu Mac OS.

Należy pamiętać, że w 2019 CUDA przestała wspierać macOS. W rzeczywistości przyszłe wersje CUDA mogą również nie obsługiwać systemu macOS.

Po skonfigurowaniu środowiska dla CUDA i cuDNN wykonaj poniższe czynności, aby zainstalować MXNet ze źródła w systemie OS X (Mac) -

Step 1- Ponieważ potrzebujemy pewnych zależności w systemie OS X, najpierw musimy zainstalować wstępnie wymagane pakiety.

xcode-select –-install #Install OS X Developer Tools

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" #Install Homebrew

brew install cmake ninja ccache opencv # Install dependencies

Możemy również zbudować MXNet bez OpenCV, ponieważ opencv jest opcjonalną zależnością.

Step 2- W tym kroku pobierzemy źródło MXNet i skonfigurujemy. Najpierw sklonujmy repozytorium za pomocą następującego polecenia -

git clone –-recursive https://github.com/apache/incubator-mxnet.git mxnet

cd mxnet
cp config/linux.cmake config.cmake

W przypadku GPU należy najpierw zainstalować zależności CUDA, ponieważ gdy ktoś próbuje zbudować wersję obsługującą GPU na maszynie bez GPU, MXNet nie może automatycznie wykryć architektury GPU. W takich przypadkach MXNet będzie kierować reklamy na wszystkie dostępne architektury GPU.

Step 3- Używając następujących poleceń, możesz zbudować współdzieloną bibliotekę MXNet core

rm -rf build
mkdir -p build && cd build
cmake -GNinja ..
cmake --build .

Dwie ważne kwestie dotyczące powyższego kroku są następujące:

Jeśli chcesz zbudować wersję debugowania, określ następująco:

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Aby ustawić liczbę równoległych zadań kompilacji, określ następujące elementy:

cmake --build . --parallel N

Po pomyślnym zbudowaniu podstawowej biblioteki współdzielonej MXNet w build folder w twoim MXNet project root, znajdziesz libmxnet.dylib, który jest wymagany do zainstalowania powiązań językowych (opcjonalnie).

Centralna jednostka przetwarzania (CPU)

Tutaj użyjemy różnych metod, a mianowicie Pip, Docker i Source, aby zainstalować MXNet, gdy używamy procesora do przetwarzania.

Korzystając z metody Pip

Możesz użyć następującego polecenia, aby zainstalować MXNet w swoim Linus OS

pip install mxnet

Korzystając z Docker

Obrazy dockera z MXNet można znaleźć w witrynie DockerHub, która jest dostępna pod adresem https://hub.docker.com/u/mxnet. Sprawdźmy poniższe kroki, aby zainstalować MXNet przy użyciu Dockera z procesorem

Step 1- Po pierwsze, postępując zgodnie z docker installation instructions które są dostępne pod adresem https://docs.docker.com/docker-for-mac musimy zainstalować Docker na naszym komputerze.

Step 2- Używając następującego polecenia, możesz pobrać plik docker MXNet -

$ docker pull mxnet/python

Teraz, aby zobaczyć, czy ściągnięcie obrazu dockera mxnet / python powiodło się, możemy wyświetlić obrazy docker w następujący sposób:

$ docker images

Aby uzyskać najszybsze prędkości wnioskowania z MXNet, zaleca się używanie najnowszego MXNet z Intel MKL-DNN. Sprawdź poniższe polecenia -

$ docker pull mxnet/python:1.3.0_cpu_mkl
$ docker images

Ze źródła

Wykonaj poniższe czynności, aby zainstalować MXNet ze źródła w systemie OS X (Mac) -

Step 1- Ponieważ potrzebujemy pewnych zależności w systemie OS X, najpierw musimy zainstalować wstępnie wymagane pakiety.

xcode-select –-install #Install OS X Developer Tools
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" #Install Homebrew
brew install cmake ninja ccache opencv # Install dependencies

Możemy również zbudować MXNet bez OpenCV, ponieważ opencv jest opcjonalną zależnością.

Step 2- W tym kroku pobierzemy źródło MXNet i skonfigurujemy. Najpierw sklonujmy repozytorium za pomocą następującego polecenia -

git clone –-recursive https://github.com/apache/incubator-mxnet.git mxnet

cd mxnet

cp config/linux.cmake config.cmake

Step 3- Używając następujących poleceń, możesz zbudować współdzieloną bibliotekę MXNet core:

rm -rf build
mkdir -p build && cd build
cmake -GNinja ..
cmake --build .

Two important points regarding the above step is as follows−

Jeśli chcesz zbudować wersję debugowania, określ następująco:

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Aby ustawić liczbę równoległych zadań kompilacji, podaj następujące:

cmake --build . --parallel N

Po pomyślnym zbudowaniu podstawowej biblioteki współdzielonej MXNet w build folder w twoim MXNet project root, znajdziesz libmxnet.dylib, który jest wymagany do zainstalowania powiązań językowych (opcjonalnie).

System operacyjny Windows

Aby zainstalować MXNet w systemie Windows, należy spełnić następujące wymagania:

Minimalne wymagania systemowe

• Windows 7, 10, Server 2012 R2 lub Server 2016

• Visual Studio 2015 lub 2017 (dowolny typ)

• Python 2.7 lub 3.6

• pip

zalecane wymagania systemowe

• Windows 10, Server 2012 R2 lub Server 2016

• Visual Studio 2017

• Co najmniej jeden procesor graficzny z obsługą NVIDIA CUDA

• Procesor z obsługą MKL: procesor Intel® Xeon®, rodzina procesorów Intel® Core ™, procesor Intel Atom® lub procesor Intel® Xeon Phi ™

• Python 2.7 lub 3.6

• pip

Graficzna jednostka przetwarzania (GPU)

Używając metody Pip

Jeśli planujesz zbudować MXNet w systemie Windows z procesorami graficznymi NVIDIA, istnieją dwie opcje instalacji MXNet z obsługą CUDA z pakietem Python:

Zainstaluj z pomocą CUDA

Poniżej znajdują się kroki, za pomocą których możemy skonfigurować MXNet z CUDA.

Step 1- Najpierw zainstaluj Microsoft Visual Studio 2017 lub Microsoft Visual Studio 2015.

Step 2- Następnie pobierz i zainstaluj NVIDIA CUDA. Zaleca się używanie wersji CUDA 9.2 lub 9.0, ponieważ w przeszłości zidentyfikowano pewne problemy z CUDA 9.1.

Step 3- Teraz pobierz i zainstaluj NVIDIA_CUDA_DNN.

Step 4- Na koniec, używając następującego polecenia pip, zainstaluj MXNet z CUDA−

pip install mxnet-cu92

Zainstaluj z obsługą CUDA i MKL

Poniżej znajdują się kroki, za pomocą których możemy skonfigurować MXNet z CUDA i MKL.

Step 1- Najpierw zainstaluj Microsoft Visual Studio 2017 lub Microsoft Visual Studio 2015.

Step 2- Następnie pobierz i zainstaluj program Intel MKL

Step 3- Teraz pobierz i zainstaluj NVIDIA CUDA.

Step 4- Teraz pobierz i zainstaluj NVIDIA_CUDA_DNN.

Step 5- Na koniec, używając następującego polecenia pip, zainstaluj MXNet z MKL.

pip install mxnet-cu92mkl

Ze źródła

Aby zbudować bibliotekę rdzenia MXNet ze źródła za pomocą GPU, mamy dwie następujące opcje:

Option 1− Build with Microsoft Visual Studio 2017

Aby samodzielnie skompilować i zainstalować MXNet przy użyciu programu Microsoft Visual Studio 2017, potrzebujesz następujących zależności.

Install/update Microsoft Visual Studio.

• Jeśli program Microsoft Visual Studio nie jest jeszcze zainstalowany na Twoim komputerze, najpierw pobierz go i zainstaluj.

• Zostanie wyświetlony monit o zainstalowanie Gita. Zainstaluj go również.

• Jeśli program Microsoft Visual Studio jest już zainstalowany na Twoim komputerze, ale chcesz go zaktualizować, przejdź do następnego kroku, aby zmodyfikować instalację. Tutaj będziesz mieć również możliwość aktualizacji Microsoft Visual Studio.

Postępuj zgodnie z instrukcjami dotyczącymi otwierania Instalatora programu Visual Studio dostępnego pod adresem https://docs.microsoft.com/en-us modyfikować poszczególne komponenty.

W aplikacji Instalator programu Visual Studio zaktualizuj zgodnie z wymaganiami. Następnie poszukaj i sprawdźVC++ 2017 version 15.4 v14.11 toolset i kliknij Modify.

Teraz, używając następującego polecenia, zmień wersję Microsoft VS2017 na v14.11−

"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat" -vcvars_ver=14.11

Następnie musisz pobrać i zainstalować CMake dostępne o https://cmake.org/download/ Zaleca się użycie CMake v3.12.2 który jest dostępny pod adresem https://cmake.org/download/ ponieważ jest testowany z MXNet.

Teraz pobierz i uruchom OpenCV pakiet dostępny pod adresem https://sourceforge.net/projects/opencvlibrary/który rozpakuje kilka plików. To od Ciebie zależy, czy chcesz umieścić je w innym katalogu, czy nie. Tutaj użyjemy ścieżkiC:\utils(mkdir C:\utils) jako nasza domyślna ścieżka.

Następnie musimy ustawić zmienną środowiskową OpenCV_DIR, aby wskazywała na katalog kompilacji OpenCV, który właśnie rozpakowaliśmy. W tym celu otwórz wiersz polecenia i wpiszset OpenCV_DIR=C:\utils\opencv\build.

Ważną kwestią jest to, że jeśli nie masz zainstalowanej biblioteki Intel MKL (Math Kernel Library), możesz ją zainstalować.

Inny pakiet open source, którego możesz użyć, to OpenBLAS. Tutaj, aby uzyskać dalsze instrukcje, które zakładamy, że używaszOpenBLAS.

Więc pobierz OpenBlas pakiet, który jest dostępny pod adresem https://sourceforge.net i rozpakuj plik, zmień jego nazwę na OpenBLAS i umieść go pod C:\utils.

Następnie musimy ustawić zmienną środowiskową OpenBLAS_HOME aby wskazać katalog OpenBLAS zawierający plik include i libkatalogi. W tym celu otwórz wiersz polecenia i wpiszset OpenBLAS_HOME=C:\utils\OpenBLAS.

Teraz pobierz i zainstaluj CUDA dostępną pod adresem https://developer.nvidia.com. Zwróć uwagę, że jeśli masz już CUDA, a następnie zainstalowałeś Microsoft VS2017, musisz teraz ponownie zainstalować CUDA, aby uzyskać komponenty zestawu narzędzi CUDA do integracji Microsoft VS2017.

Następnie musisz pobrać i zainstalować cuDNN.

Następnie musisz pobrać i zainstalować git, który jest pod adresem https://gitforwindows.org/ również.

Po zainstalowaniu wszystkich wymaganych zależności, wykonaj kroki podane poniżej, aby zbudować kod źródłowy MXNet

Step 1- Otwórz wiersz polecenia w systemie Windows.

Step 2- Teraz, używając następującego polecenia, pobierz kod źródłowy MXNet z GitHub:

cd C:\

git clone https://github.com/apache/incubator-mxnet.git --recursive

Step 3- Następnie sprawdź, czy: -

DCUDNN_INCLUDE and DCUDNN_LIBRARY zmienne środowiskowe wskazują na include folder i cudnn.lib plik lokalizacji zainstalowanej CUDA

C:\incubator-mxnet to lokalizacja kodu źródłowego, który właśnie sklonowałeś w poprzednim kroku.

Step 4- Następnie, używając następującego polecenia, utwórz kompilację directory a także przejdź do katalogu, na przykład -

mkdir C:\incubator-mxnet\build
cd C:\incubator-mxnet\build

Step 5- Teraz, używając cmake, skompiluj kod źródłowy MXNet w następujący sposób -

cmake -G "Visual Studio 15 2017 Win64" -T cuda=9.2,host=x64 -DUSE_CUDA=1 -DUSE_CUDNN=1 -DUSE_NVRTC=1 -DUSE_OPENCV=1 -DUSE_OPENMP=1 -DUSE_BLAS=open -DUSE_LAPACK=1 -DUSE_DIST_KVSTORE=0 -DCUDA_ARCH_LIST=Common -DCUDA_TOOLSET=9.2 -DCUDNN_INCLUDE=C:\cuda\include -DCUDNN_LIBRARY=C:\cuda\lib\x64\cudnn.lib "C:\incubator-mxnet"

Step 6- Po pomyślnym zakończeniu CMake użyj następującego polecenia, aby skompilować kod źródłowy MXNet

msbuild mxnet.sln /p:Configuration=Release;Platform=x64 /maxcpucount

Option 2: Build with Microsoft Visual Studio 2015

Aby samodzielnie skompilować i zainstalować MXNet przy użyciu programu Microsoft Visual Studio 2015, potrzebujesz następujących zależności.

Zainstaluj / zaktualizuj Microsoft Visual Studio 2015. Minimalnym wymaganiem do zbudowania MXnet ze źródła jest Aktualizacja 3 programu Microsoft Visual Studio 2015. Możesz użyć Tools -> Extensions and Updates... | Product Updates menu, aby go zaktualizować.

Następnie musisz pobrać i zainstalować CMake który jest dostępny pod adresem https://cmake.org/download/. Zaleca się użycieCMake v3.12.2 który jest w https://cmake.org/download/, ponieważ jest testowany z MXNet.

Teraz pobierz i uruchom pakiet OpenCV dostępny pod adresem https://excellmedia.dl.sourceforge.netktóry rozpakuje kilka plików. To zależy od Ciebie, czy chcesz umieścić je w innym katalogu, czy nie.

Następnie musimy ustawić zmienną środowiskową OpenCV_DIR wskazać plik OpenCVbuild, który właśnie rozpakowaliśmy. W tym celu otwórz wiersz polecenia i wpisz setOpenCV_DIR=C:\opencv\build\x64\vc14\bin.

Ważną kwestią jest to, że jeśli nie masz zainstalowanej biblioteki Intel MKL (Math Kernel Library), możesz ją zainstalować.

Inny pakiet open source, którego możesz użyć, to OpenBLAS. Tutaj, aby uzyskać dalsze instrukcje, które zakładamy, że używaszOpenBLAS.

Więc pobierz OpenBLAS pakiet dostępny pod adresem https://excellmedia.dl.sourceforge.net i rozpakuj plik, zmień jego nazwę na OpenBLAS i umieść go w C: \ utils.

Następnie musimy ustawić zmienną środowiskową OpenBLAS_HOME, aby wskazywała na katalog OpenBLAS zawierający katalogi include i lib. Możesz znaleźć katalog wC:\Program files (x86)\OpenBLAS\

Zwróć uwagę, że jeśli masz już CUDA, a następnie zainstalowałeś Microsoft VS2015, musisz teraz ponownie zainstalować CUDA, abyś mógł pobrać komponenty zestawu narzędzi CUDA do integracji Microsoft VS2017.

Następnie musisz pobrać i zainstalować cuDNN.

Teraz musimy ustawić zmienną środowiskową CUDACXX, aby wskazywała na plik CUDA Compiler(C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.1\bin\nvcc.exe na przykład).

Podobnie musimy także ustawić zmienną środowiskową CUDNN_ROOT wskazać plik cuDNN katalog zawierający plik include, lib i bin katalogi (C:\Downloads\cudnn-9.1-windows7-x64-v7\cuda na przykład).

Po zainstalowaniu wszystkich wymaganych zależności, wykonaj kroki podane poniżej, aby zbudować kod źródłowy MXNet

Step 1- Najpierw pobierz kod źródłowy MXNet z GitHub−

cd C:\
git clone https://github.com/apache/incubator-mxnet.git --recursive

Step 2- Następnie użyj CMake, aby utworzyć program Visual Studio w ./build.

Step 3- Teraz w Visual Studio musimy otworzyć plik rozwiązania,.slni skompiluj go. Te polecenia utworzą bibliotekę o nazwiemxnet.dll w ./build/Release/ or ./build/Debug teczka

Step 4- Po pomyślnym zakończeniu CMake użyj następującego polecenia, aby skompilować kod źródłowy MXNet

msbuild mxnet.sln /p:Configuration=Release;Platform=x64 /maxcpucount

Centralna jednostka przetwarzania (CPU)

Tutaj użyjemy różnych metod, a mianowicie Pip, Docker i Source, aby zainstalować MXNet, gdy używamy procesora do przetwarzania.

Korzystając z metody Pip

Jeśli planujesz zbudować MXNet w systemie Windows z procesorami, istnieją dwie opcje instalacji MXNet przy użyciu pakietu Python:

Install with CPUs

Użyj następującego polecenia, aby zainstalować MXNet z procesorem w Pythonie

pip install mxnet

Install with Intel CPUs

Jak omówiono powyżej, MXNet ma eksperymentalne wsparcie dla Intel MKL oraz MKL-DNN. Użyj następującego polecenia, aby zainstalować MXNet z procesorem Intel z Python−

pip install mxnet-mkl

Korzystając z Docker

Obrazy dockera w MXNet można znaleźć pod adresem DockerHub, dostępne o https://hub.docker.com/u/mxnet Sprawdźmy poniższe kroki, aby zainstalować MXNet przy użyciu Dockera z procesorem

Step 1- Po pierwsze, postępując zgodnie z instrukcjami instalacji dockera, które można przeczytać pod adresem https://docs.docker.com/docker-for-mac/install. Musimy zainstalować Dockera na naszym komputerze.

Step 2- Używając następującego polecenia, możesz pobrać plik docker MXNet -

$ docker pull mxnet/python

Teraz, aby zobaczyć, czy ściągnięcie obrazu dockera mxnet / python powiodło się, możemy wyświetlić obrazy docker w następujący sposób:

$ docker images

Aby uzyskać najszybsze prędkości wnioskowania z MXNet, zaleca się używanie najnowszego MXNet z Intel MKL-DNN.

Sprawdź poniższe polecenia -

$ docker pull mxnet/python:1.3.0_cpu_mkl $ docker images

Instalowanie MXNet w chmurze i urządzeniach

W tej sekcji opisano, jak zainstalować Apache MXNet w chmurze i na urządzeniach. Zacznijmy od zapoznania się z instalacją MXNet w chmurze.

Instalowanie MXNet On Cloud

Możesz także uzyskać Apache MXNet u kilku dostawców chmury z Graphical Processing Unit (GPU)wsparcie. Dwa inne rodzaje wsparcia, które możesz znaleźć, to:

• Obsługa hybrydy GPU / CPU w przypadkach użycia, takich jak skalowalne wnioskowanie.
• Factorial GPU wsparcie z AWS Elastic Inference.

Poniżej znajdują się dostawcy usług w chmurze zapewniający obsługę procesorów graficznych z różnymi maszynami wirtualnymi dla Apache MXNet−

Konsola Alibaba

Możesz utworzyć plik NVIDIA GPU Cloud Virtual Machine (VM) dostępne o https://docs.nvidia.com/ngc z konsolą Alibaba i korzystaj z Apache MXNet.

Amazon Web Services

Zapewnia również obsługę GPU i oferuje następujące usługi dla Apache MXNet−

Amazon SageMaker

Zarządza szkoleniem i wdrażaniem modeli Apache MXNet.

AWS Deep Learning AMI

Zapewnia preinstalowane środowisko Conda zarówno dla Python 2, jak i Python 3 z Apache MXNet, CUDA, cuDNN, MKL-DNN i AWS Elastic Inference.

Dynamiczne szkolenie na AWS

Zapewnia szkolenie w zakresie eksperymentalnej ręcznej konfiguracji EC2, a także półautomatycznej konfiguracji CloudFormation.

Możesz użyć NVIDIA VM dostępne o https://aws.amazon.com z usługami internetowymi Amazon.

Platforma Google Cloud

Google również zapewnia NVIDIA GPU cloud image który jest dostępny pod adresem https://console.cloud.google.com do pracy z Apache MXNet.

Microsoft Azure

Udostępnia również Microsoft Azure Marketplace NVIDIA GPU cloud image dostępne o https://azuremarketplace.microsoft.com do pracy z Apache MXNet.

Oracle Cloud

Oracle również zapewnia NVIDIA GPU cloud image dostępne o https://docs.cloud.oracle.com do pracy z Apache MXNet.

Centralna jednostka przetwarzania (CPU)

Apache MXNet działa na instancji każdego dostawcy usług w chmurze zawierającej tylko procesor. Istnieją różne metody instalacji, takie jak -

• Instrukcje instalacji pip w języku Python.

• Instrukcje Dockera.

• Preinstalowana opcja, taka jak Amazon Web Services, która zapewnia AWS Deep Learning AMI (z preinstalowanym środowiskiem Conda dla Pythona 2 i Pythona 3 z MXNet i MKL-DNN).

Instalowanie MXNet na urządzeniach

Dowiedz się, jak zainstalować MXNet na urządzeniach.

Raspberry Pi

Możesz także uruchomić Apache MXNet na urządzeniach Raspberry Pi 3B, ponieważ MXNet obsługuje również system operacyjny oparty na Respbian ARM. Aby MXNet działał płynnie na Raspberry Pi3, zaleca się posiadanie urządzenia, które ma więcej niż 1 GB pamięci RAM i kartę SD z co najmniej 4 GB wolnego miejsca.

Oto sposoby, za pomocą których możesz zbudować MXNet dla Raspberry Pi i zainstalować powiązania Pythona dla biblioteki -

Szybka instalacja

Wstępnie zbudowane koło Python może być używane na Raspberry Pi 3B ze stretchem w celu szybkiej instalacji. Jednym z ważnych problemów z tą metodą jest to, że musimy zainstalować kilka zależności, aby Apache MXNet działał.

Instalacja Dockera

Możesz postępować zgodnie z instrukcjami instalacji platformy Docker, które są dostępne pod adresem https://docs.docker.com/engine/install/ubuntu/aby zainstalować Docker na swoim komputerze. W tym celu możemy również zainstalować i używać Community Edition (CE).

Kompilacja natywna (ze źródła)

Aby zainstalować MXNet ze źródła, musimy wykonać następujące dwa kroki:

Krok 1

Build the shared library from the Apache MXNet C++ source code

Aby zbudować bibliotekę współdzieloną na Raspberry w wersji Wheezy i nowszych, potrzebujemy następujących zależności:

• Git- Wymagane jest pobranie kodu z GitHub.

• Libblas- Jest to wymagane dla liniowych operacji algebraicznych.

• Libopencv- Jest to wymagane do operacji związanych z widzeniem komputerowym. Jednak jest to opcjonalne, jeśli chcesz zaoszczędzić pamięć RAM i miejsce na dysku.

• C++ Compiler- Jest wymagany do kompilacji i budowania kodu źródłowego MXNet. Poniżej znajdują się obsługiwane kompilatory obsługujące C ++ 11−

  • G ++ (wersja 4.8 lub nowsza)

  • Clang(3.9-6)

Użyj następujących poleceń, aby zainstalować wyżej wymienione zależności -

sudo apt-get update
sudo apt-get -y install git cmake ninja-build build-essential g++-4.9 c++-4.9 liblapack*
libblas* libopencv*
libopenblas* python3-dev python-dev virtualenv

Następnie musimy sklonować repozytorium kodu źródłowego MXNet. W tym celu użyj następującego polecenia git w swoim katalogu domowym -

git clone https://github.com/apache/incubator-mxnet.git --recursive

cd incubator-mxnet

Teraz za pomocą następujących poleceń zbuduj współdzieloną bibliotekę:

mkdir -p build && cd build
cmake \
-DUSE_SSE=OFF \
-DUSE_CUDA=OFF \
-DUSE_OPENCV=ON \
-DUSE_OPENMP=ON \
-DUSE_MKL_IF_AVAILABLE=OFF \
-DUSE_SIGNAL_HANDLER=ON \

-DCMAKE_BUILD_TYPE=Release \
-GNinja ..
ninja -j$(nproc)

Po wykonaniu powyższych poleceń rozpocznie się proces kompilacji, który potrwa kilka godzin. Otrzymasz plik o nazwielibmxnet.so w katalogu kompilacji.

Krok 2

Install the supported language-specific packages for Apache MXNet

W tym kroku zainstalujemy powiązania MXNet Pythin. Aby to zrobić, musimy uruchomić następujące polecenie w katalogu MXNet−

cd python
pip install --upgrade pip
pip install -e .

Alternatywnie za pomocą następującego polecenia możesz również utworzyć plik whl package do zainstalowania z pip-

ci/docker/runtime_functions.sh build_wheel python/ $(realpath build)

Urządzenia NVIDIA Jetson

Możesz także uruchomić Apache MXNet na urządzeniach NVIDIA Jetson, takich jak TX2 lub Nanoponieważ MXNet obsługuje również system operacyjny oparty na Ubuntu Arch64. Aby MXNet działał płynnie na urządzeniach NVIDIA Jetson, konieczne jest zainstalowanie CUDA na urządzeniu Jetson.

Oto sposoby, za pomocą których można zbudować MXNet dla urządzeń NVIDIA Jetson:

• Używając koła potoku Jetson MXNet do programowania w języku Python

• Ze źródła

Ale zanim zbudujesz MXNet z dowolnego z wyżej wymienionych sposobów, musisz zainstalować następujące zależności na swoich urządzeniach Jetson:

Zależności Pythona

Aby korzystać z API Pythona, potrzebujemy następujących zależności:

sudo apt update
sudo apt -y install \
   build-essential \
   git \
   graphviz \
   libatlas-base-dev \
   libopencv-dev \
   python-pip
sudo pip install --upgrade \
   pip \
   setuptools
sudo pip install \
   graphviz==0.8.4 \
   jupyter \
   numpy==1.15.2

Sklonuj repozytorium kodu źródłowego MXNet

Używając następującego polecenia git w swoim katalogu domowym, sklonuj repozytorium kodu źródłowego MXNet

git clone --recursive https://github.com/apache/incubator-mxnet.git mxnet

Skonfiguruj zmienne środowiskowe

Dodaj następujące elementy do swojego .profile plik w twoim katalogu domowym -

export PATH=/usr/local/cuda/bin:$PATH export MXNET_HOME=$HOME/mxnet/
export PYTHONPATH=$MXNET_HOME/python:$PYTHONPATH

Teraz zastosuj zmianę natychmiast za pomocą następującego polecenia -

source .profile

Skonfiguruj CUDA

Przed skonfigurowaniem CUDA za pomocą nvcc, musisz sprawdzić, która wersja CUDA jest uruchomiona

nvcc --version

Załóżmy, że jeśli na urządzeniu lub komputerze jest zainstalowana więcej niż jedna wersja CUDA i chcesz zmienić wersje CUDA, użyj poniższego i zamień symboliczne łącze na żądaną wersję:

sudo rm /usr/local/cuda
sudo ln -s /usr/local/cuda-10.0 /usr/local/cuda

Powyższe polecenie przełączy się na CUDA 10.0, który jest preinstalowany na urządzeniu NVIDIA Jetson Nano.

Po spełnieniu wyżej wymienionych wymagań wstępnych możesz teraz zainstalować MXNet na urządzeniach NVIDIA Jetson. Pozwól nam więc zrozumieć sposoby, za pomocą których możesz zainstalować MXNet−

By using a Jetson MXNet pip wheel for Python development- Jeśli chcesz użyć przygotowanego koła Pythona, pobierz poniższe na swój Jetson i uruchom go

• MXNet 1.4.0 (dla Python 3) dostępne pod adresem https://docs.docker.com

• MXNet 1.4.0 (dla Python 2) dostępne pod adresem https://docs.docker.com

Kompilacja natywna (ze źródła)

Aby zainstalować MXNet ze źródła, musimy wykonać następujące dwa kroki:

Krok 1

Build the shared library from the Apache MXNet C++ source code

Aby zbudować bibliotekę współdzieloną z kodu źródłowego Apache MXNet C ++, możesz użyć metody Docker lub zrobić to ręcznie.

Metoda Dockera

W tej metodzie musisz najpierw zainstalować Docker i móc go uruchomić bez sudo (co jest również wyjaśnione w poprzednich krokach). Po zakończeniu uruchom następujące polecenie, aby wykonać kompilację krzyżową przez Docker−

$MXNET_HOME/ci/build.py -p jetson

podręcznik

W tej metodzie musisz edytować plik Makefile (za pomocą poniższego polecenia), aby zainstalować MXNet z powiązaniami CUDA w celu wykorzystania jednostek przetwarzania graficznego (GPU) na urządzeniach NVIDIA Jetson:

cp $MXNET_HOME/make/crosscompile.jetson.mk config.mk

Po edycji pliku Makefile musisz wyedytować plik config.mk, aby wprowadzić dodatkowe zmiany w urządzeniu NVIDIA Jetson.

W tym celu zaktualizuj następujące ustawienia -

• Zaktualizuj ścieżkę CUDA: USE_CUDA_PATH = / usr / local / cuda

• Dodaj -gencode arch = compute-63, code = sm_62 do ustawienia CUDA_ARCH.

• Zaktualizuj ustawienia NVCC: NVCCFLAGS: = -m64

• Włącz OpenCV: USE_OPENCV = 1

Teraz, aby upewnić się, że MXNet buduje się z przyspieszeniem o niskiej precyzji na poziomie sprzętowym Pascala, musimy edytować plik Mshadow Makefile w następujący sposób:

MSHADOW_CFLAGS += -DMSHADOW_USE_PASCAL=1

Wreszcie za pomocą następującego polecenia możesz zbudować pełną bibliotekę Apache MXNet

cd $MXNET_HOME make -j $(nproc)

Po wykonaniu powyższych poleceń rozpocznie się proces kompilacji, który potrwa kilka godzin. Otrzymasz plik o nazwielibmxnet.so w mxnet/lib directory.

Krok 2

Install the Apache MXNet Python Bindings

W tym kroku zainstalujemy powiązania MXNet Python. Aby to zrobić, musimy uruchomić następujące polecenie w katalogu MXNet−

cd $MXNET_HOME/python
sudo pip install -e .

Po wykonaniu powyższych czynności możesz teraz uruchomić MXNet na swoich urządzeniach NVIDIA Jetson TX2 lub Nano. Można to sprawdzić za pomocą następującego polecenia -

import mxnet
mxnet.__version__

Zwróci numer wersji, jeśli wszystko działa poprawnie.

Aby wspierać badania i rozwój aplikacji Deep Learning w wielu dziedzinach, Apache MXNet zapewnia nam bogaty ekosystem zestawów narzędzi, bibliotek i wiele innych. Pozwól nam je zbadać -

Zestawy narzędzi

Poniżej znajdują się niektóre z najczęściej używanych i najważniejszych zestawów narzędzi dostarczanych przez MXNet -

GluonCV

Jak sama nazwa wskazuje, GluonCV to zestaw narzędzi Gluon do wizji komputerowej obsługiwany przez MXNet. Zapewnia implementację najnowocześniejszych algorytmów DL (Deep Learning) w wizji komputerowej (CV). Z pomocą inżynierów z zestawu narzędzi GluonCV, badacze i studenci mogą łatwo weryfikować nowe pomysły i uczyć się CV.

Poniżej podano niektóre z features of GluonCV -

• Szkoli skrypty do odtwarzania najnowocześniejszych wyników zgłoszonych w najnowszych badaniach.

• Ponad 170+ wysokiej jakości wstępnie wytrenowanych modeli.

• Przyjmij elastyczny wzorzec rozwoju.

• GluonCV jest łatwy do optymalizacji. Możemy go wdrożyć bez zachowywania ciężkiego szkieletu DL.

• Zapewnia starannie zaprojektowane interfejsy API, które znacznie zmniejszają zawiłość implementacji.

• Społeczność.

• Łatwe do zrozumienia implementacje.

Poniżej znajdują się supported applications przez zestaw narzędzi GluonCV:

• Klasyfikacja obrazu

• Wykrywanie obiektów

• Segmentacja semantyczna

• Segmentacja instancji

• Szacowanie pozycji

• Rozpoznawanie akcji wideo

Możemy zainstalować GluonCV za pomocą pip w następujący sposób -

pip install --upgrade mxnet gluoncv

GluonNLP

Jak sama nazwa wskazuje, GluonNLP to zestaw narzędzi Gluon do przetwarzania języka naturalnego (NLP) obsługiwany przez MXNet. Zapewnia implementację najnowocześniejszych modeli DL (Deep Learning) w NLP.

Z pomocą inżynierów z zestawu narzędzi GluonNLP, badacze i studenci mogą budować bloki dla potoków danych tekstowych i modeli. Na podstawie tych modeli mogą szybko prototypować pomysły badawcze i produkt.

Poniżej podano niektóre cechy GluonNLP:

• Szkoli skrypty do odtwarzania najnowocześniejszych wyników zgłoszonych w najnowszych badaniach.

• Zestaw wstępnie wytrenowanych modeli do typowych zadań NLP.

• Zapewnia starannie zaprojektowane interfejsy API, które znacznie zmniejszają zawiłość implementacji.

• Społeczność.

• Zawiera również samouczki, które pomogą Ci rozpocząć nowe zadania NLP.

Poniżej przedstawiono zadania NLP, które możemy zaimplementować za pomocą zestawu narzędzi GluonNLP -

• Osadzanie słów

• Model językowy

• Tłumaczenie maszynowe

• Klasyfikacja tekstu

• Analiza nastrojów

• Wnioskowanie z języka naturalnego

• Generowanie tekstu

• Analiza zależności

• Rozpoznawanie nazwanych jednostek

• Klasyfikacja intencji i oznaczanie gniazd

Możemy zainstalować GluonNLP za pomocą pip w następujący sposób -

pip install --upgrade mxnet gluonnlp

Kleje

Jak nazwa wskazuje, GluonTS to zestaw narzędzi Gluon do probabilistycznego modelowania szeregów czasowych obsługiwany przez MXNet.

Zapewnia następujące funkcje -

• Najnowocześniejsze (SOTA) modele głębokiego uczenia się gotowe do szkolenia.

• Narzędzia do ładowania i iteracji zestawów danych szeregów czasowych.

• Bloki konstrukcyjne do zdefiniowania własnego modelu.

Z pomocą zestawu narzędzi GluonTS inżynierowie, badacze i studenci mogą trenować i oceniać dowolne z wbudowanych modeli na ich własnych danych, szybko eksperymentować z różnymi rozwiązaniami i wymyślać rozwiązanie dla swoich zadań szeregów czasowych.

Mogą również wykorzystywać dostarczone abstrakcje i bloki konstrukcyjne do tworzenia niestandardowych modeli szeregów czasowych i szybko porównywać je z algorytmami bazowymi.

Możemy zainstalować GluonTS za pomocą pip w następujący sposób -

pip install gluonts

GluonFR

Jak sama nazwa wskazuje, jest to zestaw narzędzi Apache MXNet Gluon dla FR (Rozpoznawanie twarzy). Zapewnia następujące funkcje -

• Najnowocześniejsze modele uczenia głębokiego (SOTA) w rozpoznawaniu twarzy.

• Wdrożenie SoftmaxCrossEntropyLoss, ArcLoss, TripletLoss, RingLoss, CosLoss / AMsoftmax, L2-Softmax, A-Softmax, CenterLoss, ContrastiveLoss i LGM Loss itp.

Aby zainstalować Gluon Face, potrzebujemy Pythona 3.5 lub nowszego. Najpierw musimy również zainstalować GluonCV i MXNet w następujący sposób -

pip install gluoncv --pre
pip install mxnet-mkl --pre --upgrade
pip install mxnet-cuXXmkl --pre –upgrade # if cuda XX is installed

Po zainstalowaniu zależności możesz użyć następującego polecenia, aby zainstalować GluonFR -

From Source

pip install git+https://github.com/THUFutureLab/gluon-face.git@master

Pip

pip install gluonfr

Ekosystem

Teraz poznajmy bogate biblioteki, pakiety i frameworki MXNet -

Trener RL

Coach, platforma uczenia się w Pythonie (RL) stworzona przez laboratorium Intel AI. Umożliwia łatwe eksperymentowanie z najnowocześniejszymi algorytmami RL. Coach RL obsługuje Apache MXNet jako zaplecze i umożliwia prostą integrację nowego środowiska do rozwiązania.

W celu łatwego rozszerzania i ponownego wykorzystywania istniejących komponentów, Coach RL bardzo dobrze oddzielił podstawowe komponenty uczenia się o wzmocnieniu, takie jak algorytmy, środowiska, architektury NN, zasady eksploracji.

Poniżej znajdują się agenci i obsługiwane algorytmy dla platformy Coach RL -

Agenci optymalizacji wartości

• Sieć Deep Q (DQN)

• Sieć Double Deep Q (DDQN)

• Dueling Q Network

• Mieszane Monte Carlo (MMC)

• Persistent Advantage Learning (PAL)

• Kategoryczna sieć Deep Q (C51)

• Regresja kwantowa Deep Q Network (QR-DQN)

• N-Step Q Learning

• Neuralna kontrola epizodyczna (NEC)

• Znormalizowane funkcje przewagi (NAF)

• Rainbow

Agenci optymalizacji zasad

• Gradienty zasad (PG)

• Asynchroniczny aktor-krytyk przewagi (A3C)

• Głębokie deterministyczne gradienty polityki (DDPG)

• Proximal Policy Optimization (PPO)

• Obcięta proksymalna optymalizacja polityki (CPPO)

• Uogólnione szacowanie przewagi (GAE)

• Przykładowy skuteczny aktor-krytyk z powtórką doświadczenia (ACER)

• Soft Actor-Critic (SAC)

• Podwójny, opóźniony, głęboki, deterministyczny gradient polityki (TD3)

Agenci generalni

• Bezpośrednie przewidywanie przyszłości (DFP)

Agenci naśladujący uczenie się

• Klonowanie behawioralne (BC)

• Warunkowe uczenie się naśladowania

Agenty uczenia się ze wzmocnieniem hierarchicznym

• Hierarchical Actor Critic (HAC)

Biblioteka Deep Graph

Deep Graph Library (DGL), opracowana przez zespoły NYU i AWS z Szanghaju, to pakiet Pythona, który zapewnia łatwe implementacje Graph Neural Networks (GNN) na szczycie MXNet. Zapewnia również łatwą implementację GNN na podstawie innych istniejących głównych bibliotek głębokiego uczenia, takich jak PyTorch, Gluon itp.

Deep Graph Library to darmowe oprogramowanie. Jest dostępny we wszystkich dystrybucjach Linuksa późniejszych niż Ubuntu 16.04, macOS X i Windows 7 lub nowszy. Wymaga również wersji Python 3.5 lub nowszej.

Oto cechy DGL -

No Migration cost - Korzystanie z DGL nie wiąże się z żadnymi kosztami migracji, ponieważ jest on oparty na popularnych istniejących platformach DL.

Message Passing- DGL zapewnia przekazywanie wiadomości i ma nad nią wszechstronną kontrolę. Przekazywanie wiadomości obejmuje operacje niskiego poziomu, takie jak wysyłanie wzdłuż wybranych krawędzi, po kontrolę wysokiego poziomu, taką jak aktualizacje funkcji na całym wykresie.

Smooth Learning Curve - Jest dość łatwy do nauczenia się i używania DGL, ponieważ potężne funkcje zdefiniowane przez użytkownika są elastyczne i łatwe w użyciu.

Transparent Speed Optimization - DGL zapewnia przejrzystą optymalizację prędkości, wykonując automatyczne grupowanie obliczeń i rzadkie mnożenie macierzy.

High performance - Aby osiągnąć maksymalną wydajność, DGL automatycznie grupuje szkolenia DNN (głębokich sieci neuronowych) na jednym lub wielu wykresach jednocześnie.

Easy & friendly interface - DGL zapewnia nam łatwe i przyjazne interfejsy dla dostępu do funkcji brzegowych, a także manipulacji strukturą wykresu.

InsightFace

InsightFace, zestaw narzędzi do głębokiego uczenia się do analizy twarzy, który zapewnia implementację algorytmu analizy twarzy SOTA (state-of-the-art) w wizji komputerowej obsługiwanej przez MXNet. Zapewnia -

• Wysokiej jakości duży zestaw wstępnie wytrenowanych modeli.

• Najnowocześniejsze skrypty szkoleniowe (SOTA).

• InsightFace jest łatwy do optymalizacji. Możemy go wdrożyć bez zachowywania ciężkiego szkieletu DL.

• Zapewnia starannie zaprojektowane interfejsy API, które znacznie zmniejszają zawiłość implementacji.

• Bloki konstrukcyjne do zdefiniowania własnego modelu.

Możemy zainstalować InsightFace za pomocą pip w następujący sposób -

pip install --upgrade insightface

Należy pamiętać, że przed zainstalowaniem InsightFace należy zainstalować poprawny pakiet MXNet zgodnie z konfiguracją systemu.

Keras-MXNet

Ponieważ wiemy, że Keras to interfejs API sieci neuronowej wysokiego poziomu (NN) napisany w języku Python, Keras-MXNet zapewnia nam obsługę zaplecza dla Keras. Może działać w oparciu o wysokowydajną i skalowalną strukturę Apache MXNet DL.

Funkcje Keras-MXNet są wymienione poniżej -

• Umożliwia użytkownikom łatwe, płynne i szybkie prototypowanie. Wszystko dzieje się dzięki łatwości obsługi, modułowości i rozszerzalności.

• Obsługuje zarówno CNN (konwolucyjne sieci neuronowe), jak i RNN (rekurencyjne sieci neuronowe), a także kombinację obu.

• Działa bezbłędnie zarówno na jednostce centralnej (CPU), jak i graficznej (GPU).

• Może działać na jednym lub wielu GPU.

Aby pracować z tym backendem, musisz najpierw zainstalować keras-mxnet w następujący sposób -

pip install keras-mxnet

Teraz, jeśli używasz GPU, zainstaluj MXNet z obsługą CUDA 9 w następujący sposób -

pip install mxnet-cu90

Ale jeśli używasz tylko procesora, zainstaluj podstawową MXNet w następujący sposób -

pip install mxnet

MXBoard

MXBoard to narzędzie do rejestrowania, napisane w Pythonie, które służy do rejestrowania ramek danych MXNet i wyświetlania w TensorBoard. Innymi słowy, MXBoard ma działać zgodnie z interfejsem API tensorboard-pytorch. Obsługuje większość typów danych w TensorBoard.

Niektóre z nich są wymienione poniżej -

• Graph

• Scalar

• Histogram

• Embedding

• Image

• Text

• Audio

• Precyzyjna krzywa przypominania

MXFusion

MXFusion to modułowa biblioteka probabilistycznego programowania z głębokim uczeniem się. MXFusion pozwala nam w pełni wykorzystać modułowość, która jest kluczową cechą bibliotek głębokiego uczenia się, do programowania probabilistycznego. Jest prosty w użyciu i zapewnia użytkownikom wygodny interfejs do projektowania modeli probabilistycznych i stosowania ich do rzeczywistych problemów.

MXFusion jest weryfikowany w wersji 3.4 języka Python i nowszych w systemach MacOS i Linux. Aby zainstalować MXFusion, musimy najpierw zainstalować następujące zależności -

• MXNet> = 1.3

• Networkx> = 2.1

Za pomocą następującego polecenia pip możesz zainstalować MXFusion -

pip install mxfusion

TVM

Apache TVM, kompleksowy zestaw kompilatorów do głębokiego uczenia się typu open source dla zaplecza sprzętowego, takiego jak procesory, procesory graficzne i wyspecjalizowane akceleratory, ma na celu wypełnienie luki między strukturami uczenia głębokiego skupiającego się na produktywności a zapleczem sprzętowym zorientowanym na wydajność . Dzięki najnowszej wersji MXNet 1.6.0 użytkownicy mogą wykorzystać Apache (inkubujący) program TVM do implementacji wydajnych jąder operatorów w języku programowania Python.

Apache TVM faktycznie rozpoczął się jako projekt badawczy w grupie SAMPL Paul G. Allen School of Computer Science & Engineering, University of Washington, a teraz jest to wysiłek podlegający inkubacji w The Apache Software Foundation (ASF), który jest napędzany przez OSC ( społeczność open source), która obejmuje wiele branż, a także instytucje akademickie w ramach Apache.

Oto główne cechy Apache (inkubującego) TVM -

• Upraszcza poprzedni proces programowania oparty na C ++.

• Umożliwia współdzielenie tej samej implementacji na wielu zapleczach sprzętowych, takich jak procesory, układy GPU itp.

• TVM zapewnia kompilację modeli DL w różnych platformach, takich jak Kears, MXNet, PyTorch, Tensorflow, CoreML, DarkNet w postaci minimalnych modułów, które można wdrożyć na różnych zapleczach sprzętowych.

• Zapewnia nam również infrastrukturę do automatycznego generowania i optymalizacji operatorów tensorów z lepszą wydajnością.

XFer

Xfer, platforma uczenia się transferu, została napisana w języku Python. Zasadniczo przyjmuje model MXNet i trenuje metamodel lub modyfikuje model również dla nowego docelowego zestawu danych.

Mówiąc najprościej, Xfer to biblioteka Pythona, która pozwala użytkownikom na szybki i łatwy transfer wiedzy przechowywanej w DNN (głębokie sieci neuronowe).

Xfer może być używany -

• Do klasyfikacji danych w dowolnym formacie liczbowym.

• Do typowych przypadków obrazów lub danych tekstowych.

• Jako potok, który przechodzi od wyodrębniania funkcji do szkolenia repurposera (obiektu, który przeprowadza klasyfikację w zadaniu docelowym).

Oto cechy Xfera:

• Efektywność wykorzystania zasobów

• Wydajność danych

• Łatwy dostęp do sieci neuronowych

• Modelowanie niepewności

• Szybkie prototypowanie

• Narzędzia do ekstrakcji funkcji z NN

Ten rozdział pomoże ci zrozumieć architekturę systemu MXNet. Zacznijmy od poznania modułów MXNet.

Moduły MXNet

Poniższy diagram przedstawia architekturę systemu MXNet i przedstawia główne moduły i komponenty MXNet modules and their interaction.

Na powyższym schemacie -

• Moduły w pudełkach koloru niebieskiego to User Facing Modules.

• Moduły w zielonych polach są System Modules.

• Solidna strzałka oznacza dużą zależność, tj. Silną zależność od interfejsu.

• Kropkowana strzałka reprezentuje zależność od światła, tj. Strukturę użytych danych dla wygody i spójności interfejsu. W rzeczywistości można go zastąpić alternatywami.

Omówmy więcej na temat interfejsu użytkownika i modułów systemowych.

Moduły dla użytkownika

Moduły dla użytkownika są następujące -

• NDArray- Zapewnia elastyczne niezbędne programy dla Apache MXNet. Są to dynamiczne i asynchroniczne tablice n-wymiarowe.

• KVStore- Działa jako interfejs do wydajnej synchronizacji parametrów. W KVStore KV oznacza klucz-wartość. Jest to więc interfejs magazynu klucz-wartość.

• Data Loading (IO) - Ten moduł skierowany do użytkownika służy do wydajnego ładowania i rozszerzania danych rozproszonych.

• Symbol Execution- Jest to statyczny, symboliczny wykonawca wykresu. Zapewnia wydajne wykonywanie i optymalizację grafów symbolicznych.

• Symbol Construction - Ten moduł skierowany do użytkownika zapewnia użytkownikowi sposób tworzenia wykresu obliczeniowego, tj. Konfiguracji sieci.

Moduły systemowe

Moduły systemu są następujące -

• Storage Allocator - Ten moduł systemowy, jak nazwa sugeruje, efektywnie alokuje i przetwarza bloki pamięci na hoście, tj. CPU i różnych urządzeniach, np. GPU.

• Runtime Dependency Engine - Harmonogramy modułu silnika zależności czasu wykonywania oraz wykonywanie operacji zgodnie z ich zależnością odczytu / zapisu.

• Resource Manager - Moduł systemu Resource Manager (RM) zarządza zasobami globalnymi, takimi jak generator liczb losowych i przestrzeń czasowa.

• Operator - Moduł systemu operatora składa się ze wszystkich operatorów, którzy definiują statyczne obliczenia do przodu i gradientu, czyli propagację wsteczną.

Tutaj szczegółowo wyjaśniono składniki systemu w Apache MXNet. Najpierw zbadamy silnik wykonawczy w MXNet.

Silnik wykonawczy

Silnik wykonawczy Apache MXNet jest bardzo wszechstronny. Możemy go użyć do głębokiego uczenia się, a także do dowolnego problemu specyficznego dla domeny: wykonać szereg funkcji zgodnie z ich zależnościami. Został zaprojektowany w taki sposób, że funkcje z zależnościami są serializowane, podczas gdy funkcje bez zależności mogą być wykonywane równolegle.

Interfejs podstawowy

Interfejs API podany poniżej jest podstawowym interfejsem silnika wykonawczego Apache MXNet -

virtual void PushSync(Fn exec_fun, Context exec_ctx,
std::vector<VarHandle> const& const_vars,
std::vector<VarHandle> const& mutate_vars) = 0;

Powyższy interfejs API ma następujące -

• exec_fun - Podstawowy interfejs API MXNet pozwala nam przekazać funkcję o nazwie exec_fun wraz z jej informacjami kontekstowymi i zależnościami do silnika wykonawczego.

• exec_ctx - Informacje o kontekście, w którym wspomniana funkcja exec_fun ma zostać wykonana.

• const_vars - To są zmienne, z których odczytuje funkcja.

• mutate_vars - To są zmienne, które mają zostać zmodyfikowane.

Silnik wykonawczy zapewnia użytkownikowi gwarancję, że wykonanie dwóch dowolnych funkcji modyfikujących wspólną zmienną jest serializowane w ich kolejności wypychania.

Funkcjonować

Poniżej przedstawiono typ funkcji mechanizmu wykonawczego Apache MXNet -

using Fn = std::function<void(RunContext)>;

W powyższej funkcji RunContextzawiera informacje o czasie wykonywania. Informacje o czasie wykonywania powinny być określone przez silnik wykonawczy. SkładniaRunContext jest następująca -

struct RunContext {
   // stream pointer which could be safely cast to
   // cudaStream_t* type
   void *stream;
};

Poniżej podano kilka ważnych punktów dotyczących funkcji silnika wykonawczego -

• Wszystkie funkcje są wykonywane przez wewnętrzne wątki silnika wykonawczego MXNet.

• Nie jest dobrze przekazywać blokowanie funkcji do silnika wykonawczego, ponieważ w ten sposób funkcja zajmie wątek wykonawczy, a także zmniejszy całkowitą przepustowość.

W tym MXNet zapewnia inną funkcję asynchroniczną, jak następuje:

using Callback = std::function<void()>;
using AsyncFn = std::function<void(RunContext, Callback)>;

• W tym AsyncFn funkcji możemy przekazać ciężką część naszych wątków, ale silnik wykonawczy nie uważa funkcji za zakończoną, dopóki nie wywołamy funkcji callback funkcjonować.

Kontekst

W Context, możemy określić kontekst funkcji, w ramach której ma zostać wykonana. Zwykle obejmuje to:

• Czy funkcja ma być uruchamiana na CPU czy GPU.

• Jeśli określimy GPU w Kontekście, to którego GPU użyć.

• Istnieje ogromna różnica między Context i RunContext. Kontekst ma typ urządzenia i identyfikator urządzenia, podczas gdy RunContext zawiera informacje, które można określić tylko w czasie wykonywania.

VarHandle

VarHandle, używany do określenia zależności funkcji, jest jak token (szczególnie dostarczany przez silnik wykonawczy), którego możemy użyć do reprezentowania zasobów zewnętrznych, które funkcja może modyfikować lub wykorzystywać.

Powstaje jednak pytanie, po co nam VarHandle? Dzieje się tak, ponieważ silnik Apache MXNet został zaprojektowany tak, aby oddzielić go od innych modułów MXNet.

Oto kilka ważnych punktów dotyczących VarHandle -

• Jest lekki, więc tworzenie, usuwanie lub kopiowanie zmiennej wiąże się z niewielkimi kosztami operacyjnymi.

• Musimy określić niezmienne zmienne, czyli zmienne, które będą używane w const_vars.

• Musimy określić zmienne mutowalne, tj. Zmienne, które będą modyfikowane w mutate_vars.

• Reguła używana przez silnik wykonawczy do rozwiązywania zależności między funkcjami polega na tym, że wykonanie dwóch dowolnych funkcji, gdy jedna z nich modyfikuje co najmniej jedną wspólną zmienną, jest serializowane w ich kolejności wypychania.

• Do stworzenia nowej zmiennej możemy użyć NewVar() API.

• Do usunięcia zmiennej możemy użyć PushDelete API.

Zrozummy, jak działa, na prostym przykładzie -

Załóżmy, że mamy dwie funkcje, mianowicie F1 i F2, i obie mutują zmienną, a mianowicie V2. W takim przypadku F2 jest gwarantowane do wykonania po F1, jeśli F2 zostanie wciśnięty po F1. Z drugiej strony, jeśli F1 i F2 używają V2, ich rzeczywista kolejność wykonania może być losowa.

Naciśnij i czekaj

Push i wait to dwa bardziej przydatne API silnika wykonawczego.

Oto dwie ważne cechy Push API:

• Wszystkie interfejsy API Push są asynchroniczne, co oznacza, że ​​wywołanie interfejsu API natychmiast zwraca, niezależnie od tego, czy przekazana funkcja została zakończona, czy nie.

• Push API nie jest bezpieczny dla wątków, co oznacza, że ​​tylko jeden wątek powinien wykonywać wywołania interfejsu API silnika naraz.

Jeśli mówimy o Wait API, przedstawiają to następujące punkty -

• Jeśli użytkownik chce poczekać na zakończenie określonej funkcji, powinien dołączyć funkcję wywołania zwrotnego w zamknięciu. Po dołączeniu wywołaj funkcję na końcu funkcji.

• Z drugiej strony, jeśli użytkownik chce poczekać na zakończenie wszystkich funkcji, które wymagają określonej zmiennej, powinien użyć WaitForVar(var) API.

• Jeśli ktoś chce poczekać na zakończenie wszystkich wypchniętych funkcji, użyj WaitForAll () API.

• Służy do określania zależności funkcji, działa jak token.

Operatorzy

Operator w Apache MXNet to klasa, która zawiera aktualną logikę obliczeniową, a także informacje pomocnicze i pomaga systemowi w przeprowadzaniu optymalizacji.

Interfejs operatora

Forward to podstawowy interfejs operatora, którego składnia jest następująca:

virtual void Forward(const OpContext &ctx,
const std::vector<TBlob> &in_data,
const std::vector<OpReqType> &req,
const std::vector<TBlob> &out_data,
const std::vector<TBlob> &aux_states) = 0;

Struktura OpContext, zdefiniowane w Forward() następująco:

struct OpContext {
   int is_train;
   RunContext run_ctx;
   std::vector<Resource> requested;
}

Plik OpContextopisuje stan operatora (czy to w fazie pociągu, czy w fazie testów), na którym urządzeniu powinien pracować operator, a także żądane zasoby. dwa bardziej przydatne API silnika wykonawczego.

Z góry Forward podstawowy interfejs, możemy zrozumieć żądane zasoby w następujący sposób -

• in_data i out_data reprezentują tensory wejściowe i wyjściowe.

• req oznacza, w jaki sposób wynik obliczeń jest zapisywany w out_data.

Plik OpReqType można zdefiniować jako -

enum OpReqType {
   kNullOp,
   kWriteTo,
   kWriteInplace,
   kAddTo
};

Tak jak Forward operator, możemy opcjonalnie zaimplementować Backward interfejs w następujący sposób -

virtual void Backward(const OpContext &ctx,
const std::vector<TBlob> &out_grad,
const std::vector<TBlob> &in_data,
const std::vector<TBlob> &out_data,
const std::vector<OpReqType> &req,
const std::vector<TBlob> &in_grad,
const std::vector<TBlob> &aux_states);

Różne zadania

Operator interfejs umożliwia użytkownikom wykonywanie następujących zadań -

• Użytkownik może określić aktualizacje w miejscu i może zmniejszyć koszt alokacji pamięci

• Aby uczynić go bardziej przejrzystym, użytkownik może ukryć niektóre wewnętrzne argumenty przed Pythonem.

• Użytkownik może zdefiniować relację między tensorami i tensorami wyjściowymi.

• Aby wykonać obliczenia, użytkownik może uzyskać dodatkowe tymczasowe miejsce z systemu.

Własność operatora

Ponieważ wiemy, że w konwolucyjnych sieciach neuronowych (CNN) jeden splot ma kilka implementacji. Aby uzyskać z nich najlepszą wydajność, możemy chcieć przełączać się między tymi kilkoma zwojami.

To jest powód, dla którego Apache MXNet oddziela semantyczny interfejs operatora od interfejsu implementacji. To oddzielenie odbywa się w postaciOperatorProperty klasa składająca się z następujących -

InferShape - Interfejs InferShape ma dwa cele, jak podano poniżej:

• Pierwszym celem jest poinformowanie systemu o rozmiarze każdego tensora wejściowego i wyjściowego, aby można było wcześniej przydzielić przestrzeń Forward i Backward połączenie.

• Drugim celem jest sprawdzenie rozmiaru, aby upewnić się, że nie ma błędów przed uruchomieniem.

Składnia jest podana poniżej -

virtual bool InferShape(mxnet::ShapeVector *in_shape,
mxnet::ShapeVector *out_shape,
mxnet::ShapeVector *aux_shape) const = 0;

Request Resource- A jeśli Twój system może zarządzać obszarem roboczym obliczeń dla operacji takich jak cudnnConvolutionForward? Twój system może przeprowadzać optymalizacje, takie jak ponowne wykorzystanie miejsca i wiele innych. Tutaj MXNet łatwo to osiągnąć za pomocą następujących dwóch interfejsów

virtual std::vector<ResourceRequest> ForwardResource(
   const mxnet::ShapeVector &in_shape) const;
virtual std::vector<ResourceRequest> BackwardResource(
   const mxnet::ShapeVector &in_shape) const;

Ale co jeśli ForwardResource i BackwardResourcezwrócić niepuste tablice? W takim przypadku system oferuje odpowiednie zasoby za pośrednictwemctx parametr w Forward i Backward interfejs Operator.

Backward dependency - Apache MXNet ma następujące dwa różne podpisy operatora, aby radzić sobie z zależnością wsteczną -

void FullyConnectedForward(TBlob weight, TBlob in_data, TBlob out_data);
void FullyConnectedBackward(TBlob weight, TBlob in_data, TBlob out_grad, TBlob in_grad);
void PoolingForward(TBlob in_data, TBlob out_data);
void PoolingBackward(TBlob in_data, TBlob out_data, TBlob out_grad, TBlob in_grad);

Tutaj dwie ważne kwestie, na które należy zwrócić uwagę -

• Dane out_data w FullyConnectedForward nie są używane przez FullyConnectedBackward i

• PoolingBackward wymaga wszystkich argumentów PoolingForward.

Dlatego dla FullyConnectedForward, the out_dataZużyty tensor można bezpiecznie uwolnić, ponieważ funkcja wsteczna go nie potrzebuje. Z pomocą tego systemu udało się zebrać kilka tensorów tak wcześnie, jak to możliwe.

In place Option- Apache MXNet zapewnia użytkownikom inny interfejs, aby zaoszczędzić na kosztach alokacji pamięci. Interfejs jest odpowiedni dla operacji elementarnych, w których tensory wejściowe i wyjściowe mają ten sam kształt.

Poniżej znajduje się składnia określania aktualizacji w miejscu -

Przykład tworzenia operatora

Z pomocą OperatorProperty możemy stworzyć operatora. Aby to zrobić, wykonaj kroki podane poniżej -

virtual std::vector<std::pair<int, void*>> ElewiseOpProperty::ForwardInplaceOption(
   const std::vector<int> &in_data,
   const std::vector<void*> &out_data) 
const {
   return { {in_data[0], out_data[0]} };
}
virtual std::vector<std::pair<int, void*>> ElewiseOpProperty::BackwardInplaceOption(
   const std::vector<int> &out_grad,
   const std::vector<int> &in_data,
   const std::vector<int> &out_data,
   const std::vector<void*> &in_grad) 
const {
   return { {out_grad[0], in_grad[0]} }
}

Krok 1

Create Operator

Najpierw zaimplementuj następujący interfejs w OperatorProperty:

virtual Operator* CreateOperator(Context ctx) const = 0;

Przykład podano poniżej -

class ConvolutionOp {
   public:
      void Forward( ... ) { ... }
      void Backward( ... ) { ... }
};
class ConvolutionOpProperty : public OperatorProperty {
   public:
      Operator* CreateOperator(Context ctx) const {
         return new ConvolutionOp;
      }
};

Krok 2

Parameterize Operator

Jeśli zamierzasz zaimplementować operator splotu, musisz znać rozmiar jądra, rozmiar kroku, rozmiar dopełnienia i tak dalej. Dlaczego, ponieważ te parametry należy przekazać operatorowi przed wywołaniem anyForward lub backward berło.

W tym celu musimy zdefiniować plik ConvolutionParam struktura jak poniżej -

#include <dmlc/parameter.h>
struct ConvolutionParam : public dmlc::Parameter<ConvolutionParam> {
   mxnet::TShape kernel, stride, pad;
   uint32_t num_filter, num_group, workspace;
   bool no_bias;
};

Teraz musimy to umieścić ConvolutionOpProperty i przekaż go operatorowi w następujący sposób -

class ConvolutionOp {
   public:
      ConvolutionOp(ConvolutionParam p): param_(p) {}
      void Forward( ... ) { ... }
      void Backward( ... ) { ... }
   private:
      ConvolutionParam param_;
};
class ConvolutionOpProperty : public OperatorProperty {
   public:
      void Init(const vector<pair<string, string>& kwargs) {
         // initialize param_ using kwargs
      }
      Operator* CreateOperator(Context ctx) const {
         return new ConvolutionOp(param_);
      }
   private:
      ConvolutionParam param_;
};

Krok 3

Register the Operator Property Class and the Parameter Class to Apache MXNet

W końcu musimy zarejestrować klasę właściwości operatora i klasę parametrów w MXNet. Można to zrobić za pomocą następujących makr -

DMLC_REGISTER_PARAMETER(ConvolutionParam);
MXNET_REGISTER_OP_PROPERTY(Convolution, ConvolutionOpProperty);

W powyższym makrze pierwszym argumentem jest łańcuch nazwy, a drugim nazwa klasy właściwości.

Ten rozdział zawiera informacje o ujednoliconym interfejsie programowania aplikacji operatora (API) w Apache MXNet.

SimpleOp

SimpleOp to nowy, ujednolicony interfejs API operatora, który ujednolica różne procesy wywoływania. Po wywołaniu powraca do podstawowych elementów operatorów. Zunifikowany operator jest specjalnie zaprojektowany do operacji jednoargumentowych i binarnych. Dzieje się tak, ponieważ większość operatorów matematycznych zajmuje się jednym lub dwoma operandami, a więcej operandów sprawia, że ​​optymalizacja związana z zależnością jest użyteczna.

Będziemy rozumieć jego ujednolicony operator SimpleOp na przykładzie. W tym przykładzie utworzymy operator działający jakosmooth l1 loss, co jest mieszaniną strat l1 i l2. Możemy zdefiniować i zapisać stratę w sposób podany poniżej -

loss = outside_weight .* f(inside_weight .* (data - label))
grad = outside_weight .* inside_weight .* f'(inside_weight .* (data - label))

Tutaj, w powyższym przykładzie,

• . * oznacza mnożenie według elementów

• f, f’ jest gładką funkcją straty l1, w której zakładamy mshadow.

Wydaje się niemożliwe zaimplementowanie tej konkretnej straty jako operatora jednoargumentowego lub binarnego, ale MXNet zapewnia swoim użytkownikom automatyczne różnicowanie w wykonaniu symbolicznym, co upraszcza utratę bezpośrednio do f i f '. Dlatego z pewnością możemy zaimplementować tę konkretną stratę jako jednoargumentowy operator.

Definiowanie kształtów

Jak wiemy, MXNet's mshadow librarywymaga jawnej alokacji pamięci, dlatego musimy dostarczyć wszystkie kształty danych przed wykonaniem jakichkolwiek obliczeń. Przed zdefiniowaniem funkcji i gradientu musimy zapewnić spójność kształtu wejściowego i kształt wyjściowy w następujący sposób:

typedef mxnet::TShape (*UnaryShapeFunction)(const mxnet::TShape& src,
const EnvArguments& env);
   typedef mxnet::TShape (*BinaryShapeFunction)(const mxnet::TShape& lhs,
const mxnet::TShape& rhs,
const EnvArguments& env);

Funkcja mxnet :: Tshape służy do sprawdzania kształtu danych wejściowych i wyznaczonego kształtu danych wyjściowych. W przypadku, gdy nie zdefiniujesz tej funkcji, domyślny kształt wyjściowy będzie taki sam jak kształt wejściowy. Na przykład, w przypadku operatora binarnego, kształt lewych i prawych jest domyślnie sprawdzany jako taki sam.

Teraz przejdźmy do naszego smooth l1 loss example. W tym celu musimy zdefiniować XPU do cpu lub gpu w implementacji nagłówka smooth_l1_unary-inl.h. Powodem jest ponowne użycie tego samego kodu w smooth_l1_unary.cc i smooth_l1_unary.cu.

#include <mxnet/operator_util.h>
   #if defined(__CUDACC__)
      #define XPU gpu
   #else
      #define XPU cpu
#endif

Jak w naszym smooth l1 loss example,wyjście ma taki sam kształt jak źródło, możemy użyć domyślnego zachowania. Można to zapisać w następujący sposób -

inline mxnet::TShape SmoothL1Shape_(const mxnet::TShape& src,const EnvArguments& env) {
   return mxnet::TShape(src);
}

Definiowanie funkcji

Możemy utworzyć jednoargumentową lub binarną funkcję z jednym wejściem w następujący sposób -

typedef void (*UnaryFunction)(const TBlob& src,
   const EnvArguments& env,
   TBlob* ret,
   OpReqType req,
   RunContext ctx);
typedef void (*BinaryFunction)(const TBlob& lhs,
   const TBlob& rhs,
   const EnvArguments& env,
   TBlob* ret,
   OpReqType req,
   RunContext ctx);

Poniżej znajduje się RunContext ctx struct który zawiera informacje potrzebne w czasie wykonywania do wykonania -

struct RunContext {
   void *stream; // the stream of the device, can be NULL or Stream<gpu>* in GPU mode
   template<typename xpu> inline mshadow::Stream<xpu>* get_stream() // get mshadow stream from Context
} // namespace mxnet

Teraz zobaczmy, jak możemy zapisać wyniki obliczeń ret.

enum OpReqType {
   kNullOp, // no operation, do not write anything
   kWriteTo, // write gradient to provided space
   kWriteInplace, // perform an in-place write
   kAddTo // add to the provided space
};

Teraz przejdźmy do naszego smooth l1 loss example. W tym celu użyjemy funkcji UnaryFunction do zdefiniowania funkcji tego operatora w następujący sposób:

template<typename xpu>
void SmoothL1Forward_(const TBlob& src,
   const EnvArguments& env,
   TBlob *ret,
   OpReqType req,
RunContext ctx) {
   using namespace mshadow;
   using namespace mshadow::expr;
   mshadow::Stream<xpu> *s = ctx.get_stream<xpu>();
   real_t sigma2 = env.scalar * env.scalar;
   MSHADOW_TYPE_SWITCH(ret->type_flag_, DType, {
      mshadow::Tensor<xpu, 2, DType> out = ret->get<xpu, 2, DType>(s);
      mshadow::Tensor<xpu, 2, DType> in = src.get<xpu, 2, DType>(s);
      ASSIGN_DISPATCH(out, req,
      F<mshadow_op::smooth_l1_loss>(in, ScalarExp<DType>(sigma2)));
   });
}

Definiowanie gradientów

Z wyjątkiem Input, TBlob, i OpReqTypesą podwojone, funkcje gradientowe operatorów binarnych mają podobną strukturę. Sprawdźmy poniżej, gdzie utworzyliśmy funkcję gradientową z różnymi typami danych wejściowych:

// depending only on out_grad
typedef void (*UnaryGradFunctionT0)(const OutputGrad& out_grad,
   const EnvArguments& env,
   TBlob* in_grad,
   OpReqType req,
   RunContext ctx);
// depending only on out_value
typedef void (*UnaryGradFunctionT1)(const OutputGrad& out_grad,
   const OutputValue& out_value,
   const EnvArguments& env,
   TBlob* in_grad,
   OpReqType req,
   RunContext ctx);
// depending only on in_data
typedef void (*UnaryGradFunctionT2)(const OutputGrad& out_grad,
   const Input0& in_data0,
   const EnvArguments& env,
   TBlob* in_grad,
   OpReqType req,
   RunContext ctx);

Jak zdefiniowano powyżej Input0, Input, OutputValue, i OutputGrad wszystkie mają wspólną strukturę GradientFunctionArgument. Jest zdefiniowany w następujący sposób -

struct GradFunctionArgument {
   TBlob data;
}

Teraz przejdźmy do naszego smooth l1 loss example. Aby to włączyć łańcuchową regułę gradientu, musimy pomnożyćout_grad od góry do wyniku in_grad.

template<typename xpu>
void SmoothL1BackwardUseIn_(const OutputGrad& out_grad, const Input0& in_data0,
   const EnvArguments& env,
   TBlob *in_grad,
   OpReqType req,
   RunContext ctx) {
   using namespace mshadow;
   using namespace mshadow::expr;
   mshadow::Stream<xpu> *s = ctx.get_stream<xpu>();
   real_t sigma2 = env.scalar * env.scalar;
      MSHADOW_TYPE_SWITCH(in_grad->type_flag_, DType, {
      mshadow::Tensor<xpu, 2, DType> src = in_data0.data.get<xpu, 2, DType>(s);
      mshadow::Tensor<xpu, 2, DType> ograd = out_grad.data.get<xpu, 2, DType>(s);
      mshadow::Tensor<xpu, 2, DType> igrad = in_grad->get<xpu, 2, DType>(s);
      ASSIGN_DISPATCH(igrad, req,
      ograd * F<mshadow_op::smooth_l1_gradient>(src, ScalarExp<DType>(sigma2)));
   });
}

Zarejestruj SimpleOp w MXNet

Po utworzeniu kształtu, funkcji i gradientu musimy przywrócić je zarówno do operatora NDArray, jak i do operatora symbolicznego. W tym celu możemy użyć makra rejestracji w następujący sposób -

MXNET_REGISTER_SIMPLE_OP(Name, DEV)
   .set_shape_function(Shape)
   .set_function(DEV::kDevMask, Function<XPU>, SimpleOpInplaceOption)
   .set_gradient(DEV::kDevMask, Gradient<XPU>, SimpleOpInplaceOption)
   .describe("description");

Plik SimpleOpInplaceOption można zdefiniować następująco -

enum SimpleOpInplaceOption {
   kNoInplace, // do not allow inplace in arguments
   kInplaceInOut, // allow inplace in with out (unary)
   kInplaceOutIn, // allow inplace out_grad with in_grad (unary)
   kInplaceLhsOut, // allow inplace left operand with out (binary)

   kInplaceOutLhs // allow inplace out_grad with lhs_grad (binary)
};

Teraz przejdźmy do naszego smooth l1 loss example. W tym celu mamy funkcję gradientową, która opiera się na danych wejściowych, więc nie można jej zapisać w miejscu.

MXNET_REGISTER_SIMPLE_OP(smooth_l1, XPU)
.set_function(XPU::kDevMask, SmoothL1Forward_<XPU>, kNoInplace)
.set_gradient(XPU::kDevMask, SmoothL1BackwardUseIn_<XPU>, kInplaceOutIn)
.set_enable_scalar(true)
.describe("Calculate Smooth L1 Loss(lhs, scalar)");

SimpleOp na EnvArguments

Jak wiemy, niektóre operacje mogą wymagać:

• Skalar jako dane wejściowe, takie jak skala gradientowa

• Zestaw argumentów słów kluczowych kontrolujących zachowanie

• Tymczasowa przestrzeń do przyspieszenia obliczeń.

Zaletą używania EnvArguments jest to, że zapewnia dodatkowe argumenty i zasoby, aby obliczenia były bardziej skalowalne i wydajne.

Przykład

Najpierw zdefiniujmy strukturę jak poniżej -

struct EnvArguments {
   real_t scalar; // scalar argument, if enabled
   std::vector<std::pair<std::string, std::string> > kwargs; // keyword arguments
   std::vector<Resource> resource; // pointer to the resources requested
};

Następnie musimy poprosić o dodatkowe zasoby, takie jak mshadow::Random<xpu> i tymczasowe miejsce w pamięci z EnvArguments.resource. Można to zrobić w następujący sposób -

struct ResourceRequest {
   enum Type { // Resource type, indicating what the pointer type is
      kRandom, // mshadow::Random<xpu> object
      kTempSpace // A dynamic temp space that can be arbitrary size
   };
   Type type; // type of resources
};

Teraz rejestracja zażąda zadeklarowanego żądania zasobu od mxnet::ResourceManager. Następnie umieści zasoby w std::vector<Resource> resource in EnvAgruments.

Dostęp do zasobów możemy uzyskać za pomocą następującego kodu -

auto tmp_space_res = env.resources[0].get_space(some_shape, some_stream);
auto rand_res = env.resources[0].get_random(some_stream);

Jeśli widzisz w naszym gładkim przykładzie straty l1, potrzebne jest wejście skalarne, aby zaznaczyć punkt zwrotny funkcji straty. Dlatego w procesie rejestracji używamyset_enable_scalar(true), i env.scalar w deklaracjach funkcji i gradientów.

Budowanie operacji tensora

W tym miejscu pojawia się pytanie, dlaczego musimy tworzyć operacje tensorowe? Powody są następujące -

• Obliczenia wykorzystują bibliotekę mshadow i czasami nie mamy łatwo dostępnych funkcji.

• Jeśli operacja nie jest wykonywana w sposób elementarny, taki jak strata softmax i gradient.

Przykład

Tutaj używamy powyższego przykładu płynnej utraty l1. Będziemy tworzyć dwa mapery, a mianowicie skalarne przypadki gładkiej utraty l1 i gradientu:

namespace mshadow_op {
   struct smooth_l1_loss {
      // a is x, b is sigma2
      MSHADOW_XINLINE static real_t Map(real_t a, real_t b) {
         if (a > 1.0f / b) {
            return a - 0.5f / b;
         } else if (a < -1.0f / b) {
            return -a - 0.5f / b;
         } else {
            return 0.5f * a * a * b;
         }
      }
   };
}

Ten rozdział dotyczy rozproszonego szkolenia w Apache MXNet. Zacznijmy od zrozumienia, jakie są tryby obliczeń w MXNet.

Tryby obliczeń

MXNet, wielojęzyczna biblioteka ML, oferuje swoim użytkownikom dwa tryby obliczeń -

Tryb rozkazujący

Ten tryb obliczeń udostępnia interfejs, taki jak NumPy API. Na przykład w MXNet użyj następującego imperatywnego kodu, aby skonstruować tensor zer zarówno na CPU, jak i GPU -

import mxnet as mx
tensor_cpu = mx.nd.zeros((100,), ctx=mx.cpu())
tensor_gpu= mx.nd.zeros((100,), ctx=mx.gpu(0))

Jak widać w powyższym kodzie, MXNets określa lokalizację, w której należy przechowywać tensor, w procesorze lub urządzeniu GPU. W powyższym przykładzie jest to lokalizacja 0. MXNet osiąga niesamowite wykorzystanie urządzenia, ponieważ wszystkie obliczenia są wykonywane leniwie zamiast natychmiastowo.

Tryb symboliczny

Chociaż tryb imperatywny jest całkiem przydatny, ale jedną z wad tego trybu jest jego sztywność, tj. Wszystkie obliczenia muszą być znane wcześniej wraz z predefiniowanymi strukturami danych.

Z drugiej strony, tryb symboliczny udostępnia wykres obliczeniowy, taki jak TensorFlow. Eliminuje wady imperatywnego interfejsu API, umożliwiając MXNet pracę z symbolami lub zmiennymi zamiast ustalonych / wstępnie zdefiniowanych struktur danych. Następnie symbole można zinterpretować jako zbiór operacji w następujący sposób -

import mxnet as mx
x = mx.sym.Variable(“X”)
y = mx.sym.Variable(“Y”)
z = (x+y)
m = z/100

Rodzaje równoległości

Apache MXNet obsługuje rozproszone szkolenia. Umożliwia nam wykorzystanie wielu maszyn do szybszego i efektywnego treningu.

Poniżej przedstawiono dwa sposoby, w jakie możemy rozłożyć obciążenie związane z trenowaniem sieci NN na wiele urządzeń, CPU lub GPU -

Równoległość danych

W tego rodzaju równoległości każde urządzenie przechowuje pełną kopię modelu i współpracuje z inną częścią zestawu danych. Urządzenia również zbiorczo aktualizują udostępniony model. Możemy zlokalizować wszystkie urządzenia na jednym komputerze lub na wielu komputerach.

Równoległość modelu

To inny rodzaj równoległości, który przydaje się, gdy modele są tak duże, że nie mieszczą się w pamięci urządzenia. W równoległości modelu różne urządzenia mają zadanie uczenia się różnych części modelu. Ważną kwestią, na którą należy zwrócić uwagę, jest to, że obecnie Apache MXNet obsługuje równoległość modeli tylko w jednej maszynie.

Działanie szkolenia rozproszonego

Poniższe koncepcje są kluczem do zrozumienia działania rozproszonego szkolenia w Apache MXNet -

Rodzaje procesów

Procesy komunikują się ze sobą, aby ukończyć szkolenie modelu. Apache MXNet ma następujące trzy procesy -

Pracownik

Zadaniem węzła roboczego jest przeprowadzenie szkolenia na partii próbek szkoleniowych. Węzły Worker będą pobierać wagi z serwera przed przetworzeniem każdej partii. Węzły Worker wyślą gradienty na serwer po przetworzeniu partii.

serwer

MXNet może mieć wiele serwerów do przechowywania parametrów modelu i komunikacji z węzłami roboczymi.

Planista

Zadaniem harmonogramu jest skonfigurowanie klastra, które obejmuje oczekiwanie na komunikaty, które nadszedł każdy węzeł i którego portu nasłuchuje. Po skonfigurowaniu klastra program planujący informuje wszystkie procesy o każdym innym węźle w klastrze. Dzieje się tak, ponieważ procesy mogą się ze sobą komunikować. Jest tylko jeden program planujący.

Sklep KV

Sklepy KV oznaczają Key-Valuesklep. Jest to krytyczny komponent używany do treningu na wielu urządzeniach. Jest to ważne, ponieważ komunikacja parametrów między urządzeniami na jednym, a także na wielu maszynach jest przesyłana przez jeden lub więcej serwerów z KVStore dla parametrów. Zrozummy działanie KVStore za pomocą następujących punktów -

• Każda wartość w KVStore jest reprezentowana przez key i a value.

• Każda tablica parametrów w sieci ma przypisany plik key a wagi tej tablicy parametrów są określane przez value.

• Następnie węzły robocze pushgradienty po przetworzeniu partii. Oni teżpull zaktualizowane wagi przed przetworzeniem nowej partii.

Pojęcie serwera KVStore istnieje tylko podczas szkolenia rozproszonego, a tryb rozproszony jest włączany przez wywołanie mxnet.kvstore.create funkcja z argumentem w postaci łańcucha zawierającego słowo dist -

kv = mxnet.kvstore.create(‘dist_sync’)

Dystrybucja kluczy

Nie jest konieczne, aby wszystkie serwery przechowywały wszystkie tablice parametrów lub klucze, ale są one rozmieszczone na różnych serwerach. Taka dystrybucja kluczy między różnymi serwerami jest obsługiwana w sposób przejrzysty przez KVStore, a decyzja o tym, który serwer przechowuje określony klucz, jest podejmowana losowo.

KVStore, jak omówiono powyżej, zapewnia, że ​​za każdym razem, gdy klucz jest ściągany, jego żądanie jest wysyłane do tego serwera, który ma odpowiednią wartość. Co jeśli wartość jakiegoś klucza jest duża? W takim przypadku może być współużytkowany na różnych serwerach.

Podziel dane treningowe

Jako użytkownicy chcemy, aby każda maszyna pracowała na różnych częściach zestawu danych, szczególnie podczas przeprowadzania rozproszonego szkolenia w trybie równoległym do danych. Wiemy, że aby podzielić partię próbek dostarczonych przez iterator danych do równoległego szkolenia danych na jednym pracowniku, możemy użyćmxnet.gluon.utils.split_and_load a następnie załaduj każdą część partii na urządzenie, które będzie ją dalej przetwarzać.

Z drugiej strony, w przypadku szkolenia rozproszonego, na początku musimy podzielić zbiór danych na nróżne części, aby każdy pracownik otrzymał inną część. Gdy to zrobisz, każdy pracownik może użyćsplit_and_loadaby ponownie podzielić tę część zbioru danych na różne urządzenia na jednym komputerze. Wszystko to dzieje się za pośrednictwem iteratora danych.mxnet.io.MNISTIterator i mxnet.io.ImageRecordIter są dwa takie iteratory w MXNet, które obsługują tę funkcję.

Aktualizacja wag

Aby zaktualizować wagi, KVStore obsługuje następujące dwa tryby -

• Pierwsza metoda agreguje gradienty i aktualizuje wagi przy użyciu tych gradientów.

• W drugiej metodzie serwer tylko agreguje gradienty.

Jeśli korzystasz z Gluon, istnieje możliwość wyboru jednej z powyższych metod przez przejście update_on_kvstorezmienna. Zrozummy to, tworząc pliktrainer obiekt w następujący sposób -

trainer = gluon.Trainer(net.collect_params(), optimizer='sgd',
   optimizer_params={'learning_rate': opt.lr,
      'wd': opt.wd,
      'momentum': opt.momentum,
      'multi_precision': True},
      kvstore=kv,
   update_on_kvstore=True)

Tryby rozproszonego szkolenia

Jeśli ciąg tworzenia KVStore zawiera słowo dist, oznacza to, że rozproszone uczenie jest włączone. Poniżej przedstawiono różne tryby szkolenia rozproszonego, które można włączyć za pomocą różnych typów KVStore -

dist_sync

Jak sama nazwa wskazuje, oznacza synchroniczne szkolenie rozproszone. W tym przypadku wszyscy pracownicy używają tego samego zsynchronizowanego zestawu parametrów modelu na początku każdej partii.

Wadą tego trybu jest to, że po każdej partii serwer powinien czekać na otrzymanie gradientów od każdego pracownika, zanim zaktualizuje parametry modelu. Oznacza to, że jeśli pracownik ulegnie awarii, zatrzyma to postęp wszystkich pracowników.

dist_async

Jak sama nazwa wskazuje, oznacza synchroniczne szkolenie rozproszone. W tym przypadku serwer otrzymuje gradienty od jednego pracownika i natychmiast aktualizuje swój magazyn. Serwer używa zaktualizowanego magazynu, aby odpowiedzieć na wszelkie dalsze ściągnięcia.

Zaletą w porównaniu z dist_sync modepolega na tym, że pracownik, który zakończy przetwarzanie partii, może pobrać bieżące parametry z serwera i rozpocząć kolejną. Pracownik może to zrobić, nawet jeśli drugi pracownik nie zakończył jeszcze przetwarzania wcześniejszej partii. Jest również szybszy niż tryb dist_sync, ponieważ zbieżność może zająć więcej epok bez żadnych kosztów synchronizacji.

dist_sync_device

Ten tryb jest taki sam jak dist_synctryb. Jedyna różnica polega na tym, że w każdym węźle używanych jest wiele procesorów graficznychdist_sync_device agreguje gradienty i aktualizuje wagi na GPU, podczas gdy, dist_sync agreguje gradienty i aktualizuje wagi w pamięci procesora.

Zmniejsza kosztowną komunikację między GPU i CPU. Dlatego jest szybszy niżdist_sync. Wadą jest to, że zwiększa zużycie pamięci na GPU.

dist_async_device

Ten tryb działa tak samo jak dist_sync_device tryb, ale w trybie asynchronicznym.

W tym rozdziale dowiemy się o pakietach Pythona dostępnych w Apache MXNet.

Ważne pakiety MXNet Python

MXNet ma następujące ważne pakiety Pythona, które będziemy omawiać jeden po drugim -

• Autograd (automatyczne różnicowanie)

• NDArray

• KVStore

• Gluon

• Visualization

Najpierw zacznijmy od Autograd Pakiet Pythona dla Apache MXNet.

Autograd

Autograd oznacza automatic differentiationsłuży do wstecznej propagacji gradientów z miernika strat z powrotem do każdego z parametrów. Wraz z wsteczną propagacją wykorzystuje dynamiczne podejście programistyczne do wydajnego obliczania gradientów. Nazywa się to również automatycznym różnicowaniem w trybie odwrotnym. Technika ta jest bardzo skuteczna w sytuacjach „fan-in”, w których wiele parametrów wpływa na jeden miernik strat.

Co to są gradienty?

Gradienty są podstawą procesu uczenia sieci neuronowej. Zasadniczo mówią nam, jak zmienić parametry sieci, aby poprawić jej wydajność.

Jak wiemy, sieci neuronowe (NN) składają się z operatorów, takich jak sumy, iloczyn, zwoje, itp. Operatory te do obliczeń wykorzystują takie parametry, jak wagi w jądrach splotów. Powinniśmy być zmuszeni znaleźć optymalne wartości dla tych parametrów, a gradienty wskazują nam drogę i prowadzą do rozwiązania.

Interesuje nas wpływ zmiany parametru na wydajność sieci, a gradienty mówią nam, o ile dana zmienna rośnie lub maleje, gdy zmieniamy zmienną, od której zależy. Wydajność jest zwykle definiowana przy użyciu miernika strat, który staramy się zminimalizować. Na przykład w przypadku regresji możemy spróbować zminimalizowaćL2 strata między naszymi przewidywaniami a dokładną wartością, podczas gdy w przypadku klasyfikacji możemy zminimalizować cross-entropy loss.

Po obliczeniu gradientu każdego parametru w odniesieniu do straty możemy użyć optymalizatora, takiego jak stochastyczne zejście gradientowe.

Jak obliczyć gradienty?

Mamy następujące opcje obliczania gradientów -

• Symbolic Differentiation- Pierwsza opcja to Zróżnicowanie symboliczne, które oblicza formuły dla każdego gradientu. Wadą tej metody jest to, że szybko prowadzi ona do niewiarygodnie długich formuł, ponieważ sieć pogłębia się, a operatorzy stają się bardziej złożeni.

• Finite Differencing- Inną opcją jest użycie różnicowania skończonego, które wypróbuje niewielkie różnice w każdym parametrze i zobacz, jak reaguje miernik strat. Wadą tej metody jest to, że byłaby kosztowna obliczeniowo i może mieć słabą dokładność numeryczną.

• Automatic differentiation- Rozwiązaniem wad powyższych metod jest użycie automatycznego różnicowania w celu odwrotnej propagacji gradientów z miernika strat do każdego z parametrów. Propagacja umożliwia nam dynamiczne podejście programistyczne do wydajnego obliczania gradientów. Ta metoda jest również nazywana automatycznym różnicowaniem w trybie odwrotnym.

Automatyczne różnicowanie (autograd)

Tutaj szczegółowo zrozumiemy działanie autogradu. Zasadniczo działa w dwóch etapach -

Stage 1 - Ten etap się nazywa ‘Forward Pass’treningu. Jak sama nazwa wskazuje, na tym etapie tworzy zapis operatora wykorzystywanego przez sieć do prognozowania i obliczania miernika strat.

Stage 2 - Ten etap się nazywa ‘Backward Pass’treningu. Jak sama nazwa wskazuje, na tym etapie działa wstecz na tym rekordzie. Przechodząc wstecz, ocenia częściowe pochodne każdego operatora, aż do parametru sieci.

Zalety autogradu

Oto zalety korzystania z automatycznego różnicowania (autograd) -

• Flexible- Elastyczność, jaką daje nam przy definiowaniu naszej sieci, jest jedną z ogromnych zalet korzystania z autogradu. Możemy zmieniać operacje w każdej iteracji. Nazywa się to grafami dynamicznymi, które są znacznie bardziej złożone do implementacji w strukturach wymagających grafu statycznego. Autograd, nawet w takich przypadkach, nadal będzie w stanie poprawnie odwrócić gradienty.

• Automatic- Autograd jest automatyczny, tzn. Załatwia za Ciebie zawiłości procedury wstecznej propagacji. Musimy tylko określić, jakie gradienty chcemy obliczyć.

• Efficient - Autogard bardzo sprawnie oblicza gradienty.

• Can use native Python control flow operators- Możemy użyć natywnych operatorów przepływu sterowania Pythona, takich jak if condition i while loop. Autograd nadal będzie w stanie skutecznie i poprawnie odwracać gradienty.

Korzystanie z autograd w MXNet Gluon

Tutaj, na przykładzie, zobaczymy, jak możemy wykorzystać autograd w MXNet Gluon.

Przykład implementacji

W poniższym przykładzie zaimplementujemy model regresji mający dwie warstwy. Po wdrożeniu za pomocą programu autograd automatycznie obliczymy gradient ubytku w odniesieniu do każdego z parametrów wagi -

Najpierw zaimportuj autogrard i inne wymagane pakiety w następujący sposób -

from mxnet import autograd
import mxnet as mx
from mxnet.gluon.nn import HybridSequential, Dense
from mxnet.gluon.loss import L2Loss

Teraz musimy zdefiniować sieć w następujący sposób -

N_net = HybridSequential()
N_net.add(Dense(units=3))
N_net.add(Dense(units=1))
N_net.initialize()

Teraz musimy zdefiniować stratę w następujący sposób -

loss_function = L2Loss()

Następnie musimy utworzyć fikcyjne dane w następujący sposób -

x = mx.nd.array([[0.5, 0.9]])
y = mx.nd.array([[1.5]])

Teraz jesteśmy gotowi do pierwszego przejścia przez sieć. Chcemy, aby autograd zapisywał wykres obliczeniowy, abyśmy mogli obliczyć gradienty. W tym celu musimy uruchomić kod sieciowy w zakresieautograd.record kontekst w następujący sposób -

with autograd.record():
   y_hat = N_net(x)
   loss = loss_function(y_hat, y)

Teraz jesteśmy gotowi na przejście wstecz, które zaczynamy od wywołania metody wstecznej na ilości będącej przedmiotem zainteresowania. Wartością interesującą w naszym przykładzie jest strata, ponieważ próbujemy obliczyć gradient strat w odniesieniu do parametrów -

loss.backward()

Teraz mamy gradienty dla każdego parametru sieci, które będą używane przez optymalizator do aktualizacji wartości parametru w celu poprawy wydajności. Sprawdźmy gradienty pierwszej warstwy w następujący sposób -

N_net[0].weight.grad()

Output

Wynik jest następujący -

[[-0.00470527 -0.00846948]
[-0.03640365 -0.06552657]
[ 0.00800354 0.01440637]]
<NDArray 3x2 @cpu(0)>

Kompletny przykład wdrożenia

Poniżej podano pełny przykład realizacji.

from mxnet import autograd
import mxnet as mx
from mxnet.gluon.nn import HybridSequential, Dense
from mxnet.gluon.loss import L2Loss
N_net = HybridSequential()
N_net.add(Dense(units=3))
N_net.add(Dense(units=1))
N_net.initialize()
loss_function = L2Loss()
x = mx.nd.array([[0.5, 0.9]])
y = mx.nd.array([[1.5]])
with autograd.record():
y_hat = N_net(x)
loss = loss_function(y_hat, y)
loss.backward()
N_net[0].weight.grad()

W tym rozdziale omówimy wielowymiarowy format tablic MXNet o nazwie ndarray.

Obsługa danych za pomocą NDArray

Najpierw zobaczymy, jak możemy obsługiwać dane za pomocą NDArray. Poniżej przedstawiono warunki wstępne tego samego -

Wymagania wstępne

Aby zrozumieć, w jaki sposób możemy obsługiwać dane w tym wielowymiarowym formacie tablicy, musimy spełnić następujące warunki wstępne:

• MXNet zainstalowany w środowisku Python

• Python 2.7.x lub Python 3.x

Przykład implementacji

Zrozummy podstawową funkcjonalność na przykładzie podanym poniżej -

Najpierw musimy zaimportować MXNet i ndarray z MXNet w następujący sposób -

import mxnet as mx
from mxnet import nd

Po zaimportowaniu niezbędnych bibliotek przejdziemy do następujących podstawowych funkcji:

Prosta tablica 1-D z listą w Pythonie

Example

x = nd.array([1,2,3,4,5,6,7,8,9,10])
print(x)

Output

Dane wyjściowe są takie, jak wspomniano poniżej -

[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
<NDArray 10 @cpu(0)>

Tablica 2-W z listą Pythona

Example

y = nd.array([[1,2,3,4,5,6,7,8,9,10], [1,2,3,4,5,6,7,8,9,10], [1,2,3,4,5,6,7,8,9,10]])
print(y)

Output

Wynik jest taki, jak podano poniżej -

[[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]]
<NDArray 3x10 @cpu(0)>

Tworzenie NDArray bez inicjalizacji

Tutaj utworzymy macierz z 3 wierszami i 4 kolumnami przy użyciu .emptyfunkcjonować. Użyjemy również.full funkcja, która pobierze dodatkowy operator dla wartości, którą chcesz wypełnić tablicą.

Example

x = nd.empty((3, 4))
print(x)
x = nd.full((3,4), 8)
print(x)

Output

Dane wyjściowe podano poniżej -

[[0.000e+00 0.000e+00 0.000e+00 0.000e+00]
 [0.000e+00 0.000e+00 2.887e-42 0.000e+00]
 [0.000e+00 0.000e+00 0.000e+00 0.000e+00]]
<NDArray 3x4 @cpu(0)>

[[8. 8. 8. 8.]
 [8. 8. 8. 8.]
 [8. 8. 8. 8.]]
<NDArray 3x4 @cpu(0)>

Macierz wszystkich zer z funkcją .zeros

Example

x = nd.zeros((3, 8))
print(x)

Output

Dane wyjściowe są następujące -

[[0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]]
<NDArray 3x8 @cpu(0)>

Macierz wszystkich jedynek z funkcją .ones

Example

x = nd.ones((3, 8))
print(x)

Output

Dane wyjściowe są wymienione poniżej -

[[1. 1. 1. 1. 1. 1. 1. 1.]
   [1. 1. 1. 1. 1. 1. 1. 1.]
   [1. 1. 1. 1. 1. 1. 1. 1.]]
<NDArray 3x8 @cpu(0)>

Tworzenie tablicy, której wartości są próbkowane losowo

Example

y = nd.random_normal(0, 1, shape=(3, 4))
print(y)

Output

Dane wyjściowe podano poniżej -

[[ 1.2673576 -2.0345826 -0.32537818 -1.4583491 ]
 [-0.11176403 1.3606371 -0.7889914 -0.17639421]
 [-0.2532185 -0.42614475 -0.12548696 1.4022992 ]]
<NDArray 3x4 @cpu(0)>

Znajdowanie wymiaru każdego NDArray

Example

y.shape

Output

Dane wyjściowe są następujące -

(3, 4)

Znajdowanie rozmiaru każdego NDArray

Example

y.size

Output

12

Znajdowanie typu danych każdego NDArray

Example

y.dtype

Output

numpy.float32

Operacje NDArray

W tej sekcji wprowadzimy Cię w operacje na macierzach MXNet. NDArray obsługuje dużą liczbę standardowych operacji matematycznych, a także w miejscu.

Standardowe operacje matematyczne

Poniżej przedstawiono standardowe operacje matematyczne obsługiwane przez NDArray -

Dodatek elementarny

Najpierw musimy zaimportować MXNet i ndarray z MXNet w następujący sposób:

import mxnet as mx
from mxnet import nd
x = nd.ones((3, 5))
y = nd.random_normal(0, 1, shape=(3, 5))
print('x=', x)
print('y=', y)
x = x + y
print('x = x + y, x=', x)

Output

Dane wyjściowe podano niniejszym -

x=
[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
<NDArray 3x5 @cpu(0)>
y=
[[-1.0554522 -1.3118273 -0.14674698 0.641493 -0.73820823]
[ 2.031364 0.5932667 0.10228804 1.179526 -0.5444829 ]
[-0.34249446 1.1086396 1.2756858 -1.8332436 -0.5289873 ]]
<NDArray 3x5 @cpu(0)>
x = x + y, x=
[[-0.05545223 -0.3118273 0.853253 1.6414931 0.26179177]
[ 3.031364 1.5932667 1.102288 2.1795259 0.4555171 ]
[ 0.6575055 2.1086397 2.2756858 -0.8332436 0.4710127 ]]
<NDArray 3x5 @cpu(0)>

Mnożenie według elementów

Example

x = nd.array([1, 2, 3, 4])
y = nd.array([2, 2, 2, 1])
x * y

Output

Zobaczysz następujące wyjście -

[2. 4. 6. 4.]
<NDArray 4 @cpu(0)>

Potęgowanie

Example

nd.exp(x)

Output

Po uruchomieniu kodu zobaczysz następujące dane wyjściowe:

[ 2.7182817 7.389056 20.085537 54.59815 ]
<NDArray 4 @cpu(0)>

Macierz transponowana w celu obliczenia iloczynu macierzy-macierzy

Example

nd.dot(x, y.T)

Output

Poniżej podano wynik kodu -

[16.]
<NDArray 1 @cpu(0)>

Operacje na miejscu

Za każdym razem, gdy w powyższym przykładzie uruchamialiśmy operację, przydzielaliśmy nową pamięć do hostowania jej wyniku.

Na przykład, jeśli napiszemy A = A + B, wyłuskujemy macierz, na którą wskazywał A, i zamiast tego skierujemy ją na nowo przydzieloną pamięć. Zrozummy to na przykładzie podanym poniżej, używając funkcji id () w Pythonie -

print('y=', y)
print('id(y):', id(y))
y = y + x
print('after y=y+x, y=', y)
print('id(y):', id(y))

Output

Po wykonaniu otrzymasz następujące dane wyjściowe -

y=
[2. 2. 2. 1.]
<NDArray 4 @cpu(0)>
id(y): 2438905634376
after y=y+x, y=
[3. 4. 5. 5.]
<NDArray 4 @cpu(0)>
id(y): 2438905685664

W rzeczywistości możemy również przypisać wynik do wcześniej przydzielonej tablicy w następujący sposób -

print('x=', x)
z = nd.zeros_like(x)
print('z is zeros_like x, z=', z)
print('id(z):', id(z))
print('y=', y)
z[:] = x + y
print('z[:] = x + y, z=', z)
print('id(z) is the same as before:', id(z))

Output

Wyjście pokazano poniżej -

x=
[1. 2. 3. 4.]
<NDArray 4 @cpu(0)>
z is zeros_like x, z=
[0. 0. 0. 0.]
<NDArray 4 @cpu(0)>
id(z): 2438905790760
y=
[3. 4. 5. 5.]
<NDArray 4 @cpu(0)>
z[:] = x + y, z=
[4. 6. 8. 9.]
<NDArray 4 @cpu(0)>
id(z) is the same as before: 2438905790760

Z powyższego wyniku widzimy, że x + y nadal przydziela tymczasowy bufor do przechowywania wyniku przed skopiowaniem go do z. Więc teraz możemy wykonywać operacje w miejscu, aby lepiej wykorzystać pamięć i uniknąć tymczasowego bufora. Aby to zrobić, określimy argument słowa kluczowego out, który obsługuje każdy operator w następujący sposób -

print('x=', x, 'is in id(x):', id(x))
print('y=', y, 'is in id(y):', id(y))
print('z=', z, 'is in id(z):', id(z))
nd.elemwise_add(x, y, out=z)
print('after nd.elemwise_add(x, y, out=z), x=', x, 'is in id(x):', id(x))
print('after nd.elemwise_add(x, y, out=z), y=', y, 'is in id(y):', id(y))
print('after nd.elemwise_add(x, y, out=z), z=', z, 'is in id(z):', id(z))

Output

Wykonując powyższy program, otrzymasz następujący wynik -

x=
[1. 2. 3. 4.]
<NDArray 4 @cpu(0)> is in id(x): 2438905791152
y=
[3. 4. 5. 5.]
<NDArray 4 @cpu(0)> is in id(y): 2438905685664
z=
[4. 6. 8. 9.]
<NDArray 4 @cpu(0)> is in id(z): 2438905790760
after nd.elemwise_add(x, y, out=z), x=
[1. 2. 3. 4.]
<NDArray 4 @cpu(0)> is in id(x): 2438905791152
after nd.elemwise_add(x, y, out=z), y=
[3. 4. 5. 5.]
<NDArray 4 @cpu(0)> is in id(y): 2438905685664
after nd.elemwise_add(x, y, out=z), z=
[4. 6. 8. 9.]
<NDArray 4 @cpu(0)> is in id(z): 2438905790760

Konteksty NDArray

W Apache MXNet każda tablica ma kontekst, a jeden kontekst może być procesorem, podczas gdy inne konteksty mogą obejmować kilka procesorów graficznych. Sytuacja może być jeszcze gorsza, gdy wdrażamy pracę na wielu serwerach. Dlatego musimy inteligentnie przypisywać tablice do kontekstów. Pozwoli to zminimalizować czas spędzony na przesyłaniu danych między urządzeniami.

Na przykład spróbuj zainicjować tablicę w następujący sposób -

from mxnet import nd
z = nd.ones(shape=(3,3), ctx=mx.cpu(0))
print(z)

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
<NDArray 3x3 @cpu(0)>

Możemy skopiować dany NDArray z jednego kontekstu do innego, używając metody copyto () w następujący sposób -

x_gpu = x.copyto(gpu(0))
print(x_gpu)

Tablica NumPy a NDArray

Wszyscy dobrze znamy tablice NumPy, ale Apache MXNet oferuje własną implementację tablic o nazwie NDArray. Właściwie początkowo został zaprojektowany tak, aby był podobny do NumPy, ale jest kluczowa różnica -

Kluczowa różnica polega na sposobie wykonywania obliczeń w NumPy i NDArray. Każda manipulacja NDArray w MXNet odbywa się w sposób asynchroniczny i nieblokujący, co oznacza, że ​​kiedy piszemy kod taki jak c = a * b, funkcja jest przekazywana doExecution Engine, który rozpocznie obliczenia.

Tutaj, a i b oba są NDArrayami. Zaletą jego użycia jest to, że funkcja natychmiast powraca, a wątek użytkownika może kontynuować wykonywanie, mimo że poprzednie obliczenia mogły nie zostać jeszcze zakończone.

Działanie silnika wykonawczego

Jeśli mówimy o działaniu silnika wykonawczego, buduje on wykres obliczeniowy. Wykres obliczeniowy może zmieniać kolejność lub łączyć niektóre obliczenia, ale zawsze uwzględnia kolejność zależności.

Na przykład, jeśli w dalszej części kodu programistycznego zostaną wykonane inne manipulacje z „X”, silnik wykonawczy zacznie je wykonywać, gdy wynik „X” będzie dostępny. Silnik wykonawczy zajmie się niektórymi ważnymi dla użytkowników pracami, takimi jak napisanie wywołań zwrotnych w celu rozpoczęcia wykonywania kolejnego kodu.

W Apache MXNet, z pomocą NDArray, aby uzyskać wynik obliczeń, wystarczy nam uzyskać dostęp do zmiennej wynikowej. Przepływ kodu zostanie zablokowany do momentu przypisania wyników obliczeń do zmiennej wynikowej. W ten sposób zwiększa wydajność kodu, jednocześnie wspierając bezwzględny tryb programowania.

Konwersja NDArray do NumPy Array

Nauczmy się, jak możemy przekonwertować NDArray na NumPy Array w MXNet.

Combining higher-level operator with the help of few lower-level operators

Czasami możemy zebrać operatora wyższego poziomu, używając istniejących operatorów. Jednym z najlepszych tego przykładów jestnp.full_like()operator, którego nie ma w NDArray API. Można go łatwo zastąpić kombinacją istniejących operatorów w następujący sposób:

from mxnet import nd
import numpy as np
np_x = np.full_like(a=np.arange(7, dtype=int), fill_value=15)
nd_x = nd.ones(shape=(7,)) * 15
np.array_equal(np_x, nd_x.asnumpy())

Output

Otrzymamy dane wyjściowe w następujący sposób -

True

Finding similar operator with different name and/or signature

Spośród wszystkich operatorów część z nich ma nieco inną nazwę, ale są one podobne pod względem funkcjonalności. Przykładem tego jestnd.ravel_index() z np.ravel()Funkcje. W ten sam sposób niektóre operatory mogą mieć podobne nazwy, ale mają różne podpisy. Przykładem tego jestnp.split() i nd.split() są podobne.

Rozumiemy to na następującym przykładzie programowania:

def pad_array123(data, max_length):
data_expanded = data.reshape(1, 1, 1, data.shape[0])
data_padded = nd.pad(data_expanded,
mode='constant',
pad_width=[0, 0, 0, 0, 0, 0, 0, max_length - data.shape[0]],
constant_value=0)
data_reshaped_back = data_padded.reshape(max_length)
return data_reshaped_back
pad_array123(nd.array([1, 2, 3]), max_length=10)

Output

Dane wyjściowe podano poniżej -

[1. 2. 3. 0. 0. 0. 0. 0. 0. 0.]
<NDArray 10 @cpu(0)>

Minimalizowanie wpływu blokowania połączeń

W niektórych przypadkach musimy użyć albo .asnumpy() lub .asscalar()metody, ale to zmusi MXNet do zablokowania wykonywania, dopóki nie będzie można pobrać wyniku. Możemy zminimalizować wpływ połączenia blokującego, dzwoniąc.asnumpy() lub .asscalar() metody w momencie, gdy uważamy, że obliczenie tej wartości jest już wykonane.

Przykład implementacji

Example

from __future__ import print_function
import mxnet as mx
from mxnet import gluon, nd, autograd
from mxnet.ndarray import NDArray
from mxnet.gluon import HybridBlock
import numpy as np

class LossBuffer(object):
   """
   Simple buffer for storing loss value
   """
   
   def __init__(self):
      self._loss = None

   def new_loss(self, loss):
      ret = self._loss
      self._loss = loss
      return ret

      @property
      def loss(self):
         return self._loss

net = gluon.nn.Dense(10)
ce = gluon.loss.SoftmaxCELoss()
net.initialize()
data = nd.random.uniform(shape=(1024, 100))
label = nd.array(np.random.randint(0, 10, (1024,)), dtype='int32')
train_dataset = gluon.data.ArrayDataset(data, label)
train_data = gluon.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
trainer = gluon.Trainer(net.collect_params(), optimizer='sgd')
loss_buffer = LossBuffer()
for data, label in train_data:
   with autograd.record():
      out = net(data)
      # This call saves new loss and returns previous loss
      prev_loss = loss_buffer.new_loss(ce(out, label))
   loss_buffer.loss.backward()
   trainer.step(data.shape[0])
   if prev_loss is not None:
      print("Loss: {}".format(np.mean(prev_loss.asnumpy())))

Output

Wyniki są cytowane poniżej:

Loss: 2.3373236656188965
Loss: 2.3656985759735107
Loss: 2.3613128662109375
Loss: 2.3197104930877686
Loss: 2.3054862022399902
Loss: 2.329197406768799
Loss: 2.318927526473999

Kolejnym najważniejszym pakietem MXNet Python jest Gluon. W tym rozdziale będziemy omawiać ten pakiet. Gluon zapewnia przejrzyste, zwięzłe i proste API dla projektów DL. Umożliwia Apache MXNet prototypowanie, budowanie i trenowanie modeli DL bez utraty szybkości szkolenia.

Bloki

Bloki stanowią podstawę bardziej złożonych projektów sieci. W sieci neuronowej wraz ze wzrostem złożoności sieci neuronowej musimy przejść od projektowania pojedynczych do całych warstw neuronów. Na przykład projekt NN, taki jak ResNet-152, ma bardzo duży stopień regularności, ponieważ składa się zblocks powtarzających się warstw.

Przykład

W poniższym przykładzie napiszemy w kodzie prosty blok, czyli blok dla wielowarstwowego perceptronu.

from mxnet import nd
from mxnet.gluon import nn
x = nd.random.uniform(shape=(2, 20))
N_net = nn.Sequential()
N_net.add(nn.Dense(256, activation='relu'))
N_net.add(nn.Dense(10))
N_net.initialize()
N_net(x)

Output

Daje to następujący wynik:

[[ 0.09543004 0.04614332 -0.00286655 -0.07790346 -0.05130241 0.02942038
0.08696645 -0.0190793 -0.04122177 0.05088576]
[ 0.0769287 0.03099706 0.00856576 -0.044672 -0.06926838 0.09132431
0.06786592 -0.06187843 -0.03436674 0.04234696]]
<NDArray 2x10 @cpu(0)>

Kroki potrzebne do przejścia od definiowania warstw do definiowania bloków jednej lub więcej warstw -

Step 1 - Blok przyjmuje dane jako dane wejściowe.

Step 2- Teraz bloki będą przechowywać stan w postaci parametrów. Na przykład w powyższym przykładzie kodowania blok zawiera dwie ukryte warstwy i potrzebujemy miejsca do przechowywania jego parametrów.

Step 3- Następny blok wywoła funkcję forward w celu wykonania propagacji do przodu. Nazywa się to również obliczeniem naprzód. W ramach pierwszego wywołania przekierowania bloki inicjalizują parametry w sposób leniwy.

Step 4- W końcu bloki wywołają funkcję wsteczną i obliczą gradient w odniesieniu do ich danych wejściowych. Zazwyczaj ten krok jest wykonywany automatycznie.

Blok sekwencyjny

Blok sekwencyjny to specjalny rodzaj bloku, w którym dane przepływają przez sekwencję bloków. W tym przypadku każdy blok jest stosowany na wyjściu poprzedniego, a pierwszy blok jest stosowany do samych danych wejściowych.

Zobaczmy, jak to zrobić sequential prace klasowe -

from mxnet import nd
from mxnet.gluon import nn
class MySequential(nn.Block):
   def __init__(self, **kwargs):
      super(MySequential, self).__init__(**kwargs)

   def add(self, block):
      self._children[block.name] = block
   def forward(self, x):
   for block in self._children.values():
      x = block(x)
   return x
x = nd.random.uniform(shape=(2, 20))
N_net = MySequential()
N_net.add(nn.Dense(256, activation
='relu'))
N_net.add(nn.Dense(10))
N_net.initialize()
N_net(x)

Output

Dane wyjściowe podano niniejszym -

[[ 0.09543004 0.04614332 -0.00286655 -0.07790346 -0.05130241 0.02942038
0.08696645 -0.0190793 -0.04122177 0.05088576]
[ 0.0769287 0.03099706 0.00856576 -0.044672 -0.06926838 0.09132431
0.06786592 -0.06187843 -0.03436674 0.04234696]]
<NDArray 2x10 @cpu(0)>

Blok niestandardowy

Możemy łatwo wyjść poza konkatenację z blokiem sekwencyjnym, jak zdefiniowano powyżej. Ale jeśli chcielibyśmy dokonać dostosowań, plikBlockclass zapewnia nam również wymaganą funkcjonalność. Klasa Block ma konstruktora modelu dostarczonego w module nn. Możemy odziedziczyć tego konstruktora modelu, aby zdefiniować model, który chcemy.

W poniższym przykładzie MLP class zastępuje __init__ i forward funkcje klasy Block.

Zobaczmy, jak to działa.

class MLP(nn.Block):

   def __init__(self, **kwargs):
      super(MLP, self).__init__(**kwargs)
      self.hidden = nn.Dense(256, activation='relu') # Hidden layer
      self.output = nn.Dense(10) # Output layer


   def forward(self, x):
      hidden_out = self.hidden(x)
      return self.output(hidden_out)
x = nd.random.uniform(shape=(2, 20))
N_net = MLP()
N_net.initialize()
N_net(x)

Output

Po uruchomieniu kodu zobaczysz następujące dane wyjściowe:

[[ 0.07787763 0.00216403 0.01682201 0.03059879 -0.00702019 0.01668715
0.04822846 0.0039432 -0.09300035 -0.04494302]
[ 0.08891078 -0.00625484 -0.01619131 0.0380718 -0.01451489 0.02006172
0.0303478 0.02463485 -0.07605448 -0.04389168]]
<NDArray 2x10 @cpu(0)>

Warstwy niestandardowe

Gluon API Apache MXNet zawiera niewielką liczbę wstępnie zdefiniowanych warstw. Jednak w pewnym momencie może się okazać, że potrzebna jest nowa warstwa. Z łatwością możemy dodać nową warstwę w Gluon API. W tej sekcji zobaczymy, jak możemy utworzyć nową warstwę od podstaw.

Najprostsza warstwa niestandardowa

Aby stworzyć nową warstwę w Gluon API, musimy stworzyć klasę dziedziczącą po klasie Block, która zapewnia najbardziej podstawową funkcjonalność. Możemy odziedziczyć z niej wszystkie predefiniowane warstwy bezpośrednio lub poprzez inne podklasy.

Aby utworzyć nową warstwę, jedyną metodą instancji wymaganą do zaimplementowania jest forward (self, x). Ta metoda określa, co dokładnie zrobi nasza warstwa podczas propagacji do przodu. Jak wspomniano wcześniej, przejście przez propagację wsteczną dla bloków zostanie wykonane automatycznie przez samą Apache MXNet.

Przykład

W poniższym przykładzie zdefiniujemy nową warstwę. Zaimplementujemy równieżforward() metoda normalizacji danych wejściowych poprzez dopasowanie ich do zakresu [0, 1].

from __future__ import print_function
import mxnet as mx
from mxnet import nd, gluon, autograd
from mxnet.gluon.nn import Dense
mx.random.seed(1)
class NormalizationLayer(gluon.Block):
   def __init__(self):
      super(NormalizationLayer, self).__init__()

   def forward(self, x):
      return (x - nd.min(x)) / (nd.max(x) - nd.min(x))
x = nd.random.uniform(shape=(2, 20))
N_net = NormalizationLayer()
N_net.initialize()
N_net(x)

Output

Wykonując powyższy program, otrzymasz następujący wynik -

[[0.5216355 0.03835821 0.02284337 0.5945146 0.17334817 0.69329053
0.7782702 1. 0.5508242 0. 0.07058554 0.3677264
0.4366546 0.44362497 0.7192635 0.37616986 0.6728799 0.7032008

 0.46907538 0.63514024]
[0.9157533 0.7667402 0.08980197   0.03593295 0.16176797 0.27679572
 0.07331014 0.3905285 0.6513384 0.02713427 0.05523694 0.12147208
 0.45582628 0.8139887 0.91629887 0.36665893 0.07873632 0.78268915
 0.63404864 0.46638715]]
 <NDArray 2x20 @cpu(0)>

Hybrydyzacja

Można go zdefiniować jako proces używany przez Apache MXNet do tworzenia symbolicznego wykresu przyszłych obliczeń. Hybrydyzacja pozwala MXNet na zwiększenie wydajności obliczeń poprzez optymalizację obliczeniowego wykresu symbolicznego. Zamiast bezpośrednio dziedziczyć zBlockw rzeczywistości może się okazać, że podczas implementacji istniejących warstw blok dziedziczy z pliku HybridBlock.

Oto powody tego -

• Allows us to write custom layers: HybridBlock umożliwia nam pisanie niestandardowych warstw, które mogą być dalej używane w programowaniu imperatywnym i symbolicznym.

• Increase computation performance- HybridBlock optymalizuje obliczeniowy wykres symboliczny, co pozwala MXNet na zwiększenie wydajności obliczeń.

Przykład

W tym przykładzie będziemy przepisać naszą przykładową warstwę, utworzoną powyżej, przy użyciu HybridBlock:

class NormalizationHybridLayer(gluon.HybridBlock):
   def __init__(self):
      super(NormalizationHybridLayer, self).__init__()

   def hybrid_forward(self, F, x):
      return F.broadcast_div(F.broadcast_sub(x, F.min(x)), (F.broadcast_sub(F.max(x), F.min(x))))

layer_hybd = NormalizationHybridLayer()
layer_hybd(nd.array([1, 2, 3, 4, 5, 6], ctx=mx.cpu()))

Output

Dane wyjściowe podano poniżej:

[0. 0.2 0.4 0.6 0.8 1. ]
<NDArray 6 @cpu(0)>

Hybrydyzacja nie ma nic wspólnego z obliczeniami na GPU i można trenować zarówno sieci hybrydowe, jak i niehybrydyzowane zarówno na CPU, jak i GPU.

Różnica między Block i HybridBlock

Jeśli porównamy Block Klasa i HybridBlock, zobaczymy to HybridBlock już ma forward() wdrożona metoda. HybridBlock definiuje hybrid_forward()metoda, którą należy zaimplementować podczas tworzenia warstw. Argument F tworzy główną różnicę międzyforward() i hybrid_forward(). W społeczności MXNet argument F nazywany jest backendem. F może odnosić się domxnet.ndarray API (używane do programowania imperatywnego) lub mxnet.symbol API (używane do programowania symbolicznego).

Jak dodać niestandardową warstwę do sieci?

Zamiast osobno używać warstw niestandardowych, warstwy te są używane ze wstępnie zdefiniowanymi warstwami. Możemy użyć alboSequential lub HybridSequentialkontenery z sekwencyjnej sieci neuronowej. Jak wspomniano wcześniej,Sequential kontener dziedziczenie z Block i HybridSequential dziedziczyć z HybridBlock odpowiednio.

Przykład

W poniższym przykładzie utworzymy prostą sieć neuronową z niestandardową warstwą. Dane wyjściowe zDense (5) warstwa będzie wartością wejściową NormalizationHybridLayer. WyjścieNormalizationHybridLayer stanie się wkładem Dense (1) warstwa.

net = gluon.nn.HybridSequential()
with net.name_scope():
net.add(Dense(5))
net.add(NormalizationHybridLayer())
net.add(Dense(1))
net.initialize(mx.init.Xavier(magnitude=2.24))
net.hybridize()
input = nd.random_uniform(low=-10, high=10, shape=(10, 2))
net(input)

Output

Zobaczysz następujący wynik -

[[-1.1272651]
 [-1.2299833]
 [-1.0662932]
 [-1.1805027]
 [-1.3382034]
 [-1.2081106]
 [-1.1263978]
 [-1.2524893]
 
 [-1.1044774]

 [-1.316593 ]]
<NDArray 10x1 @cpu(0)>

Niestandardowe parametry warstw

W sieci neuronowej z warstwą jest skojarzony zestaw parametrów. Czasami nazywamy je wagami, czyli stanem wewnętrznym warstwy. Te parametry odgrywają różne role -

• Czasami są to te, których chcemy się nauczyć podczas kroku wstecznej propagacji.

• Czasami są to tylko stałe, których chcemy użyć podczas przejścia do przodu.

Jeśli mówimy o koncepcji programowania, te parametry (wagi) bloku są przechowywane i dostępne za pośrednictwem ParameterDict klasa, która pomaga w ich inicjalizacji, aktualizacji, zapisywaniu i ładowaniu.

Przykład

W poniższym przykładzie zdefiniujemy dwa następujące zestawy parametrów -

• Parameter weights- Można to trenować, a jego kształt jest nieznany na etapie budowy. Zostanie to wywnioskowane podczas pierwszego przebiegu propagacji do przodu.

• Parameter scale- To stała, której wartość się nie zmienia. W przeciwieństwie do wag parametrów, jego kształt jest określany podczas budowy.

class NormalizationHybridLayer(gluon.HybridBlock):
   def __init__(self, hidden_units, scales):
      super(NormalizationHybridLayer, self).__init__()
      with self.name_scope():
      self.weights = self.params.get('weights',
      shape=(hidden_units, 0),
      allow_deferred_init=True)
      self.scales = self.params.get('scales',
         shape=scales.shape,
         init=mx.init.Constant(scales.asnumpy()),
         differentiable=False)
      def hybrid_forward(self, F, x, weights, scales):
         normalized_data = F.broadcast_div(F.broadcast_sub(x, F.min(x)),
         (F.broadcast_sub(F.max(x), F.min(x))))
         weighted_data = F.FullyConnected(normalized_data, weights, num_hidden=self.weights.shape[0], no_bias=True)
         scaled_data = F.broadcast_mul(scales, weighted_data)
return scaled_data

W tym rozdziale omówiono pakiety KVStore w języku Python oraz wizualizację.

Pakiet KVStore

Sklepy KV to skrót od Key-Value store. Jest to krytyczny komponent używany do treningu na wielu urządzeniach. Jest to ważne, ponieważ komunikacja parametrów między urządzeniami na jednym, a także na wielu maszynach jest przesyłana przez jeden lub więcej serwerów z KVStore dla parametrów.

Zrozummy działanie KVStore za pomocą następujących punktów:

• Każda wartość w KVStore jest reprezentowana przez key i a value.

• Każda tablica parametrów w sieci ma przypisany plik key a wagi tej tablicy parametrów są określane przez value.

• Następnie węzły robocze pushgradienty po przetworzeniu partii. Oni teżpull zaktualizowane wagi przed przetworzeniem nowej partii.

Krótko mówiąc, możemy powiedzieć, że KVStore to miejsce udostępniania danych, w którym każde urządzenie może przesyłać i pobierać dane.

Dane push-in i pull-out

KVStore można traktować jako pojedynczy obiekt współdzielony przez różne urządzenia, takie jak GPU i komputery, gdzie każde urządzenie może wprowadzać i pobierać dane.

Poniżej przedstawiono kroki implementacji, które muszą wykonać urządzenia, aby wypychać i pobierać dane:

Etapy wdrażania

Initialisation- Pierwszym krokiem jest zainicjowanie wartości. Tutaj, dla naszego przykładu, zainicjujemy parę (int, NDArray) w KVStrore, a następnie wyciągniemy wartości -

import mxnet as mx
kv = mx.kv.create('local') # create a local KVStore.
shape = (3,3)
kv.init(3, mx.nd.ones(shape)*2)
a = mx.nd.zeros(shape)
kv.pull(3, out = a)
print(a.asnumpy())

Output

Daje to następujący wynik -

[[2. 2. 2.]
[2. 2. 2.]
[2. 2. 2.]]

Push, Aggregate, and Update - Po zainicjowaniu możemy przesłać nową wartość do KVStore o tym samym kształcie do klucza -

kv.push(3, mx.nd.ones(shape)*8)
kv.pull(3, out = a)
print(a.asnumpy())

Output

Dane wyjściowe podano poniżej -

[[8. 8. 8.]
 [8. 8. 8.]
 [8. 8. 8.]]

Dane używane do wypychania mogą być przechowywane na dowolnym urządzeniu, takim jak GPU lub komputery. Możemy również wprowadzić wiele wartości do tego samego klucza. W takim przypadku KVStore najpierw zsumuje wszystkie te wartości, a następnie przekaże zagregowaną wartość w następujący sposób -

contexts = [mx.cpu(i) for i in range(4)]
b = [mx.nd.ones(shape, ctx) for ctx in contexts]
kv.push(3, b)
kv.pull(3, out = a)
print(a.asnumpy())

Output

Zobaczysz następujący wynik -

[[4. 4. 4.]
 [4. 4. 4.]
 [4. 4. 4.]]

Dla każdego zastosowanego wypchnięcia KVStore połączy przekazaną wartość z wartością już zapisaną. Zostanie to zrobione za pomocą aktualizatora. Tutaj domyślnym aktualizatorem jest ASSIGN.

def update(key, input, stored):
   print("update on key: %d" % key)
   
   stored += input * 2
kv.set_updater(update)
kv.pull(3, out=a)
print(a.asnumpy())

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[[4. 4. 4.]
 [4. 4. 4.]
 [4. 4. 4.]]

Example

kv.push(3, mx.nd.ones(shape))
kv.pull(3, out=a)
print(a.asnumpy())

Output

Poniżej podano wynik kodu -

update on key: 3
[[6. 6. 6.]
 [6. 6. 6.]
 [6. 6. 6.]]

Pull - Podobnie jak w przypadku Push, możemy również przeciągnąć wartość na kilka urządzeń jednym wywołaniem w następujący sposób -

b = [mx.nd.ones(shape, ctx) for ctx in contexts]
kv.pull(3, out = b)
print(b[1].asnumpy())

Output

Dane wyjściowe podano poniżej -

[[6. 6. 6.]
 [6. 6. 6.]
 [6. 6. 6.]]

Pełny przykład implementacji

Poniżej podano pełny przykład wdrożenia -

import mxnet as mx
kv = mx.kv.create('local')
shape = (3,3)
kv.init(3, mx.nd.ones(shape)*2)
a = mx.nd.zeros(shape)
kv.pull(3, out = a)
print(a.asnumpy())
kv.push(3, mx.nd.ones(shape)*8)
kv.pull(3, out = a) # pull out the value
print(a.asnumpy())
contexts = [mx.cpu(i) for i in range(4)]
b = [mx.nd.ones(shape, ctx) for ctx in contexts]
kv.push(3, b)
kv.pull(3, out = a)
print(a.asnumpy())
def update(key, input, stored):
   print("update on key: %d" % key)
   stored += input * 2
kv._set_updater(update)
kv.pull(3, out=a)
print(a.asnumpy())
kv.push(3, mx.nd.ones(shape))
kv.pull(3, out=a)
print(a.asnumpy())
b = [mx.nd.ones(shape, ctx) for ctx in contexts]
kv.pull(3, out = b)
print(b[1].asnumpy())

Obsługa par klucz-wartość

Wszystkie operacje, które zaimplementowaliśmy powyżej, dotyczą jednego klucza, ale KVStore zapewnia również interfejs dla a list of key-value pairs -

Dla jednego urządzenia

Poniżej znajduje się przykład pokazujący interfejs KVStore dla listy par klucz-wartość dla jednego urządzenia -

keys = [5, 7, 9]
kv.init(keys, [mx.nd.ones(shape)]*len(keys))
kv.push(keys, [mx.nd.ones(shape)]*len(keys))
b = [mx.nd.zeros(shape)]*len(keys)
kv.pull(keys, out = b)
print(b[1].asnumpy())

Output

Otrzymasz następujący wynik -

update on key: 5
update on key: 7
update on key: 9
[[3. 3. 3.]
 [3. 3. 3.]
 [3. 3. 3.]]

Dla wielu urządzeń

Poniżej znajduje się przykład pokazujący interfejs KVStore dla listy par klucz-wartość dla wielu urządzeń -

b = [[mx.nd.ones(shape, ctx) for ctx in contexts]] * len(keys)
kv.push(keys, b)
kv.pull(keys, out = b)
print(b[1][1].asnumpy())

Output

Zobaczysz następujący wynik -

update on key: 5
update on key: 7
update on key: 9
[[11. 11. 11.]
 [11. 11. 11.]
 [11. 11. 11.]]

Pakiet wizualizacji

Pakiet wizualizacji to pakiet Apache MXNet używany do reprezentowania sieci neuronowej (NN) jako grafu obliczeniowego składającego się z węzłów i krawędzi.

Wizualizuj sieć neuronową

W poniższym przykładzie użyjemy mx.viz.plot_networkwizualizacja sieci neuronowej. Następujące są warunki wstępne -

Prerequisites

• Notatnik Jupyter

• Biblioteka Graphviz

Przykład implementacji

W poniższym przykładzie zwizualizujemy próbkę NN dla liniowej faktoryzacji macierzy -

import mxnet as mx
user = mx.symbol.Variable('user')
item = mx.symbol.Variable('item')
score = mx.symbol.Variable('score')

# Set the dummy dimensions
k = 64
max_user = 100
max_item = 50

# The user feature lookup
user = mx.symbol.Embedding(data = user, input_dim = max_user, output_dim = k)

# The item feature lookup
item = mx.symbol.Embedding(data = item, input_dim = max_item, output_dim = k)

# predict by the inner product and then do sum
N_net = user * item
N_net = mx.symbol.sum_axis(data = N_net, axis = 1)
N_net = mx.symbol.Flatten(data = N_net)

# Defining the loss layer
N_net = mx.symbol.LinearRegressionOutput(data = N_net, label = score)

# Visualize the network
mx.viz.plot_network(N_net)

W tym rozdziale opisano bibliotekę ndarray, która jest dostępna w Apache MXNet.

Mxnet.ndarray

Biblioteka NDArray Apache MXNet definiuje podstawowe DS (struktury danych) dla wszystkich obliczeń matematycznych. Dwa podstawowe zadania NDArray są następujące -

• Obsługuje szybkie wykonywanie w szerokiej gamie konfiguracji sprzętowych.

• Automatycznie synchronizuje wiele operacji na dostępnym sprzęcie.

Poniższy przykład pokazuje, jak można utworzyć tablicę NDArray, używając „tablicy” 1-W i 2-W ze zwykłej listy Pythona -

import mxnet as mx
from mxnet import nd

x = nd.array([1,2,3,4,5,6,7,8,9,10])
print(x)

Output

Wynik podano poniżej:

[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
<NDArray 10 @cpu(0)>

Example

y = nd.array([[1,2,3,4,5,6,7,8,9,10], [1,2,3,4,5,6,7,8,9,10], [1,2,3,4,5,6,7,8,9,10]])
print(y)

Output

Daje to następujący wynik -

[[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
 [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
 [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]]
<NDArray 3x10 @cpu(0)>

Omówmy teraz szczegółowo klasy, funkcje i parametry API ndarray w MXNet.

Zajęcia

Poniższa tabela zawiera klasy ndarray API MXNet -

Klasa	Definicja
CachedOp (sym [, flagi])	Jest używany do uchwytu operatora w pamięci podręcznej.
NDArray (uchwyt [, z możliwością zapisu])	Jest używany jako obiekt tablicy, który reprezentuje wielowymiarową, jednorodną tablicę elementów o stałym rozmiarze.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów, które obejmuje interfejs API mxnet.ndarray -

Funkcja i jej parametry	Definicja
Activation([dane, typ_aktu, wyjście, nazwa])	Stosuje elementową funkcję aktywacji do wejścia. Obsługuje funkcje aktywacji relu, sigmoid, tanh, softrelu, softsign.
BatchNorm([dane, gamma, beta, move_mean,…])	Służy do normalizacji partii. Ta funkcja normalizuje pakiet danych przez średnią i wariancję. Stosuje skalę gamma i offset beta.
BilinearSampler([dane, siatka, cudnn_off,…])	Ta funkcja stosuje próbkowanie bilinearne do mapy obiektów wejściowych. Właściwie jest to klucz do „Przestrzennych sieci transformatorowych”. Jeśli znasz funkcję remapowania w OpenCV, użycie tej funkcji jest dość podobne. Jedyną różnicą jest to, że ma przejście do tyłu.
BlockGrad ([dane, wyjście, nazwa])	Jak nazwa wskazuje, funkcja ta zatrzymuje obliczenia gradientu. Zasadniczo powstrzymuje nagromadzony gradient danych wejściowych przed przepływem przez tego operatora w kierunku wstecznym.
cast ([data, dtype, out, name])	Ta funkcja będzie rzutować wszystkie elementy wejścia na nowy typ.

Przykłady wdrożeń

W poniższym przykładzie użyjemy funkcji BilinierSampler () do dwukrotnego pomniejszenia danych i przesunięcia danych w poziomie o -1 piksel -

import mxnet as mx
from mxnet import nd
data = nd.array([[[[2, 5, 3, 6],
   [1, 8, 7, 9],
   [0, 4, 1, 8],
   [2, 0, 3, 4]]]])
affine_matrix = nd.array([[2, 0, 0],
   [0, 2, 0]])

affine_matrix = nd.reshape(affine_matrix, shape=(1, 6))

grid = nd.GridGenerator(data=affine_matrix, transform_type='affine', target_shape=(4, 4))

output = nd.BilinearSampler(data, grid)

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe:

[[[[0. 0. 0. 0. ]
   [0. 4.0000005 6.25 0. ]
   [0. 1.5 4. 0. ]
   [0. 0. 0. 0. ]]]]
<NDArray 1x1x4x4 @cpu(0)>

Powyższe dane wyjściowe pokazują dwukrotne pomniejszenie danych.

Przykład przesunięcia danych o -1 piksel jest następujący -

import mxnet as mx
from mxnet import nd
data = nd.array([[[[2, 5, 3, 6],
   [1, 8, 7, 9],
   [0, 4, 1, 8],
   [2, 0, 3, 4]]]])
warp_matrix = nd.array([[[[1, 1, 1, 1],
   [1, 1, 1, 1],
   [1, 1, 1, 1],
   [1, 1, 1, 1]],
   [[0, 0, 0, 0],
   [0, 0, 0, 0],
   [0, 0, 0, 0],
   [0, 0, 0, 0]]]])
grid = nd.GridGenerator(data=warp_matrix, transform_type='warp')
output = nd.BilinearSampler(data, grid)

Output

Dane wyjściowe podano poniżej -

[[[[5. 3. 6. 0.]
[8. 7. 9. 0.]
[4. 1. 8. 0.]
[0. 3. 4. 0.]]]]
<NDArray 1x1x4x4 @cpu(0)>

Podobnie, poniższy przykład pokazuje użycie funkcji cast () -

nd.cast(nd.array([300, 10.1, 15.4, -1, -2]), dtype='uint8')

Output

Po wykonaniu otrzymasz następujące dane wyjściowe -

[ 44 10 15 255 254]
<NDArray 5 @cpu(0)>

ndarray.contrib

Interfejs API Contrib NDArray jest zdefiniowany w pakiecie ndarray.contrib. Zwykle zapewnia wiele przydatnych eksperymentalnych interfejsów API dla nowych funkcji. Ten interfejs API działa jako miejsce dla społeczności, w którym mogą wypróbować nowe funkcje. Współtwórca funkcji również otrzyma opinię.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.ndarray.contrib API -

Funkcja i jej parametry	Definicja
rand_zipfian(true_classes, num_sampled,…)	Ta funkcja pobiera losowe próbki z przybliżonej dystrybucji Zipfian. Podstawowym rozkładem tej funkcji jest rozkład Zipfian. Ta funkcja losowo próbkuje num_sampled kandydatów, a elementy sampled_candidates są pobierane z podstawowego rozkładu podanego powyżej.
foreach(body, data, init_states)	Jak sama nazwa wskazuje, ta funkcja uruchamia pętlę for z obliczeniami zdefiniowanymi przez użytkownika na tablicach NDArrays w wymiarze 0. Ta funkcja symuluje pętlę for, a treść wykonuje obliczenia dla iteracji pętli for.
while_loop (cond, func, loop_vars [,…])	Jak sama nazwa wskazuje, ta funkcja uruchamia pętlę while z obliczeniami zdefiniowanymi przez użytkownika i warunkiem pętli. Ta funkcja symuluje pętlę while, która dosłownie wykonuje niestandardowe obliczenia, jeśli warunek jest spełniony.
cond(pred, then_func, else_func)	Jak sama nazwa wskazuje, ta funkcja uruchamia warunek if-then-else przy użyciu warunku zdefiniowanego przez użytkownika i obliczeń. Ta funkcja symuluje gałąź if-like, która wybiera wykonanie jednego z dwóch obliczeń dostosowanych do określonego warunku.
isinf(dane)	Ta funkcja przeprowadza kontrolę elementów w celu określenia, czy NDArray zawiera element nieskończony, czy nie.
getnnz([dane, oś, wyjście, nazwa])	Ta funkcja daje nam liczbę przechowywanych wartości dla rzadkiego tensora. Zawiera również wyraźne zera. Obsługuje tylko macierz CSR na procesorze.
rekwantizować ([dane, zakres_min, zakres_maksymalny,…])	Ta funkcja wymienia dane dane, które są kwantyzowane w int32 i odpowiadające im progi, do int8 przy użyciu minimalnych i maksymalnych progów obliczonych w czasie wykonywania lub kalibracji.

Przykłady wdrożeń

W poniższym przykładzie będziemy używać funkcji rand_zipfian do rysowania losowych próbek z dystrybucji w przybliżeniu Zipfian -

import mxnet as mx
from mxnet import nd
trueclass = mx.nd.array([2])
samples, exp_count_true, exp_count_sample = mx.nd.contrib.rand_zipfian(trueclass, 3, 4)
samples

Output

Zobaczysz następujący wynik -

[0 0 1]
<NDArray 3 @cpu(0)>

Example

exp_count_true

Output

Wynik podano poniżej:

[0.53624076]
<NDArray 1 @cpu(0)>

Example

exp_count_sample

Output

Daje to następujący wynik:

[1.29202967 1.29202967 0.75578891]
<NDArray 3 @cpu(0)>

W poniższym przykładzie będziemy używać funkcji while_loop do uruchamiania pętli while dla obliczeń zdefiniowanych przez użytkownika i warunku pętli:

cond = lambda i, s: i <= 7
func = lambda i, s: ([i + s], [i + 1, s + i])
loop_var = (mx.nd.array([0], dtype="int64"), mx.nd.array([1], dtype="int64"))
outputs, states = mx.nd.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
outputs

Output

Wyjście pokazano poniżej -

[
[[       1]
 [      2]
 [      4]
 [      7]
 [     11]
 [     16]
 [     22]
 [     29]
 [3152434450384]
 [     257]]
<NDArray 10x1 @cpu(0)>]

Example

States

Output

Daje to następujący wynik -

[
[8]
<NDArray 1 @cpu(0)>,
[29]
<NDArray 1 @cpu(0)>]

ndarray.image

Interfejs API Image NDArray jest zdefiniowany w pakiecie ndarray.image. Jak sama nazwa wskazuje, jest on zwykle używany do obrazów i ich funkcji.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.ndarray.image API-

Funkcja i jej parametry	Definicja
adjust_lighting([dane, alfa, wyjście, nazwa])	Jak sama nazwa wskazuje, funkcja ta dostosowuje poziom oświetlenia wejścia. Jest zgodny ze stylem AlexNet.
crop([dane, x, y, szerokość, wysokość, na zewnątrz, nazwa])	Za pomocą tej funkcji możemy przyciąć obraz NDArray o kształcie (H x W x C) lub (N x H x W x C) do rozmiaru podanego przez użytkownika.
normalize([dane, średnia, std, out, nazwa])	Normalizuje tensor kształtu (C x H x W) lub (N x C x H x W) z mean i standard deviation(SD).
random_crop ([dane, xrange, yrange, width,…])	Podobnie jak crop (), losowo przycina obraz NDArray kształtu (H x W x C) lub (N x H x W x C) do rozmiaru podanego przez użytkownika. Będzie próbkować wynik, jeśli src jest mniejszy niż rozmiar.
random_lighting([data, alpha_std, out, name])	Jak sama nazwa wskazuje, funkcja ta losowo dodaje szum PCA. Jest również zgodny ze stylem AlexNet.
random_resized_crop([dane, xrange, yrange,…])	Przycina również losowo obraz NDArray o kształcie (wys. X szer. X gł.) Lub (szer. X wys. X szer. X gł.) Do podanego rozmiaru. Będzie próbkować wynik, jeśli src jest mniejsze niż rozmiar. Spowoduje to również losowanie obszaru i współczynnika kształtu.
resize([dane, rozmiar, współczynnik zachowania, interp,…])	Jak sama nazwa wskazuje, ta funkcja zmieni rozmiar obrazu NDArray kształtu (wys. X szer. X gł.) Lub (szer. X szer. X gł.) Do rozmiaru podanego przez użytkownika.
to_tensor([dane, out, nazwa])	Konwertuje obraz NDArray kształtu (H x W x C) lub (N x H x W x C) z wartościami z zakresu [0, 255] na tensor NDArray kształtu (C x H x W) lub ( N x C x H x W) z wartościami z zakresu [0, 1].

Przykłady wdrożeń

W poniższym przykładzie użyjemy funkcji to_tensor do konwersji obrazu NDArray kształtu (H x W x C) lub (N x H x W x C) z wartościami z zakresu [0, 255] na tensor NDArray kształtu (C x H x W) lub (N x C x H x W) z wartościami z zakresu [0, 1].

import numpy as np
img = mx.nd.random.uniform(0, 255, (4, 2, 3)).astype(dtype=np.uint8)
mx.nd.image.to_tensor(img)

Output

Zobaczysz następujący wynik -

[[[0.972549 0.5058824 ]
   [0.6039216 0.01960784]
   [0.28235295 0.35686275]
   [0.11764706 0.8784314 ]]

[[0.8745098 0.9764706 ]
   [0.4509804 0.03529412]
   [0.9764706 0.29411766]
   [0.6862745 0.4117647 ]]

[[0.46666667 0.05490196]
   [0.7372549 0.4392157 ]
   [0.11764706 0.47843137]
   [0.31764707 0.91764706]]]
<NDArray 3x4x2 @cpu(0)>

Example

img = mx.nd.random.uniform(0, 255, (2, 4, 2, 3)).astype(dtype=np.uint8)

mx.nd.image.to_tensor(img)

Output

Po uruchomieniu kodu zobaczysz następujące dane wyjściowe -

[[[[0.0627451 0.5647059 ]
[0.2627451 0.9137255 ]
[0.57254905 0.27450982]
[0.6666667 0.64705884]]
[[0.21568628 0.5647059 ]
[0.5058824 0.09019608]
[0.08235294 0.31764707]
[0.8392157 0.7137255 ]]
[[0.6901961 0.8627451 ]
[0.52156866 0.91764706]
[0.9254902 0.00784314]
[0.12941177 0.8392157 ]]]
[[[0.28627452 0.39607844]
[0.01960784 0.36862746]
[0.6745098 0.7019608 ]
[0.9607843 0.7529412 ]]
[[0.2627451 0.58431375]
[0.16470589 0.00392157]
[0.5686275 0.73333335]
[0.43137255 0.57254905]]
[[0.18039216 0.54901963]
[0.827451 0.14509805]
[0.26666668 0.28627452]
[0.24705882 0.39607844]]]]
<NDArgt;ray 2x3x4x2 @cpu(0)>

W poniższym przykładzie będziemy używać funkcji normalize normalizować tensor kształtu (C x H x W) lub (N x C x H x W) za pomocą mean i standard deviation(SD).

img = mx.nd.random.uniform(0, 1, (3, 4, 2))

mx.nd.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))

Output

Daje to następujący wynik -

[[[ 0.29391178 0.3218054 ]
[ 0.23084386 0.19615503]
[ 0.24175143 0.21988946]
[ 0.16710812 0.1777354 ]]
[[-0.02195817 -0.3847335 ]
[-0.17800489 -0.30256534]
[-0.28807247 -0.19059572]
[-0.19680339 -0.26256624]]
[[-1.9808068 -1.5298678 ]
[-1.6984252 -1.2839255 ]
[-1.3398265 -1.712009 ]
[-1.7099224 -1.6165378 ]]]
<NDArray 3x4x2 @cpu(0)>

Example

img = mx.nd.random.uniform(0, 1, (2, 3, 4, 2))

mx.nd.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[[[[ 2.0600514e-01 2.4972327e-01]
[ 1.4292289e-01 2.9281738e-01]
[ 4.5158025e-02 3.4287784e-02]
[ 9.9427439e-02 3.0791296e-02]]
[[-2.1501756e-01 -3.2297665e-01]
[-2.0456362e-01 -2.2409186e-01]
[-2.1283737e-01 -4.8318747e-01]
[-1.7339960e-01 -1.5519112e-02]]
[[-1.3478968e+00 -1.6790028e+00]
[-1.5685816e+00 -1.7787373e+00]
[-1.1034534e+00 -1.8587360e+00]
[-1.6324382e+00 -1.9027401e+00]]]
[[[ 1.4528830e-01 3.2801408e-01]
[ 2.9730779e-01 8.6780310e-02]
[ 2.6873133e-01 1.7900752e-01]
[ 2.3462953e-01 1.4930873e-01]]
[[-4.4988656e-01 -4.5021546e-01]
[-4.0258706e-02 -3.2384416e-01]
[-1.4287934e-01 -2.6537544e-01]
[-5.7649612e-04 -7.9429924e-02]]
[[-1.8505517e+00 -1.0953522e+00]
[-1.1318740e+00 -1.9624406e+00]
[-1.8375070e+00 -1.4916846e+00]
[-1.3844404e+00 -1.8331525e+00]]]]
<NDArray 2x3x4x2 @cpu(0)>

ndarray.random

Random NDArray API jest zdefiniowany w pakiecie ndarray.random. Jak sama nazwa wskazuje, jest to NDArray API generatora dystrybucji losowej MXNet.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.ndarray.random API -

Funkcja i jej parametry	Definicja
jednolity ([niski, wysoki, kształt, dtype, ctx, out])	Generuje losowe próbki z jednolitego rozkładu.
normalny ([loc, skala, kształt, dtype, ctx, out])	Generuje losowe próbki z rozkładu normalnego (Gaussa).
randn (* kształt, ** kwargs)	Generuje losowe próbki z rozkładu normalnego (Gaussa).
wykładniczy ([skala, kształt, dtype, ctx, out])	Generuje próbki z rozkładu wykładniczego.
gamma ([alpha, beta, shape, dtype, ctx, out])	Generuje losowe próbki z rozkładu gamma.
wielomian (dane [, kształt, get_prob, out, dtype])	Generuje równoczesne próbkowanie z wielu wielomianowych rozkładów.
minus_binomial ([k, p, kształt, dtype, ctx, out])	Generuje losowe próbki z ujemnego rozkładu dwumianowego.
generalized_negative_binomial ([mu, alfa,…])	Generuje losowe próbki z uogólnionego ujemnego rozkładu dwumianowego.
shuffle (dane, ** kwargs)	Losowo tasuje elementy.
randint (low, high [, shape, dtype, ctx, out])	Generuje losowe próbki z dyskretnego, jednolitego rozkładu.
exponential_like ([data, lam, out, name])	Generuje losowe próbki z rozkładu wykładniczego zgodnie z kształtem tablicy wejściowej.
gamma_like ([dane, alfa, beta, wyjście, nazwa])	Generuje losowe próbki z rozkładu gamma zgodnie z kształtem tablicy wejściowej.
generalized_negative_binomial_like ([dane,…])	Generuje losowe próbki z uogólnionego ujemnego rozkładu dwumianowego, zgodnie z kształtem tablicy wejściowej.
negatywne_binomialne_jakie ([dane, k, p, wyj, nazwa])	Generuje losowe próbki z ujemnego rozkładu dwumianowego, zgodnie z kształtem tablicy wejściowej.
normal_like ([data, loc, scale, out, name])	Generuje losowe próbki z rozkładu normalnego (Gaussa), zgodnie z kształtem tablicy wejściowej.
poisson_like ([dane, lam, out, nazwa])	Generuje losowe próbki z rozkładu Poissona, zgodnie z kształtem tablicy wejściowej.
uniform_like ([dane, low, high, out, name])	Generuje losowe próbki z jednorodnej dystrybucji, zgodnie z kształtem tablicy wejściowej.

Przykłady wdrożeń

W poniższym przykładzie narysujemy losowe próbki z jednolitego rozkładu. Do tego będzie używać funkcjiuniform().

mx.nd.random.uniform(0, 1)

Output

Dane wyjściowe są wymienione poniżej -

[0.12381998]
<NDArray 1 @cpu(0)>

Example

mx.nd.random.uniform(-1, 1, shape=(2,))

Output

Dane wyjściowe podano poniżej -

[0.558102 0.69601643]
<NDArray 2 @cpu(0)>

Example

low = mx.nd.array([1,2,3])
high = mx.nd.array([2,3,4])
mx.nd.random.uniform(low, high, shape=2)

Output

Zobaczysz następujący wynik -

[[1.8649333 1.8073189]
 [2.4113967 2.5691009]
 [3.1399727 3.4071832]]
<NDArray 3x2 @cpu(0)>

W poniższym przykładzie narysujemy losowe próbki z uogólnionego ujemnego rozkładu dwumianowego. W tym celu będziemy używać funkcjigeneralized_negative_binomial().

mx.nd.random.generalized_negative_binomial(10, 0.5)

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[1.]
<NDArray 1 @cpu(0)>

Example

mx.nd.random.generalized_negative_binomial(10, 0.5, shape=(2,))

Output

Dane wyjściowe podano niniejszym -

[16. 23.]
<NDArray 2 @cpu(0)>

Example

mu = mx.nd.array([1,2,3])
alpha = mx.nd.array([0.2,0.4,0.6])
mx.nd.random.generalized_negative_binomial(mu, alpha, shape=2)

Output

Poniżej podano wynik kodu -

[[0. 0.]
 [4. 1.]
 [9. 3.]]
<NDArray 3x2 @cpu(0)>

ndarray.utils

Narzędzie NDArray API jest zdefiniowane w pakiecie ndarray.utils. Jak sama nazwa wskazuje, zapewnia funkcje narzędziowe dla NDArray i BaseSparseNDArray.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.ndarray.utils API -

Funkcja i jej parametry	Definicja
zera (kształt [, ctx, dtype, stype])	Ta funkcja zwróci nową tablicę o podanym kształcie i typie, wypełnioną zerami.
pusty (shape [, ctx, dtype, stype])	Zwróci nową tablicę o podanym kształcie i typie, bez inicjalizacji wpisów.
tablica (tablica_źródłowa [, ctx, dtype])	Jak sama nazwa wskazuje, funkcja ta utworzy tablicę z dowolnego obiektu ujawniającego interfejs tablicy.
załaduj (fname)	Załaduje tablicę z pliku.
load_frombuffer (buf)	Jak sama nazwa wskazuje, funkcja ta załaduje słownik tablicowy lub listę z bufora
zapisz (fname, dane)	Ta funkcja zapisze listę tablic lub dyktę str-> array do pliku.

Przykłady wdrożeń

W poniższym przykładzie zwrócimy nową tablicę o podanym kształcie i typie, wypełnioną zerami. W tym celu będziemy używać funkcjizeros().

mx.nd.zeros((1,2), mx.cpu(), stype='csr')

Output

Daje to następujący wynik -

<CSRNDArray 1x2 @cpu(0)>

Example

mx.nd.zeros((1,2), mx.cpu(), 'float16', stype='row_sparse').asnumpy()

Output

Otrzymasz następujący wynik -

array([[0., 0.]], dtype=float16)

W poniższym przykładzie zapiszemy listę tablic i słownik ciągów. W tym celu będziemy używać funkcjisave().

Example

x = mx.nd.zeros((2,3))
y = mx.nd.ones((1,4))
mx.nd.save('list', [x,y])
mx.nd.save('dict', {'x':x, 'y':y})
mx.nd.load('list')

Output

Po wykonaniu otrzymasz następujące dane wyjściowe -

[
[[0. 0. 0.]
[0. 0. 0.]]
<NDArray 2x3 @cpu(0)>,
[[1. 1. 1. 1.]]
<NDArray 1x4 @cpu(0)>]

Example

mx.nd.load('my_dict')

Output

Wyjście pokazano poniżej -

{'x':
[[0. 0. 0.]
[0. 0. 0.]]
<NDArray 2x3 @cpu(0)>, 'y':
[[1. 1. 1. 1.]]
<NDArray 1x4 @cpu(0)>}

Jak już omówiliśmy w poprzednich rozdziałach, MXNet Gluon zapewnia przejrzyste, zwięzłe i proste API dla projektów DL. Umożliwia Apache MXNet prototypowanie, budowanie i trenowanie modeli DL bez utraty szybkości szkolenia.

Moduły podstawowe

Poznajmy podstawowe moduły interfejsu programowania aplikacji (API) gluon Apache MXNet Python.

gluon.nn

Gluon zapewnia dużą liczbę wbudowanych warstw NN w module gluon.nn. Z tego powodu nazywa się go modułem podstawowym.

Metody i ich parametry

Poniżej przedstawiono niektóre z ważnych metod i ich parametrów objętych mxnet.gluon.nn moduł podstawowy -

Metody i ich parametry	Definicja
Aktywacja (aktywacja, ** kwargs)	Jak sama nazwa wskazuje, ta metoda stosuje funkcję aktywacji do wejścia.
AvgPool1D ([pool_size, strides, padding,…])	Jest to średnia operacja łączenia danych czasowych.
AvgPool2D ([pool_size, strides, padding,…])	Jest to średnia operacja łączenia danych przestrzennych.
AvgPool3D ([pool_size, strides, padding,…])	Jest to operacja puli średniej dla danych 3D. Dane mogą być przestrzenne lub czasoprzestrzenne.
BatchNorm ([oś, pęd, epsilon, środek,…])	Reprezentuje warstwę normalizacji partii.
BatchNormReLU ([oś, pęd, epsilon,…])	Reprezentuje również warstwę normalizacji partii, ale z funkcją aktywacji Relu.
Blok ([prefiks, parametry])	Daje klasę bazową dla wszystkich warstw i modeli sieci neuronowych.
Conv1D (kanały, kernel_size [, strides,…])	Ta metoda jest stosowana dla warstwy splotu 1-D. Na przykład splot czasowy.
Conv1DTranspose (kanały, rozmiar_kernela [,…])	Ta metoda jest używana dla warstwy splotu transponowanego 1D.
Conv2D (kanały, kernel_size [, strides,…])	Ta metoda jest używana dla warstwy splotu 2D. Na przykład splot przestrzenny na obrazach).
Conv2DTranspose (kanały, rozmiar_kernela [,…])	Ta metoda jest używana w przypadku transponowanej warstwy splotu 2D.
Conv3D (kanały, kernel_size [, strides,…])	Ta metoda jest używana dla warstwy splotu 3D. Na przykład splot przestrzenny w objętości.
Conv3DTranspose (kanały, rozmiar_kernela [,…])	Ta metoda jest używana w przypadku warstwy splotu transponowanego 3D.
Gęsty (jednostki [, aktywacja, użycie_bias,…])	Ta metoda reprezentuje zwykłą gęsto połączoną warstwę NN.
Porzucenie (stopa [, osie])	Jak sama nazwa wskazuje, metoda stosuje Dropout na wejściu.
ELU ([alfa])	Ta metoda jest stosowana w przypadku wykładniczych jednostek liniowych (ELU).
Osadzanie (input_dim, output_dim [, dtype,…])	Zamienia nieujemne liczby całkowite w gęste wektory o stałym rozmiarze.
Spłaszcz (** kwargs)	Ta metoda spłaszcza dane wejściowe do 2-D.
GELU (** kwargs)	Ta metoda jest używana dla wykładniczych jednostek liniowych Gaussa (GELU).
GlobalAvgPool1D ([układ])	Za pomocą tej metody możemy wykonać operację globalnego łączenia średniej dla danych czasowych.
GlobalAvgPool2D ([układ])	Za pomocą tej metody możemy wykonać operację globalnego łączenia średnich danych przestrzennych.
GlobalAvgPool3D ([układ])	Za pomocą tej metody możemy wykonać operację globalnego łączenia średniej dla danych 3-D.
GlobalMaxPool1D ([układ])	Za pomocą tej metody możemy wykonać operację globalnego max poolingu dla danych 1-D.
GlobalMaxPool2D ([układ])	Za pomocą tej metody możemy wykonać operację globalnego max poolingu dla danych 2-D.
GlobalMaxPool3D ([układ])	Za pomocą tej metody możemy wykonać operację globalnego max poolingu dla danych trójwymiarowych.
GroupNorm ([num_groups, epsilon, center,…])	Ta metoda stosuje normalizację grupową do tablicy wejściowej nD.
HybridBlock ([prefiks, parametry])	Ta metoda obsługuje przekazywanie z obu Symbol i NDArray.
HybridLambda(funkcja [, przedrostek])	Za pomocą tej metody możemy opakować operator lub wyrażenie jako obiekt HybridBlock.
HybridSequential ([prefiks, parametry])	Układa HybridBlocks sekwencyjnie.
InstanceNorm ([oś, epsilon, środek, skala,…])	Ta metoda stosuje normalizację instancji do tablicy wejściowej nD.

Przykłady wdrożeń

W poniższym przykładzie użyjemy Block (), który podaje klasę bazową dla wszystkich warstw i modeli sieci neuronowych.

from mxnet.gluon import Block, nn
class Model(Block):
   def __init__(self, **kwargs):
      super(Model, self).__init__(**kwargs)
      # use name_scope to give child Blocks appropriate names.
      with self.name_scope():
         self.dense0 = nn.Dense(20)
         self.dense1 = nn.Dense(20)
   def forward(self, x):

      x = mx.nd.relu(self.dense0(x))
      return mx.nd.relu(self.dense1(x))

model = Model()
model.initialize(ctx=mx.cpu(0))
model(mx.nd.zeros((5, 5), ctx=mx.cpu(0)))

Output

Zobaczysz następujący wynik -

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
<NDArray 5x20 @cpu(0)*gt;

W poniższym przykładzie użyjemy HybridBlock (), która obsługuje przekazywanie zarówno z Symbolem, jak i NDArray.

import mxnet as mx
from mxnet.gluon import HybridBlock, nn


class Model(HybridBlock):
   def __init__(self, **kwargs):
      super(Model, self).__init__(**kwargs)
      # use name_scope to give child Blocks appropriate names.
      with self.name_scope():
         self.dense0 = nn.Dense(20)
         self.dense1 = nn.Dense(20)

   def forward(self, x):
      x = nd.relu(self.dense0(x))
      return nd.relu(self.dense1(x))
model = Model()
model.initialize(ctx=mx.cpu(0))

model.hybridize()
model(mx.nd.zeros((5, 5), ctx=mx.cpu(0)))

Output

Dane wyjściowe są wymienione poniżej -

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
<NDArray 5x20 @cpu(0)>

gluon.rnn

Gluon zapewnia dużą liczbę wbudowanych recurrent neural network(RNN) warstwy w module gluon.rnn. Z tego powodu nazywany jest modułem podstawowym.

Metody i ich parametry

Poniżej przedstawiono niektóre z ważnych metod i ich parametrów objętych mxnet.gluon.nn moduł podstawowy:

Metody i ich parametry	Definicja
BidirectionalCell (l_cell, r_cell [,…])	Jest używany w komórce dwukierunkowej sieci neuronowej (RNN).
DropoutCell (stopa [, osie, prefiks, parametry])	Ta metoda zastosuje przerwanie na danym wejściu.
GRU (ukryty_rozmiar [, liczba_warstw, układ,…])	Stosuje wielowarstwową bramkowaną jednostkę rekurencyjną (GRU) RNN do danej sekwencji wejściowej.
GRUCell (hidden_size [,…])	Jest używany w komórce sieciowej Gated Rectified Unit (GRU).
HybridRecurrentCell ([prefiks, parametry])	Ta metoda obsługuje hybrydyzację.
HybridSequentialRNNCell ([prefiks, parametry])	Za pomocą tej metody możemy sekwencyjnie łączyć wiele komórek HybridRNN.
LSTM (hidden_size [, num_layers, layout,…]) 0	Stosuje wielowarstwową pamięć krótkotrwałą (LSTM) RNN do danej sekwencji wejściowej.
LSTMCell (hidden_size [,…])	Jest używany w komórce sieciowej pamięci długoterminowej (LSTM).
ModifierCell (base_cell)	Jest to klasa podstawowa dla komórek modyfikujących.
RNN (hidden_size [, num_layers, aktywacja,…])	Stosuje wielowarstwowy Elman RNN z tanh lub ReLU nieliniowość do danej sekwencji wejściowej.
RNNCell (hidden_size [, aktywacja,…])	Służy do rekurencyjnej komórki sieci neuronowej Elman RNN.
RecurrentCell ([prefiks, parametry])	Reprezentuje abstrakcyjną klasę bazową dla komórek RNN.
SequentialRNNCell ([prefiks, parametry])	Za pomocą tej metody możemy sekwencyjnie układać wiele komórek RNN.
ZoneoutCell (base_cell [, zoneout_outputs,…])	Ta metoda stosuje Zoneout w komórce podstawowej.

Przykłady wdrożeń

W poniższym przykładzie użyjemy GRU (), który stosuje wielowarstwową bramkowaną jednostkę rekurencyjną (GRU) RNN do danej sekwencji wejściowej.

layer = mx.gluon.rnn.GRU(100, 3)
layer.initialize()
input_seq = mx.nd.random.uniform(shape=(5, 3, 10))
out_seq = layer(input_seq)
h0 = mx.nd.random.uniform(shape=(3, 3, 100))
out_seq, hn = layer(input_seq, h0)
out_seq

Output

Daje to następujący wynik -

[[[ 1.50152072e-01 5.19012511e-01 1.02390535e-01 ... 4.35803324e-01
1.30406499e-01 3.30152437e-02]
[ 2.91542172e-01 1.02243155e-01 1.73325196e-01 ... 5.65296151e-02
1.76546033e-02 1.66693389e-01]
[ 2.22257316e-01 3.76294643e-01 2.11277917e-01 ... 2.28903517e-01
3.43954474e-01 1.52770668e-01]]


[[ 1.40634328e-01 2.93247789e-01 5.50393537e-02 ... 2.30207980e-01
6.61415309e-02 2.70989928e-02]
[ 1.11081995e-01 7.20834285e-02 1.08342394e-01 ... 2.28330195e-02
6.79589901e-03 1.25501186e-01]
[ 1.15944080e-01 2.41565228e-01 1.18612610e-01 ... 1.14908054e-01
1.61080107e-01 1.15969211e-01]]
………………………….

Example

hn

Output

Daje to następujący wynik -

[[[-6.08105101e-02 3.86217088e-02   6.64453954e-03 8.18805695e-02
3.85607071e-02 -1.36945639e-02 7.45836645e-03 -5.46515081e-03
9.49622393e-02 6.39371723e-02 -6.37890724e-03 3.82240303e-02
9.11015049e-02 -2.01375950e-02 -7.29381144e-02 6.93765879e-02
2.71829776e-02 -6.64435029e-02 -8.45306814e-02 -1.03075653e-01
6.72040805e-02 -7.06537142e-02 -3.93818803e-02 5.16211614e-03
-4.79770005e-02 1.10734522e-01 1.56721435e-02 -6.93409378e-03
1.16915874e-01 -7.95962065e-02 -3.06530762e-02 8.42394680e-02
7.60370195e-02 2.17055440e-01 9.85361822e-03 1.16660878e-01
4.08297703e-02 1.24978097e-02 8.25245082e-02 2.28673983e-02
-7.88266212e-02 -8.04114193e-02 9.28791538e-02 -5.70827350e-03
-4.46166918e-02 -6.41122833e-02 1.80885363e-02 -2.37745279e-03
4.37298454e-02 1.28888980e-01 -3.07202265e-02 2.50503756e-02
4.00907174e-02 3.37077095e-03 -1.78839862e-02 8.90695080e-02
6.30150884e-02 1.11416787e-01 2.12221760e-02 -1.13236710e-01
5.39616570e-02 7.80710578e-02 -2.28817668e-02 1.92073174e-02
………………………….

W poniższym przykładzie użyjemy LSTM (), która stosuje pamięć długookresową (LSTM) RNN do danej sekwencji wejściowej.

layer = mx.gluon.rnn.LSTM(100, 3)
layer.initialize()

input_seq = mx.nd.random.uniform(shape=(5, 3, 10))
out_seq = layer(input_seq)
h0 = mx.nd.random.uniform(shape=(3, 3, 100))
c0 = mx.nd.random.uniform(shape=(3, 3, 100))
out_seq, hn = layer(input_seq,[h0,c0])
out_seq

Output

Dane wyjściowe są wymienione poniżej -

[[[ 9.00025964e-02 3.96071747e-02 1.83841765e-01 ... 3.95872220e-02
1.25569820e-01 2.15555862e-01]
[ 1.55962542e-01 -3.10300849e-02 1.76772922e-01 ... 1.92474753e-01
2.30574399e-01 2.81707942e-02]
[ 7.83204585e-02 6.53361529e-03 1.27262697e-01 ... 9.97719541e-02
1.28254429e-01 7.55299702e-02]]
[[ 4.41036932e-02 1.35250352e-02 9.87644792e-02 ... 5.89378644e-03
5.23949116e-02 1.00922674e-01]
[ 8.59075040e-02 -1.67027581e-02 9.69351009e-02 ... 1.17763653e-01
9.71239135e-02 2.25218050e-02]
[ 4.34580036e-02 7.62207608e-04 6.37005866e-02 ... 6.14888743e-02
5.96345589e-02 4.72368896e-02]]
……………

Example

hn

Output

Po uruchomieniu kodu zobaczysz następujące dane wyjściowe -

[
[[[ 2.21408084e-02 1.42750628e-02 9.53067932e-03 -1.22849066e-02
1.78788435e-02 5.99269159e-02 5.65306023e-02 6.42553642e-02
6.56616641e-03 9.80876666e-03 -1.15729487e-02 5.98640442e-02
-7.21173314e-03 -2.78371759e-02 -1.90690923e-02 2.21447181e-02
8.38765781e-03 -1.38521893e-02 -9.06938594e-03 1.21346042e-02
6.06449470e-02 -3.77471633e-02 5.65885007e-02 6.63008019e-02
-7.34188128e-03 6.46054149e-02 3.19911093e-02 4.11194898e-02
4.43960279e-02 4.92892228e-02 1.74766723e-02 3.40303481e-02
-5.23341820e-03 2.68163737e-02 -9.43402853e-03 -4.11836170e-02
1.55221792e-02 -5.05655073e-02 4.24557598e-03 -3.40388380e-02
……………………

Moduły szkoleniowe

Moduły szkoleniowe w Gluon są następujące -

gluon.loss

W mxnet.gluon.lossmoduł, Gluon zapewnia predefiniowaną funkcję strat. Zasadniczo ma straty do uczenia sieci neuronowej. Dlatego nazywany jest modułem szkoleniowym.

Metody i ich parametry

Poniżej przedstawiono niektóre z ważnych metod i ich parametrów objętych mxnet.gluon.loss moduł szkoleniowy:

Metody i ich parametry	Definicja
Strata (waga, oś_ partii, ** kwargs)	Działa jako klasa bazowa strat.
L2Loss ([waga, oś_ partii])	Oblicza średni kwadrat błędu (MSE) pomiędzy label i prediction(pred).
L1Loss ([waga, oś_ partii])	Oblicza średni błąd bezwzględny (MAE) pomiędzy label i pred.
SigmoidBinaryCrossEntropyLoss ([…])	Ta metoda jest używana do utraty entropii krzyżowej w klasyfikacji binarnej.
SigmoidBCELoss	Ta metoda jest używana do utraty entropii krzyżowej w klasyfikacji binarnej.
SoftmaxCrossEntropyLoss ([oś,…])	Oblicza stratę krzyżową entropii softmax (CEL).
SoftmaxCELoss	Oblicza również utratę entropii krzyżowej softmax.
KLDivLoss ([from_logits, axis, weight,…])	Służy do utraty dywergencji Kullbacka-Leiblera.
CTCLoss ([układ, etykieta_layout, waga])	Służy do koneksjonistycznej utraty klasyfikacji czasowej (TCL).
HuberLoss ([rho, weight, batch_axis])	Oblicza wygładzoną stratę L1. Wygładzona strata L1 będzie równa stracie L1, jeśli błąd bezwzględny przekracza rho, ale w przeciwnym razie jest równy stracie L2.
HingeLoss ([margines, weight, batch_axis])	Ta metoda oblicza funkcję utraty zawiasów często używaną w maszynach SVM:
SquaredHingeLoss ([margines, waga, batch_axis])	Ta metoda oblicza funkcję miękkiej straty używaną w maszynach SVM:
LogisticLoss ([weight, batch_axis, label_format])	Ta metoda oblicza stratę logistyczną.
TripletLoss ([margin, weight, batch_axis])	Ta metoda oblicza stratę tripletową przy trzech tensorach wejściowych i dodatnim marginesie.
PoissonNLLLoss ([waga, z_logits,…])	Funkcja oblicza utratę prawdopodobieństwa logarytmu ujemnego.
CosineEmbeddingLoss ([waga, oś_ partii, margines])	Funkcja oblicza odległość cosinusa między wektorami.
SDMLLoss ([parametr_ wygładzania, waga,…])	Ta metoda oblicza stratę Batchwise Smoothed Deep Metric Learning (SDML) przy dwóch wejściowych tensorach i wygładzonej utracie SDM. Uczy się podobieństwa między sparowanymi próbkami, używając niesparowanych próbek w minibatchu jako potencjalnych negatywnych przykładów.

Przykład

Jak wiemy mxnet.gluon.loss.lossobliczy MSE (błąd średniokwadratowy) między etykietą a prognozą (pred). Odbywa się to za pomocą następującego wzoru:

gluon.parameter

mxnet.gluon.parameter to pojemnik przechowujący parametry tj. wagi bloków.

Metody i ich parametry

Poniżej przedstawiono niektóre z ważnych metod i ich parametrów objętych mxnet.gluon.parameter moduł szkoleniowy -

Metody i ich parametry	Definicja
obsada (dtype)	Ta metoda rzutuje dane i gradient tego parametru na nowy typ danych.
dane ([ctx])	Ta metoda zwróci kopię tego parametru w jednym kontekście.
grad ([ctx])	Ta metoda zwróci bufor gradientu dla tego parametru w jednym kontekście.
zainicjalizuj ([init, ctx, default_init,…])	Ta metoda zainicjuje tablice parametrów i gradientów.
list_ctx ()	Ta metoda zwróci listę kontekstów, w których ten parametr jest zainicjowany.
list_data ()	Ta metoda zwróci kopie tego parametru we wszystkich kontekstach. Będzie to robione w tej samej kolejności, co tworzenie.
list_grad ()	Ta metoda zwróci bufory gradientu we wszystkich kontekstach. Zostanie to zrobione w tej samej kolejności, covalues().
list_row_sparse_data (row_id)	Ta metoda zwróci kopie parametru „row_sparse” we wszystkich kontekstach. Będzie to robione w tej samej kolejności, co tworzenie.
reset_ctx (ctx)	Ta metoda spowoduje ponowne przypisanie parametru Parameter do innych kontekstów.
row_sparse_data (row_id)	Ta metoda zwróci kopię parametru „row_sparse” w tym samym kontekście, co parametr row_id.
set_data (dane)	Ta metoda ustawi wartość tego parametru we wszystkich kontekstach.
var ()	Ta metoda zwróci symbol reprezentujący ten parametr.
zero_grad ()	Ta metoda ustawi bufor gradientu we wszystkich kontekstach na 0.

Przykład implementacji

W poniższym przykładzie zainicjujemy parametry i tablice gradientów za pomocą metody initialize () w następujący sposób -

weight = mx.gluon.Parameter('weight', shape=(2, 2))
weight.initialize(ctx=mx.cpu(0))
weight.data()

Output

Dane wyjściowe są wymienione poniżej -

[[-0.0256899 0.06511251]
[-0.00243821 -0.00123186]]
<NDArray 2x2 @cpu(0)>

Example

weight.grad()

Output

Dane wyjściowe podano poniżej -

[[0. 0.]
[0. 0.]]
<NDArray 2x2 @cpu(0)>

Example

weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
weight.data(mx.gpu(0))

Output

Zobaczysz następujący wynik -

[[-0.00873779 -0.02834515]
 [ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>

Example

weight.data(mx.gpu(1))

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[[-0.00873779 -0.02834515]
 [ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>

gluon.trainer

mxnet.gluon.trainer stosuje Optymalizator do zestawu parametrów. Powinien być używany razem z autogradem.

Metody i ich parametry

Poniżej przedstawiono niektóre z ważnych metod i ich parametrów objętych mxnet.gluon.trainer moduł szkoleniowy -

Metody i ich parametry	Definicja
allreduce_grads ()	Ta metoda zmniejszy gradienty z różnych kontekstów dla każdego parametru (wagi).
load_states (fname)	Jak sama nazwa wskazuje, ta metoda załaduje stany trenera.
save_states (fname)	Jak sama nazwa wskazuje, ta metoda pozwoli zaoszczędzić stany trenera.
set_learning_rate (lr)	Ta metoda ustawi nowy współczynnik uczenia optymalizatora.
krok (batch_size [, ignore_stale_grad])	Ta metoda stanowi jeden krok aktualizacji parametrów. Powinien zostać nazwany późniejautograd.backward() i poza record() zakres.
aktualizacja (batch_size [, ignore_stale_grad])	Ta metoda będzie również stanowić jeden krok aktualizacji parametrów. Powinien zostać nazwany późniejautograd.backward() i poza record() scope i po trainer.update ().

Moduły danych

Moduły danych Gluon są wyjaśnione poniżej -

gluon.data

Gluon zapewnia dużą liczbę wbudowanych narzędzi do zestawów danych w module gluon.data. Z tego powodu nazywany jest modułem danych.

Klasy i ich parametry

Poniżej przedstawiono niektóre z ważnych metod i ich parametrów, które obejmuje moduł podstawowy mxnet.gluon.data. Te metody są zwykle powiązane z zestawami danych, próbkowaniem i DataLoader.

Zestaw danych

Metody i ich parametry	Definicja
ArrayDataset (* args)	Ta metoda reprezentuje zestaw danych, który łączy dwa lub więcej niż dwa obiekty podobne do zestawu danych. Na przykład zbiory danych, listy, tablice itp.
BatchSampler (sampler, batch_size [, last_batch])	Ta metoda zawija się nad inną Sampler. Po zapakowaniu zwraca mini partie próbek.
DataLoader (dataset [, batch_size, shuffle,…])	Podobna do BatchSampler, ale ta metoda ładuje dane z zestawu danych. Po załadowaniu zwraca mini partie danych.
Reprezentuje abstrakcyjną klasę zestawu danych.
FilterSampler (fn, zestaw danych)	Ta metoda reprezentuje przykładowe elementy z zestawu danych, dla których funkcja fn (funkcja) zwraca True.
RandomSampler (długość)	Ta metoda reprezentuje elementy próbek od [0, długość) losowo bez wymiany.
RecordFileDataset (nazwa pliku)	Reprezentuje zawijanie zestawu danych w pliku RecordIO. Rozszerzenie pliku to.rec.
Próbnik	To jest klasa bazowa dla samplerów.
SequentialSampler (długość [, początek])	Reprezentuje sekwencyjnie przykładowe elementy z zestawu [początek, początek + długość).
Reprezentuje sekwencyjnie przykładowe elementy z zestawu [początek, początek + długość).	Reprezentuje to prostą otokę zestawu danych, szczególnie w przypadku list i tablic.

Przykłady wdrożeń

W poniższym przykładzie użyjemy gluon.data.BatchSampler()API, które otacza inny sampler. Zwraca mini partie próbek.

import mxnet as mx
from mxnet.gluon import data
sampler = mx.gluon.data.SequentialSampler(15)
batch_sampler = mx.gluon.data.BatchSampler(sampler, 4, 'keep')
list(batch_sampler)

Output

Dane wyjściowe są wymienione poniżej -

[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14]]

gluon.data.vision.datasets

Gluon zapewnia dużą liczbę wstępnie zdefiniowanych funkcji zestawu danych wizyjnych w gluon.data.vision.datasets moduł.

Klasy i ich parametry

MXNet dostarcza nam przydatne i ważne zbiory danych, których klasy i parametry podano poniżej -

Klasy i ich parametry	Definicja
MNIST ([root, train, transform])	Jest to przydatny zbiór danych, który dostarcza nam odręcznych cyfr. Adres URL zestawu danych MNIST to http://yann.lecun.com/exdb/mnist
FashionMNIST ([root, train, transform])	Ten zbiór danych składa się z obrazów artykułów Zalando, które zawierają produkty modowe. Jest to bezpośrednie zastąpienie oryginalnego zestawu danych MNIST. Możesz pobrać ten zestaw danych z https://github.com/zalandoresearch/fashion-mnist
CIFAR10 ([root, train, transform])	To jest zbiór danych klasyfikacji obrazów z https://www.cs.toronto.edu/~kriz/cifar.html. W tym zbiorze danych każda próbka jest obrazem z kształtem (32, 32, 3).
CIFAR100 ([root, fine_label, pociąg, transformacja])	To jest zbiór danych klasyfikacji obrazu CIFAR100 z https://www.cs.toronto.edu/~kriz/cifar.html. Ma również każda próbka jest obrazem z kształtem (32, 32, 3).
ImageRecordDataset (nazwa pliku [, flaga, transformacja])	Ten zestaw danych jest zawijany w pliku RecordIO zawierającym obrazy. W tym przypadku każda próbka jest obrazem z odpowiednią etykietą.
ImageFolderDataset (root [, flaga, transformacja])	Jest to zbiór danych służący do ładowania plików obrazów przechowywanych w strukturze folderów.
ImageListDataset ([root, imglist, flag])	Jest to zbiór danych służący do ładowania plików graficznych określonych na liście wpisów.

Przykład

W poniższym przykładzie pokażemy użycie funkcji ImageListDataset (), która służy do ładowania plików graficznych określonych przez listę wpisów -

# written to text file *.lst

0 0 root/cat/0001.jpg
1 0 root/cat/xxxa.jpg
2 0 root/cat/yyyb.jpg
3 1 root/dog/123.jpg
4 1 root/dog/023.jpg
5 1 root/dog/wwww.jpg

# A pure list, each item is a list [imagelabel: float or list of float, imgpath]

[[0, root/cat/0001.jpg]
[0, root/cat/xxxa.jpg]
[0, root/cat/yyyb.jpg]
[1, root/dog/123.jpg]
[1, root/dog/023.jpg]
[1, root/dog/wwww.jpg]]

Moduły narzędziowe

Moduły narzędziowe w Gluon są następujące -

gluon.utils

Gluon zapewnia dużą liczbę wbudowanych optymalizatorów narzędzi równoległych w module gluon.utils. Zapewnia różnorodne narzędzia do treningu. Z tego powodu nazywa się go modułem narzędziowym.

Funkcje i ich parametry

Poniżej przedstawiono funkcje i ich parametry składające się na ten moduł narzędziowy o nazwie gluon.utils −

Funkcje i ich parametry	Definicja
split_data (data, num_slice [, batch_axis,…])	Ta funkcja jest zwykle używana do równoległości danych, a każdy segment jest wysyłany do jednego urządzenia, tj. GPU. Dzieli NDArray nanum_slice plasterki wzdłuż batch_axis.
split_and_load (dane, ctx_list [, batch_axis,…])	Ta funkcja dzieli NDArray na len(ctx_list) plasterki wzdłuż batch_axis. Jedyną różnicą w stosunku do powyższej funkcji split_data () jest to, że ładuje ona również każdy wycinek do jednego kontekstu ctx_list.
clip_global_norm (tablice, max_norm [,…])	Zadaniem tej funkcji jest przeskalowanie tablic NDA w taki sposób, aby suma ich 2-normy była mniejsza niż max_norm.
check_sha1 (nazwa pliku, sha1_hash)	Ta funkcja sprawdzi, czy hash sha1 zawartości pliku pasuje do oczekiwanego skrótu, czy nie.
pobierz (url [, ścieżka, nadpisz, sha1_hash,…])	Jak nazwa wskazuje, funkcja ta pobierze podany adres URL.
replace_file (src, dst)	Ta funkcja zaimplementuje atomic os.replace. będzie to zrobione z Linuksem i OSX.

Ten rozdział dotyczy autograd i initializer API w MXNet.

mxnet.autograd

To jest autograd API MXNet dla NDArray. Ma następującą klasę -

Klasa: Funkcja ()

Służy do niestandardowego różnicowania w programie autograd. Można go zapisać jakomxnet.autograd.Function. Jeśli z jakiegoś powodu użytkownik nie chce używać gradientów obliczanych przez domyślną regułę łańcuchową, może użyć klasy funkcji mxnet.autograd, aby dostosować różniczkowanie do obliczeń. Ma dwie metody, a mianowicie Forward () i Backward ().

Zrozummy pracę tej klasy za pomocą następujących punktów:

• Najpierw musimy zdefiniować nasze obliczenia w metodzie forward.

• Następnie musimy zapewnić dostosowane zróżnicowanie w metodzie wstecznej.

• Teraz podczas obliczania gradientu, zamiast zdefiniowanej przez użytkownika funkcji wstecznej, mxnet.autograd użyje funkcji wstecznej zdefiniowanej przez użytkownika. Możemy również rzutować do numpy array iz powrotem dla niektórych operacji w przód lub w tył.

Example

Przed użyciem klasy mxnet.autograd.function, zdefiniujmy stabilną funkcję sigmoidalną z metodami wstecz i do przodu w następujący sposób -

class sigmoid(mx.autograd.Function):
   def forward(self, x):
      y = 1 / (1 + mx.nd.exp(-x))
      self.save_for_backward(y)
      return y
   
   def backward(self, dy):
      y, = self.saved_tensors
      return dy * y * (1-y)

Teraz klasa funkcji może być używana w następujący sposób -

func = sigmoid()
x = mx.nd.random.uniform(shape=(10,))
x.attach_grad()
with mx.autograd.record():
m = func(x)
m.backward()
dx_grad = x.grad.asnumpy()
dx_grad

Output

Po uruchomieniu kodu zobaczysz następujące dane wyjściowe -

array([0.21458015, 0.21291625, 0.23330082, 0.2361367 , 0.23086983,
0.24060014, 0.20326573, 0.21093895, 0.24968489, 0.24301809],
dtype=float32)

Metody i ich parametry

Poniżej przedstawiono metody i ich parametry klasy mxnet.autogard.function -

Metody i ich parametry	Definicja
forward (heads [, head_grads, retain_graph,…])	Ta metoda jest używana do obliczeń w przód.
backward (heads [, head_grads, retain_graph,…])	Ta metoda jest używana do obliczeń wstecz. Oblicza gradienty głów względem wcześniej zaznaczonych zmiennych. Ta metoda przyjmuje tyle danych wejściowych, ile danych wyjściowych przekazywania. Zwraca również tyle NDArray, ile danych wejściowych forward.
get_symbol (x)	Ta metoda służy do pobierania zarejestrowanej historii obliczeń jako pliku Symbol.
grad (główki, zmienne [, oceny_główne,…])	Ta metoda oblicza gradienty głów w odniesieniu do zmiennych. Po obliczeniu, zamiast zapisywania w zmiennym.grad, gradienty zostaną zwrócone jako nowe tablice NDA.
is_recording ()	Za pomocą tej metody możemy uzyskać status nagrywania, a nie nagrywania.
is_training ()	Za pomocą tej metody możemy uzyskać status treningu i prognozowania.
mark_variables (zmienne, gradienty [, grad_reqs])	Ta metoda oznaczy NDArrays jako zmienne do obliczenia gradientu dla autogradu. Ta metoda jest taka sama jak funkcja .attach_grad () w zmiennej, ale jedyną różnicą jest to, że za pomocą tego wywołania możemy ustawić gradient na dowolną wartość.
pauza ([train_mode])	Ta metoda zwraca kontekst zakresu, który ma być używany w instrukcji „with” dla kodów, które nie wymagają obliczania gradientów.
Predict_mode ()	Ta metoda zwraca kontekst zasięgu, który ma być użyty w instrukcji „with”, w której zachowanie przebiegu w przód jest ustawione na tryb wnioskowania i to bez zmiany stanów nagrywania.
record ([train_mode])	Zwróci autograd nagrywanie kontekstu zakresu do użycia w instrukcji „with” i przechwytuje kod, który wymaga obliczenia gradientów.
set_recording (is_recording)	Podobnie jak is_recoring (), za pomocą tej metody możemy uzyskać status nagrywania, a nie nagrywania.
set_training (is_training)	Podobnie jak is_traininig (), za pomocą tej metody możemy ustawić status na uczenie lub przewidywanie.
train_mode ()	Ta metoda zwróci kontekst zasięgu, który ma być użyty w instrukcji „with”, w której zachowanie przebiegu w przód jest ustawione na tryb uczenia, bez zmiany stanów nagrywania.

Przykład implementacji

W poniższym przykładzie użyjemy metody mxnet.autograd.grad () do obliczenia gradientu głowy względem zmiennych -

x = mx.nd.ones((2,))
x.attach_grad()
with mx.autograd.record():
z = mx.nd.elemwise_add(mx.nd.exp(x), x)
dx_grad = mx.autograd.grad(z, [x], create_graph=True)
dx_grad

Output

Dane wyjściowe są wymienione poniżej -

[
[3.7182817 3.7182817]
<NDArray 2 @cpu(0)>]

Możemy użyć metody mxnet.autograd.predict_mode (), aby zwrócić zakres, który ma być użyty w instrukcji 'with' -

with mx.autograd.record():
y = model(x)
with mx.autograd.predict_mode():
y = sampling(y)
backward([y])

mxnet.intializer

To jest API MXNet dla inicjatora ważenia. Ma następujące klasy -

Klasy i ich parametry

Poniżej przedstawiono metody i ich parametry mxnet.autogard.function klasa:

Klasy i ich parametry	Definicja
Dwuliniowe ()	Z pomocą tej klasy możemy zainicjować wagę dla warstw upsamplingu.
Stała wartość)	Ta klasa inicjuje wagi do podanej wartości. Wartością może być zarówno wartość skalarna, jak i NDArray, które pasują do kształtu ustawianego parametru.
FusedRNN (init, num_hidden, num_layers, mode)	Jak sama nazwa wskazuje, ta klasa inicjuje parametry dla połączonych warstw rekurencyjnych sieci neuronowych (RNN).
InitDesc	Działa jako deskryptor dla wzorca inicjalizacji.
Inicjator (** kwargs)	To jest klasa bazowa inicjatora.
LSTMBias ([zapomnij_bias])	Ta klasa inicjuje wszystkie odchylenia LSTMCell na 0,0, ale z wyjątkiem bramki zapomnienia, której odchylenie jest ustawione na niestandardową wartość.
Załaduj (param [, default_init, verbose])	Ta klasa inicjuje zmienne, ładując dane z pliku lub słownika.
MSRAPrelu ([typ_faktora, nachylenie])	Jak sama nazwa wskazuje, ta klasa Inicjalizuje wagę zgodnie z papierem MSRA.
Mieszane (wzorce, inicjatory)	Inicjuje parametry przy użyciu wielu inicjatorów.
Normalny ([sigma])	Klasa Normal () inicjuje wagi z losowymi wartościami próbkowanymi z rozkładu normalnego ze średnią zerową i odchyleniem standardowym (SD) równym sigma.
Jeden()	Inicjuje wagi parametru na jeden.
Ortogonalny ([skala, rand_type])	Jak sama nazwa wskazuje, ta klasa inicjuje wagę jako macierz ortogonalną.
Mundur ([skala])	Inicjuje wagi z losowymi wartościami, które są równomiernie próbkowane z danego zakresu.
Xavier ([rnd_type, factor_type, magnitude])	W rzeczywistości zwraca inicjalizator, który wykonuje inicjalizację „Xavier” dla wag.
Zero()	Inicjuje wagi parametru do zera.

Przykład implementacji

W poniższym przykładzie użyjemy klasy mxnet.init.Normal () utwórz inicjator i pobierzemy jego parametry -

init = mx.init.Normal(0.8)
init.dumps()

Output

Dane wyjściowe podano poniżej -

'["normal", {"sigma": 0.8}]'

Example

init = mx.init.Xavier(factor_type="in", magnitude=2.45)
init.dumps()

Output

Wyjście pokazano poniżej -

'["xavier", {"rnd_type": "uniform", "factor_type": "in", "magnitude": 2.45}]'

W poniższym przykładzie będziemy używać klasy mxnet.initializer.Mixed () do inicjowania parametrów przy użyciu wielu inicjatorów -

init = mx.initializer.Mixed(['bias', '.*'], [mx.init.Zero(),
mx.init.Uniform(0.1)])
module.init_params(init)

for dictionary in module.get_params():
for key in dictionary:
print(key)
print(dictionary[key].asnumpy())

Output

Wyjście pokazano poniżej -

fullyconnected1_weight
[[ 0.0097627 0.01856892 0.04303787]]
fullyconnected1_bias
[ 0.]

W tym rozdziale dowiemy się o interfejsie w MXNet, który jest określany jako Symbol.

Mxnet.ndarray

Apache MXNet Symbol API to interfejs do programowania symbolicznego. Symbol API wykorzystuje następujące elementy -

• Grafy obliczeniowe

• Zmniejszone zużycie pamięci

• Optymalizacja funkcji przed użyciem

Poniższy przykład pokazuje, jak można utworzyć proste wyrażenie przy użyciu interfejsu API symboli MXNet -

NDArray przy użyciu „tablicy” 1-W i 2-W ze zwykłej listy Pythona -

import mxnet as mx
# Two placeholders namely x and y will be created with mx.sym.variable
x = mx.sym.Variable('x')
y = mx.sym.Variable('y')
# The symbol here is constructed using the plus ‘+’ operator.
z = x + y

Output

Zobaczysz następujący wynik -

<Symbol _plus0>

Example

(x, y, z)

Output

Dane wyjściowe podano poniżej -

(<Symbol x>, <Symbol y>, <Symbol _plus0>)

Omówmy teraz szczegółowo klasy, funkcje i parametry API ndarray w MXNet.

Zajęcia

Poniższa tabela zawiera klasy Symbol API MXNet -

Klasa	Definicja
Symbol (uchwyt)	Ta klasa mianowicie symbol jest symbolicznym wykresem Apache MXNet.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów, które obejmuje mxnet.Symbol API -

Funkcja i jej parametry	Definicja
Aktywacja ([data, act_type, out, name])	Stosuje elementową funkcję aktywacji do wejścia. To wspierarelu, sigmoid, tanh, softrelu, softsign funkcje aktywacji.
BatchNorm ([dane, gamma, beta, move_mean,…])	Służy do normalizacji partii. Ta funkcja normalizuje pakiet danych na podstawie średniej i wariancji. Stosuje skalęgamma i offset beta.
BilinearSampler ([dane, siatka, cudnn_off,…])	Ta funkcja stosuje próbkowanie bilinearne do mapy obiektów wejściowych. Właściwie jest to klucz do „Przestrzennych sieci transformatorowych”. Jeśli znasz funkcję remapowania w OpenCV, użycie tej funkcji jest dość podobne. Jedyną różnicą jest to, że ma przejście do tyłu.
BlockGrad ([dane, wyjście, nazwa])	Jak nazwa wskazuje, funkcja ta zatrzymuje obliczenia gradientu. Zasadniczo powstrzymuje nagromadzony gradient danych wejściowych przed przepływem przez tego operatora w kierunku wstecznym.
cast ([data, dtype, out, name])	Ta funkcja będzie rzutować wszystkie elementy wejścia na nowy typ.
Ta funkcja będzie rzutować wszystkie elementy wejścia na nowy typ.	Ta funkcja, zgodnie z nazwą, zwraca nowy symbol o podanym kształcie i typie, wypełniony zerami.
jedynki (kształt [, typ])	Funkcja ta, zgodnie z nazwą, zwraca nowy symbol o podanym kształcie i typie, wypełniony jedynkami.
pełny (shape, val [, dtype])	Ta funkcja, zgodnie z nazwą, zwraca nową tablicę o podanym kształcie i typie, wypełnioną podaną wartością val.
arange (start [, stop, step, repeat,…])	Zwróci równomiernie rozmieszczone wartości w podanym przedziale. Wartości są generowane w ramach półotwartego interwału [start, stop], co oznacza, że ​​przedział obejmujestart ale wyklucza stop.
linspace (początek, stop, num [, punkt końcowy, nazwa,…])	Zwróci liczby równomiernie rozmieszczone w określonym przedziale. Podobnie jak w przypadku funkcji aranżacja (), wartości są generowane w ramach półotwartego interwału [start, stop], co oznacza, że ​​interwał zawierastart ale wyklucza stop.
histogram (a [, przedziały, zakres])	Jak sama nazwa wskazuje, funkcja ta obliczy histogram danych wejściowych.
moc (podstawa, exp)	Jak nazwa wskazuje, funkcja ta zwróci wynik w postaci elementu base element podniesiony do potęg z expelement. Oba wejścia, tj. Base i exp, mogą być symbolami lub skalarami. Zwróć uwagę, że nadawanie nie jest dozwolone. Możesz użyćbroadcast_pow jeśli chcesz skorzystać z funkcji transmisji.
SoftmaxActivation ([dane, tryb, nazwa, atr, wyjście])	Ta funkcja powoduje aktywację softmax na wejściu. Przeznaczony jest na warstwy wewnętrzne. W rzeczywistości jest przestarzały, możemy użyćsoftmax() zamiast.

Przykłady wdrożeń

W poniższym przykładzie będziemy używać funkcji power() który zwróci wynik elementu bazowego podniesiony do potęg z elementu exp:

import mxnet as mx
mx.sym.power(3, 5)

Output

Zobaczysz następujący wynik -

243

Example

x = mx.sym.Variable('x')
y = mx.sym.Variable('y')
z = mx.sym.power(x, 3)
z.eval(x=mx.nd.array([1,2]))[0].asnumpy()

Output

Daje to następujący wynik -

array([1., 8.], dtype=float32)

Example

z = mx.sym.power(4, y)
z.eval(y=mx.nd.array([2,3]))[0].asnumpy()

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

array([16., 64.], dtype=float32)

Example

z = mx.sym.power(x, y)
z.eval(x=mx.nd.array([4,5]), y=mx.nd.array([2,3]))[0].asnumpy()

Output

Dane wyjściowe są wymienione poniżej -

array([ 16., 125.], dtype=float32)

W poniższym przykładzie będziemy używać funkcji SoftmaxActivation() (or softmax()) który zostanie zastosowany na wsad i jest przeznaczony na warstwy wewnętrzne.

input_data = mx.nd.array([[2., 0.9, -0.5, 4., 8.], [4., -.7, 9., 2., 0.9]])
soft_max_act = mx.nd.softmax(input_data)
print (soft_max_act.asnumpy())

Output

Zobaczysz następujący wynik -

[[2.4258138e-03 8.0748333e-04 1.9912292e-04 1.7924475e-02 9.7864312e-01]
[6.6843745e-03 6.0796250e-05 9.9204916e-01 9.0463174e-04 3.0112563e-04]]

symbol.contrib

Interfejs API Contrib NDArray jest zdefiniowany w pakiecie symbol.contrib. Zwykle zapewnia wiele przydatnych eksperymentalnych interfejsów API dla nowych funkcji. Ten interfejs API działa jako miejsce dla społeczności, w którym mogą wypróbować nowe funkcje. Współtwórca funkcji również otrzyma opinię.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.symbol.contrib API -

Funkcja i jej parametry	Definicja
rand_zipfian (true_classes, num_sampled,…)	Ta funkcja pobiera losowe próbki z przybliżonej dystrybucji Zipfian. Podstawowym rozkładem tej funkcji jest rozkład Zipfian. Ta funkcja losowo próbkuje num_sampled kandydatów, a elementy sampled_candidates są pobierane z podstawowego rozkładu podanego powyżej.
foreach (body, data, init_states)	Jak sama nazwa wskazuje, funkcja ta uruchamia pętlę z obliczeniami zdefiniowanymi przez użytkownika na tablicach NDArrays w wymiarze 0. Ta funkcja symuluje pętlę for, a body wykonuje obliczenia dla iteracji pętli for.
while_loop (cond, func, loop_vars [,…])	Jak sama nazwa wskazuje, ta funkcja uruchamia pętlę while z obliczeniami zdefiniowanymi przez użytkownika i warunkiem pętli. Ta funkcja symuluje pętlę while, która dosłownie wykonuje niestandardowe obliczenia, jeśli warunek jest spełniony.
cond (pred, then_func, else_func)	Jak sama nazwa wskazuje, ta funkcja uruchamia warunek if-then-else przy użyciu warunku zdefiniowanego przez użytkownika i obliczeń. Ta funkcja symuluje gałąź if-like, która wybiera wykonanie jednego z dwóch obliczeń dostosowanych do określonego warunku.
getnnz ([dane, oś, wyjście, nazwa])	Ta funkcja daje nam liczbę przechowywanych wartości dla rzadkiego tensora. Zawiera również wyraźne zera. Obsługuje tylko macierz CSR na procesorze.
rekwantizować ([dane, zakres_min, zakres_maksymalny,…])	Ta funkcja wymienia dane dane, które są kwantowane w int32 i odpowiadające im progi, do int8 przy użyciu minimalnych i maksymalnych progów obliczonych w czasie wykonywania lub podczas kalibracji.
index_copy ([stary_tensor, indeks_wektor,…])	Ta funkcja kopiuje elementy pliku new_tensor into the old_tensor by selecting the indices in the order given in index. The output of this operator will be a new tensor that contains the rest elements of old tensor and the copied elements of new tensor.
interleaved_matmul_encdec_qk ([zapytania,…])	Ten operator oblicza mnożenie macierzy między rzutami zapytań i kluczy w przypadku uwagi wielogłowicowej używanej jako koder-dekoder. Warunkiem jest, aby dane wejściowe były tensorem rzutów zapytań, które są zgodne z układem: (seq_length, batch_size, num_heads *, head_dim).

Przykłady wdrożeń

W poniższym przykładzie będziemy używać funkcji rand_zipfian do rysowania losowych próbek z dystrybucji w przybliżeniu Zipfian -

import mxnet as mx
true_cls = mx.sym.Variable('true_cls')
samples, exp_count_true, exp_count_sample = mx.sym.contrib.rand_zipfian(true_cls, 5, 6)
samples.eval(true_cls=mx.nd.array([3]))[0].asnumpy()

Output

Zobaczysz następujący wynik -

array([4, 0, 2, 1, 5], dtype=int64)

Example

exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()

Output

Dane wyjściowe są wymienione poniżej -

array([0.57336551])

Example

exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()

Output

Zobaczysz następujący wynik -

array([1.78103594, 0.46847373, 1.04183923, 0.57336551, 1.04183923])

W poniższym przykładzie będziemy używać funkcji while_loop do uruchamiania pętli while dla obliczeń zdefiniowanych przez użytkownika i warunku pętli -

cond = lambda i, s: i <= 7
func = lambda i, s: ([i + s], [i + 1, s + i])
loop_vars = (mx.sym.var('i'), mx.sym.var('s'))
outputs, states = mx.sym.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
print(outputs)

Output

Wynik podano poniżej:

[<Symbol _while_loop0>]

Example

Print(States)

Output

Daje to następujący wynik -

[<Symbol _while_loop0>, <Symbol _while_loop0>]

W poniższym przykładzie będziemy używać funkcji index_copy która kopiuje elementy new_tensor do old_tensor.

import mxnet as mx
a = mx.nd.zeros((6,3))
b = mx.nd.array([[1,2,3],[4,5,6],[7,8,9]])
index = mx.nd.array([0,4,2])
mx.nd.contrib.index_copy(a, index, b)

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[[1. 2. 3.]
[0. 0. 0.]
[7. 8. 9.]
[0. 0. 0.]
[4. 5. 6.]
[0. 0. 0.]]
<NDArray 6x3 @cpu(0)>

symbol.image

Interfejs API Image Symbol jest zdefiniowany w pakiecie symbol.image. Jak sama nazwa wskazuje, jest on zwykle używany do obrazów i ich funkcji.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.symbol.image API -

Funkcja i jej parametry	Definicja
Adjust_lighting ([dane, alfa, wyjście, nazwa])	Jak sama nazwa wskazuje, funkcja ta dostosowuje poziom oświetlenia wejścia. Jest zgodny ze stylem AlexNet.
przyciąć ([dane, x, y, szerokość, wysokość, na zewnątrz, nazwa])	Za pomocą tej funkcji możemy przyciąć obraz NDArray kształtu (wys. X szer. X gł.) Lub (szer. X wys. X gł.) Do podanego przez użytkownika rozmiaru.
normalize ([data, mean, std, out, name])	Normalizuje tensor kształtu (C x H x W) lub (N x C x H x W) z mean i standard deviation(SD).
random_crop ([dane, xrange, yrange, width,…])	Podobnie jak crop (), losowo przycina obraz NDArray kształtu (H x W x C) lub (N x H x W x C) do rozmiaru podanego przez użytkownika. Będzie próbkować wynik, jeślisrc jest mniejszy niż size.
random_lighting([data, alpha_std, out, name])	Jak sama nazwa wskazuje, funkcja ta losowo dodaje szum PCA. Jest również zgodny ze stylem AlexNet.
random_resized_crop ([dane, xrange, yrange,…])	Przycina również losowo obraz NDArray o kształcie (wys. X szer. X gł.) Lub (szer. X wys. X szer. X gł.) Do podanego rozmiaru. Będzie próbkować wynik, jeśli src jest mniejszy niż rozmiar. Spowoduje to również losowanie obszaru i współczynnika kształtu.
resize ([data, size, keep_ratio, interp,…])	Jak sama nazwa wskazuje, ta funkcja zmieni rozmiar obrazu NDArray kształtu (wys. X szer. X gł.) Lub (szer. X szer. X gł.) Do rozmiaru podanego przez użytkownika.
to_tensor ([dane, out, nazwa])	Konwertuje obraz NDArray kształtu (H x W x C) lub (N x H x W x C) z wartościami z zakresu [0, 255] na tensor NDArray kształtu (C x H x W) lub ( N x C x H x W) z wartościami z zakresu [0, 1].

Przykłady wdrożeń

W poniższym przykładzie użyjemy funkcji to_tensor do konwersji obrazu NDArray kształtu (H x W x C) lub (N x H x W x C) z wartościami z zakresu [0, 255] na tensor NDArray kształtu (C x H x W) lub (N x C x H x W) z wartościami z zakresu [0, 1].

import numpy as np

img = mx.sym.random.uniform(0, 255, (4, 2, 3)).astype(dtype=np.uint8)

mx.sym.image.to_tensor(img)

Output

Dane wyjściowe podano poniżej -

<Symbol to_tensor4>

Example

img = mx.sym.random.uniform(0, 255, (2, 4, 2, 3)).astype(dtype=np.uint8)

mx.sym.image.to_tensor(img)

Output

Wynik jest wymieniony poniżej:

<Symbol to_tensor5>

W poniższym przykładzie użyjemy funkcji normalize () do normalizacji tensora kształtu (C x H x W) lub (N x C x H x W) z mean i standard deviation(SD).

img = mx.sym.random.uniform(0, 1, (3, 4, 2))

mx.sym.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))

Output

Poniżej podano wynik kodu -

<Symbol normalize0>

Example

img = mx.sym.random.uniform(0, 1, (2, 3, 4, 2))

mx.sym.image.normalize(img, mean=(0, 1, 2), std=(3, 2, 1))

Output

Wyjście pokazano poniżej -

<Symbol normalize1>

symbol.random

Interfejs API symboli losowych jest zdefiniowany w pakiecie symbol.random. Jak sama nazwa wskazuje, jest to API Symbol generatora dystrybucji losowej MXNet.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji i ich parametrów objętych mxnet.symbol.random API -

Funkcja i jej parametry	Definicja
jednolity ([niski, wysoki, kształt, dtype, ctx, out])	Generuje losowe próbki z jednolitego rozkładu.
normalny ([loc, skala, kształt, dtype, ctx, out])	Generuje losowe próbki z rozkładu normalnego (Gaussa).
randn (* kształt, ** kwargs)	Generuje losowe próbki z rozkładu normalnego (Gaussa).
poisson ([lam, shape, dtype, ctx, out])	Generuje losowe próbki z rozkładu Poissona.
wykładniczy ([skala, kształt, dtype, ctx, out])	Generuje próbki z rozkładu wykładniczego.
gamma ([alpha, beta, shape, dtype, ctx, out])	Generuje losowe próbki z rozkładu gamma.
wielomian (dane [, kształt, get_prob, out, dtype])	Generuje równoczesne próbkowanie z wielu wielomianowych rozkładów.
minus_binomial ([k, p, kształt, dtype, ctx, out])	Generuje losowe próbki z ujemnego rozkładu dwumianowego.
generalized_negative_binomial ([mu, alfa,…])	Generuje losowe próbki z uogólnionego ujemnego rozkładu dwumianowego.
shuffle (dane, ** kwargs)	Losowo tasuje elementy.
randint (low, high [, shape, dtype, ctx, out])	Generuje losowe próbki z dyskretnego, jednolitego rozkładu.
exponential_like ([data, lam, out, name])	Generuje losowe próbki z rozkładu wykładniczego zgodnie z kształtem tablicy wejściowej.
gamma_like ([dane, alfa, beta, wyjście, nazwa])	Generuje losowe próbki z rozkładu gamma zgodnie z kształtem tablicy wejściowej.
generalized_negative_binomial_like ([dane,…])	Generuje losowe próbki z uogólnionego ujemnego rozkładu dwumianowego zgodnie z kształtem tablicy wejściowej.
negatywne_binomialne_jakie ([dane, k, p, wyj, nazwa])	Generuje losowe próbki z ujemnego rozkładu dwumianowego zgodnie z kształtem tablicy wejściowej.
normal_like ([data, loc, scale, out, name])	Generuje losowe próbki z rozkładu normalnego (Gaussa) zgodnie z kształtem tablicy wejściowej.
poisson_like ([dane, lam, out, nazwa])	Generuje losowe próbki z rozkładu Poissona zgodnie z kształtem tablicy wejściowej.
uniform_like ([dane, low, high, out, name])	Generuje losowe próbki z jednolitego rozkładu zgodnie z kształtem tablicy wejściowej.

Przykłady wdrożeń

W poniższym przykładzie będziemy losowo tasować elementy za pomocą funkcji shuffle (). Powoduje to przetasowanie tablicy wzdłuż pierwszej osi.

data = mx.nd.array([[0, 1, 2], [3, 4, 5], [6, 7, 8],[9,10,11]])
x = mx.sym.Variable('x')
y = mx.sym.random.shuffle(x)
y.eval(x=data)

Output

Zobaczysz następujące dane wyjściowe:

[
[[ 9. 10. 11.]
[ 0. 1. 2.]
[ 6. 7. 8.]
[ 3. 4. 5.]]
<NDArray 4x3 @cpu(0)>]

Example

y.eval(x=data)

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[
[[ 6. 7. 8.]
[ 0. 1. 2.]
[ 3. 4. 5.]
[ 9. 10. 11.]]
<NDArray 4x3 @cpu(0)>]

W poniższym przykładzie narysujemy losowe próbki z uogólnionego ujemnego rozkładu dwumianowego. Do tego będzie używać funkcjigeneralized_negative_binomial().

mx.sym.random.generalized_negative_binomial(10, 0.1)

Output

Dane wyjściowe podano poniżej -

<Symbol _random_generalized_negative_binomial0>

symbol.sparse

Interfejs API Sparse Symbol jest zdefiniowany w pakiecie mxnet.symbol.sparse. Jak nazwa wskazuje, zapewnia rzadkie wykresy sieci neuronowych i automatyczne różnicowanie na procesorze.

Funkcje i ich parametry

Poniżej przedstawiono niektóre z ważnych funkcji (w tym procedury tworzenia symboli, procedury manipulowania symbolami, funkcje matematyczne, funkcje trygonometryczne, funkcje hybrydowe, funkcje redukcji, zaokrąglanie, moce, sieć neuronowa) oraz ich parametry objęte mxnet.symbol.sparse API -

Funkcja i jej parametry	Definicja
ElementWiseSum (* args, ** kwargs)	Ta funkcja doda wszystkie argumenty wejściowe mądrze. Na przykład _ (1,2,… = 1 + 2 + ⋯ +). Tutaj widzimy, że add_n jest potencjalnie bardziej wydajne niż wywołanie add n razy.
Osadzanie ([dane, waga, input_dim,…])	Zmapuje indeksy liczb całkowitych na reprezentacje wektorowe, tj. Osadzenia. W rzeczywistości odwzorowuje słowa na wektory o wartościach rzeczywistych w wielowymiarowej przestrzeni, która nazywa się osadzaniem słów.
LinearRegressionOutput ([dane, etykieta,…])	Oblicza i optymalizuje pod kątem kwadratu strat podczas propagacji wstecznej, dając tylko dane wyjściowe podczas propagacji do przodu.
LogisticRegressionOutput ([dane, etykieta,…])	Stosuje do danych wejściowych funkcję logistyczną, która jest również nazywana funkcją sigmoidalną. Funkcja jest obliczana jako 1/1 + exp (−x).
MAERegressionOutput ([dane, etykieta,…])	Ten operator oblicza średni bezwzględny błąd wejścia. MAE jest w rzeczywistości miernikiem ryzyka odpowiadającym oczekiwanej wartości błędu bezwzględnego.
abs ([dane, nazwa, atr, wyj])	Jak sama nazwa wskazuje, funkcja ta zwróci elementarną wartość bezwzględną wejścia.
adagrad_update ([waga, grad, historia, lr,…])	Jest to funkcja aktualizacji dla AdaGrad optimizer.
adam_update ([waga, grad, średnia, zmienna, lr,…])	Jest to funkcja aktualizacji dla Adam optimizer.
add_n (* args, ** kwargs)	Jak sama nazwa wskazuje, doda wszystkie argumenty wejściowe według elementów.
arccos ([dane, nazwa, atr, wyj])	Ta funkcja zwróci odwrotny cosinus z tablicy wejściowej.
kropka ([lhs, rhs, transpose_a, transpose_b,…])	Jak nazwa wskazuje, da iloczyn skalarny dwóch tablic. Będzie to zależeć od wymiaru tablicy wejściowej: 1-D: iloczyn wewnętrzny wektorów 2-D: mnożenie macierzy ND: iloczyn sumy ostatniej osi pierwszego wejścia i pierwszej osi drugiego wejścia.
elemwise_add ([lewa, prawa oś, nazwa, atr, koniec])	Jak nazwa wskazuje, będzie add argumenty element mądry.
elemwise_div ([lewa, prawa oś, nazwa, atr, koniec])	Jak nazwa wskazuje, będzie divide argumenty element mądry.
elemwise_mul ([lewa, prawa oś, nazwa, atr, koniec])	Jak nazwa wskazuje, będzie Multiply argumenty element mądry.
elemwise_sub ([lewa, prawa oś, nazwa, atr, koniec])	Jak sama nazwa wskazuje, będzie to mądre odejmowanie argumentów.
exp ([dane, nazwa, atr, wyj])	Ta funkcja zwróci elementarną wartość wykładniczą danego wejścia.
sgd_update ([waga, grad, lr, wd,…])	Działa jako funkcja aktualizacji dla optymalizatora Stochastic Gradient Descent.
sigmoid ([dane, nazwa, atr, wyj])	Jak nazwa wskazuje, to obliczy sigmoid x element mądry.
sign ([data, name, attr, out])	Zwróci mądry znak elementu podanego wejścia.
sin ([dane, nazwa, atr, wyj])	Jak nazwa wskazuje, funkcja ta obliczy element mądry sinus z danej tablicy wejściowej.

Przykład implementacji

W poniższym przykładzie będziemy losowo tasować elementy za pomocą ElementWiseSum()funkcjonować. Zmapuje indeksy liczb całkowitych na reprezentacje wektorowe, tj. Osadzanie słów.

input_dim = 4
output_dim = 5

Example

/* Here every row in weight matrix y represents a word. So, y = (w0,w1,w2,w3)
y = [[ 0., 1., 2., 3., 4.],
[ 5., 6., 7., 8., 9.],
[ 10., 11., 12., 13., 14.],
[ 15., 16., 17., 18., 19.]]
/* Here input array x represents n-grams(2-gram). So, x = [(w1,w3), (w0,w2)]
x = [[ 1., 3.],
[ 0., 2.]]
/* Now, Mapped input x to its vector representation y.
Embedding(x, y, 4, 5) = [[[ 5., 6., 7., 8., 9.],
[ 15., 16., 17., 18., 19.]],
[[ 0., 1., 2., 3., 4.],
[ 10., 11., 12., 13., 14.]]]

Interfejs API modułu Apache MXNet jest podobny do modelu FeedForward i łatwiej jest komponować podobnie do modułu Torch. Składa się z następujących zajęć -

BaseModule ([logger])

Reprezentuje klasę bazową modułu. Moduł można traktować jako komponent obliczeniowy lub maszynę obliczeniową. Zadaniem modułu jest wykonywanie przejść do przodu i do tyłu. Aktualizuje również parametry w modelu.

Metody

Poniższa tabela przedstawia stosowane metody BaseModule class-

Ta metoda pobierze stany ze wszystkich urządzeń

Metody	Definicja
backward ([out_grads])	Jak nazwa wskazuje, ta metoda implementuje backward obliczenie.
bind (data_shapes [, label_shapes,…])	Wiąże symbole do konstruowania wykonawców i jest to konieczne, zanim będzie można wykonać obliczenia z modułem.
fit (train_data [, eval_data, eval_metric,…])	Ta metoda szkoli parametry modułu.
forward (data_batch [, is_train])	Jak nazwa wskazuje, ta metoda implementuje obliczenia Forward. Ta metoda obsługuje partie danych o różnych kształtach, takich jak różne rozmiary partii lub różne rozmiary obrazów.
forward_backward (data_batch)	Jest to wygodna funkcja, jak sama nazwa wskazuje, która wywołuje zarówno naprzód, jak i wstecz.
get_input_grads ([merge_multi_context])	Ta metoda pobierze gradienty do danych wejściowych, które są obliczane w poprzednim obliczeniu wstecznym.
get_outputs ([merge_multi_context])	Jak sama nazwa wskazuje, ta metoda pobierze dane wyjściowe z poprzednich obliczeń do przodu.
get_params ()	Pobiera parametry, zwłaszcza te, które są potencjalnie kopiami rzeczywistych parametrów używanych do obliczeń na urządzeniu.
get_states ([merge_multi_context])
init_optimizer ([kvstore, optimizer,…])	Ta metoda instaluje i inicjalizuje optymalizatory. Inicjuje się równieżkvstore do dystrybucji szkolenia.
init_params ([inicjator, arg_params,…])	Jak sama nazwa wskazuje, ta metoda zainicjuje parametry i stany pomocnicze.
install_monitor (pon.)	Ta metoda zainstaluje monitor na wszystkich modułach wykonawczych.
iter_predict (eval_data [, num_batch, reset,…])	Ta metoda będzie powtarzać przewidywania.
load_params (fname)	Jak nazwa wskazuje, załaduje parametry modelu z pliku.
przewidzieć (eval_data [, num_batch,…])	Uruchomi prognozę i zbierze również wyniki.
przygotuj (data_batch [, sparse_row_id_fn])	Operator przygotowuje moduł do przetworzenia zadanej partii danych.
save_params (fname)	Jak nazwa wskazuje, funkcja ta zapisze parametry modelu do pliku.
wynik (eval_data, eval_metric [, num_batch,…])	Uruchamia prognozę eval_data a także ocenia wydajność zgodnie z podanymi eval_metric.
set_params (arg_params, aux_params [,…])	Ta metoda przypisze parametry i wartości stanu pomocniczego.
set_states ([stany, wartość])	Ta metoda, jak sama nazwa wskazuje, ustawia wartości dla stanów.
aktualizacja()	Ta metoda aktualizuje podane parametry zgodnie z zainstalowanym optymalizatorem. Aktualizuje również gradienty obliczone w poprzedniej partii do przodu i do tyłu.
update_metric (eval_metric, labels [, pre_sliced])	Ta metoda, jak sama nazwa wskazuje, ocenia i gromadzi metrykę oceny wyników ostatniego obliczenia w przód.
backward ([out_grads])	Jak nazwa wskazuje, ta metoda implementuje backward obliczenie.
bind (data_shapes [, label_shapes,…])	Konfiguruje zasobniki i wiąże moduł wykonawczy z domyślnym kluczem zasobnika. Ta metoda reprezentuje powiązanie dlaBucketingModule.
forward (data_batch [, is_train])	Jak nazwa wskazuje, ta metoda implementuje obliczenia Forward. Ta metoda obsługuje partie danych o różnych kształtach, takich jak różne rozmiary partii lub różne rozmiary obrazów.
get_input_grads ([merge_multi_context])	Ta metoda dostarczy gradienty do danych wejściowych, które są obliczane w poprzednim obliczeniu wstecznym.
get_outputs ([merge_multi_context])	Jak nazwa wskazuje, ta metoda uzyska dane wyjściowe z poprzedniego obliczenia w przód.
get_params ()	Pobiera bieżące parametry, szczególnie te, które są potencjalnie kopiami rzeczywistych parametrów używanych do obliczeń na urządzeniu.
get_states ([merge_multi_context])	Ta metoda pobierze stany ze wszystkich urządzeń.
init_optimizer ([kvstore, optimizer,…])	Ta metoda instaluje i inicjalizuje optymalizatory. Inicjuje się równieżkvstore do dystrybucji szkolenia.
init_params ([inicjator, arg_params,…])	Jak sama nazwa wskazuje, ta metoda zainicjuje parametry i stany pomocnicze.
install_monitor (pon.)	Ta metoda zainstaluje monitor na wszystkich modułach wykonawczych.
load (prefiks, epoch [, sym_gen,…])	Ta metoda stworzy model z wcześniej zapisanego punktu kontrolnego.
load_dict ([sym_dict, sym_gen,…])	Ta metoda utworzy model na podstawie mapowania słownikowego (dict) bucket_keydo symboli. Udostępnia równieżarg_params i aux_params.
przygotuj (data_batch [, sparse_row_id_fn])	Operator przygotowuje moduł do przetworzenia zadanej partii danych.
save_checkpoint (prefiks, epoka [, remove_amp_cast])	Ta metoda, jak sama nazwa wskazuje, zapisuje bieżący postęp w punkcie kontrolnym dla wszystkich zasobników w module BucketingModule. Zaleca się użycie mx.callback.module_checkpoint jako epoch_end_callback, aby zapisać podczas uczenia.
set_params (arg_params, aux_params [,…])	Jak nazwa wskazuje, funkcja ta przypisze parametry i wartości stanu pomocniczego.
set_states ([stany, wartość])	Ta metoda, jak sama nazwa wskazuje, ustawia wartości dla stanów.
switch_bucket (klucz_zbiornika, kształty_danych [,…])	Przełącza się do innego zasobnika.
aktualizacja()	Ta metoda aktualizuje podane parametry zgodnie z zainstalowanym optymalizatorem. Aktualizuje również gradienty obliczone w poprzedniej partii do przodu i do tyłu.
update_metric (eval_metric, labels [, pre_sliced])	Ta metoda, jak sama nazwa wskazuje, ocenia i gromadzi metrykę oceny wyników ostatniego obliczenia w przód.

Atrybuty

Poniższa tabela przedstawia atrybuty składające się z metod BaseModule klasa -

Atrybuty	Definicja
nazwy_danych	Zawiera listę nazw dla danych wymaganych przez ten moduł.
data_shapes	Składa się z listy par (nazwa, kształt) określających dane wejściowe do tego modułu.
label_shapes	Pokazuje listę par (nazwa, kształt) określających wejścia etykiet do tego modułu.
nazwy_wyjściowe	Zawiera listę nazw wyjść tego modułu.
output_shapes	Składa się z listy par (nazwa, kształt) określających wyjścia tego modułu.
symbol	Zgodnie z nazwą, ten atrybut pobiera symbol skojarzony z tym modułem.

data_shapes: Możesz polecić link dostępny pod adresem https://mxnet.apache.orgdla szczegółów. output_shapes: Więcej

output_shapes: Więcej informacji można znaleźć pod adresem https://mxnet.apache.org/api/python

BucketingModule (sym_gen […])

Reprezentuje Bucketingmodule klasa modułu, która pomaga efektywnie radzić sobie z wejściami o różnej długości.

Metody

Poniższa tabela przedstawia stosowane metody BucketingModule class -

Atrybuty

Poniższa tabela przedstawia atrybuty składające się z metod BaseModule class -

Atrybuty	Definicja
nazwy_danych	Zawiera listę nazw dla danych wymaganych przez ten moduł.
data_shapes	Składa się z listy par (nazwa, kształt) określających dane wejściowe do tego modułu.
label_shapes	Pokazuje listę par (nazwa, kształt) określających wejścia etykiet do tego modułu.
nazwy_wyjściowe	Zawiera listę nazw wyjść tego modułu.
output_shapes	Składa się z listy par (nazwa, kształt) określających wyjścia tego modułu.
Symbol	Zgodnie z nazwą, ten atrybut pobiera symbol skojarzony z tym modułem.

data_shapes - możesz skierować link pod adresem https://mxnet.apache.org/api/python/docs po więcej informacji.

output_shapes- Możesz odnieść się do linku na https://mxnet.apache.org/api/python/docs po więcej informacji.

Moduł (symbol [, data_names, label_names,…])

Reprezentuje podstawowy moduł, który zawija symbol.

Metody

Poniższa tabela przedstawia stosowane metody Module class -

Metody	Definicja
backward ([out_grads])	Jak nazwa wskazuje, ta metoda implementuje backward obliczenie.
bind (data_shapes [, label_shapes,…])	Wiąże symbole do konstruowania wykonawców i jest to konieczne, zanim będzie można wykonać obliczenia z modułem.
borrow_optimizer (shared_module)	Jak sama nazwa wskazuje, ta metoda pożyczy optymalizator z udostępnionego modułu.
forward (data_batch [, is_train])	Jak nazwa wskazuje, ta metoda implementuje Forwardobliczenie. Ta metoda obsługuje partie danych o różnych kształtach, takich jak różne rozmiary partii lub różne rozmiary obrazów.
get_input_grads ([merge_multi_context])	Ta metoda pobierze gradienty do danych wejściowych, które są obliczane w poprzednim obliczeniu wstecznym.
get_outputs ([merge_multi_context])	Jak sama nazwa wskazuje, ta metoda pobierze dane wyjściowe z poprzednich obliczeń do przodu.
get_params ()	Pobiera parametry, zwłaszcza te, które są potencjalnie kopiami rzeczywistych parametrów używanych do obliczeń na urządzeniu.
get_states ([merge_multi_context])	Ta metoda pobierze stany ze wszystkich urządzeń
init_optimizer ([kvstore, optimizer,…])	Ta metoda instaluje i inicjalizuje optymalizatory. Inicjuje się równieżkvstore do dystrybucji szkolenia.
init_params ([inicjator, arg_params,…])	Jak sama nazwa wskazuje, ta metoda zainicjuje parametry i stany pomocnicze.
install_monitor (pon.)	Ta metoda zainstaluje monitor na wszystkich modułach wykonawczych.
load (prefiks, epoch [, sym_gen,…])	Ta metoda stworzy model z wcześniej zapisanego punktu kontrolnego.
load_optimizer_states (fname)	Ta metoda załaduje optymalizator, tj. Stan Updater z pliku.
przygotuj (data_batch [, sparse_row_id_fn])	Operator przygotowuje moduł do przetworzenia zadanej partii danych.
reshape (data_shapes [, label_shapes])	Ta metoda, jak sama nazwa wskazuje, zmienia kształt modułu dla nowych kształtów wejściowych.
save_checkpoint (prefiks, epoka [,…])	Zapisuje bieżący postęp do punktu kontrolnego.
save_optimizer_states (fname)	Ta metoda zapisuje stan optymalizatora lub aktualizatora do pliku.
set_params (arg_params, aux_params [,…])	Jak nazwa wskazuje, funkcja ta przypisze parametry i wartości stanu pomocniczego.
set_states ([stany, wartość])	Ta metoda, jak sama nazwa wskazuje, ustawia wartości dla stanów.
aktualizacja()	Ta metoda aktualizuje podane parametry zgodnie z zainstalowanym optymalizatorem. Aktualizuje również gradienty obliczone w poprzedniej partii do przodu i do tyłu.
update_metric (eval_metric, labels [, pre_sliced])	Ta metoda, jak sama nazwa wskazuje, ocenia i gromadzi metrykę oceny wyników ostatniego obliczenia w przód.

Atrybuty

Poniższa tabela przedstawia atrybuty składające się z metod Module class -

Atrybuty	Definicja
nazwy_danych	Zawiera listę nazw dla danych wymaganych przez ten moduł.
data_shapes	Składa się z listy par (nazwa, kształt) określających dane wejściowe do tego modułu.
label_shapes	Pokazuje listę par (nazwa, kształt) określających wejścia etykiet do tego modułu.
nazwy_wyjściowe	Zawiera listę nazw wyjść tego modułu.
output_shapes	Składa się z listy par (nazwa, kształt) określających wyjścia tego modułu.
label_names	Zawiera listę nazw etykiet wymaganych przez ten moduł.

data_shapes: Odwiedź łącze https://mxnet.apache.org/api/python/docs/api/module dla dalszych szczegółów.

output_shapes: link podany w niniejszym dokumencie https://mxnet.apache.org/api/python/docs/api/module/index.html poda inne ważne informacje.

PythonLossModule ([nazwa, nazwa_danych,…])

Podstawą tej klasy jest mxnet.module.python_module.PythonModule. Klasa PythonLossModule to wygodna klasa modułu, która implementuje wszystkie lub wiele funkcji API modułu jako puste funkcje.

Metody

Poniższa tabela przedstawia stosowane metody PythonLossModule klasa:

Metody	Definicja
backward ([out_grads])	Jak nazwa wskazuje, ta metoda implementuje backward obliczenie.
forward (data_batch [, is_train])	Jak nazwa wskazuje, ta metoda implementuje Forwardobliczenie. Ta metoda obsługuje partie danych o różnych kształtach, takich jak różne rozmiary partii lub różne rozmiary obrazów.
get_input_grads ([merge_multi_context])	Ta metoda pobierze gradienty do danych wejściowych, które są obliczane w poprzednim obliczeniu wstecznym.
get_outputs ([merge_multi_context])	Jak sama nazwa wskazuje, ta metoda pobierze dane wyjściowe z poprzednich obliczeń do przodu.
install_monitor (pon.)	Ta metoda zainstaluje monitor na wszystkich modułach wykonawczych.

PythonModule ([data_names, label_names…])

Podstawą tej klasy jest mxnet.module.base_module.BaseModule. Klasa PythonModule jest również wygodną klasą modułu, która implementuje wszystkie lub wiele funkcji API modułu jako puste funkcje.

Metody

Poniższa tabela przedstawia stosowane metody PythonModule klasa -

Metody	Definicja
bind (data_shapes [, label_shapes,…])	Wiąże symbole do konstruowania wykonawców i jest to konieczne, zanim będzie można wykonać obliczenia z modułem.
get_params ()	Pobiera parametry, zwłaszcza te, które są potencjalnie kopiami rzeczywistych parametrów używanych do obliczeń na urządzeniu.
init_optimizer ([kvstore, optimizer,…])	Ta metoda instaluje i inicjalizuje optymalizatory. Inicjuje się równieżkvstore do dystrybucji szkolenia.
init_params ([inicjator, arg_params,…])	Jak sama nazwa wskazuje, ta metoda zainicjuje parametry i stany pomocnicze.
aktualizacja()	Ta metoda aktualizuje podane parametry zgodnie z zainstalowanym optymalizatorem. Aktualizuje również gradienty obliczone w poprzedniej partii do przodu i do tyłu.
update_metric (eval_metric, labels [, pre_sliced])	Ta metoda, jak sama nazwa wskazuje, ocenia i gromadzi metrykę oceny wyników ostatniego obliczenia w przód.

Atrybuty

Poniższa tabela przedstawia atrybuty składające się z metod PythonModule klasa -

Atrybuty	Definicja
nazwy_danych	Zawiera listę nazw dla danych wymaganych przez ten moduł.
data_shapes	Składa się z listy par (nazwa, kształt) określających dane wejściowe do tego modułu.
label_shapes	Pokazuje listę par (nazwa, kształt) określających wejścia etykiet do tego modułu.
nazwy_wyjściowe	Zawiera listę nazw wyjść tego modułu.
output_shapes	Składa się z listy par (nazwa, kształt) określających wyjścia tego modułu.

data_shapes - skorzystaj z linku https://mxnet.apache.org dla szczegółów.

output_shapes - Aby uzyskać więcej informacji, odwiedź link dostępny pod adresem https://mxnet.apache.org

SequentialModule ([logger])

Podstawą tej klasy jest mxnet.module.base_module.BaseModule. Klasa SequentialModule jest również modułem kontenera, który może łączyć ze sobą więcej niż dwa (wiele) modułów.

Metody

Poniższa tabela przedstawia stosowane metody SequentialModule klasa

Metody	Definicja
add (module, ** kwargs)	To najważniejsza funkcja tej klasy. Dodaje moduł do łańcucha.
backward ([out_grads])	Jak nazwa wskazuje, ta metoda implementuje obliczenia wsteczne.
bind (data_shapes [, label_shapes,…])	Wiąże symbole do konstruowania wykonawców i jest to konieczne, zanim będzie można wykonać obliczenia z modułem.
forward (data_batch [, is_train])	Jak nazwa wskazuje, ta metoda implementuje obliczenia Forward. Ta metoda obsługuje partie danych o różnych kształtach, takich jak różne rozmiary partii lub różne rozmiary obrazów.
get_input_grads ([merge_multi_context])	Ta metoda pobierze gradienty do danych wejściowych, które są obliczane w poprzednim obliczeniu wstecznym.
get_outputs ([merge_multi_context])	Jak sama nazwa wskazuje, ta metoda pobierze dane wyjściowe z poprzednich obliczeń do przodu.
get_params ()	Pobiera parametry, zwłaszcza te, które są potencjalnie kopiami rzeczywistych parametrów używanych do obliczeń na urządzeniu.
init_optimizer ([kvstore, optimizer,…])	Ta metoda instaluje i inicjalizuje optymalizatory. Inicjuje się równieżkvstore do dystrybucji szkolenia.
init_params ([inicjator, arg_params,…])	Jak sama nazwa wskazuje, ta metoda zainicjuje parametry i stany pomocnicze.
install_monitor (pon.)	Ta metoda zainstaluje monitor na wszystkich modułach wykonawczych.
aktualizacja()	Ta metoda aktualizuje podane parametry zgodnie z zainstalowanym optymalizatorem. Aktualizuje również gradienty obliczone w poprzedniej partii do przodu i do tyłu.
update_metric (eval_metric, labels [, pre_sliced])	Ta metoda, jak sama nazwa wskazuje, ocenia i gromadzi metrykę oceny wyników ostatniego obliczenia w przód.

Atrybuty

Poniższa tabela przedstawia atrybuty zawarte w metodach klasy BaseModule -

Atrybuty	Definicja
nazwy_danych	Zawiera listę nazw dla danych wymaganych przez ten moduł.
data_shapes	Składa się z listy par (nazwa, kształt) określających dane wejściowe do tego modułu.
label_shapes	Pokazuje listę par (nazwa, kształt) określających wejścia etykiet do tego modułu.
nazwy_wyjściowe	Zawiera listę nazw wyjść tego modułu.
output_shapes	Składa się z listy par (nazwa, kształt) określających wyjścia tego modułu.
output_shapes	Składa się z listy par (nazwa, kształt) określających wyjścia tego modułu.

data_shapes - link podany w niniejszym dokumencie https://mxnet.apache.org pomoże ci szczegółowo zrozumieć atrybut.

output_shapes - Skorzystaj z linku dostępnego pod adresem https://mxnet.apache.org/api dla szczegółów.

Przykłady wdrożeń

W poniższym przykładzie utworzymy plik mxnet moduł.

import mxnet as mx
input_data = mx.symbol.Variable('input_data')
f_connected1 = mx.symbol.FullyConnected(data, name='f_connected1', num_hidden=128)
activation_1 = mx.symbol.Activation(f_connected1, name='relu1', act_type="relu")
f_connected2 = mx.symbol.FullyConnected(activation_1, name = 'f_connected2', num_hidden = 64)
activation_2 = mx.symbol.Activation(f_connected2, name='relu2',
act_type="relu")
f_connected3 = mx.symbol.FullyConnected(activation_2, name='fc3', num_hidden=10)
out = mx.symbol.SoftmaxOutput(f_connected3, name = 'softmax')
mod = mx.mod.Module(out)
print(out)

Output

Dane wyjściowe są wymienione poniżej -

<Symbol softmax>

Example

print(mod)

Output

Wyjście pokazano poniżej -

<mxnet.module.module.Module object at 0x00000123A9892F28>

W poniższym przykładzie będziemy implementować obliczenia do przodu

import mxnet as mx
from collections import namedtuple
Batch = namedtuple('Batch', ['data'])
data = mx.sym.Variable('data')
out = data * 2
mod = mx.mod.Module(symbol=out, label_names=None)
mod.bind(data_shapes=[('data', (1, 10))])
mod.init_params()
data1 = [mx.nd.ones((1, 10))]
mod.forward(Batch(data1))
print (mod.get_outputs()[0].asnumpy())

Output

Po wykonaniu powyższego kodu powinieneś zobaczyć następujące dane wyjściowe -

[[2. 2. 2. 2. 2. 2. 2. 2. 2. 2.]]

Example

data2 = [mx.nd.ones((3, 5))]

mod.forward(Batch(data2))
print (mod.get_outputs()[0].asnumpy())

Output

Poniżej podano wynik kodu -

[[2. 2. 2. 2. 2.]
[2. 2. 2. 2. 2.]
[2. 2. 2. 2. 2.]]