Apache MXNet - Panduan Cepat

Bab ini menyoroti fitur-fitur Apache MXNet dan berbicara tentang versi terbaru dari kerangka kerja perangkat lunak pembelajaran mendalam ini.

Apa itu MXNet?

Apache MXNet adalah instrumen kerangka kerja perangkat lunak pembelajaran mendalam sumber terbuka yang kuat yang membantu pengembang membangun, melatih, dan menerapkan model Pembelajaran Mendalam. Beberapa tahun terakhir, dari perawatan kesehatan hingga transportasi hingga manufaktur dan, pada kenyataannya, dalam setiap aspek kehidupan kita sehari-hari, dampak pembelajaran mendalam telah tersebar luas. Saat ini, pembelajaran mendalam dicari oleh perusahaan untuk memecahkan beberapa masalah sulit seperti Pengenalan wajah, deteksi objek, Pengenalan Karakter Optik (OCR), Pengenalan Ucapan, dan Terjemahan Mesin.

Itulah alasan Apache MXNet didukung oleh:

Beberapa perusahaan besar seperti Intel, Baidu, Microsoft, Wolfram Research, dll.
Penyedia cloud publik termasuk Amazon Web Services (AWS), dan Microsoft Azure
Beberapa lembaga penelitian besar seperti Carnegie Mellon, MIT, Universitas Washington, dan Universitas Sains & Teknologi Hong Kong.

Mengapa Apache MXNet?

Ada berbagai platform pembelajaran mendalam seperti Torch7, Caffe, Theano, TensorFlow, Keras, Microsoft Cognitive Toolkit, dll. Ada maka Anda mungkin bertanya-tanya mengapa Apache MXNet? Mari kita lihat beberapa alasan di baliknya:

Apache MXNet memecahkan salah satu masalah terbesar dari platform pembelajaran mendalam yang ada. Masalahnya adalah untuk menggunakan platform pembelajaran yang dalam, seseorang harus mempelajari sistem lain untuk citarasa pemrograman yang berbeda.
Dengan bantuan pengembang Apache MXNet dapat memanfaatkan kemampuan penuh GPU serta komputasi awan.
Apache MXNet dapat mempercepat komputasi numerik apa pun dan memberikan penekanan khusus pada percepatan pengembangan dan penerapan DNN skala besar (jaringan neural dalam).
Ini memberikan pengguna kemampuan pemrograman imperatif dan simbolik.

Berbagai Fitur

Jika Anda mencari library deep learning yang fleksibel untuk mengembangkan penelitian deep learning mutakhir dengan cepat atau platform yang kuat untuk mendorong beban kerja produksi, pencarian Anda berakhir di Apache MXNet. Itu karena fitur-fiturnya berikut ini:

Pelatihan Terdistribusi

Baik itu pelatihan multi-gpu atau multi-host dengan efisiensi penskalaan yang hampir linier, Apache MXNet memungkinkan pengembang untuk memaksimalkan perangkat keras mereka. MXNet juga mendukung integrasi dengan Horovod, yang merupakan kerangka pembelajaran terdistribusi sumber terbuka yang dibuat di Uber.

Untuk integrasi ini, berikut adalah beberapa API terdistribusi umum yang ditentukan di Horovod:

horovod.broadcast()
horovod.allgather()
horovod.allgather()

Dalam hal ini, MXNet menawarkan kepada kami kemampuan berikut:

Device Placement - Dengan bantuan MXNet kita dapat dengan mudah menentukan setiap struktur data (DS).
Automatic Differentiation - Apache MXNet mengotomatiskan diferensiasi, yaitu kalkulasi turunan.
Multi-GPU training - MXNet memungkinkan kami mencapai efisiensi penskalaan dengan sejumlah GPU yang tersedia.
Optimized Predefined Layers - Kita dapat mengkodekan lapisan kita sendiri di MXNet serta mengoptimalkan lapisan yang telah ditentukan sebelumnya untuk kecepatan juga.

Hibridisasi

Apache MXNet memberi penggunanya front-end hybrid. Dengan bantuan Gluon Python API, ia dapat menjembatani kesenjangan antara kemampuan imperatif dan simbolisnya. Itu dapat dilakukan dengan menyebutnya fungsi hibridisasi.

Komputasi Lebih Cepat

Operasi linier seperti puluhan atau ratusan perkalian matriks adalah penghambat komputasi untuk jaringan saraf dalam. Untuk mengatasi kemacetan ini MXNet menyediakan -

Perhitungan numerik yang dioptimalkan untuk GPU
Perhitungan numerik yang dioptimalkan untuk ekosistem terdistribusi
Otomatisasi alur kerja umum dengan bantuan NN standar yang dapat diekspresikan secara singkat.

Binding Bahasa

MXNet memiliki integrasi yang dalam ke bahasa tingkat tinggi seperti Python dan R. Ini juga menyediakan dukungan untuk bahasa pemrograman lain seperti-

Scala
Julia
Clojure
Java
C/C++
Perl

Kami tidak perlu mempelajari bahasa pemrograman baru, melainkan MXNet, yang dikombinasikan dengan fitur hibridisasi, memungkinkan transisi yang sangat mulus dari Python ke penerapan dalam bahasa pemrograman pilihan kami.

Versi MXNet 1.6.0

Apache Software Foundation (ASF) telah merilis Apache MXNet versi 1.6.0 yang stabil pada 21 Februari 2020 di bawah Lisensi Apache 2.0. Ini adalah rilis MXNet terakhir yang mendukung Python 2 karena komunitas MXNet memilih untuk tidak lagi mendukung Python 2 di rilis selanjutnya. Mari kita lihat beberapa fitur baru yang dibawa rilis ini untuk penggunanya.

Antarmuka yang Kompatibel dengan NumPy

Karena fleksibilitas dan keumumannya, NumPy telah banyak digunakan oleh praktisi, ilmuwan, dan pelajar Machine Learning. Namun seperti yang kita ketahui bahwa, akselerator perangkat keras saat ini seperti Graphical Processing Units (GPU) telah semakin berasimilasi dengan berbagai toolkit Machine Learning (ML), pengguna NumPy, untuk memanfaatkan kecepatan GPU, perlu beralih ke framework baru dengan sintaks yang berbeda.

Dengan MXNet 1.6.0, Apache MXNet bergerak menuju pengalaman pemrograman yang kompatibel dengan NumPy. Antarmuka baru memberikan kegunaan yang setara serta ekspresif bagi praktisi yang akrab dengan sintaks NumPy. Bersamaan dengan itu MXNet 1.6.0 juga memungkinkan sistem Numpy yang ada untuk memanfaatkan akselerator perangkat keras seperti GPU untuk mempercepat komputasi skala besar.

Integrasi dengan Apache TVM

Apache TVM, tumpukan kompiler pembelajaran mendalam end-to-end open-source untuk backend perangkat keras seperti CPU, GPU, dan akselerator khusus, bertujuan untuk mengisi celah antara kerangka kerja pembelajaran mendalam yang berfokus pada produktivitas dan backend perangkat keras yang berorientasi pada kinerja . Dengan rilis terbaru MXNet 1.6.0, pengguna dapat memanfaatkan Apache (inkubasi) TVM untuk mengimplementasikan kernel operator berperforma tinggi dalam bahasa pemrograman Python. Dua keuntungan utama dari fitur baru ini adalah sebagai berikut -

Menyederhanakan proses pengembangan berbasis C ++ sebelumnya.
Memungkinkan berbagi implementasi yang sama di beberapa backend perangkat keras seperti CPU, GPU, dll.

Perbaikan fitur yang ada

Terlepas dari fitur MXNet 1.6.0 yang terdaftar di atas, ini juga memberikan beberapa peningkatan atas fitur yang ada. Perbaikannya adalah sebagai berikut -

Pengelompokan operasi berdasarkan elemen untuk GPU

Seperti yang kita ketahui kinerja operasi elemen-bijaksana adalah memori-bandwidth dan itulah alasannya, merangkai operasi semacam itu dapat mengurangi kinerja secara keseluruhan. Apache MXNet 1.6.0 melakukan fusi operasi berdasarkan elemen, yang sebenarnya menghasilkan operasi gabungan just-in-time jika memungkinkan. Fusi operasi yang bijak dengan elemen tersebut juga mengurangi kebutuhan penyimpanan dan meningkatkan kinerja secara keseluruhan.

Menyederhanakan ekspresi umum

MXNet 1.6.0 menghilangkan ekspresi redundan dan menyederhanakan ekspresi umum. Peningkatan tersebut juga meningkatkan penggunaan memori dan waktu eksekusi total.

Optimasi

MXNet 1.6.0 juga memberikan berbagai optimasi pada fitur & operator yang ada, yaitu sebagai berikut:

Presisi Campuran Otomatis
API Gluon Fit
MKL-DNN
Dukungan tensor besar
TensorRT integrasi
Dukungan gradien tingkat tinggi
Operators
Profiler kinerja operator
Impor / ekspor ONNX
Peningkatan pada Gluon API
Perbaikan pada Symbol API
Lebih dari 100 perbaikan bug

Untuk memulai MXNet, hal pertama yang perlu kita lakukan adalah menginstalnya di komputer kita. Apache MXNet berfungsi pada hampir semua platform yang tersedia, termasuk Windows, Mac, dan Linux.

OS Linux

Kami dapat menginstal MXNet di OS Linux dengan cara berikut -

Unit Pemrosesan Grafis (GPU)

Di sini, kami akan menggunakan berbagai metode yaitu Pip, Docker, dan Sumber untuk menginstal MXNet saat kami menggunakan GPU untuk pemrosesan -

Dengan menggunakan metode Pip

Anda dapat menggunakan perintah berikut untuk menginstal MXNet di Linus OS -

pip install mxnet

Apache MXNet juga menawarkan paket pip MKL, yang jauh lebih cepat jika dijalankan pada perangkat keras intel. Di sini misalnyamxnet-cu101mkl artinya -

Paket ini dibangun dengan CUDA / cuDNN
Paket ini mendukung MKL-DNN
Versi CUDA adalah 10.1

Untuk opsi lain, Anda juga bisa merujuk ke https://pypi.org/project/mxnet/.

Dengan menggunakan Docker

Anda dapat menemukan image buruh pelabuhan dengan MXNet di DockerHub, yang tersedia di https://hub.docker.com/u/mxnet Mari kita lihat langkah-langkah di bawah ini untuk menginstal MXNet dengan menggunakan Docker dengan GPU -

Step 1- Pertama, dengan mengikuti petunjuk instalasi buruh pelabuhan yang tersedia di https://docs.docker.com/engine/install/ubuntu/. Kita perlu menginstal Docker di komputer kita.

Step 2- Untuk mengaktifkan penggunaan GPU dari container docker, selanjutnya kita perlu menginstal nvidia-docker-plugin. Anda dapat mengikuti petunjuk penginstalan yang diberikan dihttps://github.com/NVIDIA/nvidia-docker/wiki.

Step 3- Dengan menggunakan perintah berikut, Anda dapat menarik gambar buruh pelabuhan MXNet -

$ sudo docker pull mxnet/python:gpu

Sekarang untuk melihat apakah mxnet / python docker image pull berhasil, kita dapat membuat daftar gambar docker sebagai berikut -

$ sudo docker images

Untuk kecepatan inferensi tercepat dengan MXNet, disarankan untuk menggunakan MXNet terbaru dengan Intel MKL-DNN. Periksa perintah di bawah ini -

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

Dari sumber

Untuk membangun pustaka bersama MXNet dari sumber dengan GPU, pertama-tama kita perlu menyiapkan lingkungan untuk CUDA dan cuDNN sebagai berikut−

Unduh dan instal toolkit CUDA, di sini CUDA 9.2 direkomendasikan.
Selanjutnya unduh cuDNN 7.1.4.
Sekarang kita perlu mengekstrak file. Juga diperlukan untuk mengubah ke direktori root cuDNN. Juga pindahkan tajuk dan pustaka ke folder CUDA Toolkit lokal sebagai berikut -

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

Setelah menyiapkan lingkungan untuk CUDA dan cuDNN, ikuti langkah-langkah di bawah ini untuk membuat pustaka bersama MXNet dari sumber -

Step 1- Pertama, kita perlu menginstal paket prasyarat. Ketergantungan ini diperlukan pada Ubuntu versi 16.04 atau yang lebih baru.

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

Step 2- Pada langkah ini, kita akan mengunduh sumber MXNet dan mengkonfigurasi. Pertama mari kita mengkloning repositori dengan menggunakan perintah berikut−

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

Step 3- Dengan menggunakan perintah berikut, Anda dapat membangun pustaka bersama inti MXNet−

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

Two important points regarding the above step is as follows−

Jika Anda ingin membangun versi Debug, tentukan sebagai berikut-

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Untuk menyetel jumlah pekerjaan kompilasi paralel, tentukan yang berikut -

cmake --build . --parallel N

Setelah Anda berhasil membangun pustaka bersama inti MXNet, di build folder di MXNet project root, Anda akan menemukan libmxnet.so yang diperlukan untuk menginstal binding bahasa (opsional).

Unit Pemrosesan Pusat (CPU)

Di sini, kami akan menggunakan berbagai metode yaitu Pip, Docker, dan Source untuk menginstal MXNet saat kami menggunakan CPU untuk pemrosesan -

Dengan menggunakan metode Pip

Anda dapat menggunakan perintah berikut untuk menginstal MXNet pada Linus OS− Anda

pip install mxnet

Apache MXNet juga menawarkan paket pip berkemampuan MKL-DNN yang jauh lebih cepat, saat dijalankan pada perangkat keras intel.

pip install mxnet-mkl

Dengan menggunakan Docker

Anda dapat menemukan image buruh pelabuhan dengan MXNet di DockerHub, yang tersedia di https://hub.docker.com/u/mxnet. Mari kita lihat langkah-langkah di bawah ini untuk menginstal MXNet dengan menggunakan Docker dengan CPU -

Step 1- Pertama, dengan mengikuti petunjuk instalasi buruh pelabuhan yang tersedia di https://docs.docker.com/engine/install/ubuntu/. Kita perlu menginstal Docker di komputer kita.

Step 2- Dengan menggunakan perintah berikut, Anda dapat menarik image buruh pelabuhan MXNet:

$ sudo docker pull mxnet/python

Sekarang, untuk melihat apakah mxnet / python docker image pull berhasil, kita dapat membuat daftar gambar docker sebagai berikut -

$ sudo docker images

Untuk kecepatan inferensi tercepat dengan MXNet, disarankan untuk menggunakan MXNet terbaru dengan Intel MKL-DNN.

Periksa perintah di bawah ini -

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

Dari sumber

Untuk membangun pustaka bersama MXNet dari sumber dengan CPU, ikuti langkah-langkah di bawah ini -

Step 1- Pertama, kita perlu menginstal paket prasyarat. Ketergantungan ini diperlukan pada Ubuntu versi 16.04 atau yang lebih baru.

sudo apt-get update

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

Step 2- Pada langkah ini kita akan mengunduh sumber MXNet dan mengkonfigurasi. Pertama mari kita kloning repositori dengan menggunakan perintah berikut:

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

cd mxnet
cp config/linux.cmake config.cmake

Step 3- Dengan menggunakan perintah berikut, Anda dapat membuat pustaka bersama inti MXNet:

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

Two important points regarding the above step is as follows−

Jika Anda ingin membuat versi Debug, tentukan yang berikut ini:

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Untuk menyetel jumlah pekerjaan kompilasi paralel, tentukan yang berikut-

cmake --build . --parallel N

Setelah Anda berhasil membangun pustaka bersama inti MXNet, di build folder di root proyek MXNet Anda, Anda akan menemukan libmxnet.so, yang diperlukan untuk menginstal binding bahasa (opsional).

MacOS

Kita dapat menginstal MXNet pada MacOS dengan cara berikut−

Unit Pemrosesan Grafis (GPU)

Jika Anda berencana untuk membangun MXNet di MacOS dengan GPU, maka TIDAK ada metode Pip dan Docker yang tersedia. Satu-satunya metode dalam kasus ini adalah membangunnya dari sumber.

Dari sumber

Untuk membangun pustaka bersama MXNet dari sumber dengan GPU, pertama-tama kita perlu menyiapkan lingkungan untuk CUDA dan cuDNN. Anda harus mengikutiNVIDIA CUDA Installation Guide yang tersedia di https://docs.nvidia.com dan cuDNN Installation Guide, yang tersedia di https://docs.nvidia.com/deeplearning untuk mac OS.

Harap perhatikan bahwa pada 2019 CUDA berhenti mendukung macOS. Faktanya, versi CUDA mendatang mungkin juga tidak mendukung macOS.

Setelah Anda mengatur lingkungan untuk CUDA dan cuDNN, ikuti langkah-langkah yang diberikan di bawah ini untuk menginstal MXNet dari sumber di OS X (Mac) -

Step 1- Karena kita membutuhkan beberapa dependensi pada OS x, Pertama, kita perlu menginstal paket prasyarat.

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

Kami juga dapat membangun MXNet tanpa OpenCV karena opencv adalah ketergantungan opsional.

Step 2- Pada langkah ini kita akan mengunduh sumber MXNet dan mengkonfigurasi. Pertama mari kita mengkloning repositori dengan menggunakan perintah berikut−

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

cd mxnet
cp config/linux.cmake config.cmake

Untuk yang mendukung GPU, perlu menginstal dependensi CUDA terlebih dahulu karena ketika seseorang mencoba membangun build yang mendukung GPU pada mesin tanpa GPU, build MXNet tidak dapat mendeteksi arsitektur GPU Anda secara otomatis. Dalam kasus seperti itu MXNet akan menargetkan semua arsitektur GPU yang tersedia.

Step 3- Dengan menggunakan perintah berikut, Anda dapat membangun pustaka bersama inti MXNet−

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

Dua poin penting mengenai langkah di atas adalah sebagai berikut-

Jika Anda ingin membangun versi Debug, tentukan sebagai berikut-

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Untuk menyetel jumlah pekerjaan kompilasi paralel, tentukan berikut ini:

cmake --build . --parallel N

Setelah Anda berhasil membangun pustaka bersama inti MXNet, di build folder di MXNet project root, Anda akan menemukan libmxnet.dylib, yang diperlukan untuk menginstal binding bahasa (opsional).

Unit Pemrosesan Pusat (CPU)

Di sini, kita akan menggunakan berbagai metode yaitu Pip, Docker, dan Source untuk menginstal MXNet saat kita menggunakan CPU untuk pemrosesan−

Dengan menggunakan metode Pip

Anda dapat menggunakan perintah berikut untuk menginstal MXNet di Linus OS Anda

pip install mxnet

Dengan menggunakan Docker

Anda dapat menemukan image buruh pelabuhan dengan MXNet di DockerHub, yang tersedia di https://hub.docker.com/u/mxnet. Mari kita periksa langkah-langkah di bawah ini untuk menginstal MXNet dengan menggunakan Docker dengan CPU−

Step 1- Pertama, dengan mengikuti docker installation instructions yang tersedia di https://docs.docker.com/docker-for-mac kita perlu menginstal Docker di komputer kita.

Step 2- Dengan menggunakan perintah berikut, Anda dapat menarik image buruh pelabuhan MXNet−

$ docker pull mxnet/python

Sekarang untuk melihat apakah mxnet / python docker image pull berhasil, kita dapat membuat daftar gambar docker sebagai berikut−

$ docker images

Untuk kecepatan inferensi tercepat dengan MXNet, disarankan untuk menggunakan MXNet terbaru dengan Intel MKL-DNN. Periksa perintah di bawah-

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

Dari sumber

Ikuti langkah-langkah yang diberikan di bawah ini untuk menginstal MXNet dari sumber di OS X (Mac) -

Step 1- Karena kami memerlukan beberapa dependensi pada OS x, pertama-tama, kami perlu menginstal paket prasyarat.

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

Kami juga dapat membangun MXNet tanpa OpenCV karena opencv adalah ketergantungan opsional.

Step 2- Pada langkah ini kita akan mengunduh sumber MXNet dan mengkonfigurasi. Pertama, mari kita mengkloning repositori dengan menggunakan perintah berikut−

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

cd mxnet

cp config/linux.cmake config.cmake

Step 3- Dengan menggunakan perintah berikut, Anda dapat membuat pustaka bersama inti MXNet:

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

Two important points regarding the above step is as follows−

Jika Anda ingin membangun versi Debug, tentukan sebagai berikut-

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Untuk menyetel jumlah pekerjaan kompilasi paralel, tentukan yang berikut-

cmake --build . --parallel N

OS Windows

Untuk menginstal MXNet pada Windows, berikut adalah prasyarat-

Persyaratan Sistem Minimum

Windows 7, 10, Server 2012 R2, atau Server 2016
Visual Studio 2015 atau 2017 (tipe apa pun)
Python 2.7 atau 3.6
pip

Persyaratan Sistem yang Direkomendasikan

Windows 10, Server 2012 R2, atau Server 2016
Visual Studio 2017
Setidaknya satu GPU berkemampuan NVIDIA CUDA
CPU berkemampuan MKL: Prosesor Intel® Xeon®, keluarga prosesor Intel® Core ™, prosesor Intel Atom®, atau prosesor Intel® Xeon Phi ™
Python 2.7 atau 3.6
pip

Unit Pemrosesan Grafis (GPU)

Dengan menggunakan metode Pip−

Jika Anda berencana untuk membangun MXNet di Windows dengan GPU NVIDIA, ada dua opsi untuk menginstal MXNet dengan dukungan CUDA dengan paket Python−

Instal dengan Dukungan CUDA

Di bawah ini adalah langkah-langkah dengan bantuan yang, kami dapat mengatur MXNet dengan CUDA.

Step 1- Pertama instal Microsoft Visual Studio 2017 atau Microsoft Visual Studio 2015.

Step 2- Selanjutnya, unduh dan instal NVIDIA CUDA. Direkomendasikan untuk menggunakan CUDA versi 9.2 atau 9.0 karena beberapa masalah dengan CUDA 9.1 telah diidentifikasi sebelumnya.

Step 3- Sekarang, unduh dan instal NVIDIA_CUDA_DNN.

Step 4- Terakhir, dengan menggunakan perintah pip berikut, instal MXNet dengan CUDA−

pip install mxnet-cu92

Instal dengan CUDA dan Dukungan MKL

Di bawah ini adalah langkah-langkah dengan bantuan yang, kami dapat mengatur MXNet dengan CUDA dan MKL.

Step 1- Pertama instal Microsoft Visual Studio 2017 atau Microsoft Visual Studio 2015.

Step 2- Selanjutnya, unduh dan instal intel MKL

Step 3- Sekarang, unduh dan instal NVIDIA CUDA.

Step 4- Sekarang, unduh dan instal NVIDIA_CUDA_DNN.

Step 5- Terakhir, dengan menggunakan perintah pip berikut, instal MXNet dengan MKL.

pip install mxnet-cu92mkl

Dari sumber

Untuk membangun pustaka inti MXNet dari sumber dengan GPU, kami memiliki dua opsi berikut−

Option 1− Build with Microsoft Visual Studio 2017

Untuk membuat dan menginstal MXNet sendiri dengan menggunakan Microsoft Visual Studio 2017, Anda memerlukan dependensi berikut ini.

Install/update Microsoft Visual Studio.

Jika Microsoft Visual Studio belum diinstal di komputer Anda, unduh dan instal terlebih dahulu.
Ini akan meminta untuk menginstal Git. Instal juga.
Jika Microsoft Visual Studio telah diinstal di komputer Anda tetapi Anda ingin memperbaruinya, lanjutkan ke langkah berikutnya untuk mengubah penginstalan Anda. Di sini Anda akan diberi kesempatan untuk memperbarui Microsoft Visual Studio juga.

Ikuti petunjuk untuk membuka Penginstal Visual Studio yang tersedia di https://docs.microsoft.com/en-us untuk memodifikasi komponen Individual.

Di aplikasi Visual Studio Installer, perbarui sesuai kebutuhan. Setelah itu cari dan periksaVC++ 2017 version 15.4 v14.11 toolset dan klik Modify.

Sekarang dengan menggunakan perintah berikut, ubah versi Microsoft VS2017 menjadi v14.11−

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

Selanjutnya, Anda perlu mengunduh dan menginstal CMake Tersedia di https://cmake.org/download/ Dianjurkan untuk digunakan CMake v3.12.2 yang tersedia di https://cmake.org/download/ karena telah diuji dengan MXNet.

Sekarang, unduh dan jalankan OpenCV paket tersedia di https://sourceforge.net/projects/opencvlibrary/yang akan mengekstrak beberapa file. Terserah Anda apakah Anda ingin menempatkannya di direktori lain atau tidak. Di sini, kami akan menggunakan jalurC:\utils(mkdir C:\utils) sebagai jalur default kami.

Selanjutnya, kita perlu menyetel variabel lingkungan OpenCV_DIR agar mengarah ke direktori build OpenCV yang baru saja kita unzip. Untuk jenis dan prompt perintah terbuka iniset OpenCV_DIR=C:\utils\opencv\build.

Satu hal penting adalah jika Anda tidak menginstal Intel MKL (Math Kernel Library), Anda dapat menginstalnya.

Paket open source lain yang dapat Anda gunakan adalah OpenBLAS. Di sini untuk instruksi lebih lanjut, kami mengasumsikan bahwa Anda menggunakanOpenBLAS.

Jadi, Unduh OpenBlas paket yang tersedia di https://sourceforge.net dan unzip file tersebut, ganti namanya menjadi OpenBLAS dan meletakkannya di bawah C:\utils.

Selanjutnya, kita perlu mengatur variabel lingkungan OpenBLAS_HOME untuk menunjuk ke direktori OpenBLAS yang berisi file include dan libdirektori. Untuk jenis dan prompt perintah terbuka iniset OpenBLAS_HOME=C:\utils\OpenBLAS.

Sekarang, unduh dan instal CUDA yang tersedia di https://developer.nvidia.com. Perhatikan bahwa, jika Anda sudah memiliki CUDA, lalu menginstal Microsoft VS2017, Anda perlu menginstal ulang CUDA sekarang, sehingga Anda bisa mendapatkan komponen toolkit CUDA untuk integrasi Microsoft VS2017.

Selanjutnya, Anda perlu mengunduh dan menginstal cuDNN.

Selanjutnya, Anda perlu mengunduh dan menginstal git yang ada di https://gitforwindows.org/ juga.

Setelah Anda menginstal semua dependensi yang diperlukan, ikuti langkah-langkah yang diberikan di bawah ini untuk membuat kode sumber MXNet−

Step 1- Buka command prompt di windows.

Step 2- Sekarang, dengan menggunakan perintah berikut, unduh kode sumber MXNet dari GitHub:

cd C:\

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

Step 3- Selanjutnya, verifikasi berikut-

DCUDNN_INCLUDE and DCUDNN_LIBRARY variabel lingkungan mengarah ke include folder dan cudnn.lib file dari lokasi pemasangan CUDA Anda

C:\incubator-mxnet adalah lokasi kode sumber yang baru saja Anda kloning pada langkah sebelumnya.

Step 4- Selanjutnya dengan menggunakan perintah berikut, buat file build directory dan juga pergi ke direktori, misalnya−

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

Step 5- Sekarang, dengan menggunakan cmake, kompilasi kode sumber MXNet sebagai berikut-

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- Setelah CMake berhasil diselesaikan, gunakan perintah berikut untuk mengompilasi kode sumber MXNet−

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

Option 2: Build with Microsoft Visual Studio 2015

Untuk membuat dan menginstal MXNet sendiri dengan menggunakan Microsoft Visual Studio 2015, Anda memerlukan dependensi berikut ini.

Instal / perbarui Microsoft Visual Studio 2015. Persyaratan minimum untuk membangun MXnet dari sumber adalah Pembaruan 3 dari Microsoft Visual Studio 2015. Anda dapat menggunakan Tools -> Extensions and Updates... | Product Updates menu untuk meningkatkannya.

Selanjutnya, Anda perlu mengunduh dan menginstal CMake yang tersedia di https://cmake.org/download/. Dianjurkan untuk digunakanCMake v3.12.2 yang pada https://cmake.org/download/, karena telah diuji dengan MXNet.

Sekarang, unduh dan jalankan paket OpenCV yang tersedia di https://excellmedia.dl.sourceforge.netyang akan mengekstrak beberapa file. Terserah Anda, apakah Anda ingin menempatkannya di direktori lain atau tidak.

Selanjutnya, kita perlu mengatur variabel lingkungan OpenCV_DIR untuk menunjuk ke OpenCVmembangun direktori yang baru saja kita buka zipnya. Untuk ini, buka command prompt dan ketik setOpenCV_DIR=C:\opencv\build\x64\vc14\bin.

Satu hal penting adalah jika Anda tidak menginstal Intel MKL (Math Kernel Library), Anda dapat menginstalnya.

Paket open source lain yang dapat Anda gunakan adalah OpenBLAS. Di sini untuk instruksi lebih lanjut, kami mengasumsikan bahwa Anda menggunakanOpenBLAS.

Jadi, Unduh OpenBLAS paket tersedia di https://excellmedia.dl.sourceforge.net dan unzip file, ganti namanya menjadi OpenBLAS dan letakkan di bawah C: \ utils.

Selanjutnya, kita perlu menyetel variabel lingkungan OpenBLAS_HOME agar mengarah ke direktori OpenBLAS yang berisi direktori include dan lib. Anda dapat menemukan direktori diC:\Program files (x86)\OpenBLAS\

Perhatikan bahwa, jika Anda sudah memiliki CUDA, lalu menginstal Microsoft VS2015, Anda perlu menginstal ulang CUDA sekarang agar Anda bisa mendapatkan komponen toolkit CUDA untuk integrasi Microsoft VS2017.

Selanjutnya, Anda perlu mengunduh dan menginstal cuDNN.

Sekarang, kita perlu mengatur variabel lingkungan CUDACXX agar mengarah ke CUDA Compiler(C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.1\bin\nvcc.exe sebagai contoh).

Demikian pula, kita juga perlu mengatur variabel lingkungan CUDNN_ROOT untuk menunjuk ke cuDNN direktori yang berisi include, lib dan bin direktori (C:\Downloads\cudnn-9.1-windows7-x64-v7\cuda sebagai contoh).

Setelah Anda menginstal semua dependensi yang diperlukan, ikuti langkah-langkah yang diberikan di bawah ini untuk membuat kode sumber MXNet−

Step 1- Pertama, unduh kode sumber MXNet dari GitHub−

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

Step 2- Selanjutnya, gunakan CMake untuk membuat Visual Studio di ./build.

Step 3- Sekarang, di Visual Studio, kita perlu membuka file solusi,.sln, dan kompilasi. Perintah-perintah ini akan menghasilkan perpustakaan yang disebutmxnet.dll dalam ./build/Release/ or ./build/Debug map

Step 4- Setelah CMake berhasil diselesaikan, gunakan perintah berikut untuk mengompilasi kode sumber MXNet

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

Unit Pemrosesan Pusat (CPU)

Di sini, kita akan menggunakan berbagai metode yaitu Pip, Docker, dan Source untuk menginstal MXNet saat kita menggunakan CPU untuk pemrosesan−

Dengan menggunakan metode Pip

Jika Anda berencana untuk membangun MXNet di Windows dengan CPU, ada dua opsi untuk menginstal MXNet menggunakan paket Python−

Install with CPUs

Gunakan perintah berikut untuk menginstal MXNet dengan CPU dengan Python−

pip install mxnet

Install with Intel CPUs

Seperti dibahas di atas, MXNet memiliki dukungan eksperimental untuk Intel MKL serta MKL-DNN. Gunakan perintah berikut untuk menginstal MXNet dengan Intel CPU dengan Python−

pip install mxnet-mkl

Dengan menggunakan Docker

Anda dapat menemukan gambar buruh pelabuhan dengan MXNet di DockerHub, Tersedia di https://hub.docker.com/u/mxnet Mari kita periksa langkah-langkah di bawah ini, untuk menginstal MXNet dengan menggunakan Docker dengan CPU−

Step 1- Pertama, dengan mengikuti petunjuk instalasi buruh pelabuhan yang bisa dibaca di https://docs.docker.com/docker-for-mac/install. Kita perlu menginstal Docker di komputer kita.

Step 2- Dengan menggunakan perintah berikut, Anda dapat menarik image buruh pelabuhan MXNet−

$ docker pull mxnet/python

Sekarang untuk melihat apakah mxnet / python docker image pull berhasil, kita dapat membuat daftar gambar docker sebagai berikut−

$ docker images

Untuk kecepatan inferensi tercepat dengan MXNet, disarankan untuk menggunakan MXNet terbaru dengan Intel MKL-DNN.

Periksa perintah di bawah-

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

Menginstal MXNet Di Cloud dan Perangkat

Bagian ini menyoroti cara menginstal Apache MXNet di Cloud dan perangkat. Mari kita mulai dengan mempelajari tentang menginstal MXNet di cloud.

Menginstal MXNet Di Cloud

Anda juga bisa mendapatkan Apache MXNet di beberapa penyedia cloud dengan Graphical Processing Unit (GPU)dukung. Dua jenis dukungan lain yang dapat Anda temukan adalah sebagai berikut-

Dukungan GPU / CPU-hybrid untuk kasus penggunaan seperti inferensi yang dapat diskalakan.
Dukungan GPU faktorial dengan AWS Elastic Inference.

Berikut adalah penyedia cloud yang menyediakan dukungan GPU dengan mesin virtual yang berbeda untuk Apache MXNet−

Konsol Alibaba

Anda dapat membuat file NVIDIA GPU Cloud Virtual Machine (VM) Tersedia di https://docs.nvidia.com/ngc dengan Konsol Alibaba dan gunakan Apache MXNet.

Layanan Web Amazon

Ini juga menyediakan dukungan GPU dan memberikan layanan berikut untuk Apache MXNet−

Amazon SageMaker

Ia mengelola pelatihan dan penerapan model Apache MXNet.

AMI Deep Learning AWS

Ini menyediakan lingkungan Conda prainstal untuk Python 2 dan Python 3 dengan Apache MXNet, CUDA, cuDNN, MKL-DNN, dan AWS Elastic Inference.

Pelatihan Dinamis di AWS

Ini memberikan pelatihan untuk pengaturan EC2 manual eksperimental serta untuk pengaturan CloudFormation semi-otomatis.

Kamu dapat memakai NVIDIA VM Tersedia di https://aws.amazon.com dengan layanan web Amazon.

Google Cloud Platform

Google juga menyediakan NVIDIA GPU cloud image yang tersedia di https://console.cloud.google.com untuk bekerja dengan Apache MXNet.

Microsoft Azure

Microsoft Azure Marketplace juga menyediakan NVIDIA GPU cloud image Tersedia di https://azuremarketplace.microsoft.com untuk bekerja dengan Apache MXNet.

Oracle Cloud

Oracle juga menyediakan NVIDIA GPU cloud image Tersedia di https://docs.cloud.oracle.com untuk bekerja dengan Apache MXNet.

Unit Pemrosesan Pusat (CPU)

Apache MXNet berfungsi pada setiap instance khusus CPU penyedia cloud. Ada berbagai metode untuk menginstal seperti−

Petunjuk pemasangan pip Python.
Instruksi Docker.
Opsi prainstal seperti Amazon Web Services yang menyediakan AMI Deep Learning AWS (memiliki lingkungan Conda prainstal untuk Python 2 dan Python 3 dengan MXNet dan MKL-DNN).

Menginstal MXNet di Perangkat

Mari kita pelajari cara menginstal MXNet di perangkat.

Raspberry Pi

Anda juga dapat menjalankan Apache MXNet pada perangkat Raspberry Pi 3B karena MXNet juga mendukung OS berbasis Respbian ARM. Untuk menjalankan MXNet dengan lancar di Raspberry Pi3, disarankan untuk memiliki perangkat yang memiliki RAM lebih dari 1 GB dan kartu SD dengan ruang kosong minimal 4 GB.

Berikut adalah cara-cara dengan bantuan yang Anda dapat membangun MXNet untuk Raspberry Pi dan menginstal pengikatan Python untuk perpustakaan juga-

Instalasi cepat

Roda Python yang dibuat sebelumnya dapat digunakan pada Raspberry Pi 3B dengan Stretch untuk instalasi cepat. Salah satu masalah penting dengan metode ini adalah, kita perlu menginstal beberapa dependensi agar Apache MXNet berfungsi.

Instalasi Docker

Anda dapat mengikuti petunjuk penginstalan buruh pelabuhan, yang tersedia di https://docs.docker.com/engine/install/ubuntu/untuk menginstal Docker di komputer Anda. Untuk tujuan ini, kita dapat menginstal dan menggunakan Community Edition (CE) juga.

Bentukan Asli (dari sumber)

Untuk menginstal MXNet dari sumber, kita perlu mengikuti dua langkah berikut-

Langkah 1

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

Untuk membangun pustaka bersama pada versi Raspberry Wheezy dan yang lebih baru, kami memerlukan dependensi berikut:

Git- Diperlukan untuk menarik kode dari GitHub.
Libblas- Diperlukan untuk operasi aljabar linier.
Libopencv- Diperlukan untuk operasi terkait computer vision. Namun, ini opsional jika Anda ingin menghemat RAM dan Ruang Disk Anda.
C++ Compiler- Diperlukan untuk mengompilasi dan membuat kode sumber MXNet. Berikut adalah kompiler yang didukung yang mendukung C ++ 11−
- G ++ (4.8 atau versi yang lebih baru)
- Clang(3.9-6)

Gunakan perintah berikut untuk menginstal dependensi yang disebutkan di atas−

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

Selanjutnya, kita perlu menggandakan repositori kode sumber MXNet. Untuk ini gunakan perintah git berikut di direktori home Anda−

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

cd incubator-mxnet

Sekarang, dengan bantuan perintah berikut, buat pustaka bersama:

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)

Setelah Anda menjalankan perintah di atas, itu akan memulai proses pembangunan yang akan memakan waktu beberapa jam untuk menyelesaikannya. Anda akan mendapatkan file bernamalibmxnet.so di direktori build.

Langkah 2

Install the supported language-specific packages for Apache MXNet

Pada langkah ini, kita akan menginstal MXNet Pythin binding. Untuk melakukannya, kita perlu menjalankan perintah berikut di direktori MXNet−

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

Alternatifnya, dengan perintah berikut, Anda juga dapat membuat file whl package dapat dipasang dengan pip-

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

Perangkat NVIDIA Jetson

Anda juga dapat menjalankan Apache MXNet di Perangkat NVIDIA Jetson, seperti TX2 atau Nanokarena MXNet juga mendukung OS berbasis Ubuntu Arch64. Untuk menjalankan MXNet dengan lancar di Perangkat NVIDIA Jetson, CUDA harus diinstal pada perangkat Jetson Anda.

Berikut adalah cara-cara dengan bantuan yang Anda dapat membangun MXNet untuk perangkat NVIDIA Jetson:

Dengan menggunakan roda pip Jetson MXNet untuk pengembangan Python
Dari sumber

Tetapi, sebelum membangun MXNet dari salah satu cara yang disebutkan di atas, Anda perlu menginstal dependensi berikut pada perangkat Jetson Anda−

Dependensi Python

Untuk menggunakan Python API, kita membutuhkan dependensi berikut-

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

Gandakan repositori kode sumber MXNet

Dengan menggunakan perintah git berikut di direktori beranda Anda, klon repositori kode sumber MXNet−

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

Siapkan variabel lingkungan

Tambahkan yang berikut ini di .profile file di direktori home Anda−

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

Sekarang, terapkan perubahan segera dengan perintah berikut−

source .profile

Konfigurasi CUDA

Sebelum mengkonfigurasi CUDA, dengan nvcc, Anda perlu memeriksa versi CUDA mana yang sedang berjalan−

nvcc --version

Misalkan, jika lebih dari satu versi CUDA diinstal pada perangkat atau komputer Anda dan Anda ingin mengganti versi CUDA, gunakan yang berikut ini dan ganti symbolic link ke versi yang Anda inginkan−

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

Perintah di atas akan beralih ke CUDA 10.0, yang sudah diinstal sebelumnya pada perangkat NVIDIA Jetson Nano.

Setelah Anda selesai dengan prasyarat yang disebutkan di atas, Anda sekarang dapat menginstal MXNet di Perangkat NVIDIA Jetson. Jadi, mari kita pahami cara-cara yang dengannya Anda dapat menginstal MXNet−

By using a Jetson MXNet pip wheel for Python development- Jika Anda ingin menggunakan roda Python yang telah disiapkan, unduh yang berikut ini ke Jetson Anda dan jalankan-

MXNet 1.4.0 (untuk Python 3) tersedia di https://docs.docker.com
MXNet 1.4.0 (untuk Python 2) tersedia di https://docs.docker.com

Bentukan Asli (dari sumber)

Untuk menginstal MXNet dari sumber, kita perlu mengikuti dua langkah berikut-

Langkah 1

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

Untuk membangun pustaka bersama dari kode sumber Apache MXNet C ++, Anda dapat menggunakan metode Docker atau melakukannya secara manual−

Metode Docker

Dalam metode ini, Anda harus menginstal Docker terlebih dahulu dan dapat menjalankannya tanpa sudo (yang juga dijelaskan di langkah sebelumnya). Setelah selesai, jalankan perintah berikut untuk menjalankan kompilasi silang melalui Docker−

$MXNET_HOME/ci/build.py -p jetson

Manual

Dalam metode ini, Anda perlu mengedit file Makefile (dengan perintah di bawah ini) untuk menginstal MXNet dengan ikatan CUDA untuk memanfaatkan unit Pemrosesan Grafis (GPU) pada perangkat NVIDIA Jetson:

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

Setelah mengedit Makefile, Anda perlu mengedit file config.mk untuk membuat beberapa perubahan tambahan untuk perangkat NVIDIA Jetson.

Untuk ini, perbarui pengaturan berikut−

Perbarui jalur CUDA: USE_CUDA_PATH = / usr / local / cuda
Tambahkan -gencode arch = compute-63, code = sm_62 ke pengaturan CUDA_ARCH.
Perbarui pengaturan NVCC: NVCCFLAGS: = -m64
Hidupkan OpenCV: USE_OPENCV = 1

Sekarang untuk memastikan bahwa MXNet dibangun dengan akselerasi presisi rendah tingkat perangkat keras Pascal, kita perlu mengedit Mshadow Makefile sebagai berikut−

MSHADOW_CFLAGS += -DMSHADOW_USE_PASCAL=1

Terakhir, dengan bantuan perintah berikut Anda dapat membangun pustaka Apache MXNet lengkap−

cd $MXNET_HOME make -j $(nproc)

Langkah 2

Install the Apache MXNet Python Bindings

Pada langkah ini, kita akan menginstal bindings MXNet Python. Untuk melakukannya kita perlu menjalankan perintah berikut di direktori MXNet−

cd $MXNET_HOME/python
sudo pip install -e .

Setelah selesai dengan langkah-langkah di atas, Anda sekarang siap untuk menjalankan MXNet pada perangkat NVIDIA Jetson TX2 atau Nano Anda. Itu dapat diverifikasi dengan perintah berikut-

import mxnet
mxnet.__version__

Ini akan mengembalikan nomor versi jika semuanya berfungsi dengan benar.

Untuk mendukung penelitian dan pengembangan aplikasi Deep Learning di banyak bidang, Apache MXNet memberi kami ekosistem yang kaya akan toolkit, pustaka, dan banyak lagi. Mari kita jelajahi -

ToolKits

Berikut adalah beberapa toolkit yang paling banyak digunakan dan penting yang disediakan oleh MXNet -

GluonCV

Sesuai namanya GluonCV adalah toolkit Gluon untuk computer vision yang didukung oleh MXNet. Ini menyediakan implementasi algoritma DL (Deep Learning) yang canggih dalam computer vision (CV). Dengan bantuan insinyur toolkit GluonCV, peneliti, dan siswa dapat memvalidasi ide-ide baru dan mempelajari CV dengan mudah.

Diberikan di bawah ini adalah beberapa features of GluonCV -

Ini melatih skrip untuk mereproduksi hasil mutakhir yang dilaporkan dalam penelitian terbaru.
Lebih dari 170+ model pretrained berkualitas tinggi.
Gunakan pola pengembangan yang fleksibel.
GluonCV mudah untuk dioptimalkan. Kami dapat menerapkannya tanpa mempertahankan kerangka kerja DL yang berat.
Ini memberikan API yang dirancang dengan cermat yang sangat mengurangi kerumitan implementasi.
Dukungan komunitas.
Penerapan yang mudah dipahami.

Berikut ini adalah supported applications oleh toolkit GluonCV:

Klasifikasi Gambar
Deteksi Objek
Segmentasi Semantik
Segmentasi Instance
Estimasi Pose
Video Action Recognition

Kita dapat menginstal GluonCV dengan menggunakan pip sebagai berikut -

pip install --upgrade mxnet gluoncv

GluonNLP

Sesuai namanya, GluonNLP adalah toolkit Gluon untuk Pemrosesan Bahasa Alami (NLP) yang didukung oleh MXNet. Ini menyediakan implementasi model DL (Deep Learning) yang canggih di NLP.

Dengan bantuan insinyur toolkit GluonNLP, peneliti, dan siswa dapat membuat blok untuk pipeline dan model data teks. Berdasarkan model ini, mereka dapat dengan cepat membuat prototipe ide dan produk penelitian.

Diberikan di bawah ini adalah beberapa fitur GluonNLP:

Ini melatih skrip untuk mereproduksi hasil mutakhir yang dilaporkan dalam penelitian terbaru.
Kumpulan model yang dilatih sebelumnya untuk tugas NLP umum.
Ini memberikan API yang dirancang dengan cermat yang sangat mengurangi kerumitan implementasi.
Dukungan komunitas.
Ini juga menyediakan tutorial untuk membantu Anda memulai tugas NLP baru.

Berikut adalah tugas-tugas NLP yang dapat kita implementasikan dengan toolkit GluonNLP -

Penyematan Kata
Model Bahasa
Mesin penerjemah
Klasifikasi Teks
Analisis Sentimen
Inferensi Bahasa Alami
Pembuatan Teks
Penguraian Ketergantungan
Pengakuan Entitas Bernama
Klasifikasi Maksud dan Pelabelan Slot

Kita dapat menginstal GluonNLP dengan menggunakan pip sebagai berikut -

pip install --upgrade mxnet gluonnlp

GluonTS

Seperti namanya GluonTS adalah toolkit Gluon untuk Pemodelan Deret Waktu Probabilistik yang didukung oleh MXNet.

Ini menyediakan fitur-fitur berikut -

Model deep learning yang canggih (SOTA) siap untuk dilatih.
Utilitas untuk memuat serta melakukan iterasi dari kumpulan data deret waktu.
Membangun blok untuk menentukan model Anda sendiri.

Dengan bantuan insinyur toolkit GluonTS, peneliti, dan siswa dapat melatih dan mengevaluasi model built-in pada data mereka sendiri, bereksperimen dengan cepat dengan solusi yang berbeda, dan menghasilkan solusi untuk tugas deret waktu mereka.

Mereka juga dapat menggunakan abstraksi dan blok penyusun yang disediakan untuk membuat model deret waktu kustom, dan dengan cepat melakukan tolok ukur terhadap algoritme dasar.

Kita dapat menginstal GluonTS dengan menggunakan pip sebagai berikut -

pip install gluonts

GluonFR

Seperti namanya, ini adalah toolkit Gluon Apache MXNet untuk FR (Pengenalan Wajah). Ini menyediakan fitur-fitur berikut -

Model pembelajaran mendalam yang canggih (SOTA) dalam pengenalan wajah.
Implementasi SoftmaxCrossEntropyLoss, ArcLoss, TripletLoss, RingLoss, CosLoss / AMsoftmax, L2-Softmax, A-Softmax, CenterLoss, ContrastiveLoss, dan LGM Loss, dll.

Untuk menginstal Gluon Face, kita membutuhkan Python 3.5 atau yang lebih baru. Pertama-tama kita juga perlu menginstal GluonCV dan MXNet terlebih dahulu sebagai berikut -

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

Setelah Anda menginstal dependensi, Anda dapat menggunakan perintah berikut untuk menginstal GluonFR -

From Source

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

Pip

pip install gluonfr

Ekosistem

Sekarang mari kita jelajahi pustaka, paket, dan kerangka kerja MXNet yang kaya -

Pelatih RL

Coach, framework Python Reinforcement Learning (RL) yang dibuat oleh lab Intel AI. Ini memungkinkan eksperimen mudah dengan algoritme RL yang canggih. Coach RL mendukung Apache MXNet sebagai back end dan memungkinkan integrasi sederhana dari lingkungan baru untuk diselesaikan.

Untuk memperluas dan menggunakan kembali komponen yang ada dengan mudah, Coach RL dengan sangat baik memisahkan komponen pembelajaran penguatan dasar seperti algoritma, lingkungan, arsitektur NN, kebijakan eksplorasi.

Berikut adalah agen dan algoritma yang didukung untuk kerangka kerja Coach RL -

Agen Pengoptimalan Nilai

Deep Q Network (DQN)
Double Deep Q Network (DDQN)
Duel Jaringan Q.
Campuran Monte Carlo (MMC)
Persistent Advantage Learning (PAL)
Jaringan Q Dalam Kategorikal (C51)
Jaringan Q Dalam Regresi Kuantil (QR-DQN)
Pembelajaran N-Langkah Q.
Neural Episodic Control (NEC)
Fungsi Keuntungan Normalisasi (NAF)
Rainbow

Agen Pengoptimalan Kebijakan

Gradien Kebijakan (PG)
Asynchronous Advantage Actor-Critic (A3C)
Gradien Kebijakan Deterministik Mendalam (DDPG)
Pengoptimalan Kebijakan Proksimal (PPO)
Pengoptimalan Kebijakan Proksimal Terpotong (CPPO)
Estimasi Keuntungan Umum (GAE)
Contoh Aktor-Kritikus Efisien dengan Experience Replay (ACER)
Soft Actor-Critic (SAC)
Gradien Kebijakan Deterministik Jauh Tertunda Kembar (TD3)

Agen Umum

Prediksi Masa Depan Langsung (DFP)

Agen Pembelajaran Imitasi

Kloning Perilaku (BC)
Pembelajaran Imitasi Bersyarat

Agen Pembelajaran Penguatan Hierarki

Kritikus Hierarki Aktor (HAC)

Perpustakaan Grafik Dalam

Deep Graph Library (DGL), yang dikembangkan oleh tim NYU dan AWS, Shanghai, adalah paket Python yang menyediakan implementasi mudah Graph Neural Networks (GNNs) di atas MXNet. Ini juga menyediakan implementasi GNN yang mudah di atas pustaka pembelajaran mendalam utama lainnya yang ada seperti PyTorch, Gluon, dll.

Deep Graph Library adalah perangkat lunak gratis. Ini tersedia di semua distribusi Linux setelah Ubuntu 16.04, macOS X, dan Windows 7 atau lebih baru. Ini juga membutuhkan versi Python 3.5 atau yang lebih baru.

Berikut adalah fitur-fitur DGL -

No Migration cost - Tidak ada biaya migrasi untuk menggunakan DGL karena dibangun di atas kerangka kerja DL yang populer.

Message Passing- DGL menyediakan penyampaian pesan dan memiliki kontrol serbaguna di atasnya. Pengalihan pesan berkisar dari operasi tingkat rendah seperti mengirim sepanjang tepi yang dipilih hingga kontrol tingkat tinggi seperti pembaruan fitur di seluruh grafik.

Smooth Learning Curve - Sangat mudah untuk mempelajari dan menggunakan DGL karena fungsi yang ditentukan pengguna bersifat fleksibel serta mudah digunakan.

Transparent Speed Optimization - DGL menyediakan pengoptimalan kecepatan transparan dengan melakukan batching otomatis dari komputasi dan perkalian matriks renggang.

High performance - Untuk mencapai efisiensi maksimum, DGL secara otomatis menggabungkan pelatihan DNN (jaringan neural dalam) pada satu atau banyak grafik secara bersamaan.

Easy & friendly interface - DGL memberi kami antarmuka yang mudah & ramah untuk akses fitur tepi serta manipulasi struktur grafik.

InsightFace

InsightFace, Alat Pembelajaran Mendalam untuk Analisis Wajah yang menyediakan implementasi algoritme analisis wajah SOTA (canggih) di computer vision yang diberdayakan oleh MXNet. Ini menyediakan -

Model terlatih dalam jumlah besar dan berkualitas tinggi.
Skrip pelatihan canggih (SOTA).
InsightFace mudah untuk dioptimalkan. Kami dapat menerapkannya tanpa mempertahankan kerangka kerja DL yang berat.
Ini memberikan API yang dirancang dengan cermat yang sangat mengurangi kerumitan implementasi.
Membangun blok untuk menentukan model Anda sendiri.

Kita dapat menginstal InsightFace dengan menggunakan pip sebagai berikut -

pip install --upgrade insightface

Harap diperhatikan bahwa sebelum menginstal InsightFace, harap instal paket MXNet yang benar sesuai dengan konfigurasi sistem Anda.

Keras-MXNet

Seperti yang kita ketahui bahwa Keras adalah API Jaringan Neural (NN) tingkat tinggi yang ditulis dengan Python, Keras-MXNet memberi kita dukungan backend untuk Keras. Ini dapat berjalan di atas kerangka kerja Apache MXNet DL berperforma tinggi dan dapat diskalakan.

Fitur Keras-MXNet disebutkan di bawah -

Memungkinkan pengguna untuk membuat prototipe yang mudah, lancar, dan cepat. Itu semua terjadi melalui keramahan pengguna, modularitas, dan ekstensibilitas.
Mendukung CNN (Convolutional Neural Networks) dan RNN (Recurrent Neural Networks) serta kombinasi keduanya juga.
Berjalan dengan sempurna di Central Processing Unit (CPU) dan Graphical Processing Unit (GPU).
Bisa berjalan di satu atau multi GPU.

Untuk bekerja dengan backend ini, Anda harus menginstal keras-mxnet sebagai berikut -

pip install keras-mxnet

Sekarang, jika Anda menggunakan GPU, instal MXNet dengan dukungan CUDA 9 sebagai berikut -

pip install mxnet-cu90

Tetapi jika Anda hanya menggunakan CPU, instal MXNet dasar sebagai berikut -

pip install mxnet

MXBoard

MXBoard adalah alat logging, ditulis dengan Python, yang digunakan untuk merekam bingkai data MXNet dan ditampilkan di TensorBoard. Dengan kata lain, MXBoard dimaksudkan untuk mengikuti API tensorboard-pytorch. Ini mendukung sebagian besar tipe data di TensorBoard.

Beberapa dari mereka disebutkan di bawah -

Graph
Scalar
Histogram
Embedding
Image
Text
Audio
Kurva Pemanggilan Presisi

MXFusion

MXFusion adalah pustaka pemrograman probabilistik modular dengan pembelajaran mendalam. MXFusion memungkinkan kita untuk sepenuhnya memanfaatkan modularitas, yang merupakan fitur kunci dari pustaka pembelajaran yang mendalam, untuk pemrograman probabilistik. Ini mudah digunakan dan memberi pengguna antarmuka yang nyaman untuk merancang model probabilistik dan menerapkannya pada masalah dunia nyata.

MXFusion diverifikasi pada Python versi 3.4 dan lebih banyak di MacOS dan Linux OS. Untuk menginstal MXFusion, pertama-tama kita perlu menginstal dependensi berikut -

MXNet> = 1.3
Jaringanx> = 2.1

Dengan bantuan perintah pip berikut, Anda dapat menginstal MXFusion -

pip install mxfusion

TVM

Apache TVM sebenarnya dimulai sebagai proyek penelitian di SAMPL group of Paul G. Allen School of Computer Science & Engineering, University of Washington dan sekarang merupakan upaya inkubasi di The Apache Software Foundation (ASF) yang digerakkan oleh OSC ( komunitas open source) yang melibatkan banyak industri serta institusi akademik di bawah cara Apache.

Berikut adalah fitur utama dari Apache (menginkubasi) TVM -

Menyederhanakan proses pengembangan berbasis C ++ sebelumnya.
Memungkinkan berbagi implementasi yang sama di beberapa backend perangkat keras seperti CPU, GPU, dll.
TVM menyediakan kompilasi model DL dalam berbagai kerangka kerja seperti Kears, MXNet, PyTorch, Tensorflow, CoreML, DarkNet menjadi modul minimum yang dapat diterapkan pada berbagai backend perangkat keras.
Ini juga memberi kami infrastruktur untuk secara otomatis menghasilkan dan mengoptimalkan operator tensor dengan kinerja yang lebih baik.

XFer

Xfer, kerangka belajar transfer, ditulis dengan Python. Ini pada dasarnya mengambil model MXNet dan melatih model meta atau memodifikasi model untuk kumpulan data target baru juga.

Dengan kata sederhana, Xfer adalah pustaka Python yang memungkinkan pengguna mentransfer pengetahuan dengan cepat dan mudah yang disimpan di DNN (jaringan neural dalam).

Xfer dapat digunakan -

Untuk klasifikasi data format numerik arbitrer.
Untuk kasus umum gambar atau data teks.
Sebagai pipeline yang melakukan spam mulai dari mengekstrak fitur hingga melatih repurposer (objek yang melakukan klasifikasi dalam tugas target).

Berikut adalah fitur-fitur Xfer:

Efisiensi sumber daya
Efisiensi data
Akses mudah ke jaringan saraf
Pemodelan ketidakpastian
Pembuatan prototipe cepat
Utilitas untuk ekstraksi fitur dari NN

Bab ini akan membantu Anda memahami tentang arsitektur sistem MXNet. Mari kita mulai dengan mempelajari tentang Modul MXNet.

Modul MXNet

Diagram di bawah adalah arsitektur sistem MXNet dan menampilkan modul dan komponen utama MXNet modules and their interaction.

Pada diagram di atas -

Modul dalam kotak warna biru adalah User Facing Modules.
Modul dalam kotak warna hijau adalah System Modules.
Panah padat menunjukkan ketergantungan yang tinggi, yaitu sangat bergantung pada antarmuka.
Panah putus-putus mewakili ketergantungan cahaya, yaitu struktur data yang digunakan untuk kenyamanan dan konsistensi antarmuka. Bahkan bisa diganti dengan alternatif.

Mari kita bahas lebih lanjut tentang menghadapi pengguna dan modul sistem.

Modul yang Menghadap Pengguna

Modul yang dapat dilihat pengguna adalah sebagai berikut -

NDArray- Ini menyediakan program penting yang fleksibel untuk Apache MXNet. Mereka adalah array n-dimensi yang dinamis dan asinkron.
KVStore- Bertindak sebagai antarmuka untuk sinkronisasi parameter yang efisien. Di KVStore, KV adalah singkatan dari Key-Value. Jadi, ini adalah antarmuka toko nilai kunci.
Data Loading (IO) - Modul yang menghadap pengguna ini digunakan untuk pemuatan dan augmentasi data terdistribusi secara efisien.
Symbol Execution- Ini adalah pelaksana grafik simbolik statis. Ini menyediakan eksekusi dan pengoptimalan grafik simbolik yang efisien.
Symbol Construction - Modul yang menghadap pengguna ini memberi pengguna cara untuk membuat grafik komputasi, yaitu konfigurasi bersih.

Modul Sistem

Modul sistem adalah sebagai berikut -

Storage Allocator - Modul sistem ini, seperti namanya, mengalokasikan dan mendaur ulang blok memori secara efisien pada host yaitu CPU dan perangkat yang berbeda yaitu GPU.
Runtime Dependency Engine - Jadwal modul mesin dependensi runtime serta menjalankan operasi sesuai dependensi baca / tulisnya.
Resource Manager - Modul sistem Resource Manager (RM) mengelola sumber daya global seperti generator nomor acak dan ruang temporal.
Operator - Modul sistem operator terdiri dari semua operator yang mendefinisikan maju statis dan kalkulasi gradien yaitu propagasi mundur.

Di sini, komponen sistem di Apache MXNet dijelaskan secara mendetail. Pertama, kita akan mempelajari tentang mesin eksekusi di MXNet.

Mesin Eksekusi

Mesin eksekusi Apache MXNet sangat serbaguna. Kita dapat menggunakannya untuk pembelajaran mendalam serta masalah khusus domain apa pun: menjalankan banyak fungsi mengikuti dependensinya. Ini dirancang sedemikian rupa sehingga fungsi dengan dependensi diserialkan sedangkan, fungsi tanpa dependensi dapat dijalankan secara paralel.

Antarmuka Inti

API yang diberikan di bawah ini adalah antarmuka inti untuk mesin eksekusi Apache MXNet -

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

API di atas memiliki yang berikut -

exec_fun - API antarmuka inti MXNet memungkinkan kita untuk mendorong fungsi bernama exec_fun, bersama dengan informasi konteks dan ketergantungannya, ke mesin eksekusi.
exec_ctx - Informasi konteks di mana fungsi yang disebutkan di atas exec_fun harus dijalankan.
const_vars - Ini adalah variabel yang dibaca oleh fungsi.
mutate_vars - Ini adalah variabel yang akan dimodifikasi.

Mesin eksekusi memberikan jaminan kepada penggunanya bahwa eksekusi dua fungsi yang mengubah variabel umum diserialkan dalam urutan push mereka.

Fungsi

Berikut adalah jenis fungsi mesin eksekusi Apache MXNet -

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

Dalam fungsi di atas, RunContextberisi informasi runtime. Informasi runtime harus ditentukan oleh mesin eksekusi. Sintaks dariRunContext adalah sebagai berikut-

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

Di bawah ini diberikan beberapa poin penting tentang fungsi mesin eksekusi -

Semua fungsi dijalankan oleh thread internal mesin eksekusi MXNet.
Tidaklah baik untuk mendorong fungsi pemblokiran ke mesin eksekusi karena dengan itu fungsi tersebut akan menempati thread eksekusi dan juga akan mengurangi total throughput.

Untuk MXNet ini menyediakan fungsi asinkron lainnya sebagai berikut-

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

Di dalam AsyncFn fungsi kita dapat melewatkan bagian yang berat dari utas kita, tetapi mesin eksekusi tidak mempertimbangkan fungsi selesai sampai kita memanggil callback fungsi.

Konteks

Di Context, kita dapat menentukan konteks fungsi yang akan dijalankan di dalamnya. Ini biasanya termasuk yang berikut -

Apakah fungsi tersebut harus dijalankan pada CPU atau GPU.
Jika kita menentukan GPU dalam Konteks, lalu GPU mana yang akan digunakan.
Ada perbedaan besar antara Konteks dan RunContext. Konteks memiliki jenis perangkat dan id perangkat, sedangkan RunContext memiliki informasi yang hanya dapat ditentukan selama waktu proses.

VarHandle

VarHandle, digunakan untuk menentukan dependensi fungsi, seperti token (terutama disediakan oleh mesin eksekusi) yang dapat kita gunakan untuk mewakili sumber daya eksternal yang dapat dimodifikasi atau digunakan oleh fungsi.

Namun muncul pertanyaan, mengapa kita perlu menggunakan VarHandle? Itu karena, mesin Apache MXNet dirancang untuk dipisahkan dari modul MXNet lainnya.

Berikut adalah beberapa poin penting tentang VarHandle -

Ini ringan sehingga untuk membuat, menghapus, atau menyalin variabel memerlukan sedikit biaya pengoperasian.
Kita perlu menentukan variabel yang tidak dapat diubah yaitu variabel yang akan digunakan di const_vars.
Kita perlu menentukan variabel yang bisa berubah yaitu variabel yang akan dimodifikasi di mutate_vars.
Aturan yang digunakan oleh mesin eksekusi untuk menyelesaikan dependensi di antara fungsi adalah eksekusi dua fungsi saat salah satunya memodifikasi setidaknya satu variabel umum yang diserialkan dalam urutan push-nya.
Untuk membuat variabel baru, kita bisa menggunakan NewVar() API.
Untuk menghapus variabel, kita bisa menggunakan PushDelete API.

Mari kita pahami cara kerjanya dengan contoh sederhana -

Misalkan jika kita memiliki dua fungsi yaitu F1 dan F2 dan keduanya sama-sama memutasi variabel yaitu V2. Dalam hal ini, F2 dijamin akan dijalankan setelah F1 jika F2 didorong setelah F1. Di sisi lain, jika F1 dan F2 sama-sama menggunakan V2 maka urutan eksekusi sebenarnya bisa acak.

Dorong dan Tunggu

Push dan wait adalah dua API mesin eksekusi yang lebih berguna.

Berikut adalah dua fitur penting dari Push API:

Semua Push API bersifat asynchronous yang berarti bahwa panggilan API segera kembali terlepas dari apakah fungsi yang didorong sudah selesai atau belum.
Push API bukanlah thread safe, yang berarti hanya satu thread yang dapat melakukan panggilan API mesin pada satu waktu.

Sekarang jika kita berbicara tentang Wait API, poin berikut mewakilinya -

Jika pengguna ingin menunggu fungsi tertentu selesai, dia harus menyertakan fungsi panggilan balik di closure. Setelah disertakan, panggil fungsi tersebut di akhir fungsi.
Di sisi lain, jika pengguna ingin menunggu semua fungsi yang melibatkan variabel tertentu selesai, dia harus menggunakan WaitForVar(var) API.
Jika seseorang ingin menunggu semua fungsi yang didorong selesai, gunakan WaitForAll () API.
Digunakan untuk menentukan dependensi fungsi, seperti token.

Operator

Operator di Apache MXNet adalah kelas yang berisi logika komputasi aktual serta informasi tambahan dan membantu sistem dalam melakukan pengoptimalan.

Antarmuka Operator

Forward adalah antarmuka operator inti yang sintaksnya adalah sebagai berikut:

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;

Struktur OpContext, didefinisikan di Forward() adalah sebagai berikut:

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

Itu OpContextmenjelaskan status operator (baik dalam fase train atau pengujian), perangkat mana yang harus dioperasikan oleh operator dan juga resource yang diminta. dua API mesin eksekusi yang lebih berguna.

Dari atas Forward antarmuka inti, kita dapat memahami sumber daya yang diminta sebagai berikut -

in_data dan out_data mewakili tensor input dan output.
req menunjukkan bagaimana hasil komputasi ditulis ke dalam out_data.

Itu OpReqType dapat didefinisikan sebagai -

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

Seperti Forward operator, kami secara opsional dapat mengimplementasikan Backward antarmuka sebagai berikut -

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);

Berbagai tugas

Operator antarmuka memungkinkan pengguna untuk melakukan tugas-tugas berikut -

Pengguna dapat menentukan pembaruan di tempat dan dapat mengurangi biaya alokasi memori
Untuk membuatnya lebih bersih, pengguna dapat menyembunyikan beberapa argumen internal dari Python.
Pengguna dapat menentukan hubungan antara tensor dan tensor keluaran.
Untuk melakukan komputasi, pengguna dapat memperoleh ruang sementara tambahan dari sistem.

Properti Operator

Seperti yang kita ketahui bahwa dalam jaringan saraf konvolusional (CNN), satu konvolusi memiliki beberapa implementasi. Untuk mencapai kinerja terbaik dari mereka, kita mungkin ingin beralih di antara beberapa konvolusi tersebut.

Itulah alasannya, Apache MXNet memisahkan antarmuka semantik operator dari antarmuka implementasi. Pemisahan ini dilakukan dalam bentukOperatorProperty kelas yang terdiri dari berikut-

InferShape - Antarmuka InferShape memiliki dua tujuan seperti yang diberikan di bawah ini:

Tujuan pertama adalah memberi tahu sistem ukuran setiap input dan output tensor sehingga ruang dapat dialokasikan sebelumnya Forward dan Backward panggilan.
Tujuan kedua adalah melakukan pemeriksaan ukuran untuk memastikan tidak ada kesalahan sebelum menjalankan.

Sintaksnya diberikan di bawah ini -

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

Request Resource- Bagaimana jika sistem Anda dapat mengelola ruang kerja komputasi untuk operasi seperti cudnnConvolutionForward? Sistem Anda dapat melakukan pengoptimalan seperti penggunaan kembali ruang dan banyak lagi. Di sini, MXNet dengan mudah mencapai ini dengan bantuan dua antarmuka berikut-

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

Tapi, bagaimana jika file ForwardResource dan BackwardResourcemengembalikan array yang tidak kosong? Dalam hal ini, sistem menawarkan sumber daya yang sesuai melaluictx parameter di Forward dan Backward antarmuka Operator.

Backward dependency - Apache MXNet memiliki dua tanda tangan operator yang berbeda untuk menangani ketergantungan mundur -

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);

Di sini, dua hal penting yang perlu diperhatikan -

Out_data di FullyConnectedForward tidak digunakan oleh FullyConnectedBackward, dan
PoolingBackward membutuhkan semua argumen PoolingForward.

Itulah mengapa untuk FullyConnectedForward, itu out_datatensor yang pernah dikonsumsi dapat dibebaskan dengan aman karena fungsi mundur tidak memerlukannya. Dengan bantuan sistem ini dapat mengumpulkan beberapa tensor sampah sedini mungkin.

In place Option- Apache MXNet menyediakan antarmuka lain kepada pengguna untuk menghemat biaya alokasi memori. Antarmuka sesuai untuk operasi bijak-elemen di mana tensor input dan output memiliki bentuk yang sama.

Berikut ini adalah sintaks untuk menentukan pembaruan di tempat -

Contoh Membuat Operator

Dengan bantuan OperatorProperty kita bisa membuat operator. Untuk melakukannya, ikuti langkah-langkah yang diberikan di bawah ini -

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]} }
}

Langkah 1

Create Operator

Pertama-tama, terapkan antarmuka berikut di OperatorProperty:

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

Contoh diberikan di bawah ini -

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

Langkah 2

Parameterize Operator

Jika Anda akan menerapkan operator konvolusi, Anda wajib mengetahui ukuran kernel, ukuran langkah, ukuran bantalan, dan sebagainya. Mengapa, karena parameter ini harus diteruskan ke operator sebelum memanggil apapunForward atau backward antarmuka.

Untuk ini, kita perlu mendefinisikan file ConvolutionParam struktur seperti di bawah ini -

#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;
};

Sekarang, kita perlu memasukkan ini ConvolutionOpProperty dan berikan ke operator sebagai berikut -

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_;
};

LANGKAH 3

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

Terakhir, kita perlu mendaftarkan Kelas Properti Operator dan Kelas Parameter ke MXNet. Itu dapat dilakukan dengan bantuan makro berikut -

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

Dalam makro di atas, argumen pertama adalah string nama dan yang kedua adalah nama kelas properti.

Bab ini memberikan informasi tentang antarmuka pemrograman aplikasi operator (API) terpadu di Apache MXNet.

SimpleOp

SimpleOp adalah API operator terpadu baru yang menyatukan berbagai proses pemanggilan. Setelah dipanggil, ia kembali ke elemen dasar operator. Operator terpadu dirancang khusus untuk operasi unary serta biner. Itu karena sebagian besar operator matematika memperhatikan satu atau dua operan dan lebih banyak operan membuat pengoptimalan, terkait dengan ketergantungan, berguna.

Kami akan memahami operator terpadu SimpleOp yang bekerja dengan bantuan sebuah contoh. Dalam contoh ini, kami akan membuat operator yang berfungsi sebagaismooth l1 loss, yang merupakan campuran dari kerugian l1 dan l2. Kita dapat mendefinisikan dan menulis kerugian seperti yang diberikan di bawah ini -

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

Di sini, pada contoh di atas,

. * adalah singkatan dari perkalian berdasarkan elemen
f, f’ adalah fungsi kerugian l1 halus yang kita asumsikan berada mshadow.

Tampaknya tidak mungkin untuk menerapkan kerugian khusus ini sebagai operator unary atau biner, tetapi MXNet menyediakan diferensiasi otomatis kepada penggunanya dalam eksekusi simbolik yang menyederhanakan kerugian ke f dan f 'secara langsung. Itu sebabnya kami pasti dapat menerapkan kerugian khusus ini sebagai operator unary.

Mendefinisikan Bentuk

Seperti yang kita tahu MXNet mshadow librarymembutuhkan alokasi memori eksplisit sehingga kita perlu menyediakan semua bentuk data sebelum perhitungan apapun terjadi. Sebelum mendefinisikan fungsi dan gradien, kita perlu memberikan konsistensi bentuk masukan dan bentuk keluaran sebagai berikut:

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);

Fungsi mxnet :: Tshape digunakan untuk memeriksa bentuk data masukan dan bentuk data keluaran yang ditentukan. Dalam kasus ini, jika Anda tidak mendefinisikan fungsi ini maka bentuk keluaran default akan sama dengan bentuk masukan. Misalnya, dalam kasus operator biner, bentuk lhs dan rhs secara default dicentang sama.

Sekarang mari kita lanjutkan ke smooth l1 loss example. Untuk ini, kita perlu mendefinisikan XPU ke cpu atau gpu dalam implementasi header smooth_l1_unary-inl.h. Alasannya adalah untuk menggunakan kembali kode yang sama di smooth_l1_unary.cc dan smooth_l1_unary.cu.

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

Seperti di kami smooth l1 loss example,Outputnya memiliki bentuk yang sama dengan sumbernya, kita dapat menggunakan perilaku default. Itu dapat ditulis sebagai berikut -

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

Mendefinisikan Fungsi

Kita dapat membuat fungsi unary atau binary dengan satu input sebagai berikut -

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);

Berikut ini adalah RunContext ctx struct yang berisi informasi yang diperlukan selama runtime untuk eksekusi -

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

Sekarang, mari kita lihat bagaimana kita bisa menulis hasil komputasi 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
};

Sekarang, mari kita lanjutkan ke smooth l1 loss example. Untuk ini, kami akan menggunakan UnaryFunction untuk mendefinisikan fungsi operator ini sebagai berikut:

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)));
   });
}

Mendefinisikan Gradien

Kecuali Input, TBlob, dan OpReqTypedigandakan, fungsi Gradien dari operator biner memiliki struktur yang serupa. Mari kita lihat di bawah, di mana kita membuat fungsi gradien dengan berbagai jenis input:

// 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);

Seperti yang didefinisikan di atas Input0, Input, OutputValue, dan OutputGrad semua berbagi struktur GradientFunctionArgument. Ini didefinisikan sebagai berikut -

struct GradFunctionArgument {
   TBlob data;
}

Sekarang mari kita lanjutkan ke smooth l1 loss example. Untuk mengaktifkan aturan rantai gradien, kita perlu mengalikannyaout_grad dari atas ke hasil 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)));
   });
}

Daftarkan SimpleOp ke MXNet

Setelah kita membuat bentuk, fungsi, dan gradien, kita perlu mengembalikannya menjadi operator NDArray dan juga menjadi operator simbolik. Untuk ini, kita dapat menggunakan makro registrasi sebagai berikut -

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");

Itu SimpleOpInplaceOption dapat didefinisikan sebagai berikut -

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)
};

Sekarang mari kita lanjutkan ke smooth l1 loss example. Untuk ini, kami memiliki fungsi gradien yang bergantung pada data masukan sehingga fungsi tersebut tidak dapat ditulis pada tempatnya.

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 di EnvArguments

Seperti yang kita ketahui, beberapa operasi mungkin memerlukan yang berikut -

Skalar sebagai masukan seperti skala gradien
Seperangkat argumen kata kunci yang mengontrol perilaku
Ruang sementara untuk mempercepat penghitungan.

Manfaat menggunakan EnvArguments adalah menyediakan argumen dan sumber daya tambahan untuk membuat penghitungan lebih skalabel dan efisien.

Contoh

Pertama mari kita definisikan struct seperti di bawah ini -

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
};

Selanjutnya, kita perlu meminta sumber daya tambahan seperti mshadow::Random<xpu> dan ruang memori sementara dari EnvArguments.resource. Itu dapat dilakukan sebagai berikut -

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
};

Sekarang, pendaftaran akan meminta permintaan sumber daya yang dideklarasikan dari mxnet::ResourceManager. Setelah itu, itu akan menempatkan sumber daya std::vector<Resource> resource in EnvAgruments.

Kami dapat mengakses sumber daya dengan bantuan kode berikut -

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

Jika Anda melihat dalam contoh kerugian l1 halus kami, masukan skalar diperlukan untuk menandai titik balik fungsi kerugian. Karena itulah dalam proses registrasi, kami menggunakanset_enable_scalar(true), dan env.scalar dalam deklarasi fungsi dan gradien.

Membangun Operasi Tensor

Di sini muncul pertanyaan mengapa kita perlu membuat operasi tensor? Alasannya adalah sebagai berikut -

Komputasi menggunakan pustaka mshadow dan terkadang kami tidak memiliki fungsi yang tersedia.
Jika sebuah operasi tidak dilakukan dengan cara yang bijaksana elemen seperti kehilangan dan gradien softmax.

Contoh

Di sini, kami menggunakan contoh kerugian l1 halus di atas. Kami akan membuat dua pembuat peta yaitu kasus skalar kerugian l1 halus dan gradien:

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;
         }
      }
   };
}

Bab ini membahas tentang pelatihan terdistribusi di Apache MXNet. Mari kita mulai dengan memahami apa saja mode komputasi di MXNet.

Mode Komputasi

MXNet, pustaka ML multi-bahasa, menawarkan kepada penggunanya dua mode komputasi berikut -

Mode imperatif

Mode komputasi ini memperlihatkan antarmuka seperti NumPy API. Misalnya, di MXNet, gunakan kode imperatif berikut untuk membuat tensor nol pada CPU serta GPU -

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

Seperti yang kita lihat pada kode di atas, MXNets menentukan lokasi tempat menyimpan tensor, baik di perangkat CPU atau GPU. Dalam contoh di atas, ini berada di lokasi 0. MXNet mencapai pemanfaatan perangkat yang luar biasa, karena semua komputasi terjadi secara malas dan bukan secara instan.

Mode simbolik

Meskipun mode imperatif cukup berguna, namun salah satu kekurangan mode ini adalah kekakuannya, yaitu semua perhitungan perlu diketahui sebelumnya bersama dengan struktur data yang telah ditentukan sebelumnya.

Di sisi lain, mode Simbolik menampilkan grafik komputasi seperti TensorFlow. Ini menghilangkan kelemahan API imperatif dengan mengizinkan MXNet untuk bekerja dengan simbol atau variabel alih-alih struktur data tetap / yang telah ditentukan sebelumnya. Setelah itu, simbol dapat diartikan sebagai satu set operasi sebagai berikut -

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

Macam-Macam Paralelisme

Apache MXNet mendukung pelatihan terdistribusi. Ini memungkinkan kami memanfaatkan banyak mesin untuk pelatihan yang lebih cepat dan efektif.

Berikut adalah dua cara di mana, kami dapat mendistribusikan beban kerja pelatihan NN di beberapa perangkat, CPU atau perangkat GPU -

Paralelisme Data

Dalam jenis paralelisme ini, setiap perangkat menyimpan salinan lengkap model dan bekerja dengan bagian berbeda dari kumpulan data. Perangkat juga memperbarui model bersama secara kolektif. Kami dapat menemukan semua perangkat di satu mesin atau di beberapa mesin.

Model Paralelisme

Ini adalah jenis paralelisme lain, yang berguna saat model sangat besar sehingga tidak cocok dengan memori perangkat. Dalam model paralelisme, perangkat yang berbeda ditugaskan untuk mempelajari bagian-bagian model yang berbeda. Hal penting yang perlu diperhatikan di sini adalah bahwa saat ini Apache MXNet mendukung paralelisme model hanya dalam satu mesin.

Kerja pelatihan terdistribusi

Konsep yang diberikan di bawah ini adalah kunci untuk memahami cara kerja pelatihan terdistribusi di Apache MXNet -

Jenis proses

Proses berkomunikasi satu sama lain untuk menyelesaikan pelatihan model. Apache MXNet memiliki tiga proses berikut -

Pekerja

Tugas node pekerja adalah melakukan pelatihan pada sekumpulan sampel pelatihan. Node Pekerja akan menarik bobot dari server sebelum memproses setiap kelompok. Node Pekerja akan mengirim gradien ke server, setelah batch diproses.

Server

MXNet dapat memiliki beberapa server untuk menyimpan parameter model dan untuk berkomunikasi dengan node pekerja.

Penjadwal

Peran penjadwal adalah untuk mengatur cluster, yang mencakup menunggu pesan yang setiap node telah muncul dan port mana yang didengarkan oleh node. Setelah menyiapkan cluster, penjadwal memungkinkan semua proses mengetahui tentang setiap node lain di cluster. Itu karena proses dapat berkomunikasi satu sama lain. Hanya ada satu penjadwal.

Toko KV

Toko KV adalah singkatan dari Key-Valuetoko. Ini adalah komponen penting yang digunakan untuk pelatihan multi-perangkat. Ini penting karena, komunikasi parameter di seluruh perangkat pada satu maupun di beberapa mesin ditransmisikan melalui satu atau lebih server dengan KVStore untuk parameter. Mari kita pahami cara kerja KVStore dengan bantuan poin-poin berikut -

Setiap nilai di KVStore diwakili oleh a key dan a value.
Setiap larik parameter dalam jaringan diberikan a key dan bobot dari parameter array tersebut dirujuk oleh value.
Setelah itu, node pekerja pushgradien setelah memproses batch. Mereka jugapull memperbarui bobot sebelum memproses kelompok baru.

Gagasan server KVStore hanya ada selama pelatihan terdistribusi dan mode terdistribusi itu diaktifkan dengan memanggil mxnet.kvstore.create berfungsi dengan argumen string yang berisi kata dist -

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

Distribusi Kunci

Tidak perlu bahwa, semua server menyimpan semua larik parameter atau kunci, tetapi mereka didistribusikan ke server yang berbeda. Distribusi kunci semacam itu di berbagai server ditangani secara transparan oleh KVStore dan keputusan server mana yang menyimpan kunci tertentu dibuat secara acak.

KVStore, sebagaimana dibahas di atas, memastikan bahwa setiap kali kunci ditarik, permintaannya dikirim ke server itu, yang memiliki nilai yang sesuai. Bagaimana jika nilai beberapa kunci besar? Dalam hal ini, ini mungkin dibagikan ke server yang berbeda.

Pisahkan data pelatihan

Sebagai pengguna, kami ingin setiap mesin bekerja pada bagian yang berbeda dari kumpulan data, terutama, saat menjalankan pelatihan terdistribusi dalam mode paralel data. Kita tahu bahwa, untuk membagi sekumpulan sampel yang disediakan oleh iterator data untuk pelatihan paralel data pada satu pekerja, kita dapat menggunakanmxnet.gluon.utils.split_and_load lalu, muat setiap bagian dari kelompok tersebut pada perangkat yang akan memprosesnya lebih lanjut.

Di sisi lain, dalam kasus pelatihan terdistribusi, pada awalnya kita perlu membagi dataset menjadi nbagian yang berbeda sehingga setiap pekerja mendapatkan bagian yang berbeda. Setelah didapat, setiap pekerja kemudian dapat menggunakansplit_and_loaduntuk sekali lagi membagi bagian dari kumpulan data tersebut ke berbagai perangkat pada satu mesin. Semua ini terjadi melalui iterator data.mxnet.io.MNISTIterator dan mxnet.io.ImageRecordIter adalah dua iterator di MXNet yang mendukung fitur ini.

Pembaruan bobot

Untuk memperbarui bobot, KVStore mendukung dua mode berikut -

Metode pertama menggabungkan gradien dan memperbarui bobot dengan menggunakan gradien tersebut.
Dalam metode kedua, server hanya menggabungkan gradien.

Jika Anda menggunakan Gluon, ada opsi untuk memilih di antara metode yang disebutkan di atas dengan meneruskan update_on_kvstorevariabel. Mari kita pahami dengan membuat filetrainer objek sebagai berikut -

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)

Mode Pelatihan Terdistribusi

Jika string pembuatan KVStore berisi kata dist, itu berarti pelatihan terdistribusi diaktifkan. Berikut ini adalah berbagai mode pelatihan terdistribusi yang dapat diaktifkan dengan menggunakan berbagai jenis KVStore -

dist_sync

Seperti namanya, ini menunjukkan pelatihan terdistribusi sinkron. Dalam hal ini, semua pekerja menggunakan set parameter model tersinkronisasi yang sama di awal setiap batch.

Kekurangan dari mode ini adalah, setelah setiap kelompok server harus menunggu untuk menerima gradien dari setiap pekerja sebelum memperbarui parameter model. Ini berarti bahwa jika seorang pekerja mengalami kecelakaan, itu akan menghentikan kemajuan semua pekerja.

dist_async

Seperti namanya, ini menunjukkan pelatihan terdistribusi sinkron. Dalam hal ini, server menerima gradien dari satu pekerja dan segera memperbarui penyimpanannya. Server menggunakan toko yang diperbarui untuk menanggapi tarikan lebih lanjut.

Keuntungannya, dibandingkan dist_sync mode, adalah bahwa seorang pekerja yang menyelesaikan pemrosesan batch dapat menarik parameter saat ini dari server dan memulai batch berikutnya. Pekerja bisa melakukannya, meskipun pekerja lain belum selesai memproses kelompok sebelumnya. Ini juga lebih cepat daripada mode dist_sync karena, diperlukan waktu lebih lama untuk berkumpul tanpa biaya sinkronisasi.

dist_sync_device

Mode ini sama dengan dist_syncmode. Satu-satunya perbedaan adalah, ketika ada beberapa GPU yang digunakan pada setiap nodedist_sync_device menggabungkan gradien dan memperbarui bobot pada GPU sedangkan, dist_sync menggabungkan gradien dan memperbarui bobot pada memori CPU.

Ini mengurangi komunikasi mahal antara GPU dan CPU. Itulah mengapa, ini lebih cepat daridist_sync. Kekurangannya adalah meningkatkan penggunaan memori pada GPU.

dist_async_device

Mode ini berfungsi sama seperti dist_sync_device mode, tetapi dalam mode asynchronous.

Di bab ini kita akan mempelajari tentang Paket Python yang tersedia di Apache MXNet.

Paket MXNet Python penting

MXNet memiliki paket Python penting berikut yang akan kita diskusikan satu per satu -

Autograd (Diferensiasi Otomatis)
NDArray
KVStore
Gluon
Visualization

Pertama mari kita mulai dengan Autograd Paket Python untuk Apache MXNet.

Autograd

Autograd berdiri untuk automatic differentiationdigunakan untuk melakukan propagasi mundur gradien dari metrik kerugian kembali ke masing-masing parameter. Bersama dengan propagasi mundur, ia menggunakan pendekatan pemrograman dinamis untuk menghitung gradien secara efisien. Ini juga disebut diferensiasi otomatis mode terbalik. Teknik ini sangat efisien dalam situasi 'fan-in' di mana, banyak parameter mempengaruhi metrik kerugian tunggal.

Apa itu gradien?

Gradien adalah dasar dari proses pelatihan jaringan saraf. Mereka pada dasarnya memberi tahu kami cara mengubah parameter jaringan untuk meningkatkan kinerjanya.

Seperti yang kita ketahui, jaringan saraf (NN) terdiri dari operator seperti jumlah, produk, konvolusi, dll. Operator ini, untuk perhitungannya, menggunakan parameter seperti bobot dalam kernel konvolusi. Kita harus menemukan nilai optimal untuk parameter ini dan gradien menunjukkan jalan dan membawa kita ke solusi juga.

Kami tertarik pada efek mengubah parameter pada kinerja jaringan dan gradien memberi tahu kami, seberapa banyak variabel tertentu meningkat atau menurun ketika kami mengubah variabel yang bergantung padanya. Performa biasanya ditentukan dengan menggunakan metrik kerugian yang kami coba minimalkan. Misalnya, untuk regresi kita mungkin mencoba meminimalkanL2 kerugian antara prediksi kami dan nilai pasti, sedangkan untuk klasifikasi kami mungkin meminimalkan cross-entropy loss.

Setelah kita menghitung gradien setiap parameter dengan mengacu pada kerugian, kita kemudian dapat menggunakan pengoptimal, seperti penurunan gradien stokastik.

Bagaimana cara menghitung gradien?

Kami memiliki opsi berikut untuk menghitung gradien -

Symbolic Differentiation- Opsi pertama adalah Diferensiasi Simbolik, yang menghitung rumus untuk setiap gradien. Kelemahan dari metode ini adalah, metode ini akan dengan cepat menghasilkan rumus yang sangat panjang karena jaringan semakin dalam dan operator menjadi lebih kompleks.
Finite Differencing- Pilihan lainnya adalah, menggunakan perbedaan terbatas yang mencoba sedikit perbedaan pada setiap parameter dan melihat bagaimana metrik kerugian merespons. Kelemahan dari metode ini adalah, secara komputasi mahal dan mungkin memiliki presisi numerik yang buruk.
Automatic differentiation- Solusi untuk kelemahan metode di atas adalah, menggunakan diferensiasi otomatis untuk melakukan propagasi mundur gradien dari metrik kerugian kembali ke masing-masing parameter. Propagasi memungkinkan kita menggunakan pendekatan pemrograman dinamis untuk menghitung gradien secara efisien. Metode ini juga disebut diferensiasi otomatis mode terbalik.

Diferensiasi Otomatis (autograd)

Di sini, kami akan memahami secara detail cara kerja autograd. Ini pada dasarnya bekerja dalam dua tahap berikut -

Stage 1 - Tahap ini disebut ‘Forward Pass’dari latihan. Sesuai namanya, dalam tahap ini membuat record operator yang digunakan oleh jaringan untuk membuat prediksi dan menghitung metrik kerugian.

Stage 2 - Tahap ini disebut ‘Backward Pass’dari latihan. Sesuai namanya, dalam tahap ini bekerja mundur melalui rekaman ini. Ke belakang, ini mengevaluasi turunan parsial dari setiap operator, sampai ke parameter jaringan.

Keuntungan dari autograd

Berikut adalah keuntungan menggunakan Diferensiasi Otomatis (autograd) -

Flexible- Fleksibilitas, yang diberikan kepada kami saat mendefinisikan jaringan kami, adalah salah satu manfaat besar menggunakan autograd. Kami dapat mengubah operasi di setiap iterasi. Ini disebut grafik dinamis, yang jauh lebih kompleks untuk diterapkan dalam kerangka kerja yang membutuhkan grafik statis. Autograd, bahkan dalam kasus seperti itu, masih dapat melakukan propagasi mundur gradien dengan benar.
Automatic- Autograd otomatis, yaitu kerumitan prosedur propagasi mundur diurus olehnya untuk Anda. Kami hanya perlu menentukan gradien apa yang ingin kami hitung.
Efficient - Autogard menghitung gradien dengan sangat efisien.
Can use native Python control flow operators- Kita dapat menggunakan operator aliran kontrol asli Python seperti if condition dan while loop. Autograd masih dapat melakukan propagasi mundur gradien secara efisien dan benar.

Menggunakan autograd di MXNet Gluon

Di sini, dengan bantuan sebuah contoh, kita akan melihat bagaimana kita dapat menggunakannya autograd di MXNet Gluon.

Contoh Implementasi

Dalam contoh berikut, kami akan menerapkan model regresi yang memiliki dua lapisan. Setelah menerapkan, kami akan menggunakan autograd untuk secara otomatis menghitung gradien kerugian dengan mengacu pada masing-masing parameter bobot -

Pertama impor autogrard dan paket lain yang diperlukan sebagai berikut -

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

Sekarang, kita perlu mendefinisikan jaringan sebagai berikut -

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

Sekarang kita perlu mendefinisikan kerugian sebagai berikut -

loss_function = L2Loss()

Selanjutnya, kita perlu membuat data dummy sebagai berikut -

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

Sekarang, kami siap untuk forward pass pertama kami melalui jaringan. Kami ingin autograd merekam grafik komputasi sehingga kami dapat menghitung gradien. Untuk ini, kita perlu menjalankan kode jaringan dalam lingkupautograd.record konteksnya sebagai berikut -

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

Sekarang, kita siap untuk backward pass, yang kita mulai dengan memanggil metode mundur pada kuantitas bunga. Quatity of interest dalam contoh kami adalah kerugian karena kami mencoba menghitung gradien kerugian dengan mengacu pada parameter -

loss.backward()

Sekarang, kami memiliki gradien untuk setiap parameter jaringan, yang akan digunakan oleh pengoptimal untuk memperbarui nilai parameter untuk meningkatkan kinerja. Mari kita periksa gradien dari lapisan pertama sebagai berikut -

N_net[0].weight.grad()

Output

Outputnya adalah sebagai berikut-

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

Contoh implementasi lengkap

Diberikan di bawah ini adalah contoh implementasi lengkap.

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()

Pada bab ini, kita akan membahas tentang format array multi-dimensi MXNet yang disebut ndarray.

Menangani data dengan NDArray

Pertama, kita akan melihat bagaimana kita dapat menangani data dengan NDArray. Berikut adalah prasyarat untuk hal yang sama -

Prasyarat

Untuk memahami bagaimana kita dapat menangani data dengan format array multi-dimensi ini, kita perlu memenuhi prasyarat berikut:

MXNet diinstal di lingkungan Python
Python 2.7.x atau Python 3.x

Contoh Implementasi

Mari kita pahami fungsionalitas dasar dengan bantuan contoh yang diberikan di bawah ini -

Pertama, kita perlu mengimpor MXNet dan ndarray dari MXNet sebagai berikut -

import mxnet as mx
from mxnet import nd

Setelah kami mengimpor pustaka yang diperlukan, kami akan menggunakan fungsi dasar berikut:

Array 1-D sederhana dengan daftar python

Example

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

Output

Outputnya seperti yang disebutkan di bawah ini -

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

Array 2-D dengan daftar python

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

Outputnya seperti yang dinyatakan di bawah ini -

[[ 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)>

Membuat NDArray tanpa inisialisasi apa pun

Di sini, kita akan membuat matriks dengan 3 baris dan 4 kolom dengan menggunakan .emptyfungsi. Kami juga akan menggunakan.full fungsi, yang akan mengambil operator tambahan untuk nilai apa yang ingin Anda isi dalam array.

Example

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

Output

Outputnya diberikan di bawah ini -

[[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)>

Matriks semua nol dengan fungsi .zeros

Example

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

Output

Outputnya adalah sebagai berikut -

[[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)>

Matriks semua yang memiliki fungsi .ones

Example

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

Output

Outputnya disebutkan di bawah ini -

[[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)>

Membuat larik yang nilainya diambil sampelnya secara acak

Example

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

Output

Outputnya diberikan di bawah ini -

[[ 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)>

Menemukan dimensi dari setiap NDArray

Example

y.shape

Output

Outputnya adalah sebagai berikut -

(3, 4)

Menemukan ukuran setiap NDArray

Example

y.size

Output

Menemukan tipe data dari setiap NDArray

Example

y.dtype

Output

numpy.float32

Operasi NDArray

Di bagian ini, kami akan memperkenalkan Anda pada operasi array MXNet. NDArray mendukung sejumlah besar matematika standar serta operasi di tempat.

Operasi Matematika Standar

Berikut adalah operasi matematika standar yang didukung oleh NDArray -

Penambahan berdasarkan elemen

Pertama, kita perlu mengimpor MXNet dan ndarray dari MXNet sebagai berikut:

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

Output diberikan bersama ini -

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)>

Perkalian bijak

Example

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

Output

Anda akan melihat keluaran berikut−

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

Eksponensial

Example

nd.exp(x)

Output

Saat Anda menjalankan kode, Anda akan melihat output berikut:

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

Matriks diubah urutannya untuk menghitung perkalian matriks-matriks

Example

nd.dot(x, y.T)

Output

Diberikan di bawah ini adalah output dari kode -

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

Operasi Di Tempat

Setiap kali, dalam contoh di atas, kami menjalankan operasi, kami mengalokasikan memori baru untuk menampung hasilnya.

Misalnya, jika kita menulis A = A + B, kita akan mendereferensi matriks yang digunakan A untuk menunjuk dan sebagai gantinya mengarahkannya ke memori yang baru dialokasikan. Mari kita pahami dengan contoh yang diberikan di bawah ini, menggunakan fungsi id () Python -

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

Output

Setelah dieksekusi, Anda akan menerima output berikut -

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

Faktanya, kita juga dapat menetapkan hasilnya ke array yang sebelumnya dialokasikan sebagai berikut -

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

Outputnya ditunjukkan di bawah ini -

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

Dari output di atas, kita dapat melihat bahwa x + y masih akan mengalokasikan buffer sementara untuk menyimpan hasil sebelum menyalinnya ke z. Jadi sekarang, kita dapat melakukan operasi di tempat untuk menggunakan memori dengan lebih baik dan untuk menghindari buffer sementara. Untuk melakukan ini, kami akan menentukan argumen kata kunci keluar yang didukung setiap operator sebagai berikut -

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

Saat menjalankan program di atas, Anda akan mendapatkan hasil sebagai berikut -

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

Konteks NDArray

Di Apache MXNet, setiap array memiliki konteks dan satu konteks bisa jadi CPU, sedangkan konteks lain mungkin beberapa GPU. Hal-hal bisa menjadi lebih buruk, ketika kami menerapkan pekerjaan di beberapa server. Itu sebabnya, kita perlu menetapkan array ke konteks secara cerdas. Ini akan meminimalkan waktu yang dihabiskan untuk mentransfer data antar perangkat.

Misalnya, coba inisialisasi array sebagai berikut -

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

Output

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

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

Kita dapat menyalin NDArray yang diberikan dari satu konteks ke konteks lain dengan menggunakan metode copyto () sebagai berikut -

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

Array NumPy vs. NDArray

Kita semua sudah familiar dengan array NumPy tetapi Apache MXNet menawarkan implementasi arraynya sendiri bernama NDArray. Sebenarnya, ini awalnya dirancang agar mirip dengan NumPy tetapi ada perbedaan utama -

Perbedaan utamanya terletak pada cara penghitungan dieksekusi di NumPy dan NDArray. Setiap manipulasi NDArray di MXNet dilakukan dengan cara asynchronous dan non-blocking, yang artinya, ketika kita menulis kode seperti c = a * b, fungsinya didorong keExecution Engine, yang akan memulai penghitungan.

Di sini, a dan b keduanya adalah sinar NDA. Manfaat menggunakannya adalah, fungsinya segera kembali, dan utas pengguna dapat melanjutkan eksekusi meskipun fakta bahwa penghitungan sebelumnya mungkin belum diselesaikan.

Kerja Mesin Eksekusi

Jika kita berbicara tentang cara kerja mesin eksekusi, itu membangun grafik komputasi. Grafik komputasi dapat menyusun ulang atau menggabungkan beberapa perhitungan, tetapi selalu mengikuti urutan ketergantungan.

Misalnya, jika ada manipulasi lain dengan 'X' yang dilakukan nanti dalam kode pemrograman, Mesin Eksekusi akan mulai melakukannya setelah hasil 'X' tersedia. Mesin eksekusi akan menangani beberapa pekerjaan penting bagi pengguna, seperti penulisan callback untuk memulai eksekusi kode berikutnya.

Di Apache MXNet, dengan bantuan NDArray, untuk mendapatkan hasil komputasi kita hanya perlu mengakses variabel yang dihasilkan. Aliran kode akan diblokir hingga hasil komputasi ditetapkan ke variabel yang dihasilkan. Dengan cara ini, ini meningkatkan kinerja kode sambil tetap mendukung mode pemrograman imperatif.

Mengonversi NDArray ke NumPy Array

Mari kita pelajari bagaimana kita dapat mengubah NDArray menjadi NumPy Array di MXNet.

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

Terkadang, kita bisa merakit operator level yang lebih tinggi dengan menggunakan operator yang ada. Salah satu contoh terbaiknya adalah, filenp.full_like()operator, yang tidak ada di NDArray API. Ini dapat dengan mudah diganti dengan kombinasi operator yang ada sebagai berikut:

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

Kami akan mendapatkan hasil yang serupa sebagai berikut -

True

Finding similar operator with different name and/or signature

Di antara semua operator, beberapa di antaranya memiliki nama yang sedikit berbeda, tetapi serupa dalam hal fungsionalitas. Contohnya adalahnd.ravel_index() dengan np.ravel()fungsi. Dengan cara yang sama, beberapa operator mungkin memiliki nama yang mirip, tetapi memiliki tanda tangan yang berbeda. Contohnya adalahnp.split() dan nd.split() serupa.

Mari kita pahami dengan contoh pemrograman berikut:

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

Outputnya dinyatakan di bawah ini -

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

Meminimalkan dampak dari memblokir panggilan

Dalam beberapa kasus, kami harus menggunakan keduanya .asnumpy() atau .asscalar()metode, tetapi ini akan memaksa MXNet untuk memblokir eksekusi, hingga hasilnya dapat diambil. Kami dapat meminimalkan dampak panggilan pemblokiran dengan menelepon.asnumpy() atau .asscalar() metode saat ini, ketika kami berpikir perhitungan nilai ini sudah dilakukan.

Contoh Implementasi

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

Outputnya dikutip di bawah ini:

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

Paket MXNet Python terpenting lainnya adalah Gluon. Pada bab ini, kita akan membahas paket ini. Gluon menyediakan API yang jelas, ringkas, dan sederhana untuk proyek DL. Ini memungkinkan Apache MXNet untuk membuat prototipe, membangun, dan melatih model DL tanpa mengorbankan kecepatan pelatihan.

Blok

Blok membentuk dasar dari desain jaringan yang lebih kompleks. Dalam jaringan saraf, ketika kompleksitas jaringan saraf meningkat, kita perlu beralih dari mendesain satu lapisan ke seluruh lapisan neuron. Misalnya, desain NN seperti ResNet-152 memiliki tingkat keteraturan yang sangat wajar dengan terdiri dariblocks dari lapisan berulang.

Contoh

Pada contoh yang diberikan di bawah ini, kita akan menulis kode blok sederhana, yaitu blok untuk perceptron multilayer.

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

Ini menghasilkan keluaran berikut:

[[ 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)>

Langkah-langkah yang diperlukan untuk pergi dari mendefinisikan lapisan ke menentukan blok dari satu atau lebih lapisan -

Step 1 - Blok mengambil data sebagai input.

Step 2- Sekarang, blok akan menyimpan status dalam bentuk parameter. Misalnya, dalam contoh pengkodean di atas, blok berisi dua lapisan tersembunyi dan kami membutuhkan tempat untuk menyimpan parameter untuknya.

Step 3- Blok berikutnya akan memanggil fungsi maju untuk melakukan propagasi maju. Ini juga disebut komputasi maju. Sebagai bagian dari panggilan penerusan pertama, blok menginisialisasi parameter dengan cara malas.

Step 4- Akhirnya blok akan memanggil fungsi mundur dan menghitung gradien dengan mengacu pada masukannya. Biasanya, langkah ini dilakukan secara otomatis.

Blok Berurutan

Blok berurutan adalah jenis blok khusus tempat data mengalir melalui rangkaian blok. Dalam hal ini, setiap blok diterapkan ke keluaran dari satu sebelumnya dengan blok pertama diterapkan pada data masukan itu sendiri.

Mari kita lihat caranya sequential pekerjaan kelas -

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

Output diberikan bersama ini -

[[ 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 Kustom

Kita dapat dengan mudah melampaui penggabungan dengan blok sekuensial seperti yang didefinisikan di atas. Tapi, jika kita ingin membuat kustomisasi maka fileBlockkelas juga memberi kita fungsionalitas yang diperlukan. Kelas blok memiliki konstruktor model yang disediakan dalam modul nn. Kita dapat mewarisi konstruktor model tersebut untuk menentukan model yang kita inginkan.

Dalam contoh berikut, file MLP class menimpa __init__ dan meneruskan fungsi kelas Block.

Mari kita lihat cara kerjanya.

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

Saat Anda menjalankan kode, Anda akan melihat output berikut:

[[ 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)>

Lapisan Kustom

API Gluon Apache MXNet hadir dengan sejumlah lapisan yang telah ditentukan sebelumnya. Tetapi masih pada titik tertentu, kami mungkin menemukan bahwa lapisan baru diperlukan. Kita dapat dengan mudah menambahkan layer baru di Gluon API. Di bagian ini, kita akan melihat bagaimana kita dapat membuat layer baru dari awal.

Lapisan Kustom Paling Sederhana

Untuk membuat layer baru di Gluon API, kita harus membuat kelas yang diwarisi dari kelas Block yang menyediakan fungsionalitas paling dasar. Kita dapat mewarisi semua lapisan yang telah ditentukan sebelumnya secara langsung atau melalui subkelas lain.

Untuk membuat layer baru, satu-satunya metode instance yang perlu diterapkan adalah forward (self, x). Metode ini menentukan, apa sebenarnya yang akan dilakukan lapisan kita selama propagasi maju. Seperti yang dibahas sebelumnya, pass propagasi mundur untuk blok akan dilakukan oleh Apache MXNet itu sendiri secara otomatis.

Contoh

Pada contoh di bawah ini, kami akan mendefinisikan layer baru. Kami juga akan menerapkanforward() metode untuk menormalkan data masukan dengan memasangnya ke dalam kisaran [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

Saat menjalankan program di atas, Anda akan mendapatkan hasil sebagai berikut -

[[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)>

Hibridisasi

Ini dapat didefinisikan sebagai proses yang digunakan oleh Apache MXNet untuk membuat grafik simbolis dari komputasi maju. Hibridisasi memungkinkan MXNet untuk meningkatkan kinerja komputasi dengan mengoptimalkan grafik simbolik komputasi. Daripada mewarisi langsung dariBlock, pada kenyataannya, kita mungkin menemukan bahwa saat mengimplementasikan lapisan yang ada, sebuah blok diwarisi dari a HybridBlock.

Berikut adalah alasannya -

Allows us to write custom layers: HybridBlock memungkinkan kita untuk menulis lapisan khusus yang selanjutnya dapat digunakan dalam pemrograman imperatif dan simbolik keduanya.
Increase computation performance- HybridBlock mengoptimalkan grafik simbolik komputasi yang memungkinkan MXNet meningkatkan kinerja komputasi.

Contoh

Dalam contoh ini, kami akan menulis ulang layer contoh kami, yang dibuat di atas, dengan menggunakan 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

Outputnya dinyatakan di bawah ini:

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

Hibridisasi tidak ada hubungannya dengan komputasi pada GPU dan seseorang dapat melatih jaringan hibridisasi maupun non-hibrid pada CPU dan GPU.

Perbedaan antara Block dan HybridBlock

Jika kita akan membandingkan Block Kelas dan HybridBlock, kita akan lihat itu HybridBlock sudah memilikinya forward() metode diterapkan. HybridBlock mendefinisikan a hybrid_forward()metode yang perlu diterapkan saat membuat lapisan. Argumen F menciptakan perbedaan utama antaraforward() dan hybrid_forward(). Dalam komunitas MXNet, argumen F disebut sebagai backend. F bisa merujuk kemxnet.ndarray API (digunakan untuk pemrograman imperatif) atau mxnet.symbol API (digunakan untuk pemrograman Simbolik).

Bagaimana cara menambahkan lapisan khusus ke jaringan?

Alih-alih menggunakan lapisan khusus secara terpisah, lapisan ini digunakan dengan lapisan yang telah ditentukan sebelumnya. Kita bisa menggunakan keduanyaSequential atau HybridSequentialkontainer ke dari jaringan neural berurutan. Seperti dibahas sebelumnya juga,Sequential kontainer mewarisi dari Block dan HybridSequential mewarisi dari HybridBlock masing-masing.

Contoh

Pada contoh di bawah, kami akan membuat jaringan neural sederhana dengan lapisan khusus. Keluaran dariDense (5) lapisan akan menjadi masukan NormalizationHybridLayer. Output dariNormalizationHybridLayer akan menjadi masukan dari Dense (1) lapisan.

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

Anda akan melihat output berikut -

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

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

Parameter lapisan khusus

Dalam jaringan neural, lapisan memiliki sekumpulan parameter yang terkait dengannya. Kami terkadang menyebutnya sebagai bobot, yang merupakan status internal lapisan. Parameter ini memainkan peran yang berbeda -

Terkadang ini adalah hal-hal yang ingin kita pelajari selama langkah propagasi mundur.
Terkadang ini hanya konstanta yang ingin kami gunakan selama forward pass.

Jika kita berbicara tentang konsep pemrograman, parameter (bobot) blok ini disimpan dan diakses melalui ParameterDict kelas yang membantu inisialisasi, pembaruan, penyimpanan, dan pemuatannya.

Contoh

Pada contoh di bawah ini, kami akan menentukan dua set parameter berikut -

Parameter weights- Ini bisa dilatih, dan bentuknya tidak diketahui selama fase konstruksi. Ini akan disimpulkan pada run pertama dari propagasi maju.
Parameter scale- Ini adalah konstanta yang nilainya tidak berubah. Berbeda dengan bobot parameter, bentuknya ditentukan selama konstruksi.

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

Bab ini membahas paket python KVStore dan visualisasi.

Paket KVStore

Toko KV adalah singkatan dari Key-Value store. Ini adalah komponen penting yang digunakan untuk pelatihan multi-perangkat. Ini penting karena, komunikasi parameter di seluruh perangkat pada satu maupun di beberapa mesin ditransmisikan melalui satu atau lebih server dengan KVStore untuk parameter.

Mari kita pahami cara kerja KVStore dengan bantuan poin-poin berikut:

Setiap nilai di KVStore diwakili oleh a key dan a value.
Setiap larik parameter dalam jaringan diberikan a key dan bobot dari parameter array tersebut dirujuk oleh value.
Setelah itu, node pekerja pushgradien setelah memproses batch. Mereka jugapull memperbarui bobot sebelum memproses kelompok baru.

Dengan kata sederhana, kita dapat mengatakan bahwa KVStore adalah tempat untuk berbagi data di mana, setiap perangkat dapat memasukkan dan menarik data keluar.

Data Push-In dan Pull-Out

KVStore dapat dianggap sebagai objek tunggal yang dibagikan di berbagai perangkat seperti GPU & komputer, di mana setiap perangkat dapat memasukkan dan menarik data keluar.

Berikut adalah langkah-langkah implementasi yang perlu diikuti oleh perangkat untuk mendorong dan menarik data keluar:

Langkah-langkah implementasi

Initialisation- Langkah pertama adalah menginisialisasi nilai. Di sini untuk contoh kita, kita akan menginisialisasi pasangan pasangan (int, NDArray) ke KVStrore dan setelah itu menarik nilainya -

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

Ini menghasilkan keluaran berikut -

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

Push, Aggregate, and Update - Setelah diinisialisasi, kita dapat memasukkan nilai baru ke dalam KVStore dengan bentuk yang sama ke kunci -

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

Output

Outputnya diberikan di bawah ini -

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

Data yang digunakan untuk mendorong dapat disimpan di perangkat apa pun seperti GPU atau komputer. Kami juga dapat memasukkan beberapa nilai ke dalam kunci yang sama. Dalam kasus ini, KVStore pertama-tama akan menjumlahkan semua nilai ini dan kemudian mendorong nilai gabungan sebagai berikut -

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

Anda akan melihat output berikut -

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

Untuk setiap dorongan yang Anda terapkan, KVStore akan menggabungkan nilai yang didorong dengan nilai yang sudah disimpan. Ini akan dilakukan dengan bantuan pembaru. Di sini, pembaru default adalah 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

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

[[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

Diberikan di bawah ini adalah output dari kode -

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

Pull - Seperti halnya Push, kami juga dapat menarik nilai ke beberapa perangkat dengan satu panggilan sebagai berikut -

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

Output

Outputnya dinyatakan di bawah ini -

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

Contoh Implementasi Lengkap

Diberikan di bawah ini adalah contoh implementasi lengkap -

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())

Menangani Pasangan Nilai-Kunci

Semua operasi yang kami terapkan di atas melibatkan satu kunci, tetapi KVStore juga menyediakan antarmuka untuk a list of key-value pairs -

Untuk satu perangkat

Berikut adalah contoh untuk menampilkan antarmuka KVStore untuk daftar pasangan nilai kunci untuk satu perangkat -

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

Anda akan menerima output berikut -

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

Untuk banyak perangkat

Berikut adalah contoh untuk menampilkan antarmuka KVStore untuk daftar pasangan nilai kunci untuk beberapa perangkat -

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

Anda akan melihat output berikut -

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

Paket visualisasi

Paket visualisasi adalah paket Apache MXNet yang digunakan untuk merepresentasikan neural network (NN) sebagai grafik komputasi yang terdiri dari node dan edge.

Visualisasikan jaringan saraf

Pada contoh di bawah ini kami akan menggunakan mx.viz.plot_networkuntuk memvisualisasikan jaringan saraf. Berikut adalah prasyarat untuk ini -

Prerequisites

Notebook Jupyter
Perpustakaan Graphviz

Contoh Implementasi

Dalam contoh di bawah ini, kita akan memvisualisasikan sampel NN untuk faktorisasi matriks linier -

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)

Bab ini menjelaskan pustaka ndarray yang tersedia di Apache MXNet.

Mxnet.ndarray

Pustaka NDArray Apache MXNet mendefinisikan DS inti (struktur data) untuk semua komputasi matematis. Dua pekerjaan dasar NDArray adalah sebagai berikut -

Ini mendukung eksekusi cepat pada berbagai konfigurasi perangkat keras.
Ini secara otomatis memparalelkan beberapa operasi di perangkat keras yang tersedia.

Contoh yang diberikan di bawah ini menunjukkan bagaimana seseorang dapat membuat NDArray dengan menggunakan 'array' 1-D dan 2-D dari daftar Python biasa -

import mxnet as mx
from mxnet import nd

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

Output

Outputnya diberikan di bawah ini:

[ 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

Ini menghasilkan keluaran berikut -

[[ 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)>

Sekarang mari kita bahas secara detail tentang kelas, fungsi, dan parameter dari ndarray API MXNet.

Kelas

Tabel berikut terdiri dari kelas-kelas ndarray API dari MXNet -

Kelas	Definisi
CachedOp (sym [, flags])	Ini digunakan untuk pegangan operator cache.
NDArray (pegangan [, dapat ditulis])	Ini digunakan sebagai objek array yang mewakili array homogen multi-dimensi dari item berukuran tetap.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.ndarray API -

Fungsi & Parameternya	Definisi
Activation([data, act_type, out, name])	Ini menerapkan elemen fungsi aktivasi ke input. Mendukung fungsi aktivasi relu, sigmoid, tanh, softrelu, softsign.
BatchNorm([data, gamma, beta, moving_mean,…])	Ini digunakan untuk normalisasi batch. Fungsi ini menormalkan kumpulan data dengan mean dan varians. Ini menerapkan skala gamma dan offset beta.
BilinearSampler([data, grid, cudnn_off,…])	Fungsi ini menerapkan sampling bilinear untuk memasukkan peta fitur. Sebenarnya itu adalah kunci dari “Spatial Transformer Networks”. Jika Anda familiar dengan fungsi remap di OpenCV, penggunaan fungsi ini sangat mirip dengan itu. Satu-satunya perbedaan adalah bahwa ia memiliki umpan mundur.
BlockGrad ([data, keluar, nama])	Seperti yang ditentukan namanya, fungsi ini menghentikan komputasi gradien. Ini pada dasarnya menghentikan akumulasi gradien input agar tidak mengalir melalui operator ini ke arah belakang.
cast ([data, dtype, out, name])	Fungsi ini akan mentransmisikan semua elemen masukan ke tipe baru.

Contoh Implementasi

Pada contoh di bawah ini, kita akan menggunakan fungsi BilinierSampler () untuk memperkecil data dua kali dan menggeser data secara horizontal sebesar -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

Saat Anda menjalankan kode di atas, Anda akan melihat output berikut:

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

Output di atas menunjukkan pembesaran data dua kali.

Contoh menggeser data sebesar -1 piksel adalah sebagai berikut -

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

Outputnya dinyatakan di bawah ini -

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

Demikian pula, contoh berikut menunjukkan penggunaan fungsi cast () -

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

Output

Setelah dieksekusi, Anda akan menerima output berikut -

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

ndarray.contrib

Contrib NDArray API didefinisikan dalam paket ndarray.contrib. Ini biasanya menyediakan banyak API eksperimental yang berguna untuk fitur baru. API ini berfungsi sebagai tempat komunitas di mana mereka dapat mencoba fitur-fitur baru. Kontributor fitur juga akan mendapatkan umpan balik.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.ndarray.contrib API -

Fungsi & Parameternya	Definisi
rand_zipfian(true_classes, num_sampled,…)	Fungsi ini mengambil sampel acak dari sekitar distribusi Zipfian. Distribusi dasar dari fungsi ini adalah distribusi Zipfian. Fungsi ini secara acak mengambil sampel num_sampled kandidat dan elemen sampled_candidates diambil dari distribusi dasar yang diberikan di atas.
foreach(body, data, init_states)	Sesuai namanya, fungsi ini menjalankan loop for dengan komputasi yang ditentukan pengguna melalui NDArray pada dimensi 0. Fungsi ini mensimulasikan loop for dan body memiliki komputasi untuk iterasi loop for.
while_loop (cond, func, loop_vars [,…])	Sesuai namanya, fungsi ini menjalankan while loop dengan komputasi dan kondisi loop yang ditentukan pengguna. Fungsi ini mensimulasikan loop sementara yang secara literal melakukan komputasi yang disesuaikan jika kondisinya terpenuhi.
cond(pred, lalu_func, else_func)	Sesuai namanya, fungsi ini menjalankan if-then-else menggunakan kondisi dan komputasi yang ditentukan pengguna. Fungsi ini mensimulasikan cabang if-like yang memilih untuk melakukan salah satu dari dua penghitungan yang disesuaikan sesuai dengan kondisi yang ditentukan.
isinf(data)	Fungsi ini melakukan pemeriksaan elemen-bijaksana untuk menentukan apakah NDArray berisi elemen tak terbatas atau tidak.
getnnz([data, sumbu, keluar, nama])	Fungsi ini memberi kita jumlah nilai yang disimpan untuk tensor renggang. Ini juga mencakup nol eksplisit. Ini hanya mendukung matriks CSR pada CPU.
mempersyaratkan ([data, rentang_min, rentang_aks,…])	Fungsi ini mengubah data yang diberikan yang dikelompokkan dalam int32 dan ambang batas yang sesuai, menjadi int8 menggunakan ambang batas minimum dan maksimum baik yang dihitung pada saat runtime atau dari kalibrasi.

Contoh Implementasi

Dalam contoh di bawah ini, kita akan menggunakan fungsi rand_zipfian untuk menggambar sampel acak dari sekitar distribusi 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

Anda akan melihat output berikut -

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

Example

exp_count_true

Output

Outputnya diberikan di bawah ini:

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

Example

exp_count_sample

Output

Ini menghasilkan keluaran berikut:

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

Pada contoh di bawah ini, kami akan menggunakan fungsi tersebut while_loop untuk menjalankan loop sementara untuk komputasi yang ditentukan pengguna dan kondisi loop:

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

Outputnya ditunjukkan di bawah ini -

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

Example

States

Output

Ini menghasilkan keluaran berikut -

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

ndarray.image

Image NDArray API didefinisikan dalam paket ndarray.image. Seperti namanya, biasanya digunakan untuk gambar dan fiturnya.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting & parameternya yang dicakup oleh mxnet.ndarray.image API-

Fungsi & Parameternya	Definisi
adjust_lighting([data, alfa, keluar, nama])	Sesuai namanya, fungsi ini mengatur level pencahayaan dari input. Ini mengikuti gaya AlexNet.
crop([data, x, y, lebar, tinggi, keluar, nama])	Dengan bantuan fungsi ini, kita dapat memotong gambar NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan oleh pengguna.
normalize([data, mean, std, out, name])	Ini akan menormalkan tensor bentuk (C x H x W) atau (N x C x H x W) dengan mean dan standard deviation(SD).
random_crop ([data, xrange, yrange, lebar,…])	Mirip dengan crop (), ini secara acak memotong gambar NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan oleh pengguna. Ini akan meningkatkan hasil jika src lebih kecil dari ukurannya.
random_lighting([data, alpha_std, out, name])	Sesuai namanya, fungsi ini menambahkan noise PCA secara acak. Ini juga mengikuti gaya AlexNet.
random_resized_crop([data, xrange, thn,…])	Ini juga memotong gambar secara acak NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan. Ini akan meningkatkan hasilnya, jika src lebih kecil dari ukurannya. Ini akan mengacak area dan aspek rasio juga.
resize([data, size, keep_ratio, interp,…])	Sesuai dengan namanya, fungsi ini akan mengubah ukuran gambar NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan oleh pengguna.
to_tensor([data, keluar, nama])	Ini mengubah gambar NDArray bentuk (H x W x C) atau (N x H x W x C) dengan nilai dalam rentang [0, 255] menjadi tensor NDArray bentuk (C x H x W) atau ( N x C x H x W) dengan nilai dalam rentang [0, 1].

Contoh Implementasi

Pada contoh di bawah ini, kita akan menggunakan fungsi to_tensor untuk mengubah gambar NDArray bentuk (H x W x C) atau (N x H x W x C) dengan nilai dalam rentang [0, 255] menjadi tensor NDArray bentuk (C x H x W) atau (N x C x H x W) dengan nilai dalam rentang [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

Anda akan melihat output berikut -

[[[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

Saat Anda menjalankan kode, Anda akan melihat output berikut -

[[[[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)>

Pada contoh di bawah ini, kami akan menggunakan fungsi tersebut normalize untuk menormalkan tensor bentuk (C x H x W) atau (N x C x H x W) dengan mean dan 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

Ini menghasilkan keluaran berikut -

[[[ 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

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

[[[[ 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

API NDArray Acak didefinisikan dalam paket ndarray.random. Seperti namanya, itu adalah generator distribusi acak NDArray API dari MXNet.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.ndarray.random API -

Fungsi dan Parameternya	Definisi
seragam ([rendah, tinggi, bentuk, tipe, ctx, keluar])	Ini menghasilkan sampel acak dari distribusi seragam.
normal ([loc, scale, shape, dtype, ctx, out])	Ini menghasilkan sampel acak dari distribusi normal (Gaussian).
randn (* bentuk, ** kwargs)	Ini menghasilkan sampel acak dari distribusi normal (Gaussian).
eksponensial ([skala, bentuk, tipe d, ctx, keluar])	Ini menghasilkan sampel dari distribusi eksponensial.
gamma ([alpha, beta, shape, dtype, ctx, out])	Ini menghasilkan sampel acak dari distribusi gamma.
multinomial (data [, shape, get_prob, out, dtype])	Ini menghasilkan pengambilan sampel bersamaan dari beberapa distribusi multinomial.
binomial_ negatif ([k, p, bentuk, tipe d, ctx, keluar])	Ini menghasilkan sampel acak dari distribusi binomial negatif.
generalized_negative_binomial ([mu, alpha,…])	Ini menghasilkan sampel acak dari distribusi binomial negatif umum.
acak (data, ** kwargs)	Ini mengocok elemen secara acak.
randint (rendah, tinggi [, bentuk, tipe, ctx, keluar])	Ini menghasilkan sampel acak dari distribusi seragam diskrit.
exponential_like ([data, lam, out, name])	Ini menghasilkan sampel acak dari distribusi eksponensial sesuai dengan bentuk larik input.
gamma_like ([data, alpha, beta, out, name])	Ini menghasilkan sampel acak dari distribusi gamma sesuai dengan bentuk larik masukan.
generalized_negative_binomial_like ([data,…])	Ini menghasilkan sampel acak dari distribusi binomial negatif umum, sesuai dengan bentuk larik masukan.
negative_binomial_like ([data, k, p, out, name])	Ini menghasilkan sampel acak dari distribusi binomial negatif, sesuai dengan bentuk larik masukan.
normal_like ([data, loc, scale, out, name])	Ini menghasilkan sampel acak dari distribusi normal (Gaussian), sesuai dengan bentuk larik masukan.
poisson_like ([data, lam, out, name])	Ini menghasilkan sampel acak dari distribusi Poisson, sesuai dengan bentuk larik masukan.
uniform_like ([data, low, high, out, name])	Ini menghasilkan sampel acak dari distribusi seragam, sesuai dengan bentuk larik masukan.

Contoh Implementasi

Dalam contoh di bawah ini, kita akan menarik sampel acak dari distribusi seragam. Untuk ini akan menggunakan fungsi tersebutuniform().

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

Output

Outputnya disebutkan di bawah ini -

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

Example

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

Output

Outputnya diberikan di bawah ini -

[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

Anda akan melihat output berikut -

[[1.8649333 1.8073189]
 [2.4113967 2.5691009]
 [3.1399727 3.4071832]]
<NDArray 3x2 @cpu(0)>

Dalam contoh di bawah ini, kita akan menarik sampel acak dari distribusi binomial negatif umum. Untuk ini, kami akan menggunakan fungsinyageneralized_negative_binomial().

mx.nd.random.generalized_negative_binomial(10, 0.5)

Output

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

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

Example

mx.nd.random.generalized_negative_binomial(10, 0.5, shape=(2,))

Output

Output diberikan bersama ini -

[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

Diberikan di bawah ini adalah output dari kode -

[[0. 0.]
 [4. 1.]
 [9. 3.]]
<NDArray 3x2 @cpu(0)>

ndarray.utils

Utilitas NDArray API didefinisikan dalam paket ndarray.utils. Seperti namanya, ini menyediakan fungsi utilitas untuk NDArray dan BaseSparseNDArray.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.ndarray.utils API -

Fungsi dan Parameternya	Definisi
nol (bentuk [, ctx, dtype, stype])	Fungsi ini akan mengembalikan larik baru dengan bentuk dan tipe tertentu, diisi dengan nol.
kosong (bentuk [, ctx, dtype, stype])	Ini akan mengembalikan larik baru dengan bentuk dan tipe yang diberikan, tanpa menginisialisasi entri.
larik (larik_sumber [, ctx, dtype])	Sesuai namanya, fungsi ini akan membuat array dari objek apa pun yang mengekspos antarmuka array.
memuat (fname)	Ini akan memuat array dari file.
load_frombuffer (buf)	Sesuai namanya, fungsi ini akan memuat kamus atau daftar array dari buffer
simpan (fname, data)	Fungsi ini akan menyimpan daftar array atau dikt dari str-> array ke file.

Contoh Implementasi

Pada contoh di bawah ini, kita akan mengembalikan array baru dengan bentuk dan tipe tertentu, diisi dengan nol. Untuk ini, kami akan menggunakan fungsinyazeros().

mx.nd.zeros((1,2), mx.cpu(), stype='csr')

Output

Ini menghasilkan keluaran berikut -

<CSRNDArray 1x2 @cpu(0)>

Example

mx.nd.zeros((1,2), mx.cpu(), 'float16', stype='row_sparse').asnumpy()

Output

Anda akan menerima output berikut -

array([[0., 0.]], dtype=float16)

Pada contoh di bawah ini, kita akan menyimpan daftar array dan kamus string. Untuk ini, kami akan menggunakan fungsinyasave().

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

Setelah dieksekusi, Anda akan menerima output berikut -

[
[[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

Outputnya ditunjukkan di bawah ini -

{'x':
[[0. 0. 0.]
[0. 0. 0.]]
<NDArray 2x3 @cpu(0)>, 'y':
[[1. 1. 1. 1.]]
<NDArray 1x4 @cpu(0)>}

Seperti yang telah kita bahas di bab sebelumnya bahwa, MXNet Gluon menyediakan API yang jelas, ringkas, dan sederhana untuk proyek DL. Ini memungkinkan Apache MXNet untuk membuat prototipe, membangun, dan melatih model DL tanpa mengorbankan kecepatan pelatihan.

Modul Inti

Mari kita pelajari modul inti gluon antarmuka pemrograman aplikasi (API) Apache MXNet Python.

gluon.nn

Gluon menyediakan sejumlah besar lapisan NN bawaan dalam modul gluon.nn. Itulah alasannya disebut modul inti.

Metode dan parameternya

Berikut adalah beberapa metode penting dan parameternya yang dicakup oleh mxnet.gluon.nn modul inti -

Metode dan Parameternya	Definisi
Aktivasi (aktivasi, ** kwargs)	Sesuai namanya, metode ini menerapkan fungsi aktivasi ke input.
AvgPool1D ([ukuran_koleksi, langkah, padding,…])	Ini adalah operasi penggabungan rata-rata untuk data temporal.
AvgPool2D ([ukuran_koleksi, langkah, padding,…])	Ini adalah operasi pengumpulan rata-rata untuk data spasial.
AvgPool3D ([ukuran_koleksi, langkah, padding,…])	Ini adalah operasi penggabungan rata-rata untuk data 3D. Data tersebut dapat berupa spasial atau spasial-temporal.
BatchNorm ([sumbu, momentum, epsilon, tengah,…])	Ini mewakili lapisan normalisasi batch.
BatchNormReLU ([sumbu, momentum, epsilon,…])	Ini juga mewakili lapisan normalisasi batch tetapi dengan fungsi aktivasi Relu.
Blokir ([awalan, params])	Ini memberikan kelas dasar untuk semua lapisan dan model jaringan saraf.
Konv1D (saluran, ukuran_kernel [, langkah,…])	Metode ini digunakan untuk lapisan konvolusi 1-D. Misalnya, konvolusi temporal.
Conv1DTranspose (saluran, ukuran_kernel [,…])	Metode ini digunakan untuk lapisan konvolusi 1D yang dialihkan.
Konv2D (saluran, ukuran_kernel [, langkah,…])	Metode ini digunakan untuk lapisan konvolusi 2D. Misalnya, konvolusi spasial di atas gambar).
Conv2DTranspose (saluran, ukuran_kernel [,…])	Metode ini digunakan untuk lapisan konvolusi 2D yang dialihkan.
Konv3D (saluran, ukuran_kernel [, langkah,…])	Metode ini digunakan untuk lapisan konvolusi 3D. Misalnya, konvolusi spasial atas volume.
Conv3DTranspose (saluran, ukuran_kernel [,…])	Metode ini digunakan untuk lapisan konvolusi 3D yang dialihkan.
Padat (unit [, aktivasi, use_bias,…])	Metode ini mewakili lapisan NN yang terhubung dengan kepadatan biasa.
Putus sekolah (tingkat [, sumbu])	Sesuai namanya, metode ini menerapkan Dropout ke input.
ELU ([alpha])	Metode ini digunakan untuk Unit Linear Eksponensial (ELU).
Menyematkan (input_dim, output_dim [, dtype,…])	Ini mengubah bilangan bulat non-negatif menjadi vektor padat dengan ukuran tetap.
Ratakan (** kwargs)	Metode ini meratakan input ke 2-D.
GELU (** kwargs)	Metode ini digunakan untuk Gaussian Exponential Linear Unit (GELU).
GlobalAvgPool1D ([tata letak])	Dengan bantuan metode ini, kita dapat melakukan operasi penggabungan rata-rata global untuk data temporal.
GlobalAvgPool2D ([tata letak])	Dengan bantuan metode ini, kita dapat melakukan operasi penggabungan rata-rata global untuk data spasial.
GlobalAvgPool3D ([tata letak])	Dengan bantuan metode ini, kita dapat melakukan operasi penggabungan rata-rata global untuk data 3-D.
GlobalMaxPool1D ([tata letak])	Dengan bantuan metode ini, kita bisa melakukan operasi global max pooling untuk data 1-D.
GlobalMaxPool2D ([tata letak])	Dengan bantuan metode ini, kita bisa melakukan operasi global max pooling untuk data 2-D.
GlobalMaxPool3D ([tata letak])	Dengan bantuan metode ini, kita bisa melakukan operasi global max pooling untuk data 3-D.
GroupNorm ([num_groups, epsilon, center,…])	Metode ini menerapkan normalisasi grup ke larik masukan nD.
HybridBlock ([prefix, params])	Metode ini mendukung penerusan dengan keduanya Symbol dan NDArray.
HybridLambda(fungsi [, awalan])	Dengan bantuan metode ini kita dapat membungkus operator atau ekspresi sebagai objek HybridBlock.
HybridSequential ([prefix, params])	Ini menumpuk HybridBlocks secara berurutan.
InstanceNorm ([sumbu, epsilon, tengah, skala,…])	Metode ini menerapkan normalisasi instance ke larik masukan nD.

Contoh Implementasi

Dalam contoh di bawah ini, kita akan menggunakan Block () yang memberikan kelas dasar untuk semua lapisan dan model jaringan saraf.

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

Anda akan melihat output berikut -

[[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;

Pada contoh di bawah ini, kita akan menggunakan HybridBlock () yang mendukung penerusan dengan Symbol dan 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

Outputnya disebutkan di bawah ini -

[[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 menyediakan banyak build-in recurrent neural network(RNN) dalam modul gluon.rnn. Itulah alasannya, disebut modul inti.

Metode dan parameternya

Berikut adalah beberapa metode penting dan parameternya yang dicakup oleh mxnet.gluon.nn modul inti:

Metode dan Parameternya	Definisi
BidirectionalCell (l_cell, r_cell [,…])	Ini digunakan untuk sel Bidirectional Recurrent Neural Network (RNN).
DropoutCell (rate [, sumbu, awalan, params])	Metode ini akan menerapkan putus sekolah pada masukan yang diberikan.
GRU (hidden_size [, num_layers, layout,…])	Ini menerapkan multi-layer gated recurrent unit (GRU) RNN ke urutan input yang diberikan.
GRUCell (hidden_size [,…])	Ini digunakan untuk sel jaringan Gated Rectified Unit (GRU).
HybridRecurrentCell ([prefix, params])	Metode ini mendukung hibridisasi.
HybridSequentialRNNCell ([prefix, params])	Dengan bantuan metode ini kita dapat menumpuk beberapa sel HybridRNN secara berurutan.
LSTM (hidden_size [, num_layers, layout,…]) 0	Ini menerapkan RNN memori jangka pendek (LSTM) multi-layer pada urutan input yang diberikan.
LSTMCell (hidden_size [,…])	Ini digunakan untuk sel jaringan Long-Short Term Memory (LSTM).
ModifierCell (base_cell)	Ini adalah kelas Basis untuk sel pengubah.
RNN (hidden_size [, num_layers, aktivasi,…])	Ini menerapkan multi-layer Elman RNN dengan tanh atau ReLU non-linearitas ke urutan masukan tertentu.
RNNCell (hidden_size [, aktivasi,…])	Ini digunakan untuk sel jaringan saraf berulang Elman RNN.
RecurrentCell ([prefix, params])	Ini mewakili kelas dasar abstrak untuk sel RNN.
SequentialRNNCell ([prefix, params])	Dengan bantuan metode ini kita dapat menumpuk beberapa sel RNN secara berurutan.
ZoneoutCell (base_cell [, zoneout_outputs,…])	Metode ini menerapkan Zoneout pada sel dasar.

Contoh Implementasi

Dalam contoh di bawah ini, kita akan menggunakan GRU () yang menerapkan multi-layer gated recurrent unit (GRU) RNN ke urutan input tertentu.

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

Ini menghasilkan keluaran berikut -

[[[ 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

Ini menghasilkan keluaran berikut -

[[[-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
………………………….

Dalam contoh di bawah ini kita akan menggunakan LSTM () yang menerapkan memori jangka pendek (LSTM) RNN ke urutan input tertentu.

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

Outputnya disebutkan di bawah ini -

[[[ 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

Saat Anda menjalankan kode, Anda akan melihat output berikut -

[
[[[ 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
……………………

Modul Pelatihan

Modul pelatihan di Gluon adalah sebagai berikut -

gluon.loss

Di mxnet.gluon.lossmodul, Gluon menyediakan fungsi kerugian yang telah ditentukan sebelumnya. Pada dasarnya, ini memiliki kerugian untuk melatih jaringan saraf. Itulah alasannya disebut modul pelatihan.

Metode dan parameternya

Berikut adalah beberapa metode penting dan parameternya yang dicakup oleh mxnet.gluon.loss modul pelatihan:

Metode dan Parameternya	Definisi
Rugi (berat, sumbu_batch, ** kwargs)	Ini bertindak sebagai kelas dasar untuk kerugian.
L2Loss ([berat, sumbu_batch])	Ini menghitung kesalahan kuadrat rata-rata (MSE) antara label dan prediction(pred).
L1Loss ([berat, sumbu_batch])	Ini menghitung kesalahan absolut rata-rata (MAE) antara label dan pred.
SigmoidBinaryCrossEntropyLoss ([…])	Metode ini digunakan untuk kerugian cross-entropy untuk klasifikasi biner.
SigmoidBCELoss	Metode ini digunakan untuk kerugian cross-entropy untuk klasifikasi biner.
SoftmaxCrossEntropyLoss ([sumbu,…])	Ini menghitung kerugian softmax cross-entropy (CEL).
SoftmaxCELoss	Ini juga menghitung kerugian entropi silang softmax.
KLDivLoss ([from_logits, axis, weight,…])	Ini digunakan untuk kerugian divergensi Kullback-Leibler.
CTCLoss ([tata letak, label_layout, bobot])	Ini digunakan untuk Connectionist Temporal Classification Loss (TCL).
HuberLoss ([rho, weight, batch_axis])	Ini menghitung kerugian L1 yang diperhalus. Kerugian L1 yang dihaluskan akan sama dengan kerugian L1 jika kesalahan absolut melebihi rho tetapi sama dengan kerugian L2 sebaliknya.
HingeLoss ([margin, weight, batch_axis])	Metode ini menghitung fungsi kerugian engsel yang sering digunakan dalam SVM:
SquaredHingeLoss ([margin, weight, batch_axis])	Metode ini menghitung fungsi kerugian margin lunak yang digunakan dalam SVM:
Kehilangan Logistik ([berat, sumbu_batch, format_label])	Metode ini menghitung kerugian logistik.
TripletLoss ([margin, weight, batch_axis])	Metode ini menghitung kerugian triplet dengan tiga tensor input dan margin positif.
PoissonNLLLoss ([bobot, from_logits,…])	Fungsi menghitung kemungkinan kerugian Log Negatif.
CosineEmbeddingLoss ([berat, sumbu_batch, margin])	Fungsi tersebut menghitung jarak kosinus antara vektor.
SDMLLoss ([smoothing_parameter, weight,…])	Metode ini menghitung Loss Batchwise Smoothed Deep Metric Learning (SDML) yang diberi dua tensor input dan bobot smoothing SDM Loss. Ia mempelajari kesamaan antara sampel berpasangan dengan menggunakan sampel yang tidak berpasangan di minibatch sebagai contoh negatif potensial.

Contoh

Seperti yang kita tahu mxnet.gluon.loss.lossakan menghitung MSE (Mean Squared Error) antara label dan prediksi (pred). Itu dilakukan dengan bantuan rumus berikut:

gluon.parameter

mxnet.gluon.parameter adalah wadah yang menyimpan parameter yaitu bobot dari Blok.

Metode dan parameternya

Berikut adalah beberapa metode penting dan parameternya yang dicakup oleh mxnet.gluon.parameter modul pelatihan -

Metode dan Parameternya	Definisi
cast (dtype)	Metode ini akan mentransmisikan data dan gradien Parameter ini ke tipe data baru.
data ([ctx])	Metode ini akan mengembalikan salinan parameter ini pada satu konteks.
grad ([ctx])	Metode ini akan mengembalikan buffer gradien untuk parameter ini pada satu konteks.
menginisialisasi ([init, ctx, default_init,…])	Metode ini akan menginisialisasi parameter dan array gradien.
list_ctx ()	Metode ini akan mengembalikan daftar konteks tempat parameter ini diinisialisasi.
list_data ()	Metode ini akan mengembalikan salinan parameter ini pada semua konteks. Itu akan dilakukan dalam urutan yang sama seperti penciptaan.
list_grad ()	Metode ini akan mengembalikan buffer gradien pada semua konteks. Ini akan dilakukan dengan urutan yang sama sepertivalues().
list_row_sparse_data (row_id)	Metode ini akan mengembalikan salinan parameter 'row_sparse' pada semua konteks. Ini akan dilakukan dalam urutan yang sama seperti pembuatan.
reset_ctx (ctx)	Metode ini akan menetapkan kembali Parameter ke konteks lain.
row_sparse_data (row_id)	Metode ini akan mengembalikan salinan parameter 'row_sparse' pada konteks yang sama seperti row_id's.
set_data (data)	Metode ini akan menetapkan nilai parameter ini pada semua konteks.
var ()	Metode ini akan mengembalikan simbol yang mewakili parameter ini.
zero_grad ()	Metode ini akan menyetel buffer gradien pada semua konteks ke 0.

Contoh Implementasi

Pada contoh di bawah ini, kita akan menginisialisasi parameter dan array gradien dengan menggunakan metode initialize () sebagai berikut -

weight = mx.gluon.Parameter('weight', shape=(2, 2))
weight.initialize(ctx=mx.cpu(0))
weight.data()

Output

Outputnya disebutkan di bawah ini -

[[-0.0256899 0.06511251]
[-0.00243821 -0.00123186]]
<NDArray 2x2 @cpu(0)>

Example

weight.grad()

Output

Outputnya diberikan di bawah ini -

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

Example

weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
weight.data(mx.gpu(0))

Output

Anda akan melihat output berikut -

[[-0.00873779 -0.02834515]
 [ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>

Example

weight.data(mx.gpu(1))

Output

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

[[-0.00873779 -0.02834515]
 [ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>

gluon.trainer

mxnet.gluon.trainer menerapkan Pengoptimal pada sekumpulan parameter. Ini harus digunakan bersama dengan autograd.

Metode dan parameternya

Berikut adalah beberapa metode penting dan parameternya yang dicakup oleh mxnet.gluon.trainer modul pelatihan -

Metode dan Parameternya	Definisi
allreduce_grads ()	Metode ini akan mengurangi gradien dari konteks yang berbeda untuk setiap parameter (bobot).
load_states (fname)	Sesuai namanya, metode ini akan memuat status pelatih.
save_states (fname)	Sesuai namanya, metode ini akan menghemat status pelatih.
set_learning_rate (lr)	Metode ini akan menyetel kecepatan pemelajaran baru pengoptimal.
langkah (ukuran_batch [, ignore_stale_grad])	Metode ini akan membuat satu langkah pembaruan parameter. Ini harus dipanggil setelahnyaautograd.backward() dan di luar record() cakupan.
perbarui (batch_size [, ignore_stale_grad])	Metode ini juga akan membuat satu langkah pembaruan parameter. Ini harus dipanggil setelahnyaautograd.backward() dan di luar record() scope dan setelah trainer.update ().

Modul Data

Modul data Gluon dijelaskan di bawah ini -

gluon.data

Gluon menyediakan sejumlah besar utilitas kumpulan data bawaan dalam modul gluon.data. Itulah alasannya disebut modul data.

Kelas dan parameternya

Berikut adalah beberapa metode penting dan parameternya yang dicakup oleh modul inti mxnet.gluon.data. Metode ini biasanya terkait dengan Kumpulan Data, Pengambilan Sampel, dan DataLoader.

Himpunan data

Metode dan Parameternya	Definisi
ArrayDataset (* args)	Metode ini merepresentasikan kumpulan data yang menggabungkan dua atau lebih dari dua objek mirip kumpulan data. Misalnya, Kumpulan Data, daftar, larik, dll.
BatchSampler (sampler, batch_size [, last_batch])	Metode ini membungkus yang lain Sampler. Setelah dibungkus, ia mengembalikan kumpulan sampel mini.
DataLoader (kumpulan data [, batch_size, shuffle,…])	Mirip dengan BatchSampler tetapi metode ini memuat data dari set data. Setelah dimuat, ia mengembalikan kumpulan data mini.
Ini mewakili kelas dataset abstrak.
FilterSampler (fn, dataset)	Metode ini merepresentasikan elemen sampel dari Set Data yang dikembalikan oleh fn (fungsi) True.
RandomSampler (panjang)	Metode ini merepresentasikan elemen sampel dari [0, panjang) secara acak tanpa penggantian.
RecordFileDataset (nama file)	Ini mewakili kumpulan data yang membungkus file RecordIO. Ekstensi dari file tersebut adalah.rec.
Sampler	Ini adalah kelas dasar untuk sampler.
SequentialSampler (panjang [, mulai])	Ini mewakili elemen sampel dari set [start, start + length) secara berurutan.
Ini mewakili elemen sampel dari set [start, start + length) secara berurutan.	Ini mewakili pembungkus Set Data sederhana terutama untuk daftar dan array.

Contoh Implementasi

Pada contoh di bawah ini, kami akan menggunakan gluon.data.BatchSampler()API, yang membungkus sampler lain. Ini mengembalikan batch mini sampel.

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

Outputnya disebutkan di bawah ini -

[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14]]

gluon.data.vision.datasets

Gluon menyediakan sejumlah besar fungsi kumpulan data vision yang telah ditentukan sebelumnya di gluon.data.vision.datasets modul.

Kelas dan parameternya

MXNet memberi kami kumpulan data yang berguna dan penting, yang kelas dan parameternya diberikan di bawah ini -

Kelas dan Parameternya	Definisi
MNIST ([root, train, transform])	Ini adalah kumpulan data yang berguna memberi kami angka tulisan tangan. Url untuk dataset MNIST adalah http://yann.lecun.com/exdb/mnist
FashionMNIST ([root, train, transform])	Dataset ini terdiri dari gambar artikel Zalando yang terdiri dari produk fashion. Ini adalah pengganti drop-in dari set data MNIST asli. Anda bisa mendapatkan kumpulan data ini dari https://github.com/zalandoresearch/fashion-mnist
CIFAR10 ([root, train, transform])	Ini adalah kumpulan data klasifikasi gambar dari https://www.cs.toronto.edu/~kriz/cifar.html. Dalam dataset ini setiap sampel merupakan citra dengan bentuk (32, 32, 3).
CIFAR100 ([root, fine_label, train, transform])	Ini adalah kumpulan data klasifikasi gambar CIFAR100 dari https://www.cs.toronto.edu/~kriz/cifar.html. Itu juga memiliki setiap sampel adalah gambar dengan bentuk (32, 32, 3).
ImageRecordDataset (nama file [, bendera, transformasi])	Dataset ini membungkus file RecordIO yang berisi gambar. Dalam hal ini, setiap sampel adalah gambar dengan labelnya yang sesuai.
ImageFolderDataset (root [, flag, transform])	Ini adalah dataset untuk memuat file gambar yang disimpan dalam struktur folder.
ImageListDataset ([root, imglist, flag])	Ini adalah kumpulan data untuk memuat file gambar yang ditentukan oleh daftar entri.

Contoh

Dalam contoh di bawah ini, kami akan menunjukkan penggunaan ImageListDataset (), yang digunakan untuk memuat file gambar yang ditentukan oleh daftar entri -

# 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]]

Modul Utilitas

Modul utilitas di Gluon adalah sebagai berikut -

gluon.utils

Gluon menyediakan sejumlah besar pengoptimal utilitas paralelisasi bawaan dalam modul gluon.utils. Ini menyediakan berbagai utilitas untuk pelatihan. Itulah alasannya disebut modul utilitas.

Fungsi dan parameternya

Berikut adalah fungsi dan parameternya yang terdiri dari modul utilitas bernama gluon.utils −

Fungsi dan Parameternya	Definisi
split_data (data, num_slice [, batch_axis,…])	Fungsi ini biasanya digunakan untuk paralelisme data dan setiap irisan dikirim ke satu perangkat yaitu GPU. Ini membagi NDArray menjadinum_slice irisan bersama batch_axis.
split_and_load (data, ctx_list [, batch_axis,…])	Fungsi ini membagi NDArray menjadi len(ctx_list) irisan bersama batch_axis. Satu-satunya perbedaan dari fungsi split_data () di atas adalah, ia juga memuat setiap potongan ke dalam satu konteks ctx_list.
clip_global_norm (array, max_norm [,…])	Tugas dari fungsi ini adalah untuk mengubah skala NDArays sedemikian rupa sehingga jumlah 2-norma mereka lebih kecil dari max_norm.
check_sha1 (nama file, sha1_hash)	Fungsi ini akan memeriksa apakah hash sha1 dari konten file cocok dengan hash yang diharapkan atau tidak.
unduh (url [, jalur, timpa, sha1_hash,…])	Seperti yang ditentukan namanya, fungsi ini akan mengunduh URL tertentu.
ganti_file (src, dst)	Fungsi ini akan mengimplementasikan atomic os.replace. itu akan dilakukan dengan Linux dan OSX.

Bab ini membahas tentang autograd dan API penginisialisasi di MXNet.

mxnet.autograd

Ini adalah API autograd MXNet untuk NDArray. Ini memiliki kelas berikut -

Kelas: Fungsi ()

Ini digunakan untuk diferensiasi khusus dalam autograd. Dapat ditulis sebagaimxnet.autograd.Function. Jika, karena alasan apa pun, pengguna tidak ingin menggunakan gradien yang dihitung oleh aturan rantai default, maka dia dapat menggunakan kelas Fungsi mxnet.autograd untuk menyesuaikan diferensiasi untuk komputasi. Ini memiliki dua metode yaitu Forward () dan Backward ().

Marilah kita memahami pekerjaan kelas ini dengan bantuan poin-poin berikut -

Pertama, kita perlu mendefinisikan perhitungan kita dalam metode maju.
Kemudian, kami perlu memberikan diferensiasi yang disesuaikan dalam metode mundur.
Sekarang selama komputasi gradien, alih-alih fungsi mundur yang ditentukan pengguna, mxnet.autograd akan menggunakan fungsi mundur yang ditentukan oleh pengguna. Kita juga dapat melakukan cast ke numpy array dan back untuk beberapa operasi maju maupun mundur.

Example

Sebelum menggunakan kelas mxnet.autograd.function, mari kita definisikan fungsi sigmoid stabil dengan metode mundur dan maju sebagai berikut -

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)

Sekarang, kelas fungsi dapat digunakan sebagai berikut -

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

Saat Anda menjalankan kode, Anda akan melihat output berikut -

array([0.21458015, 0.21291625, 0.23330082, 0.2361367 , 0.23086983,
0.24060014, 0.20326573, 0.21093895, 0.24968489, 0.24301809],
dtype=float32)

Metode dan parameternya

Berikut adalah metode dan parameter kelas mxnet.autogard.function -

Metode dan Parameternya	Definisi
maju (kepala [, head_grads, mempertahankan_graf,…])	Metode ini digunakan untuk komputasi maju.
mundur (kepala [, head_grads, mempertahankan_graf,…])	Metode ini digunakan untuk komputasi mundur. Ini menghitung gradien kepala sehubungan dengan variabel yang ditandai sebelumnya. Metode ini mengambil masukan sebanyak keluaran maju. Ini juga mengembalikan sebanyak NDArray sebagai input ke depan.
get_symbol (x)	Metode ini digunakan untuk mengambil riwayat komputasi yang direkam sebagai Symbol.
grad (kepala, variabel [, head_grads,…])	Metode ini menghitung gradien kepala sehubungan dengan variabel. Setelah dihitung, alih-alih menyimpan ke variable.grad, gradien akan dikembalikan sebagai NDArrays baru.
is_recording ()	Dengan bantuan metode ini kita bisa mendapatkan status merekam dan bukan merekam.
is_training ()	Dengan bantuan metode ini kita bisa mendapatkan status pelatihan dan prediksi.
mark_variables (variabel, gradien [, grad_reqs])	Metode ini akan menandai NDArrays sebagai variabel untuk menghitung gradien untuk autograd. Metode ini sama dengan fungsi .attach_grad () dalam variabel tetapi satu-satunya perbedaan adalah bahwa dengan panggilan ini kita dapat menyetel gradien ke nilai apa pun.
jeda ([train_mode])	Metode ini mengembalikan konteks cakupan untuk digunakan dalam pernyataan 'dengan' untuk kode yang tidak memerlukan penghitungan gradien.
predict_mode ()	Metode ini mengembalikan konteks cakupan untuk digunakan dalam pernyataan 'with' di mana perilaku forward pass diatur ke mode inferensi dan tanpa mengubah status perekaman.
rekor ([train_mode])	Ini akan mengembalikan autograd merekam konteks lingkup untuk digunakan dalam pernyataan 'dengan' dan menangkap kode yang memerlukan penghitungan gradien.
set_recording (is_recording)	Mirip dengan is_recoring (), dengan bantuan metode ini kita bisa mendapatkan status merekam dan bukan merekam.
set_training (is_training)	Mirip dengan is_traininig (), dengan bantuan metode ini kita dapat menyetel status ke pelatihan atau prediksi.
train_mode ()	Metode ini akan mengembalikan konteks cakupan untuk digunakan dalam pernyataan 'with' di mana perilaku forward pass diatur ke mode pelatihan dan tanpa mengubah status perekaman.

Contoh Implementasi

Pada contoh di bawah ini, kita akan menggunakan metode mxnet.autograd.grad () untuk menghitung gradien head sehubungan dengan variabel -

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

Outputnya disebutkan di bawah ini -

[
[3.7182817 3.7182817]
<NDArray 2 @cpu(0)>]

Kita bisa menggunakan metode mxnet.autograd.predict_mode () untuk mengembalikan ruang lingkup yang akan digunakan dalam pernyataan 'with' -

with mx.autograd.record():
y = model(x)
with mx.autograd.predict_mode():
y = sampling(y)
backward([y])

mxnet.intializer

Ini adalah MXNet 'API untuk penginisialisasi timbangan. Ini memiliki kelas-kelas berikut -

Kelas dan parameternya

Berikut adalah metode dan parameternya mxnet.autogard.function kelas:

Kelas dan Parameternya	Definisi
Bilinear ()	Dengan bantuan kelas ini kita dapat menginisialisasi bobot untuk lapisan pengambilan sampel.
Nilai konstan)	Kelas ini menginisialisasi bobot ke nilai tertentu. Nilainya dapat berupa skalar serta NDArray yang cocok dengan bentuk parameter yang akan ditetapkan.
FusedRNN (init, num_hidden, num_layers, mode)	Sesuai namanya, kelas ini menginisialisasi parameter untuk lapisan Recurrent Neural Network (RNN) gabungan.
InitDesc	Ini bertindak sebagai pendeskripsi untuk pola inisialisasi.
Penginisialisasi (** kwargs)	Ini adalah kelas dasar penginisialisasi.
LSTMBias ([forget_bias])	Kelas ini menginisialisasi semua bias LSTMCell ke 0,0 tetapi kecuali untuk gerbang lupa yang biasnya disetel ke nilai khusus.
Muat (param [, default_init, verbose])	Kelas ini menginisialisasi variabel dengan memuat data dari file atau kamus.
MSRAPrelu ([factor_type, slope])	Sesuai namanya, kelas ini menginisialisasi pemberat menurut kertas MSRA.
Campuran (pola, penginisialisasi)	Ini menginisialisasi parameter menggunakan beberapa penginisialisasi.
Normal ([sigma])	Kelas normal () menginisialisasi bobot dengan nilai acak yang diambil sampelnya dari distribusi normal dengan mean nol dan deviasi standar (SD) sigma.
Satu()	Ini menginisialisasi bobot parameter menjadi satu.
Ortogonal ([skala, rand_type])	Sesuai namanya, kelas ini menginisialisasi bobot sebagai matriks ortogonal.
Seragam ([skala])	Ini menginisialisasi bobot dengan nilai acak yang diambil sampelnya secara seragam dari rentang tertentu.
Xavier ([rnd_type, factor_type, magnitude])	Ini sebenarnya mengembalikan penginisialisasi yang melakukan inisialisasi "Xavier" untuk bobot.
Nol()	Ini menginisialisasi bobot parameter ke nol.

Contoh Implementasi

Pada contoh di bawah ini, kita akan menggunakan kelas mxnet.init.Normal () membuat penginisialisasi dan mengambil parameternya -

init = mx.init.Normal(0.8)
init.dumps()

Output

Outputnya diberikan di bawah ini -

'["normal", {"sigma": 0.8}]'

Example

init = mx.init.Xavier(factor_type="in", magnitude=2.45)
init.dumps()

Output

Outputnya ditunjukkan di bawah ini -

'["xavier", {"rnd_type": "uniform", "factor_type": "in", "magnitude": 2.45}]'

Pada contoh di bawah ini, kita akan menggunakan kelas mxnet.initializer.Mixed () untuk menginisialisasi parameter menggunakan beberapa penginisialisasi -

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

Outputnya ditunjukkan di bawah ini -

fullyconnected1_weight
[[ 0.0097627 0.01856892 0.04303787]]
fullyconnected1_bias
[ 0.]

Pada bab ini, kita akan mempelajari tentang antarmuka di MXNet yang disebut sebagai Simbol.

Mxnet.ndarray

Symbol API Apache MXNet adalah antarmuka untuk pemrograman simbolik. Symbol API menampilkan penggunaan berikut ini -

Grafik komputasi
Mengurangi penggunaan memori
Optimalisasi fungsi pra-penggunaan

Contoh yang diberikan di bawah ini menunjukkan bagaimana seseorang dapat membuat ekspresi sederhana dengan menggunakan API Simbol MXNet -

Sebuah NDArray dengan menggunakan 1-D dan 2-D 'array' dari daftar Python biasa -

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

Anda akan melihat output berikut -

<Symbol _plus0>

Example

(x, y, z)

Output

Outputnya diberikan di bawah ini -

(<Symbol x>, <Symbol y>, <Symbol _plus0>)

Sekarang mari kita bahas secara detail tentang kelas, fungsi, dan parameter dari ndarray API MXNet.

Kelas

Tabel berikut terdiri dari kelas Symbol API MXNet -

Kelas	Definisi
Simbol (pegangan)	Kelas yaitu simbol adalah grafik simbolis dari Apache MXNet.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet. Symbol API -

Fungsi dan Parameternya	Definisi
Aktivasi ([data, act_type, out, name])	Ini menerapkan elemen fungsi aktivasi ke input. Ini mendukungrelu, sigmoid, tanh, softrelu, softsign fungsi aktivasi.
BatchNorm ([data, gamma, beta, moving_mean,…])	Ini digunakan untuk normalisasi batch. Fungsi ini menormalkan kumpulan data dengan mean dan varians. Ini menerapkan skalagamma dan offset beta.
BilinearSampler ([data, grid, cudnn_off,…])	Fungsi ini menerapkan sampling bilinear untuk memasukkan peta fitur. Sebenarnya itu adalah kunci dari “Spatial Transformer Networks”. Jika Anda familiar dengan fungsi remap di OpenCV, penggunaan fungsi ini sangat mirip dengan itu. Satu-satunya perbedaan adalah bahwa ia memiliki umpan mundur.
BlockGrad ([data, keluar, nama])	Seperti yang ditentukan namanya, fungsi ini menghentikan komputasi gradien. Ini pada dasarnya menghentikan akumulasi gradien input agar tidak mengalir melalui operator ini ke arah belakang.
cast ([data, dtype, out, name])	Fungsi ini akan mentransmisikan semua elemen masukan ke tipe baru.
Fungsi ini akan mentransmisikan semua elemen masukan ke tipe baru.	Fungsi ini, seperti yang ditentukan namanya, mengembalikan simbol baru dari bentuk dan tipe tertentu, diisi dengan nol.
satu (bentuk [, tipe d])	Fungsi ini, seperti yang ditentukan namanya mengembalikan simbol baru dari bentuk dan tipe tertentu, diisi dengan satu.
full (shape, val [, dtype])	Fungsi ini, seperti nama yang ditentukan mengembalikan larik baru dengan bentuk dan tipe tertentu, diisi dengan nilai yang diberikan val.
arange (mulai [, berhenti, langkah, ulangi,…])	Ini akan mengembalikan nilai yang berjarak sama dalam interval tertentu. Nilai-nilai dihasilkan dalam interval setengah terbuka [start, stop) yang berarti bahwa interval termasukstart tapi tidak termasuk stop.
linspace (mulai, berhenti, num [, titik akhir, nama,…])	Ini akan mengembalikan angka yang berjarak sama dalam interval tertentu. Mirip dengan fungsi mengatur (), nilai-nilai dihasilkan dalam interval setengah terbuka [mulai, berhenti) yang berarti bahwa intervalnya termasukstart tapi tidak termasuk stop.
histogram (a [, bins, range])	Sesuai namanya, fungsi ini akan menghitung histogram dari data masukan.
daya (basis, exp)	Sesuai namanya, fungsi ini akan mengembalikan hasil dari segi elemen base elemen yang dinaikkan menjadi kekuatan dari expelemen. Kedua input yaitu basis dan exp, dapat berupa Simbol atau skalar. Di sini perhatikan bahwa penyiaran tidak diperbolehkan. Kamu dapat memakaibroadcast_pow jika Anda ingin menggunakan fitur siaran.
SoftmaxActivation ([data, mode, nama, attr, out])	Fungsi ini menerapkan aktivasi softmax ke input. Ini ditujukan untuk lapisan internal. Ini sebenarnya sudah usang, kita bisa gunakansoftmax() sebagai gantinya.

Contoh Implementasi

Pada contoh di bawah ini kita akan menggunakan fungsi tersebut power() yang akan mengembalikan hasil elemen-bijaksana dari elemen dasar yang dinaikkan ke pangkat dari elemen exp:

import mxnet as mx
mx.sym.power(3, 5)

Output

Anda akan melihat output berikut -

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

Ini menghasilkan keluaran berikut -

array([1., 8.], dtype=float32)

Example

z = mx.sym.power(4, y)
z.eval(y=mx.nd.array([2,3]))[0].asnumpy()

Output

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

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

Outputnya disebutkan di bawah ini -

array([ 16., 125.], dtype=float32)

Dalam contoh yang diberikan di bawah ini, kami akan menggunakan fungsi tersebut SoftmaxActivation() (or softmax()) yang akan diterapkan ke masukan dan ditujukan untuk lapisan internal.

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

Anda akan melihat output berikut -

[[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

Contrib NDArray API didefinisikan dalam paket symbol.contrib. Ini biasanya menyediakan banyak API eksperimental yang berguna untuk fitur baru. API ini berfungsi sebagai tempat komunitas di mana mereka dapat mencoba fitur-fitur baru. Kontributor fitur juga akan mendapatkan umpan balik.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.symbol.contrib API -

Fungsi dan Parameternya	Definisi
rand_zipfian (true_classes, num_sampled,…)	Fungsi ini mengambil sampel acak dari sekitar distribusi Zipfian. Distribusi dasar dari fungsi ini adalah distribusi Zipfian. Fungsi ini secara acak mengambil sampel num_sampled kandidat dan elemen sampled_candidates diambil dari distribusi dasar yang diberikan di atas.
foreach (body, data, init_states)	Sesuai namanya, fungsi ini menjalankan loop dengan komputasi yang ditentukan pengguna melalui NDArray pada dimensi 0. Fungsi ini mensimulasikan loop for dan body memiliki komputasi untuk iterasi loop for.
while_loop (cond, func, loop_vars [,…])	Sesuai namanya, fungsi ini menjalankan while loop dengan komputasi dan kondisi loop yang ditentukan pengguna. Fungsi ini mensimulasikan loop sementara yang secara literal melakukan komputasi yang disesuaikan jika kondisinya terpenuhi.
cond (pred, then_func, else_func)	Sesuai namanya, fungsi ini menjalankan if-then-else menggunakan kondisi dan komputasi yang ditentukan pengguna. Fungsi ini mensimulasikan cabang if-like yang memilih untuk melakukan salah satu dari dua penghitungan yang disesuaikan sesuai dengan kondisi yang ditentukan.
getnnz ([data, sumbu, keluar, nama])	Fungsi ini memberi kita jumlah nilai yang disimpan untuk tensor renggang. Ini juga mencakup nol eksplisit. Ini hanya mendukung matriks CSR pada CPU.
mempersyaratkan ([data, rentang_min, rentang_aks,…])	Fungsi ini menghitung ulang data yang diberikan yang dikuantisasi dalam int32 dan ambang batas yang sesuai, menjadi int8 menggunakan ambang batas minimum dan maksimum baik yang dihitung pada saat runtime atau dari kalibrasi.
index_copy ([sensor_ lama, index_vector,…])	Fungsi ini menyalin elemen a 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 ([kueri,…])	Operator ini menghitung perkalian matriks antara proyeksi kueri dan kunci dalam penggunaan perhatian multi-kepala sebagai encoder-decoder. Syaratnya adalah bahwa input harus berupa tensor proyeksi kueri yang mengikuti tata letak: (seq_length, batch_size, num_heads *, head_dim).

Contoh Implementasi

Dalam contoh di bawah ini kita akan menggunakan fungsi rand_zipfian untuk menggambar sampel acak dari sekitar distribusi 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

Anda akan melihat output berikut -

array([4, 0, 2, 1, 5], dtype=int64)

Example

exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()

Output

Outputnya disebutkan di bawah ini -

array([0.57336551])

Example

exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()

Output

Anda akan melihat output berikut -

array([1.78103594, 0.46847373, 1.04183923, 0.57336551, 1.04183923])

Pada contoh di bawah ini kita akan menggunakan fungsi tersebut while_loop untuk menjalankan loop sementara untuk komputasi yang ditentukan pengguna dan kondisi loop -

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

Outputnya diberikan di bawah ini:

[<Symbol _while_loop0>]

Example

Print(States)

Output

Ini menghasilkan keluaran berikut -

[<Symbol _while_loop0>, <Symbol _while_loop0>]

Pada contoh di bawah ini kita akan menggunakan fungsi tersebut index_copy yang menyalin elemen new_tensor ke 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

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

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

symbol.image

API Simbol Gambar didefinisikan dalam paket symbol.image. Seperti namanya, biasanya digunakan untuk gambar dan fiturnya.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.symbol.image API -

Fungsi dan Parameternya	Definisi
Adjust_lighting ([data, alpha, out, name])	Sesuai namanya, fungsi ini mengatur level pencahayaan dari input. Ini mengikuti gaya AlexNet.
pangkas ([data, x, y, lebar, tinggi, keluar, nama])	Dengan bantuan fungsi ini kita dapat memotong gambar NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan oleh pengguna.
menormalkan ([data, mean, std, out, name])	Ini akan menormalkan tensor bentuk (C x H x W) atau (N x C x H x W) dengan mean dan standard deviation(SD).
random_crop ([data, xrange, yrange, lebar,…])	Mirip dengan crop (), ini secara acak memotong gambar NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan oleh pengguna. Ini akan meningkatkan hasilnya jikasrc lebih kecil dari size.
random_lighting([data, alpha_std, out, name])	Sesuai namanya, fungsi ini menambahkan noise PCA secara acak. Ini juga mengikuti gaya AlexNet.
random_resized_crop ([data, xrange, yrange,…])	Ini juga memotong gambar secara acak NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan. Ini akan meningkatkan hasil jika src lebih kecil dari ukurannya. Ini akan mengacak area dan aspek rasio juga.
ubah ukuran ([data, size, keep_ratio, interp,…])	Sesuai dengan namanya, fungsi ini akan mengubah ukuran gambar NDArray bentuk (H x W x C) atau (N x H x W x C) ke ukuran yang diberikan oleh pengguna.
to_tensor ([data, out, name])	Ini mengubah gambar NDArray bentuk (H x W x C) atau (N x H x W x C) dengan nilai dalam rentang [0, 255] menjadi tensor NDArray bentuk (C x H x W) atau ( N x C x H x W) dengan nilai dalam rentang [0, 1].

Contoh Implementasi

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

Outputnya dinyatakan di bawah ini -

<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

Outputnya disebutkan di bawah ini:

<Symbol to_tensor5>

Pada contoh di bawah ini, kita akan menggunakan fungsi normalize () untuk menormalkan tensor bentuk (C x H x W) atau (N x C x H x W) dengan mean dan 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

Diberikan di bawah ini adalah output dari kode -

<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

Outputnya ditunjukkan di bawah ini -

<Symbol normalize1>

symbol.random

API Simbol Acak didefinisikan dalam paket symbol.random. Seperti namanya, ini adalah API Simbol generator distribusi acak dari MXNet.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting dan parameternya yang dicakup oleh mxnet.symbol.random API -

Fungsi dan Parameternya	Definisi
seragam ([rendah, tinggi, bentuk, tipe, ctx, keluar])	Ini menghasilkan sampel acak dari distribusi seragam.
normal ([loc, scale, shape, dtype, ctx, out])	Ini menghasilkan sampel acak dari distribusi normal (Gaussian).
randn (* bentuk, ** kwargs)	Ini menghasilkan sampel acak dari distribusi normal (Gaussian).
poisson ([lam, shape, dtype, ctx, out])	Ini menghasilkan sampel acak dari distribusi Poisson.
eksponensial ([skala, bentuk, tipe d, ctx, keluar])	Ini menghasilkan sampel dari distribusi eksponensial.
gamma ([alpha, beta, shape, dtype, ctx, out])	Ini menghasilkan sampel acak dari distribusi gamma.
multinomial (data [, shape, get_prob, out, dtype])	Ini menghasilkan pengambilan sampel bersamaan dari beberapa distribusi multinomial.
binomial_ negatif ([k, p, bentuk, tipe d, ctx, keluar])	Ini menghasilkan sampel acak dari distribusi binomial negatif.
generalized_negative_binomial ([mu, alpha,…])	Ini menghasilkan sampel acak dari distribusi binomial negatif umum.
acak (data, ** kwargs)	Ini mengocok elemen secara acak.
randint (rendah, tinggi [, bentuk, tipe, ctx, keluar])	Ini menghasilkan sampel acak dari distribusi seragam diskrit.
exponential_like ([data, lam, out, name])	Ini menghasilkan sampel acak dari distribusi eksponensial sesuai dengan bentuk larik input.
gamma_like ([data, alpha, beta, out, name])	Ini menghasilkan sampel acak dari distribusi gamma sesuai dengan bentuk larik masukan.
generalized_negative_binomial_like ([data,…])	Ini menghasilkan sampel acak dari distribusi binomial negatif umum sesuai dengan bentuk larik masukan.
negative_binomial_like ([data, k, p, out, name])	Ini menghasilkan sampel acak dari distribusi binomial negatif sesuai dengan bentuk larik masukan.
normal_like ([data, loc, scale, out, name])	Ini menghasilkan sampel acak dari distribusi normal (Gaussian) sesuai dengan bentuk larik masukan.
poisson_like ([data, lam, out, name])	Ini menghasilkan sampel acak dari distribusi Poisson sesuai dengan bentuk larik masukan.
uniform_like ([data, low, high, out, name])	Ini menghasilkan sampel acak dari distribusi seragam sesuai dengan bentuk larik masukan.

Contoh Implementasi

Pada contoh di bawah ini, kita akan mengacak elemen secara acak menggunakan fungsi shuffle (). Ini akan mengocok array di sepanjang sumbu pertama.

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

Anda akan melihat output berikut:

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

Example

y.eval(x=data)

Output

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

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

Dalam contoh di bawah ini, kita akan menarik sampel acak dari distribusi binomial negatif umum. Untuk ini akan menggunakan fungsi tersebutgeneralized_negative_binomial().

mx.sym.random.generalized_negative_binomial(10, 0.1)

Output

Outputnya diberikan di bawah ini -

<Symbol _random_generalized_negative_binomial0>

symbol.sparse

API Simbol Jarang didefinisikan dalam paket mxnet.symbol.sparse. Seperti namanya, ini memberikan grafik jaringan saraf jarang dan diferensiasi otomatis pada CPU.

Fungsi dan parameternya

Berikut adalah beberapa fungsi penting (termasuk rutinitas pembuatan Simbol, rutinitas Manipulasi Simbol, Fungsi Matematika, Fungsi Trigonometri, Fungsi Hyberbolic, Fungsi Kurangi, Pembulatan, Kekuatan, Jaringan Saraf Tiruan) dan parameternya dicakup oleh mxnet.symbol.sparse API -

Fungsi dan Parameternya	Definisi
ElementWiseSum (* args, ** kwargs)	Fungsi ini akan menambahkan semua elemen argumen masukan secara bijaksana. Misalnya, _ (1,2,… = 1 + 2 + ⋯ +). Di sini, kita dapat melihat bahwa add_n berpotensi lebih efisien daripada memanggil add sebanyak n kali.
Menyematkan ([data, weight, input_dim,…])	Ini akan memetakan indeks integer ke representasi vektor yaitu embeddings. Ini sebenarnya memetakan kata-kata ke vektor bernilai nyata dalam ruang dimensi tinggi yang disebut embeddings kata.
LinearRegressionOutput ([data, label,…])	Ini menghitung dan mengoptimalkan kerugian kuadrat selama propagasi mundur yang memberikan hanya data keluaran selama propagasi maju.
LogisticRegressionOutput ([data, label,…])	Menerapkan fungsi logistik yang juga disebut fungsi sigmoid ke input. Fungsi tersebut dihitung sebagai 1/1 + exp (−x).
MAERegressionOutput ([data, label,…])	Operator ini menghitung kesalahan mutlak dari input. MAE sebenarnya adalah metrik risiko yang sesuai dengan nilai yang diharapkan dari kesalahan absolut.
abs ([data, nama, attr, out])	Seperti namanya, fungsi ini akan mengembalikan nilai absolut dari segi elemen dari input.
adagrad_update ([berat badan, grad, sejarah, lr,…])	Ini adalah fungsi pembaruan untuk AdaGrad optimizer.
adam_update ([weight, grad, mean, var, lr,…])	Ini adalah fungsi pembaruan untuk Adam optimizer.
add_n (* args, ** kwargs)	Seperti namanya, ia akan menambahkan semua argumen masukan dari segi elemen.
arccos ([data, name, attr, out])	Fungsi ini akan mengembalikan kosinus inversi berdasarkan elemen dari larik masukan.
titik ([lhs, rhs, transpose_a, transpose_b,…])	Seperti namanya, ini akan memberikan hasil kali dari dua larik. Ini akan tergantung pada dimensi larik masukan: 1-D: hasil kali dalam vektor 2-D: perkalian matriks ND: Hasil kali penjumlahan dari sumbu terakhir masukan pertama dan sumbu pertama masukan kedua.
elemwise_add ([lhs, rhs, name, attr, out])	Seperti namanya itu akan add elemen argumen yang bijaksana.
elemwise_div ([lhs, rhs, name, attr, out])	Seperti namanya itu akan divide elemen argumen yang bijaksana.
elemwise_mul ([lhs, rhs, name, attr, out])	Seperti namanya itu akan Multiply elemen argumen yang bijaksana.
elemwise_sub ([lhs, rhs, name, attr, out])	Seperti namanya itu akan mengurangi elemen argumen yang bijaksana.
exp ([data, nama, attr, out])	Fungsi ini akan mengembalikan nilai eksponensial bijak elemen dari input yang diberikan.
sgd_update ([berat, grad, lr, wd,…])	Ini bertindak sebagai fungsi pembaruan untuk pengoptimal Stochastic Gradient Descent.
sigmoid ([data, nama, attr, out])	Seperti namanya itu akan menghitung sigmoid dari x elemen bijaksana.
tanda ([data, nama, attr, out])	Ini akan mengembalikan tanda bijak elemen dari masukan yang diberikan.
sin ([data, nama, attr, out])	Seperti namanya, fungsi ini akan menghitung sinus bijak elemen dari larik masukan yang diberikan.

Contoh Implementasi

Pada contoh di bawah ini, kita akan mengacak elemen secara acak menggunakan ElementWiseSum()fungsi. Ini akan memetakan indeks integer ke representasi vektor yaitu embeddings kata.

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.]]]

API modul Apache MXNet seperti model FeedForward dan lebih mudah untuk dibuat mirip dengan modul Torch. Ini terdiri dari kelas-kelas berikut -

BaseModule ([logger])

Ini mewakili kelas dasar dari sebuah modul. Sebuah modul dapat dianggap sebagai komponen komputasi atau mesin komputasi. Tugas modul adalah menjalankan operan maju dan mundur. Ini juga memperbarui parameter dalam model.

Metode

Tabel berikut menunjukkan metode yang terdiri BaseModule class-

Metode ini akan mendapatkan status dari semua perangkat

Metode	Definisi
mundur ([out_grads])	Sesuai namanya, metode ini mengimplementasikan file backward komputasi.
mengikat (bentuk_data [, bentuk_label,…])	Ini mengikat simbol untuk membangun pelaksana dan diperlukan sebelum seseorang dapat melakukan komputasi dengan modul.
fit (train_data [, eval_data, eval_metric,…])	Metode ini melatih parameter modul.
maju (data_batch [, is_train])	Sesuai namanya, metode ini mengimplementasikan komputasi Teruskan. Metode ini mendukung kumpulan data dengan berbagai bentuk seperti ukuran kumpulan yang berbeda atau ukuran gambar yang berbeda.
maju_balik (data_batch)	Ini adalah fungsi yang nyaman, seperti namanya, yang memanggil maju dan mundur.
get_input_grads ([merge_multi_context])	Metode ini akan mendapatkan gradien ke input yang dihitung dalam komputasi mundur sebelumnya.
get_outputs ([merge_multi_context])	Sesuai dengan namanya, metode ini akan mendapatkan keluaran dari komputasi maju sebelumnya.
get_params ()	Ia mendapatkan parameter terutama yang berpotensi merupakan salinan dari parameter aktual yang digunakan untuk melakukan komputasi pada perangkat.
get_states ([merge_multi_context])
init_optimizer ([kvstore, pengoptimal,…])	Metode ini menginstal dan menginisialisasi pengoptimal. Ini juga menginisialisasikvstore untuk mendistribusikan pelatihan.
init_params ([penginisialisasi, arg_params,…])	Sesuai namanya, metode ini akan menginisialisasi parameter dan status tambahan.
install_monitor (mon)	Metode ini akan menginstal monitor pada semua pelaksana.
iter_predict (eval_data [, num_batch, setel ulang,…])	Metode ini akan mengulangi prediksi.
load_params (fname)	Ini akan, seperti yang ditentukan namanya, memuat parameter model dari file.
prediksi (eval_data [, num_batch,…])	Ini akan menjalankan prediksi dan mengumpulkan output juga.
persiapkan (data_batch [, sparse_row_id_fn])	Operator menyiapkan modul untuk memproses kumpulan data tertentu.
save_params (fname)	Seperti yang ditentukan namanya, fungsi ini akan menyimpan parameter model ke file.
skor (data_valuasi, nilai_metrik [, jumlah_batch,…])	Prediksi akan dijalankan eval_data dan juga mengevaluasi kinerja sesuai dengan yang diberikan eval_metric.
set_params (arg_params, aux_params [,…])	Metode ini akan menetapkan parameter dan nilai status aux.
set_states ([status, nilai])	Metode ini, sesuai namanya, menetapkan nilai untuk status.
memperbarui()	Metode ini memperbarui parameter yang diberikan sesuai dengan pengoptimal yang diinstal. Ini juga memperbarui gradien yang dihitung dalam kelompok maju-mundur sebelumnya.
update_metric (eval_metric, label [, pre_sliced])	Metode ini, sesuai namanya, mengevaluasi dan mengakumulasi metrik evaluasi pada keluaran dari komputasi maju terakhir.
mundur ([out_grads])	Sesuai namanya, metode ini mengimplementasikan file backward komputasi.
mengikat (bentuk_data [, bentuk_label,…])	Ini menyiapkan bucket dan mengikat eksekutor untuk kunci bucket default. Metode ini mewakili pengikatan untuk aBucketingModule.
maju (data_batch [, is_train])	Sesuai namanya, metode ini mengimplementasikan komputasi Teruskan. Metode ini mendukung kumpulan data dengan berbagai bentuk seperti ukuran kumpulan yang berbeda atau ukuran gambar yang berbeda.
get_input_grads ([merge_multi_context])	Metode ini akan mendapatkan gradien ke input yang dihitung dalam komputasi mundur sebelumnya.
get_outputs ([merge_multi_context])	Sesuai dengan namanya, metode ini akan mendapatkan keluaran dari komputasi maju sebelumnya.
get_params ()	Ia mendapatkan parameter saat ini terutama yang berpotensi merupakan salinan dari parameter aktual yang digunakan untuk melakukan komputasi pada perangkat.
get_states ([merge_multi_context])	Metode ini akan mendapatkan status dari semua perangkat.
init_optimizer ([kvstore, pengoptimal,…])	Metode ini menginstal dan menginisialisasi pengoptimal. Ini juga menginisialisasikvstore untuk mendistribusikan pelatihan.
init_params ([penginisialisasi, arg_params,…])	Sesuai namanya, metode ini akan menginisialisasi parameter dan status tambahan.
install_monitor (mon)	Metode ini akan menginstal monitor pada semua pelaksana.
memuat (awalan, epoch [, sym_gen,…])	Metode ini akan membuat model dari pos pemeriksaan yang disimpan sebelumnya.
load_dict ([sym_dict, sym_gen,…])	Metode ini akan membuat model dari pemetaan kamus (dict) bucket_keyke simbol. Itu juga berbagiarg_params dan aux_params.
persiapkan (data_batch [, sparse_row_id_fn])	Operator menyiapkan modul untuk memproses kumpulan data tertentu.
save_checkpoint (awalan, epoch [, remove_amp_cast])	Metode ini, seperti namanya, menyimpan kemajuan saat ini ke checkpoint untuk semua bucket di BucketingModule. Direkomendasikan untuk menggunakan mx.callback.module_checkpoint sebagai epoch_end_callback untuk menyimpan selama pelatihan.
set_params (arg_params, aux_params [,…])	Seperti yang ditentukan namanya, fungsi ini akan menetapkan parameter dan nilai status aux.
set_states ([status, nilai])	Metode ini, sesuai namanya, menetapkan nilai untuk status.
switch_bucket (kunci_ bucket, bentuk_data [,…])	Ini akan beralih ke keranjang yang berbeda.
memperbarui()	Metode ini memperbarui parameter yang diberikan sesuai dengan pengoptimal yang diinstal. Ini juga memperbarui gradien yang dihitung dalam kelompok maju-mundur sebelumnya.
update_metric (eval_metric, label [, pre_sliced])	Metode ini, sesuai namanya, mengevaluasi dan mengakumulasi metrik evaluasi pada keluaran dari komputasi maju terakhir.

Atribut

Tabel berikut menunjukkan atribut-atribut yang terdiri dari metode BaseModule kelas -

Atribut	Definisi
data_names	Ini terdiri dari daftar nama untuk data yang dibutuhkan oleh modul ini.
data_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan input data ke modul ini.
label_shapes	Ini menunjukkan daftar pasangan (nama, bentuk) menentukan input label untuk modul ini.
output_names	Ini terdiri dari daftar nama untuk keluaran modul ini.
output_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan keluaran dari modul ini.
simbol	Seperti nama yang ditentukan, atribut ini mendapatkan simbol yang terkait dengan modul ini.

data_shapes: Anda dapat merujuk tautan yang tersedia di https://mxnet.apache.orguntuk detailnya. output_shapes: Selengkapnya

output_shapes: Informasi lebih lanjut tersedia di https://mxnet.apache.org/api/python

BucketingModule (sym_gen […])

Ini mewakili Bucketingmodule kelas Modul yang membantu untuk menangani secara efisien dengan input panjang yang bervariasi.

Metode

Tabel berikut menunjukkan metode yang terdiri BucketingModule class -

Atribut

Tabel berikut menunjukkan atribut-atribut yang terdiri dari metode BaseModule class -

Atribut	Definisi
data_names	Ini terdiri dari daftar nama untuk data yang dibutuhkan oleh modul ini.
data_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan input data ke modul ini.
label_shapes	Ini menunjukkan daftar pasangan (nama, bentuk) menentukan input label untuk modul ini.
output_names	Ini terdiri dari daftar nama untuk keluaran modul ini.
output_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan keluaran dari modul ini.
Simbol	Seperti nama yang ditentukan, atribut ini mendapatkan simbol yang terkait dengan modul ini.

data_shapes - Anda dapat merujuk tautan di https://mxnet.apache.org/api/python/docs untuk informasi lebih lanjut.

output_shapes− Anda dapat merujuk tautan di https://mxnet.apache.org/api/python/docs untuk informasi lebih lanjut.

Modul (simbol [, nama_data, nama_label,…])

Ini mewakili modul dasar yang membungkus a symbol.

Metode

Tabel berikut menunjukkan metode yang terdiri Module class -

Metode	Definisi
mundur ([out_grads])	Sesuai namanya, metode ini mengimplementasikan file backward komputasi.
mengikat (bentuk_data [, bentuk_label,…])	Ini mengikat simbol untuk membangun pelaksana dan diperlukan sebelum seseorang dapat melakukan komputasi dengan modul.
loan_optimizer (shared_module)	Sesuai namanya, metode ini akan meminjam pengoptimal dari modul bersama.
maju (data_batch [, is_train])	Sesuai namanya, metode ini mengimplementasikan file Forwardkomputasi. Metode ini mendukung kumpulan data dengan berbagai bentuk seperti ukuran kumpulan yang berbeda atau ukuran gambar yang berbeda.
get_input_grads ([merge_multi_context])	Metode ini akan mendapatkan gradien ke input yang dihitung dalam komputasi mundur sebelumnya.
get_outputs ([merge_multi_context])	Sesuai dengan namanya, metode ini akan mendapatkan keluaran dari komputasi maju sebelumnya.
get_params ()	Ia mendapatkan parameter terutama yang berpotensi merupakan salinan dari parameter aktual yang digunakan untuk melakukan komputasi pada perangkat.
get_states ([merge_multi_context])	Metode ini akan mendapatkan status dari semua perangkat
init_optimizer ([kvstore, pengoptimal,…])	Metode ini menginstal dan menginisialisasi pengoptimal. Ini juga menginisialisasikvstore untuk mendistribusikan pelatihan.
init_params ([penginisialisasi, arg_params,…])	Sesuai namanya, metode ini akan menginisialisasi parameter dan status tambahan.
install_monitor (mon)	Metode ini akan menginstal monitor pada semua pelaksana.
memuat (awalan, epoch [, sym_gen,…])	Metode ini akan membuat model dari pos pemeriksaan yang disimpan sebelumnya.
load_optimizer_states (fname)	Metode ini akan memuat pengoptimal yaitu status updater dari file.
persiapkan (data_batch [, sparse_row_id_fn])	Operator menyiapkan modul untuk memproses kumpulan data tertentu.
membentuk kembali (data_shapes [, label_shapes])	Metode ini, sesuai namanya, membentuk kembali modul untuk bentuk masukan baru.
save_checkpoint (awalan, epoch [,…])	Ini menyimpan kemajuan saat ini ke pos pemeriksaan.
save_optimizer_states (fname)	Metode ini menyimpan pengoptimal atau status pembaru ke file.
set_params (arg_params, aux_params [,…])	Seperti yang ditentukan namanya, fungsi ini akan menetapkan parameter dan nilai status aux.
set_states ([status, nilai])	Metode ini, sesuai namanya, menetapkan nilai untuk status.
memperbarui()	Metode ini memperbarui parameter yang diberikan sesuai dengan pengoptimal yang diinstal. Ini juga memperbarui gradien yang dihitung dalam kelompok maju-mundur sebelumnya.
update_metric (eval_metric, label [, pre_sliced])	Metode ini, sesuai namanya, mengevaluasi dan mengakumulasi metrik evaluasi pada keluaran dari komputasi maju terakhir.

Atribut

Tabel berikut menunjukkan atribut-atribut yang terdiri dari metode Module class -

Atribut	Definisi
data_names	Ini terdiri dari daftar nama untuk data yang dibutuhkan oleh modul ini.
data_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan input data ke modul ini.
label_shapes	Ini menunjukkan daftar pasangan (nama, bentuk) menentukan input label untuk modul ini.
output_names	Ini terdiri dari daftar nama untuk keluaran modul ini.
output_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan keluaran dari modul ini.
label_names	Ini terdiri dari daftar nama untuk label yang dibutuhkan oleh modul ini.

data_shapes: Kunjungi link https://mxnet.apache.org/api/python/docs/api/module untuk keterangan lebih lanjut.

output_shapes: Tautan yang diberikan bersama ini https://mxnet.apache.org/api/python/docs/api/module/index.html akan menawarkan informasi penting lainnya.

PythonLossModule ([nama, nama_data,…])

Basis kelas ini adalah mxnet.module.python_module.PythonModule. Kelas PythonLossModule adalah kelas modul yang nyaman yang mengimplementasikan semua atau banyak API modul sebagai fungsi kosong.

Metode

Tabel berikut menunjukkan metode yang terdiri PythonLossModule kelas:

Metode	Definisi
mundur ([out_grads])	Sesuai namanya, metode ini mengimplementasikan file backward komputasi.
maju (data_batch [, is_train])	Sesuai namanya, metode ini mengimplementasikan file Forwardkomputasi. Metode ini mendukung kumpulan data dengan berbagai bentuk seperti ukuran kumpulan yang berbeda atau ukuran gambar yang berbeda.
get_input_grads ([merge_multi_context])	Metode ini akan mendapatkan gradien ke input yang dihitung dalam komputasi mundur sebelumnya.
get_outputs ([merge_multi_context])	Sesuai dengan namanya, metode ini akan mendapatkan keluaran dari komputasi maju sebelumnya.
install_monitor (mon)	Metode ini akan menginstal monitor pada semua pelaksana.

PythonModule ([nama_data, nama_label…])

Basis kelas ini adalah mxnet.module.base_module.BaseModule. Kelas PythonModule juga merupakan kelas modul yang nyaman yang mengimplementasikan semua atau banyak API modul sebagai fungsi kosong.

Metode

Tabel berikut menunjukkan metode yang terdiri PythonModule kelas -

Metode	Definisi
mengikat (bentuk_data [, bentuk_label,…])	Ini mengikat simbol untuk membangun pelaksana dan diperlukan sebelum seseorang dapat melakukan komputasi dengan modul.
get_params ()	Ia mendapatkan parameter terutama yang berpotensi merupakan salinan dari parameter aktual yang digunakan untuk melakukan komputasi pada perangkat.
init_optimizer ([kvstore, pengoptimal,…])	Metode ini menginstal dan menginisialisasi pengoptimal. Ini juga menginisialisasikvstore untuk mendistribusikan pelatihan.
init_params ([penginisialisasi, arg_params,…])	Sesuai namanya, metode ini akan menginisialisasi parameter dan status tambahan.
memperbarui()	Metode ini memperbarui parameter yang diberikan sesuai dengan pengoptimal yang diinstal. Ini juga memperbarui gradien yang dihitung dalam kelompok maju-mundur sebelumnya.
update_metric (eval_metric, label [, pre_sliced])	Metode ini, sesuai namanya, mengevaluasi dan mengakumulasi metrik evaluasi pada keluaran dari komputasi maju terakhir.

Atribut

Tabel berikut menunjukkan atribut-atribut yang terdiri dari metode PythonModule kelas -

Atribut	Definisi
data_names	Ini terdiri dari daftar nama untuk data yang dibutuhkan oleh modul ini.
data_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan input data ke modul ini.
label_shapes	Ini menunjukkan daftar pasangan (nama, bentuk) menentukan input label untuk modul ini.
output_names	Ini terdiri dari daftar nama untuk keluaran modul ini.
output_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan keluaran dari modul ini.

data_shapes - Ikuti tautannya https://mxnet.apache.org untuk detailnya.

output_shapes - Untuk lebih jelasnya, kunjungi tautan yang tersedia di https://mxnet.apache.org

SequentialModule ([logger])

Basis kelas ini adalah mxnet.module.base_module.BaseModule. Kelas SequentialModule juga merupakan modul kontainer yang dapat menghubungkan lebih dari dua (beberapa) modul bersama-sama.

Metode

Tabel berikut menunjukkan metode yang terdiri SequentialModule kelas

Metode	Definisi
tambahkan (modul, ** kwargs)	Ini adalah fungsi terpenting dari kelas ini. Ini menambahkan modul ke rantai.
mundur ([out_grads])	Seperti namanya, metode ini mengimplementasikan komputasi mundur.
mengikat (bentuk_data [, bentuk_label,…])	Ini mengikat simbol untuk membangun pelaksana dan diperlukan sebelum seseorang dapat melakukan komputasi dengan modul.
maju (data_batch [, is_train])	Sesuai namanya, metode ini mengimplementasikan komputasi Teruskan. Metode ini mendukung kumpulan data dengan berbagai bentuk seperti ukuran kumpulan yang berbeda atau ukuran gambar yang berbeda.
get_input_grads ([merge_multi_context])	Metode ini akan mendapatkan gradien ke input yang dihitung dalam komputasi mundur sebelumnya.
get_outputs ([merge_multi_context])	Sesuai dengan namanya, metode ini akan mendapatkan keluaran dari komputasi maju sebelumnya.
get_params ()	Ia mendapatkan parameter terutama yang berpotensi merupakan salinan dari parameter aktual yang digunakan untuk melakukan komputasi pada perangkat.
init_optimizer ([kvstore, pengoptimal,…])	Metode ini menginstal dan menginisialisasi pengoptimal. Ini juga menginisialisasikvstore untuk mendistribusikan pelatihan.
init_params ([penginisialisasi, arg_params,…])	Sesuai namanya, metode ini akan menginisialisasi parameter dan status tambahan.
install_monitor (mon)	Metode ini akan menginstal monitor pada semua pelaksana.
memperbarui()	Metode ini memperbarui parameter yang diberikan sesuai dengan pengoptimal yang diinstal. Ini juga memperbarui gradien yang dihitung dalam kelompok maju-mundur sebelumnya.
update_metric (eval_metric, label [, pre_sliced])	Metode ini, sesuai namanya, mengevaluasi dan mengakumulasi metrik evaluasi pada keluaran dari komputasi maju terakhir.

Atribut

Tabel berikut menunjukkan atribut yang terdiri dari metode kelas BaseModule -

Atribut	Definisi
data_names	Ini terdiri dari daftar nama untuk data yang dibutuhkan oleh modul ini.
data_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan input data ke modul ini.
label_shapes	Ini menunjukkan daftar pasangan (nama, bentuk) menentukan input label untuk modul ini.
output_names	Ini terdiri dari daftar nama untuk keluaran modul ini.
output_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan keluaran dari modul ini.
output_shapes	Ini terdiri dari daftar pasangan (nama, bentuk) yang menentukan keluaran dari modul ini.

data_shapes - Tautan yang diberikan bersama ini https://mxnet.apache.org akan membantu Anda memahami atribut dengan lebih detail.

output_shapes - Ikuti tautan yang tersedia di https://mxnet.apache.org/api untuk detailnya.

Contoh Implementasi

Pada contoh di bawah ini, kita akan membuat file mxnet modul.

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

Outputnya disebutkan di bawah ini -

<Symbol softmax>

Example

print(mod)

Output

Outputnya ditunjukkan di bawah ini -

<mxnet.module.module.Module object at 0x00000123A9892F28>

Dalam contoh di bawah ini, kami akan menerapkan komputasi maju

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

Ketika Anda menjalankan kode di atas, Anda akan melihat output berikut -

[[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

Diberikan di bawah ini adalah output dari kode -

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