Apache MXNet - Hızlı Kılavuz

Bu bölüm Apache MXNet'in özelliklerini vurgular ve bu derin öğrenme yazılımı çerçevesinin en son sürümünden bahseder.

MXNet nedir?

Apache MXNet, geliştiricilerin Derin Öğrenme modellerini oluşturmasına, eğitmesine ve dağıtmasına yardımcı olan güçlü bir açık kaynaklı derin öğrenme yazılımı çerçeve aracıdır. Sağlık hizmetinden nakliyeye, üretime ve aslında günlük hayatımızın her alanında, son birkaç yılda derin öğrenmenin etkisi yaygınlaştı. Günümüzde, şirketler tarafından Yüz tanıma, nesne algılama, Optik Karakter Tanıma (OCR), Konuşma Tanıma ve Makine Çevirisi gibi bazı zor sorunları çözmek için derin öğrenme aranmaktadır.

Apache MXNet'in aşağıdakiler tarafından desteklenmesinin nedeni budur:

• Intel, Baidu, Microsoft, Wolfram Research vb. Gibi bazı büyük şirketler

• Amazon Web Services (AWS) ve Microsoft Azure dahil genel bulut sağlayıcıları

• Carnegie Mellon, MIT, Washington Üniversitesi ve Hong Kong Bilim ve Teknoloji Üniversitesi gibi bazı büyük araştırma enstitüleri.

Neden Apache MXNet?

Torch7, Caffe, Theano, TensorFlow, Keras, Microsoft Cognitive Toolkit, vb. Gibi çeşitli derin öğrenme platformları vardı, o zaman neden Apache MXNet'i merak edebilirsiniz? Bunun arkasındaki bazı nedenleri inceleyelim:

• Apache MXNet, mevcut derin öğrenme platformlarının en büyük sorunlarından birini çözer. Sorun, derin öğrenme platformlarını kullanmak için farklı bir programlama çeşidi için başka bir sistemi öğrenmenin gerekmesidir.

• Apache MXNet'in yardımıyla geliştiriciler, GPU'ların tüm yeteneklerinden ve bulut bilişiminden yararlanabilirler.

• Apache MXNet, herhangi bir sayısal hesaplamayı hızlandırabilir ve büyük ölçekli DNN'nin (derin sinir ağları) geliştirme ve dağıtımını hızlandırmaya özel bir önem verir.

• Kullanıcılara hem zorunlu hem de sembolik programlama yetenekleri sağlar.

Çeşitli Özellikler

En son derin öğrenme araştırmalarını hızlı bir şekilde geliştirmek için esnek bir derin öğrenme kitaplığı veya üretim iş yükünü zorlamak için sağlam bir platform arıyorsanız, aramanız Apache MXNet'te sona erer. Aşağıdaki özelliklerinden dolayıdır:

Dağıtılmış Eğitim

Apache MXNet, geliştiricilerin donanımlarından en iyi şekilde yararlanmalarına olanak tanır. MXNet, Uber'de oluşturulan açık kaynak dağıtılmış bir derin öğrenme çerçevesi olan Horovod ile entegrasyonu da destekler.

Bu entegrasyon için, Horovod'da tanımlanan yaygın dağıtılmış API'lerden bazıları şunlardır:

• horovod.broadcast()

• horovod.allgather()

• horovod.allgather()

Bu bağlamda, MXNet bize aşağıdaki yetenekleri sunar:

• Device Placement - MXNet yardımıyla her bir veri yapısını (DS) kolayca belirleyebiliriz.

• Automatic Differentiation - Apache MXNet, farklılaştırmayı, yani türev hesaplamalarını otomatikleştirir.

• Multi-GPU training - MXNet, mevcut GPU sayısı ile ölçeklendirme verimliliği elde etmemizi sağlar.

• Optimized Predefined Layers - MXNet'te kendi katmanlarımızı kodlayabiliriz ve önceden tanımlanmış katmanları da hız için optimize edebiliriz.

Hibridizasyon

Apache MXNet, kullanıcılarına hibrit bir ön uç sağlar. Gluon Python API'nin yardımıyla, zorunlu ve sembolik yetenekleri arasındaki boşluğu doldurabilir. Hibritleştirme işlevi olarak adlandırılarak yapılabilir.

Daha Hızlı Hesaplama

Onlarca veya yüzlerce matris çarpımı gibi doğrusal işlemler, derin sinir ağları için hesaplama darboğazıdır. Bu darboğazı çözmek için MXNet şunları sağlar:

• GPU'lar için optimize edilmiş sayısal hesaplama

• Dağıtılmış ekosistemler için optimize edilmiş sayısal hesaplama

• Standart NN'nin kısaca ifade edilebileceği ortak iş akışlarının otomasyonu.

Dil Bağlamaları

MXNet, Python ve R gibi yüksek seviyeli dillerle derin bir entegrasyona sahiptir.Ayrıca, diğer programlama dilleri için destek sağlar.

• Scala

• Julia

• Clojure

• Java

• C/C++

• Perl

Melezleştirme özelliği ile birlikte MXNet yerine yeni bir programlama dili öğrenmemize gerek yoktur, Python'dan seçtiğimiz programlama dilinde dağıtıma son derece yumuşak bir geçiş sağlar.

En son sürüm MXNet 1.6.0

Apache Software Foundation (ASF) Apache MXNet'in kararlı sürümü 1.6.0'ı 21 Şubat 2020'de Apache License 2.0 kapsamında yayınladı. Bu, Python 2'yi destekleyen son MXNet sürümüdür çünkü MXNet topluluğu, sonraki sürümlerde Python 2'yi artık desteklemeyecek şekilde oylanmıştır. Bu sürümün kullanıcıları için sunduğu bazı yeni özelliklere göz atalım.

NumPy uyumlu arayüz

Esnekliği ve genelliği nedeniyle NumPy, Makine Öğrenimi uygulayıcıları, bilim adamları ve öğrenciler tarafından yaygın olarak kullanılmaktadır. Ancak, günümüzün Grafik İşleme Birimleri (GPU'lar) gibi donanım hızlandırıcılarının giderek daha fazla çeşitli Makine Öğrenimi (ML) araç kitlerine asimile edildiğini bildiğimiz gibi NumPy kullanıcıları, GPU'ların hızından yararlanmak için yeni çerçevelere geçmeleri gerekiyor. farklı sözdizimi ile.

MXNet 1.6.0 ile Apache MXNet, NumPy uyumlu bir programlama deneyimine doğru ilerliyor. Yeni arayüz, NumPy sözdizimine aşina olan uygulayıcılar için eşdeğer kullanılabilirlik ve ifade gücü sağlar. Bununla birlikte MXNet 1.6.0, mevcut Numpy sisteminin büyük ölçekli hesaplamaları hızlandırmak için GPU'lar gibi donanım hızlandırıcıları kullanmasına da olanak tanır.

Apache TVM ile entegrasyon

CPU'lar, GPU'lar ve özel hızlandırıcılar gibi donanım arka uçları için açık kaynaklı bir uçtan uca derin öğrenme derleyici yığını olan Apache TVM, üretkenlik odaklı derin öğrenme çerçeveleri ile performans odaklı donanım arka uçları arasındaki boşluğu doldurmayı hedefliyor. . En son sürüm MXNet 1.6.0 ile kullanıcılar, yüksek performanslı operatör çekirdeklerini Python programlama dilinde uygulamak için Apache (kuluçka) TVM'den yararlanabilir. Bu yeni özelliğin iki ana avantajı şunlardır:

• Eski C ++ tabanlı geliştirme sürecini basitleştirir.

• Aynı uygulamanın CPU'lar, GPU'lar vb. Gibi birden çok donanım arka uçta paylaşılmasını sağlar.

Mevcut özelliklerde iyileştirmeler

MXNet 1.6.0'ın yukarıda listelenen özelliklerinin yanı sıra, mevcut özelliklere göre bazı iyileştirmeler de sağlar. İyileştirmeler aşağıdaki gibidir -

GPU için öğe bazında işlemi gruplama

Öğelere göre işlemlerin performansının bellek bant genişliği olduğunu bildiğimiz için bu tür işlemlerin zincirlenmesi genel performansı düşürebilir. Apache MXNet 1.6.0, gerçekte mümkün olduğu kadar ve zamanda tam zamanında kaynaştırılmış işlemler üreten eleman bazlı işlem füzyonu yapar. Bu tür eleman bazlı operasyon füzyonu ayrıca depolama ihtiyaçlarını azaltır ve genel performansı iyileştirir.

Yaygın ifadeleri basitleştirme

MXNet 1.6.0, gereksiz ifadeleri ortadan kaldırır ve yaygın ifadeleri basitleştirir. Bu tür bir geliştirme ayrıca bellek kullanımını ve toplam yürütme süresini de iyileştirir.

Optimizasyonlar

MXNet 1.6.0 ayrıca, aşağıdaki gibi mevcut özelliklere ve operatörlere çeşitli optimizasyonlar sağlar:

• Otomatik Karışık Hassas

• Gluon Fit API

• MKL-DNN

• Büyük tensör Desteği

• TensorRT entegrasyon

• Daha yüksek dereceli gradyan desteği

• Operators

• Operatör performans profili

• ONNX içe / dışa aktarma

• Gluon API'lerinde iyileştirmeler

• Symbol API'lerinde İyileştirmeler

• 100'den fazla hata düzeltmesi

MXNet'e başlamak için yapmamız gereken ilk şey onu bilgisayarımıza kurmaktır. Apache MXNet, Windows, Mac ve Linux dahil olmak üzere hemen hemen tüm platformlarda çalışır.

Linux İşletim Sistemi

MXNet'i Linux işletim sistemine aşağıdaki şekillerde kurabiliriz -

Grafik İşleme Birimi (GPU)

Burada, işleme için GPU kullandığımızda MXNet'i kurmak için Pip, Docker ve Source gibi çeşitli yöntemler kullanacağız -

Pip yöntemini kullanarak

MXNet'i Linus İşletim Sisteminize kurmak için aşağıdaki komutu kullanabilirsiniz -

pip install mxnet

Apache MXNet ayrıca, intel donanım üzerinde çalışırken çok daha hızlı olan MKL pip paketleri sunar. Örneğin buradamxnet-cu101mkl şu anlama gelir -

• Paket CUDA / cuDNN ile oluşturulmuştur

• Paket MKL-DNN etkindir

• CUDA sürümü 10.1'dir

Diğer seçenek için ayrıca başvurabilirsiniz https://pypi.org/project/mxnet/.

Docker kullanarak

Docker görüntülerini MXNet ile DockerHub'da bulabilirsiniz. https://hub.docker.com/u/mxnet Docker'ı GPU ile kullanarak MXNet'i kurmak için aşağıdaki adımlara göz atalım -

Step 1- Öncelikle, şu adresteki docker kurulum talimatlarını takip ederek https://docs.docker.com/engine/install/ubuntu/. Makinemize Docker yüklememiz gerekiyor.

Step 2- Docker konteynerlerinden GPU'ların kullanımını etkinleştirmek için, daha sonra nvidia-docker-plugin'i kurmamız gerekiyor. Aşağıdaki kurulum talimatlarını takip edebilirsiniz.https://github.com/NVIDIA/nvidia-docker/wiki.

Step 3- Aşağıdaki komutu kullanarak, MXNet docker görüntüsünü çekebilirsiniz -

$ sudo docker pull mxnet/python:gpu

Şimdi mxnet / python docker imaj çekme işleminin başarılı olup olmadığını görmek için docker imajlarını aşağıdaki gibi listeleyebiliriz -

$ sudo docker images

MXNet ile en yüksek çıkarım hızları için, Intel MKL-DNN ile en son MXNet'in kullanılması önerilir. Aşağıdaki komutları kontrol edin -

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

Kaynaktan

MXNet paylaşılan kitaplığını GPU ile kaynaktan oluşturmak için, önce CUDA ve cuDNN için ortamı aşağıdaki gibi ayarlamamız gerekir−

• CUDA araç setini indirin ve yükleyin, burada CUDA 9.2 önerilir.

• Sonraki indirme cuDNN 7.1.4.

• Şimdi dosyayı açmamız gerekiyor. Ayrıca cuDNN kök dizinine geçmek gerekir. Ayrıca başlık ve kitaplıkları aşağıdaki gibi yerel CUDA Toolkit klasörüne taşıyın -

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

CUDA ve cuDNN için ortamı kurduktan sonra, MXNet paylaşılan kitaplığını kaynaktan oluşturmak için aşağıdaki adımları izleyin -

Step 1- Öncelikle önkoşul paketlerini kurmamız gerekiyor. Bu bağımlılıklar Ubuntu 16.04 veya sonraki sürümlerde gereklidir.

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

Step 2- Bu adımda, MXNet kaynağını indirip yapılandıracağız. Öncelikle aşağıdaki komutu kullanarak depoyu klonlayalım−

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

Step 3- Aşağıdaki komutları kullanarak MXNet çekirdek paylaşımlı kitaplığı oluşturabilirsiniz−

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

Two important points regarding the above step is as follows−

Hata Ayıklama sürümünü oluşturmak istiyorsanız, aşağıdaki gibi belirtin−

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Paralel derleme işlerinin sayısını ayarlamak için aşağıdakileri belirtin -

cmake --build . --parallel N

MXNet çekirdek paylaşılan kitaplığını başarıyla oluşturduktan sonra, build klasörünüzde MXNet project root, bulacaksın libmxnet.so dil bağlamalarını yüklemek için gerekli olan (isteğe bağlı).

Merkezi İşlem Birimi (CPU)

Burada, işleme için CPU kullandığımızda MXNet'i kurmak için Pip, Docker ve Source gibi çeşitli yöntemler kullanacağız -

Pip yöntemini kullanarak

MXNet'i Linus OS'nize kurmak için aşağıdaki komutu kullanabilirsiniz−

pip install mxnet

Apache MXNet ayrıca, intel donanım üzerinde çalışırken çok daha hızlı olan MKL-DNN etkinleştirilmiş pip paketleri sunar.

pip install mxnet-mkl

Docker kullanarak

Docker görüntülerini MXNet ile DockerHub'da bulabilirsiniz. https://hub.docker.com/u/mxnet. Docker'ı CPU ile kullanarak MXNet'i kurmak için aşağıdaki adımları inceleyelim -

Step 1- Öncelikle, şu adresteki docker kurulum talimatlarını takip ederek https://docs.docker.com/engine/install/ubuntu/. Makinemize Docker yüklememiz gerekiyor.

Step 2- Aşağıdaki komutu kullanarak MXNet docker görüntüsünü çekebilirsiniz:

$ sudo docker pull mxnet/python

Şimdi, mxnet / python docker imaj çekme işleminin başarılı olup olmadığını görmek için docker imajlarını aşağıdaki gibi listeleyebiliriz -

$ sudo docker images

MXNet ile en yüksek çıkarım hızları için, Intel MKL-DNN ile en son MXNet'in kullanılması önerilir.

Aşağıdaki komutları kontrol edin -

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

Kaynaktan

MXNet paylaşılan kitaplığını CPU ile kaynaktan oluşturmak için aşağıdaki adımları izleyin -

Step 1- Öncelikle önkoşul paketlerini kurmamız gerekiyor. Bu bağımlılıklar Ubuntu 16.04 veya sonraki sürümlerde gereklidir.

sudo apt-get update

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

Step 2- Bu adımda MXNet kaynağını indirip yapılandıracağız. Öncelikle aşağıdaki komutu kullanarak depoyu klonlayalım:

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

cd mxnet
cp config/linux.cmake config.cmake

Step 3- Aşağıdaki komutları kullanarak, MXNet çekirdek paylaşımlı kitaplığı oluşturabilirsiniz:

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

Two important points regarding the above step is as follows−

Hata Ayıklama sürümünü oluşturmak istiyorsanız, aşağıdaki gibi belirtin:

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Paralel derleme işlerinin sayısını ayarlamak için aşağıdakileri belirtin−

cmake --build . --parallel N

MXNet çekirdek paylaşılan kitaplığını başarıyla oluşturduktan sonra, build MXNet proje kök klasörünüzde, dil bağlamalarını kurmak için gerekli olan libmxnet.so dosyasını bulacaksınız (isteğe bağlı).

Mac os işletim sistemi

MXNet'i MacOS'a aşağıdaki şekillerde kurabiliriz−

Grafik İşleme Birimi (GPU)

GPU ile MacOS üzerinde MXNet oluşturmayı planlıyorsanız, kullanılabilir Pip ve Docker yöntemi YOKTUR. Bu durumda tek yöntem, onu kaynaktan oluşturmaktır.

Kaynaktan

MXNet paylaşılan kitaplığını GPU ile kaynaktan oluşturmak için, önce CUDA ve cuDNN için ortamı ayarlamamız gerekir. Takip etmelisinNVIDIA CUDA Installation Guide hangisi mevcuttur https://docs.nvidia.com ve cuDNN Installation Guide, hangisi mevcuttur https://docs.nvidia.com/deeplearning mac OS için.

Lütfen 2019'da CUDA'nın macOS'u desteklemeyi bıraktığını unutmayın. Aslında, CUDA'nın gelecekteki sürümleri de macOS'u desteklemeyebilir.

CUDA ve cuDNN için ortamı kurduktan sonra, MXNet'i OS X (Mac) üzerindeki kaynaktan yüklemek için aşağıdaki adımları izleyin -

Step 1- OS x üzerinde bazı bağımlılıklara ihtiyacımız olduğu için, Öncelikle önkoşul paketlerini kurmamız gerekiyor.

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

OpenCV olmadan da MXNet kurabiliriz çünkü opencv isteğe bağlı bir bağımlılıktır.

Step 2- Bu adımda MXNet kaynağını indirip yapılandıracağız. Öncelikle aşağıdaki komutu kullanarak depoyu klonlayalım−

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

cd mxnet
cp config/linux.cmake config.cmake

GPU özellikli bir makine için önce CUDA bağımlılıklarını kurmak gerekir çünkü biri GPU'suz bir makinede GPU özellikli bir yapı oluşturmaya çalıştığında, MXNet derlemesi GPU mimarinizi otomatik olarak algılayamaz. Bu gibi durumlarda MXNet, mevcut tüm GPU mimarilerini hedefleyecektir.

Step 3- Aşağıdaki komutları kullanarak MXNet çekirdek paylaşımlı kitaplığı oluşturabilirsiniz−

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

Yukarıdaki adımla ilgili iki önemli nokta şu şekildedir−

Hata Ayıklama sürümünü oluşturmak istiyorsanız, aşağıdaki gibi belirtin−

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Paralel derleme işlerinin sayısını ayarlamak için aşağıdakileri belirtin:

cmake --build . --parallel N

MXNet çekirdek paylaşılan kitaplığını başarıyla oluşturduktan sonra, build klasörünüzde MXNet project root, bulacaksın libmxnet.dylib, dil bağlamalarını yüklemek için gerekli olan (isteğe bağlı).

Merkezi İşlem Birimi (CPU)

Burada, işleme için CPU kullandığımızda MXNet'i kurmak için Pip, Docker ve Source gibi çeşitli yöntemler kullanacağız−

Pip yöntemini kullanarak

MXNet'i Linus İşletim Sisteminize kurmak için aşağıdaki komutu kullanabilirsiniz

pip install mxnet

Docker kullanarak

Docker görüntülerini MXNet ile DockerHub'da bulabilirsiniz. https://hub.docker.com/u/mxnet. Docker'ı CPU ile kullanarak MXNet'i kurmak için aşağıdaki adımlara göz atalım−

Step 1- İlk olarak, aşağıdaki docker installation instructions hangileri mevcuttur https://docs.docker.com/docker-for-mac Docker'ı makinemize kurmamız gerekiyor.

Step 2- Aşağıdaki komutu kullanarak MXNet docker görüntüsünü çekebilirsiniz−

$ docker pull mxnet/python

Şimdi mxnet / python docker imaj çekme işleminin başarılı olup olmadığını görmek için docker imajlarını aşağıdaki gibi listeleyebiliriz−

$ docker images

MXNet ile en yüksek çıkarım hızları için, Intel MKL-DNN ile en son MXNet'in kullanılması önerilir. Aşağıdaki komutları kontrol edin−

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

Kaynaktan

MXNet'i OS X'te (Mac) kaynaktan yüklemek için aşağıdaki adımları izleyin -

Step 1- OS x üzerinde bazı bağımlılıklara ihtiyacımız olduğu için, önce önkoşul paketlerini kurmamız gerekiyor.

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

OpenCV olmadan da MXNet kurabiliriz çünkü opencv isteğe bağlı bir bağımlılıktır.

Step 2- Bu adımda MXNet kaynağını indirip yapılandıracağız. Öncelikle aşağıdaki komutu kullanarak depoyu klonlayalım

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

cd mxnet

cp config/linux.cmake config.cmake

Step 3- Aşağıdaki komutları kullanarak, MXNet çekirdek paylaşımlı kitaplığı oluşturabilirsiniz:

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

Two important points regarding the above step is as follows−

Hata Ayıklama sürümünü oluşturmak istiyorsanız, aşağıdaki gibi belirtin−

cmake -DCMAKE_BUILD_TYPE=Debug -GNinja ..

Paralel derleme işlerinin sayısını ayarlamak için aşağıdakileri belirtin−

cmake --build . --parallel N

MXNet çekirdek paylaşılan kitaplığını başarıyla oluşturduktan sonra, build klasörünüzde MXNet project root, bulacaksın libmxnet.dylib, dil bağlamalarını yüklemek için gerekli olan (isteğe bağlı).

Windows İşletim Sistemi

MXNet'i Windows'a kurmak için ön koşullar aşağıdadır−

minimum sistem gereksinimleri

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

• Visual Studio 2015 veya 2017 (herhangi bir tür)

• Python 2.7 veya 3.6

• pip

Önerilen Sistem Gereksinimleri

• Windows 10, Server 2012 R2 veya Server 2016

• Visual Studio 2017

• En az bir NVIDIA CUDA etkin GPU

• MKL özellikli CPU: Intel® Xeon® işlemci, Intel® Core ™ işlemci ailesi, Intel Atom® işlemci veya Intel® Xeon Phi ™ işlemci

• Python 2.7 veya 3.6

• pip

Grafik İşleme Birimi (GPU)

Pip yöntemini kullanarak−

NVIDIA GPU'larla Windows üzerinde MXNet oluşturmayı planlıyorsanız, bir Python paketi ile CUDA destekli MXNet'i yüklemek için iki seçenek vardır−

CUDA Desteği ile yükleyin

MXNet'i CUDA ile kurabileceğimiz adımlar aşağıdadır.

Step 1- Önce Microsoft Visual Studio 2017 veya Microsoft Visual Studio 2015'i yükleyin.

Step 2- Ardından, NVIDIA CUDA'yı indirin ve yükleyin. Geçmişte CUDA 9.1 ile ilgili bazı sorunlar tanımlandığı için CUDA 9.2 veya 9.0 sürümlerinin kullanılması önerilir.

Step 3- Şimdi, NVIDIA_CUDA_DNN'yi indirin ve kurun.

Step 4- Son olarak, aşağıdaki pip komutunu kullanarak MXNet'i CUDA ile kurun install

pip install mxnet-cu92

CUDA ve MKL Desteği ile yükleyin

Aşağıda, MXNet'i CUDA ve MKL ile kurabileceğimiz adımlar bulunmaktadır.

Step 1- Önce Microsoft Visual Studio 2017 veya Microsoft Visual Studio 2015'i yükleyin.

Step 2- Sonra, intel MKL'yi indirin ve yükleyin

Step 3- Şimdi, NVIDIA CUDA'yı indirin ve yükleyin.

Step 4- Şimdi, NVIDIA_CUDA_DNN'yi indirin ve kurun.

Step 5- Son olarak, aşağıdaki pip komutunu kullanarak, MXNet'i MKL ile kurun.

pip install mxnet-cu92mkl

Kaynaktan

MXNet çekirdek kitaplığını GPU ile kaynaktan oluşturmak için aşağıdaki iki seçeneğe sahibiz−

Option 1− Build with Microsoft Visual Studio 2017

MXNet'i Microsoft Visual Studio 2017 kullanarak kendiniz oluşturmak ve kurmak için aşağıdaki bağımlılıklara ihtiyacınız vardır.

Install/update Microsoft Visual Studio.

• Microsoft Visual Studio, makinenizde halihazırda kurulu değilse, önce onu indirin ve kurun.

• Git'i kurmayı isteyecektir. Ayrıca kurun.

• Microsoft Visual Studio, makinenizde zaten yüklüyse ancak onu güncellemek istiyorsanız, yüklemenizi değiştirmek için bir sonraki adıma geçin. Burada size Microsoft Visual Studio'yu güncelleme fırsatı da verilecektir.

Şu adreste bulunan Visual Studio Yükleyicisini açma talimatlarını izleyin. https://docs.microsoft.com/en-us Bireysel bileşenleri değiştirmek için.

Visual Studio Installer uygulamasında gerektiği gibi güncelleyin. Bundan sonra arayın ve kontrol edinVC++ 2017 version 15.4 v14.11 toolset ve tıklayın Modify.

Şimdi aşağıdaki komutu kullanarak Microsoft VS2017 sürümünü v14.11 olarak değiştirin−

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

Ardından, indirip yüklemeniz gerekiyor CMake mevcut https://cmake.org/download/ Kullanılması tavsiye edilir CMake v3.12.2 hangisi mevcuttur https://cmake.org/download/ çünkü MXNet ile test edilmiştir.

Şimdi indirin ve çalıştırın OpenCV mevcut paket https://sourceforge.net/projects/opencvlibrary/bu birkaç dosyayı açacaktır. Bunları başka bir dizine yerleştirmek isteyip istemediğiniz size bağlıdır. Burada yolu kullanacağızC:\utils(mkdir C:\utils) varsayılan yolumuz olarak.

Daha sonra, OpenCV_DIR ortam değişkenini, fermuarını yeni açtığımız OpenCV oluşturma dizinine işaret edecek şekilde ayarlamamız gerekir. Bu açık komut istemi için ve yazınset OpenCV_DIR=C:\utils\opencv\build.

Önemli bir nokta, Intel MKL (Math Kernel Library) kurulu değilse, onu yükleyebilirsiniz.

Kullanabileceğiniz başka bir açık kaynak paketi OpenBLAS. Burada, kullandığınızı varsaydığımız diğer talimatlar içinOpenBLAS.

Öyleyse, indirin OpenBlas mevcut paket https://sourceforge.net ve dosyayı açın, yeniden adlandırın OpenBLAS ve altına koy C:\utils.

Ardından, ortam değişkenini ayarlamamız gerekiyor OpenBLAS_HOME OpenBLAS dizinine işaret etmek için include ve libdizinler. Bu açık komut istemi için ve yazınset OpenBLAS_HOME=C:\utils\OpenBLAS.

Şimdi, CUDA'yı şu adresten indirip yükleyin: https://developer.nvidia.com. Zaten CUDA'ya sahipseniz ve ardından Microsoft VS2017'yi yüklediyseniz, Microsoft VS2017 entegrasyonu için CUDA araç seti bileşenlerini alabilmeniz için şimdi CUDA'yı yeniden yüklemeniz gerektiğini unutmayın.

Ardından, cuDNN'yi indirip yüklemeniz gerekir.

Ardından, adresinde bulunan git'i indirip yüklemeniz gerekir. https://gitforwindows.org/ Ayrıca.

Gerekli tüm bağımlılıkları kurduktan sonra, MXNet kaynak kodunu oluşturmak için aşağıda verilen adımları izleyin−

Step 1- Windows'ta komut istemini açın.

Step 2- Şimdi aşağıdaki komutu kullanarak GitHub'dan MXNet kaynak kodunu indirin:

cd C:\

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

Step 3- Ardından aşağıdakileri doğrulayın−

DCUDNN_INCLUDE and DCUDNN_LIBRARY ortam değişkenleri, include klasör ve cudnn.lib CUDA kurulu konumunuzun dosyası

C:\incubator-mxnet önceki adımda klonladığınız kaynak kodun konumudur.

Step 4- Sonra aşağıdaki komutu kullanarak bir yapı oluşturun directory ve ayrıca dizine gidin, örneğin−

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

Step 5- Şimdi cmake kullanarak MXNet kaynak kodunu aşağıdaki gibi derleyin−

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- CMake başarıyla tamamlandığında, MXNet kaynak kodunu derlemek için aşağıdaki komutu kullanın use

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

Option 2: Build with Microsoft Visual Studio 2015

MXNet'i Microsoft Visual Studio 2015 kullanarak kendiniz oluşturmak ve kurmak için aşağıdaki bağımlılıklara ihtiyacınız vardır.

Microsoft Visual Studio 2015'i yükleyin / güncelleyin. MXnet'i kaynaktan derlemek için minimum gereksinim, Microsoft Visual Studio 2015'in 3. Güncellemesidir. Tools -> Extensions and Updates... | Product Updates yükseltmek için menü.

Ardından, indirip yüklemeniz gerekiyor CMake hangisi mevcuttur https://cmake.org/download/. Kullanılması tavsiye edilirCMake v3.12.2 hangisi https://cmake.org/download/, çünkü MXNet ile test edilmiştir.

Şimdi, adresinde bulunan OpenCV paketini indirin ve çalıştırın. https://excellmedia.dl.sourceforge.netbu birkaç dosyayı açacaktır. Bunları başka bir dizine yerleştirmek isteyip istemediğiniz size bağlıdır.

Ardından, ortam değişkenini ayarlamamız gerekiyor OpenCV_DIR işaret etmek OpenCVhenüz açtığımız dizini oluşturun. Bunun için komut istemini açın ve set yazınOpenCV_DIR=C:\opencv\build\x64\vc14\bin.

Önemli bir nokta, Intel MKL (Math Kernel Library) kurulu değilse, onu yükleyebilirsiniz.

Kullanabileceğiniz başka bir açık kaynak paketi OpenBLAS. Burada, kullandığınızı varsaydığımız diğer talimatlar içinOpenBLAS.

Öyleyse, indirin OpenBLAS mevcut paket https://excellmedia.dl.sourceforge.net ve dosyayı açın, OpenBLAS olarak yeniden adlandırın ve C: \ utils altına koyun.

Daha sonra, OpenBLAS_HOME ortam değişkenini, include ve lib dizinlerini içeren OpenBLAS dizinine işaret edecek şekilde ayarlamamız gerekir. Dizini şurada bulabilirsiniz:C:\Program files (x86)\OpenBLAS\

Zaten CUDA'ya sahipseniz ve ardından Microsoft VS2015'i yüklediyseniz, Microsoft VS2017 entegrasyonu için CUDA araç seti bileşenlerini alabilmeniz için CUDA'yı şimdi yeniden yüklemeniz gerektiğini unutmayın.

Ardından, cuDNN'yi indirip yüklemeniz gerekir.

Şimdi, CUDACXX ortam değişkenini, CUDA Compiler(C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.1\bin\nvcc.exe Örneğin).

Benzer şekilde, ortam değişkenini de ayarlamamız gerekiyor. CUDNN_ROOT işaret etmek cuDNN içeren dizin include, lib ve bin dizinler (C:\Downloads\cudnn-9.1-windows7-x64-v7\cuda Örneğin).

Gerekli tüm bağımlılıkları kurduktan sonra, MXNet kaynak kodunu oluşturmak için aşağıda verilen adımları izleyin−

Step 1- Öncelikle MXNet kaynak kodunu GitHub'dan indirin−

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

Step 2- Sonra, ./build içinde bir Visual Studio oluşturmak için CMake kullanın.

Step 3- Şimdi, Visual Studio'da çözüm dosyasını açmamız gerekiyor,.slnve derleyin. Bu komutlar adlı bir kitaplık oluşturacaktır.mxnet.dll içinde ./build/Release/ or ./build/Debug Klasör

Step 4- CMake başarıyla tamamlandığında, MXNet kaynak kodunu derlemek için aşağıdaki komutu kullanın

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

Merkezi İşlem Birimi (CPU)

Burada, işleme için CPU kullandığımızda MXNet'i kurmak için Pip, Docker ve Source gibi çeşitli yöntemler kullanacağız−

Pip yöntemini kullanarak

Windows üzerinde CPU'lu MXNet oluşturmayı planlıyorsanız, bir Python paketi kullanarak MXNet'i kurmak için iki seçenek vardır−

Install with CPUs

MXNet'i Python ile CPU ile kurmak için aşağıdaki komutu kullanın−

pip install mxnet

Install with Intel CPUs

Yukarıda tartışıldığı gibi, MXNet, Intel MKL ve MKL-DNN için deneysel desteğe sahiptir. MXNet'i Python ile Intel CPU ile kurmak için aşağıdaki komutu kullanın−

pip install mxnet-mkl

Docker kullanarak

Docker görüntülerini MXNet ile şu adreste bulabilirsiniz: DockerHub, mevcut https://hub.docker.com/u/mxnet Docker ile CPU kullanarak MXNet'i kurmak için aşağıdaki adımlara göz atalım−

Step 1- Öncelikle, şu adresten okunabilen docker kurulum talimatlarını takip ederek https://docs.docker.com/docker-for-mac/install. Makinemize Docker yüklememiz gerekiyor.

Step 2- Aşağıdaki komutu kullanarak MXNet docker görüntüsünü çekebilirsiniz−

$ docker pull mxnet/python

Şimdi mxnet / python docker imaj çekme işleminin başarılı olup olmadığını görmek için docker imajlarını aşağıdaki gibi listeleyebiliriz−

$ docker images

MXNet ile en yüksek çıkarım hızları için, Intel MKL-DNN ile en son MXNet'in kullanılması önerilir.

Aşağıdaki komutları kontrol edin−

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

MXNet'i Bulut ve Cihazlara Kurmak

Bu bölüm, Apache MXNet'in Bulut'a ve cihazlara nasıl kurulacağını vurgular. MXNet'i buluta kurmayı öğrenerek başlayalım.

MXNet'i Buluta Kurmak

Apache MXNet'i birkaç bulut sağlayıcıda da edinebilirsiniz. Graphical Processing Unit (GPU)destek. Bulabileceğiniz diğer iki destek türü aşağıdaki gibidir

• Ölçeklenebilir çıkarım gibi kullanım durumları için GPU / CPU-hibrit desteği.
• AWS Elastic Inference ile faktörlü GPU desteği.

Aşağıda, Apache MXNet için farklı sanal makine ile GPU desteği sağlayan bulut sağlayıcıları verilmiştir

Alibaba Konsolu

Sen yaratabilirsin NVIDIA GPU Cloud Virtual Machine (VM) mevcut https://docs.nvidia.com/ngc Alibaba Konsolu ile ve Apache MXNet'i kullanın.

Amazon Web Hizmetleri

Ayrıca GPU desteği sağlar ve Apache MXNet için aşağıdaki hizmetleri verir−

Amazon SageMaker

Apache MXNet modellerinin eğitimini ve dağıtımını yönetir.

AWS Deep Learning AMI

Apache MXNet, CUDA, cuDNN, MKL-DNN ve AWS Elastic Inference ile hem Python 2 hem de Python 3 için önceden yüklenmiş Conda ortamı sağlar.

AWS'de Dinamik Eğitim

Deneysel manuel EC2 kurulumunun yanı sıra yarı otomatik CloudFormation kurulumu için eğitim sağlar.

Kullanabilirsiniz NVIDIA VM mevcut https://aws.amazon.com Amazon web hizmetleri ile.

Google Bulut Platformu

Google ayrıca NVIDIA GPU cloud image hangisi mevcuttur https://console.cloud.google.com Apache MXNet ile çalışmak için.

Microsoft Azure

Microsoft Azure Marketplace ayrıca NVIDIA GPU cloud image mevcut https://azuremarketplace.microsoft.com Apache MXNet ile çalışmak için.

Oracle Bulut

Oracle ayrıca NVIDIA GPU cloud image mevcut https://docs.cloud.oracle.com Apache MXNet ile çalışmak için.

Merkezi İşlem Birimi (CPU)

Apache MXNet, her bulut sağlayıcısının yalnızca CPU örneğinde çalışır. Yüklemek için çeşitli yöntemler vardır:

• Python pip kurulum talimatları.

• Docker talimatları.

• AWS Deep Learning AMI (MXNet ve MKL-DNN ile Python 2 ve Python 3 için önceden yüklenmiş Conda ortamına sahip) sağlayan Amazon Web Services gibi önceden yüklenmiş seçenek.

MXNet'i Cihazlara Kurmak

MXNet'i cihazlara nasıl kuracağımızı öğrenelim.

Ahududu Pi

MXNet, Respbian ARM tabanlı işletim sistemini de desteklediğinden, Apache MXNet'i Raspberry Pi 3B cihazlarında da çalıştırabilirsiniz. MXNet'i Raspberry Pi3 üzerinde sorunsuz bir şekilde çalıştırmak için 1 GB'den fazla RAM'e ve en az 4GB boş alana sahip bir SD karta sahip bir cihaza sahip olmanız önerilir.

Aşağıda, Raspberry Pi için MXNet oluşturabileceğiniz ve kitaplık için Python bağlamalarını kurabileceğiniz yollar verilmiştir are

Hızlı kurulum

Önceden oluşturulmuş Python çarkı, hızlı kurulum için Stretch ile bir Raspberry Pi 3B üzerinde kullanılabilir. Bu yöntemle ilgili önemli sorunlardan biri, Apache MXNet'in çalışması için birkaç bağımlılık yüklememiz gerektiğidir.

Docker kurulumu

Docker kurulum talimatlarını takip edebilirsiniz. https://docs.docker.com/engine/install/ubuntu/Docker'ı makinenize kurmak için. Bu amaçla, Community Edition'ı (CE) da kurabilir ve kullanabiliriz.

Yerel Derleme (kaynaktan)

MXNet'i kaynaktan kurmak için aşağıdaki iki adımı izlememiz gerekir−

Aşama 1

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

Paylaşılan kitaplığı Raspberry sürüm Wheezy ve sonraki sürümlerde oluşturmak için aşağıdaki bağımlılıklara ihtiyacımız var:

• Git- Kodun GitHub'dan alınması gerekir.

• Libblas- Doğrusal cebirsel işlemler için gereklidir.

• Libopencv- Bilgisayarla görme ile ilgili işlemler için gereklidir. Ancak, RAM'inizi ve Disk Alanınızı kaydetmek istiyorsanız isteğe bağlıdır.

• C++ Compiler- MXNet kaynak kodunu derlemek ve inşa etmek gerekir. Aşağıda C ++ 11'i destekleyen desteklenen derleyiciler verilmiştir comp

  • G ++ (4.8 veya sonraki sürüm)

  • Clang(3.9-6)

Yukarıda belirtilen bağımlılıkları kurmak için aşağıdaki komutları kullanın−

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

Next, we need to clone the MXNet source code repository. For this use the following git command in your home directory−

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

cd incubator-mxnet

Now, with the help of following commands, build the shared library:

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)

Once you execute the above commands, it will start the build process which will take couple of hours to finish. You will get a file named libmxnet.so in the build directory.

Step 2

Install the supported language-specific packages for Apache MXNet

In this step, we will install MXNet Pythin bindings. To do so, we need to run the following command in the MXNet directory−

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

Alternatively, with the following command, you can also create a whl package installable with pip−

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

NVIDIA Jetson Devices

You can also run Apache MXNet on NVIDIA Jetson Devices, such as TX2 or Nano as MXNet also support the Ubuntu Arch64 based OS. In order to run, MXNet smoothly on the NVIDIA Jetson Devices, it is necessary to have CUDA installed on your Jetson device.

Following are the ways with the help of which you can build MXNet for NVIDIA Jetson devices:

• By using a Jetson MXNet pip wheel for Python development

• From source

But, before building MXNet from any of the above-mentioned ways, you need to install following dependencies on your Jetson devices−

Python Dependencies

In order to use the Python API, we need the following dependencies−

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

Clone the MXNet source code repository

By using the following git command in your home directory, clone the MXNet source code repository−

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

Setup environment variables

Add the following in your .profile file in your home directory−

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

Now, apply the change immediately with the following command−

source .profile

Configure CUDA

Before configuring CUDA, with nvcc, you need to check what version of CUDA is running−

nvcc --version

Suppose, if more than one CUDA version is installed on your device or computer and you want to switch CUDA versions then, use the following and replace the symbolic link to the version you want−

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

The above command will switch to CUDA 10.0, which is preinstalled on NVIDIA Jetson device Nano.

Once you done with the above-mentioned prerequisites, you can now install MXNet on NVIDIA Jetson Devices. So, let us understand the ways with the help of which you can install MXNet−

By using a Jetson MXNet pip wheel for Python development− If you want to use a prepared Python wheel then download the following to your Jetson and run it−

• MXNet 1.4.0 (for Python 3) available at https://docs.docker.com

• MXNet 1.4.0 (for Python 2) available at https://docs.docker.com

Native Build (from source)

In order to install MXNet from source, we need to follow the following two steps−

Step 1

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

To build the shared library from the Apache MXNet C++ source code, you can either use Docker method or do it manually−

Docker method

In this method, you first need to install Docker and able to run it without sudo (which is also explained in previous steps). Once done, run the following to execute cross-compilation via Docker−

$MXNET_HOME/ci/build.py -p jetson

Manual

In this method, you need to edit the Makefile (with below command) to install the MXNet with CUDA bindings to leverage the Graphical Processing units (GPU) on NVIDIA Jetson devices:

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

After editing the Makefile, you need to edit config.mk file to make some additional changes for the NVIDIA Jetson device.

For this, update the following settings−

• Update the CUDA path: USE_CUDA_PATH = /usr/local/cuda

• Add -gencode arch=compute-63, code=sm_62 to the CUDA_ARCH setting.

• Update the NVCC settings: NVCCFLAGS := -m64

• Turn on OpenCV: USE_OPENCV = 1

Now to ensure that the MXNet builds with Pascal’s hardware level low precision acceleration, we need to edit the Mshadow Makefile as follow−

MSHADOW_CFLAGS += -DMSHADOW_USE_PASCAL=1

Finally, with the help of following command you can build the complete Apache MXNet library−

cd $MXNET_HOME make -j $(nproc)

Once you execute the above commands, it will start the build process which will take couple of hours to finish. You will get a file named libmxnet.so in the mxnet/lib directory.

Step 2

Install the Apache MXNet Python Bindings

In this step, we will install MXNet Python bindings. To do so we need to run the following command in the MXNet directory−

cd $MXNET_HOME/python
sudo pip install -e .

Once done with above steps, you are now ready to run MXNet on your NVIDIA Jetson devices TX2 or Nano. It can be verified with the following command−

import mxnet
mxnet.__version__

It will return the version number if everything is properly working.

To support the research and development of Deep Learning applications across many fields, Apache MXNet provides us a rich ecosystem of toolkits, libraries and many more. Let us explore them −

ToolKits

Following are some of the most used and important toolkits provided by MXNet −

GluonCV

As name implies GluonCV is a Gluon toolkit for computer vision powered by MXNet. It provides implementation of state-of-the-art DL (Deep Learning) algorithms in computer vision (CV). With the help of GluonCV toolkit engineers, researchers, and students can validate new ideas and learn CV easily.

Given below are some of the features of GluonCV −

• It trains scripts for reproducing state-of-the-art results reported in latest research.

• More than 170+ high quality pretrained models.

• Embrace flexible development pattern.

• GluonCV is easy to optimize. We can deploy it without retaining heavy weight DL framework.

• It provides carefully designed APIs that greatly lessen the implementation intricacy.

• Community support.

• Easy to understand implementations.

Following are the supported applications by GluonCV toolkit:

• Image Classification

• Object Detection

• Semantic Segmentation

• Instance Segmentation

• Pose Estimation

• Video Action Recognition

We can install GluonCV by using pip as follows −

pip install --upgrade mxnet gluoncv

GluonNLP

As name implies GluonNLP is a Gluon toolkit for Natural Language Processing (NLP) powered by MXNet. It provides implementation of state-of-the-art DL (Deep Learning) models in NLP.

GluonNLP araç takımı mühendislerinin, araştırmacıların ve öğrencilerin yardımıyla, metin veri ardışık düzenleri ve modelleri için bloklar oluşturabilirler. Bu modellere dayanarak, araştırma fikirlerini ve ürünü hızlı bir şekilde prototip oluşturabilirler.

Aşağıda GluonNLP'nin bazı özellikleri verilmiştir:

• En son araştırmalarda bildirilen son teknoloji ürünü sonuçları yeniden üretmek için komut dosyalarını eğitir.

• Ortak NLP görevleri için önceden eğitilmiş modeller seti.

• Uygulama karmaşıklığını büyük ölçüde azaltan dikkatlice tasarlanmış API'ler sağlar.

• Topluluk desteği.

• Ayrıca yeni NLP görevlerine başlamanıza yardımcı olacak eğitimler de sağlar.

GluonNLP araç seti ile uygulayabileceğimiz NLP görevleri aşağıdadır -

• Kelime Gömme

• Dil Modeli

• Makine Çevirisi

• Metin Sınıflandırması

• Duygu Analizi

• Doğal Dil Çıkarımı

• Metin Üretimi

• Bağımlılık Ayrıştırma

• Adlandırılmış Varlık Tanıma

• Amaç Sınıflandırması ve Yuva Etiketleme

GluonNLP'yi pip kullanarak aşağıdaki gibi kurabiliriz -

pip install --upgrade mxnet gluonnlp

GluonTS

Adından da anlaşılacağı gibi GluonTS, MXNet tarafından desteklenen Olasılıklı Zaman Serisi Modellemesi için bir Gluon araç setidir.

Aşağıdaki özellikleri sağlar -

• Eğitime hazır son teknoloji ürünü (SOTA) derin öğrenme modelleri.

• Zaman serisi veri kümeleri üzerinde yükleme ve yineleme için yardımcı programlar.

• Kendi modelinizi tanımlamak için yapı taşları.

GluonTS araç takımı mühendislerinin yardımıyla araştırmacılar ve öğrenciler, yerleşik modellerden herhangi birini kendi verileri üzerinde eğitebilir ve değerlendirebilir, farklı çözümleri hızlıca deneyebilir ve zaman serisi görevleri için bir çözüm bulabilir.

Ayrıca, özel zaman serisi modelleri oluşturmak için sağlanan soyutlamaları ve yapı taşlarını kullanabilir ve bunları temel algoritmalarla hızlı bir şekilde karşılaştırabilirler.

GluonTS'yi pip kullanarak aşağıdaki şekilde kurabiliriz -

pip install gluonts

GluonFR

Adından da anlaşılacağı gibi, FR (Yüz Tanıma) için bir Apache MXNet Gluon araç setidir. Aşağıdaki özellikleri sağlar -

• Yüz tanımada son teknoloji ürünü (SOTA) derin öğrenme modelleri.

• SoftmaxCrossEntropyLoss, ArcLoss, TripletLoss, RingLoss, CosLoss / AMsoftmax, L2-Softmax, A-Softmax, CenterLoss, ContrastiveLoss ve LGM Loss vb. Uygulaması.

Gluon Face'i kurmak için Python 3.5 veya sonrasına ihtiyacımız var. Ayrıca önce GluonCV ve MXNet'i aşağıdaki gibi kurmamız gerekiyor -

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

Bağımlılıkları yükledikten sonra, GluonFR'yi kurmak için aşağıdaki komutu kullanabilirsiniz -

From Source

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

Pip

pip install gluonfr

Ekosistem

Şimdi MXNet'in zengin kitaplıklarını, paketlerini ve çerçevelerini inceleyelim -

Koç RL

Coach, Intel AI laboratuvarı tarafından oluşturulan bir Python Reinforcement Learning (RL) çerçevesi. Son teknoloji ürünü RL algoritmalarıyla kolay deney yapmayı sağlar. Coach RL, arka uç olarak Apache MXNet'i destekler ve çözmek için yeni ortamın basit entegrasyonuna izin verir.

Coach RL, mevcut bileşenleri kolayca genişletmek ve yeniden kullanmak için algoritmalar, ortamlar, NN mimarileri, keşif politikaları gibi temel takviye öğrenme bileşenlerini çok iyi ayrıştırdı.

Aşağıda Coach RL çerçevesi için aracılar ve desteklenen algoritmalar verilmiştir -

Değer Optimizasyon Aracıları

• Derin Q Ağı (DQN)

• Double Deep Q Ağı (DDQN)

• Düello Yapan Q Ağı

• Karışık Monte Carlo (MMC)

• Kalıcı Avantajlı Öğrenme (PAL)

• Kategorik Derin Q Ağı (C51)

• Nicelik Regresyon Derin Q Ağı (QR-DQN)

• N-Adımlı Q Öğrenme

• Nöral Epizodik Kontrol (NEC)

• Normalleştirilmiş Avantaj İşlevleri (NAF)

• Rainbow

Politika Optimizasyon Aracıları

• Politika Degradeleri (PG)

• Eşzamansız Avantaj Aktör-Eleştirmen (A3C)

• Derin Deterministik Politika Degradeleri (DDPG)

• Proksimal Politika Optimizasyonu (PPO)

• Kırpılmış Proksimal Politika Optimizasyonu (CPPO)

• Genelleştirilmiş Avantaj Tahmini (GAE)

• Deneyim Tekrarı (ACER) ile Örnek Verimli Aktör-Eleştirmen

• Yumuşak Aktör-Eleştirmen (SAC)

• İkiz Gecikmeli Derin Deterministik Politika Gradyan (TD3)

Genel Temsilciler

• Doğrudan Gelecek Tahmini (DFP)

Taklit Öğrenme Ajanları

• Davranışsal Klonlama (BC)

• Koşullu Taklit Öğrenme

Hiyerarşik Pekiştirmeli Öğrenme Aracıları

• Hiyerarşik Aktör Eleştirmeni (HAC)

Derin Grafik Kitaplığı

NYU ve AWS ekipleri Shanghai tarafından geliştirilen Deep Graph Library (DGL), MXNet üzerinde Graph Neural Networks (GNN'ler) için kolay uygulamalar sağlayan bir Python paketidir. Ayrıca, GNN'lerin PyTorch, Gluon, vb. Gibi diğer mevcut büyük derin öğrenme kitaplıklarının üzerinde kolay uygulanmasını sağlar.

Deep Graph Library ücretsiz bir yazılımdır. Ubuntu 16.04, macOS X ve Windows 7 veya sonraki sürümlerden sonraki tüm Linux dağıtımlarında mevcuttur. Ayrıca Python 3.5 veya sonraki bir sürümünü gerektirir.

DGL'nin özellikleri aşağıdadır -

No Migration cost - Popüler DL çerçevelerinin üzerine inşa edildiği için DGL'yi kullanmanın geçiş maliyeti yoktur.

Message Passing- DGL, mesaj geçişini sağlar ve üzerinde çok yönlü kontrole sahiptir. Mesaj geçişi, seçilen kenarlar boyunca gönderme gibi düşük seviyeli işlemlerden grafik çapında özellik güncellemeleri gibi yüksek seviyeli kontrole kadar uzanır.

Smooth Learning Curve - Güçlü kullanıcı tanımlı işlevler esnek ve kullanımı kolay olduğu için DGL'yi öğrenmek ve kullanmak oldukça kolaydır.

Transparent Speed Optimization - DGL, hesaplamaları ve seyrek matris çarpımını otomatik olarak toplu hale getirerek şeffaf hız optimizasyonu sağlar.

High performance - Maksimum verim elde etmek için DGL, DNN (derin sinir ağları) eğitimini bir veya daha fazla grafik üzerinde otomatik olarak gruplandırır.

Easy & friendly interface - DGL, kenar özellik erişimi ve grafik yapısı manipülasyonu için bize kolay ve kullanıcı dostu arayüzler sağlar.

InsightFace

InsightFace, MXNet tarafından desteklenen bilgisayar görüşünde SOTA (son teknoloji ürünü) yüz analizi algoritmasının uygulanmasını sağlayan Yüz Analizi için Derin Öğrenme Araç Seti. Şunları sağlar -

• Yüksek kaliteli geniş önceden eğitilmiş model seti.

• Son teknoloji ürünü (SOTA) eğitim komut dosyaları.

• InsightFace'in optimize edilmesi kolaydır. Bunu, ağır ağırlıklı DL çerçevesini korumadan dağıtabiliriz.

• Uygulama karmaşıklığını büyük ölçüde azaltan dikkatlice tasarlanmış API'ler sağlar.

• Kendi modelinizi tanımlamak için yapı taşları.

InsightFace'i pip kullanarak aşağıdaki gibi kurabiliriz -

pip install --upgrade insightface

InsightFace'i kurmadan önce, lütfen sistem konfigürasyonunuza göre doğru MXNet paketini kurun.

Keras-MXNet

Keras'ın Python'da yazılmış yüksek seviyeli bir Sinir Ağı (NN) API'si olduğunu bildiğimiz için, Keras-MXNet bize Keras için arka uç desteği sağlıyor. Yüksek performanslı ve ölçeklenebilir Apache MXNet DL çerçevesi üzerinde çalışabilir.

Keras-MXNet'in özellikleri aşağıda belirtilmiştir -

• Kullanıcıların kolay, sorunsuz ve hızlı prototip oluşturmasına olanak tanır. Bunların hepsi kullanım kolaylığı, modülerlik ve genişletilebilirlik sayesinde gerçekleşir.

• Hem CNN'yi (Evrişimli Sinir Ağları) hem de RNN'yi (Tekrarlayan Sinir Ağları) ve her ikisinin kombinasyonunu da destekler.

• Hem Merkezi İşlem Birimi (CPU) hem de Grafik İşlem Birimi (GPU) üzerinde kusursuz çalışır.

• Bir veya çoklu GPU'da çalışabilir.

Bu arka uçla çalışmak için önce keras-mxnet'i aşağıdaki gibi kurmanız gerekir -

pip install keras-mxnet

Şimdi, GPU kullanıyorsanız, MXNet'i CUDA 9 desteği ile aşağıdaki gibi yükleyin -

pip install mxnet-cu90

Ancak yalnızca CPU kullanıyorsanız, temel MXNet'i aşağıdaki gibi kurun -

pip install mxnet

MXBoard

MXBoard, MXNet veri çerçevelerini kaydetmek ve TensorBoard'da görüntülemek için kullanılan, Python'da yazılmış bir kayıt aracıdır. Diğer bir deyişle, MXBoard tensorboard-pytorch API'sini takip etmek içindir. TensorBoard'daki veri türlerinin çoğunu destekler.

Bazılarından aşağıda bahsedilmiştir -

• Graph

• Scalar

• Histogram

• Embedding

• Image

• Text

• Audio

• Hassas Geri Çağırma Eğrisi

MXFusion

MXFusion, derin öğrenmeye sahip modüler bir olasılıklı programlama kitaplığıdır. MXFusion, olasılıklı programlama için derin öğrenme kitaplıklarının temel bir özelliği olan modülerlikten tamamen yararlanmamızı sağlar. Kullanımı basittir ve kullanıcılara olasılıklı modeller tasarlamak ve bunları gerçek dünyadaki problemlere uygulamak için uygun bir arayüz sağlar.

MXFusion, Python 3.4 ve daha fazlası MacOS ve Linux OS üzerinde doğrulanmıştır. MXFusion'ı kurmak için önce aşağıdaki bağımlılıkları kurmamız gerekiyor -

• MXNet> = 1.3

• Networkx> = 2.1

Aşağıdaki pip komutunun yardımıyla, MXFusion'ı kurabilirsiniz -

pip install mxfusion

TVM

CPU'lar, GPU'lar ve özel hızlandırıcılar gibi donanım arka uçları için açık kaynaklı bir uçtan uca derin öğrenme derleyici yığını olan Apache TVM, üretkenlik odaklı derin öğrenme çerçeveleri ile performans odaklı donanım arka uçları arasındaki boşluğu doldurmayı hedefliyor. . En son sürüm MXNet 1.6.0 ile kullanıcılar, yüksek performanslı operatör çekirdeklerini Python programlama dilinde uygulamak için Apache (kuluçka) TVM'den yararlanabilir.

Apache TVM aslında Washington Üniversitesi, Paul G. Allen Bilgisayar Bilimi ve Mühendisliği Okulu SAMPL grubunda bir araştırma projesi olarak başladı ve şu anda bir OSC ( Açık kaynak topluluğu), Apache yolu altında birden fazla endüstriyi ve akademik kurumları içerir.

Apache (kuluçka) TVM'nin ana özellikleri aşağıdadır -

• Eski C ++ tabanlı geliştirme sürecini basitleştirir.

• Aynı uygulamanın CPU'lar, GPU'lar vb. Gibi birden çok donanım arka ucunda paylaşılmasını sağlar.

• TVM, Kears, MXNet, PyTorch, Tensorflow, CoreML, DarkNet gibi çeşitli çerçevelerde DL modellerinin çeşitli donanım arka uçlarında minimum dağıtılabilir modüllere derlenmesini sağlar.

• Ayrıca, tensör operatörlerini daha iyi performansla otomatik olarak üretip optimize etmemiz için altyapı sağlar.

XFer

Bir transfer öğrenme çerçevesi olan Xfer, Python'da yazılmıştır. Temelde bir MXNet modelini alır ve bir meta modeli eğitir veya modeli yeni bir hedef veri kümesi için de değiştirir.

Basit bir deyişle, Xfer, kullanıcıların DNN'de (derin sinir ağları) depolanan bilgilerin hızlı ve kolay bir şekilde aktarılmasını sağlayan bir Python kitaplığıdır.

Xfer kullanılabilir -

• Keyfi sayısal formattaki verilerin sınıflandırılması için.

• Görüntü veya metin verilerinin genel durumlarına.

• Özelliklerin ayıklanmasından bir yeniden amaçlayıcı eğitimine (hedef görevde sınıflandırma gerçekleştiren bir nesne) kadar çıkan bir ardışık düzen olarak.

Xfer'in özellikleri şunlardır:

• Kaynak verimliliği

• Veri verimliliği

• Sinir ağlarına kolay erişim

• Belirsizlik modellemesi

• Hızlı prototipleme

• NN'den özellik çıkarma için yardımcı programlar

Bu bölüm, MXNet sistem mimarisini anlamanıza yardımcı olacaktır. MXNet Modülleri hakkında bilgi edinerek başlayalım.

MXNet Modülleri

Aşağıdaki şema, MXNet sistem mimarisidir ve ana modül ve bileşenlerini gösterir. MXNet modules and their interaction.

Yukarıdaki diyagramda -

• Mavi renkli kutulardaki modüller User Facing Modules.

• Yeşil renkli kutulardaki modüller System Modules.

• Kesintisiz ok yüksek bağımlılığı temsil eder, yani büyük ölçüde arayüze bağlıdır.

• Noktalı ok, ışık bağımlılığını, yani, kolaylık ve arayüz tutarlılığı için kullanılan veri yapısını temsil eder. Aslında alternatifler ile değiştirilebilir.

Kullanıcıya dönük ve sistem modülleri hakkında daha fazla tartışalım.

Kullanıcıya Yönelik Modüller

Kullanıcıya dönük modüller aşağıdaki gibidir -

• NDArray- Apache MXNet için esnek zorunlu programlar sağlar. Dinamik ve asenkron n boyutlu dizilerdir.

• KVStore- Verimli parametre senkronizasyonu için arayüz görevi görür. KVStore'da KV, Anahtar-Değer anlamına gelir. Yani, bir anahtar-değer saklama arayüzü.

• Data Loading (IO) - Bu kullanıcıya dönük modül, verimli dağıtılmış veri yükleme ve büyütme için kullanılır.

• Symbol Execution- Statik bir sembolik grafik yürütücüsüdür. Verimli sembolik grafik yürütme ve optimizasyon sağlar.

• Symbol Construction - Kullanıcıya dönük olan bu modül, kullanıcıya bir hesaplama grafiği, yani ağ yapılandırması oluşturmanın bir yolunu sağlar.

Sistem Modülleri

Sistem modülleri aşağıdaki gibidir -

• Storage Allocator - Bu sistem modülü, adından da anlaşılacağı gibi, bellek bloklarını ana bilgisayar, yani CPU ve farklı cihazlar, yani GPU'lar üzerinde verimli bir şekilde tahsis eder ve geri dönüştürür.

• Runtime Dependency Engine - Çalışma zamanı bağımlılık motoru modülü programları yanı sıra okuma / yazma bağımlılıklarına göre işlemleri yürütür.

• Resource Manager - Resource Manager (RM) sistem modülü, rastgele sayı üreteci ve zamansal uzay gibi küresel kaynakları yönetir.

• Operator - Operatör sistem modülü, statik ileri ve gradyan hesaplamasını yani geri yayılımı tanımlayan tüm operatörlerden oluşur.

Burada Apache MXNet'teki sistem bileşenleri ayrıntılı olarak açıklanmıştır. İlk olarak, MXNet'teki yürütme motoru hakkında çalışacağız.

Yürütme Motoru

Apache MXNet'in yürütme motoru çok yönlüdür. Bunu derin öğrenmenin yanı sıra herhangi bir alana özgü problem için de kullanabiliriz: bağımlılıklarını takip eden bir dizi işlevi yürütün. Bağımlılıkları olan işlevler serileştirilirken, bağımlılığı olmayan işlevler paralel olarak çalıştırılabilecek şekilde tasarlanmıştır.

Çekirdek Arayüz

Aşağıda verilen API, Apache MXNet'in yürütme motoru için temel arayüzdür -

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

Yukarıdaki API aşağıdakilere sahiptir -

• exec_fun - MXNet'in temel arayüz API'si, exec_fun adlı işlevi bağlam bilgisi ve bağımlılıkları ile birlikte yürütme motoruna göndermemize olanak tanır.

• exec_ctx - Yukarıda belirtilen exec_fun işlevinin çalıştırılması gereken bağlam bilgisi.

• const_vars - Bunlar, fonksiyonun okuduğu değişkenlerdir.

• mutate_vars - Bunlar değiştirilecek değişkenlerdir.

Yürütme motoru, kullanıcısına, ortak bir değişkeni değiştiren herhangi iki işlevin yürütülmesinin, itme sırasına göre serileştirilmesi garantisini sağlar.

Fonksiyon

Apache MXNet yürütme motorunun işlev türü aşağıdadır -

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

Yukarıdaki işlevde, RunContextçalışma zamanı bilgilerini içerir. Çalışma zamanı bilgisi, yürütme motoru tarafından belirlenmelidir. SözdizimiRunContext aşağıdaki gibidir−

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

Aşağıda, yürütme motorunun işlevleri hakkında bazı önemli noktalar verilmiştir -

• Tüm işlevler, MXNet'in yürütme motorunun dahili iş parçacıkları tarafından yürütülür.

• İşlevin yürütme motoruna engellenmesini sağlamak iyi değildir, çünkü bununla işlev yürütme iş parçacığını işgal edecek ve ayrıca toplam verimi azaltacaktır.

Bunun için MXNet, aşağıdaki gibi başka bir eşzamansız işlev sağlar−

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

• Bunda AsyncFn işlevi iş parçacıklarımızın ağır kısmını geçebiliriz, ancak yürütme motoru, biz çağrılıncaya kadar işlevin bitmiş olduğunu düşünmez. callback işlevi.

Bağlam

İçinde Context, içinde yürütülecek işlevin bağlamını belirleyebiliriz. Bu genellikle aşağıdakileri içerir -

• İşlevin bir CPU veya GPU üzerinde çalıştırılıp çalıştırılmayacağı.

• Bağlamda GPU belirtirsek, hangi GPU'nun kullanılacağı.

• Context ve RunContext arasında çok büyük bir fark var. Bağlam, cihaz türüne ve cihaz kimliğine sahipken, RunContext yalnızca çalışma süresi sırasında karar verilebilecek bilgilere sahiptir.

VarHandle

Fonksiyonların bağımlılıklarını belirtmek için kullanılan VarHandle, fonksiyonun değiştirebileceği veya kullanabileceği harici kaynakları temsil etmek için kullanabileceğimiz bir belirteç gibidir (özellikle yürütme motoru tarafından sağlanır).

Ancak şu soru ortaya çıkıyor, neden VarHandle'ı kullanmamız gerekiyor? Bunun nedeni, Apache MXNet motorunun diğer MXNet modüllerinden ayrıştırılacak şekilde tasarlanmış olmasıdır.

VarHandle ile ilgili bazı önemli noktalar aşağıdadır -

• Hafiftir, bu nedenle bir değişkeni oluşturmak, silmek veya kopyalamak çok az işletim maliyeti gerektirir.

• Değişmez değişkenleri, yani burada kullanılacak değişkenleri belirtmemiz gerekir. const_vars.

• Değişken değişkenleri, yani içinde değiştirilecek değişkenleri belirtmemiz gerekir. mutate_vars.

• Yürütme motoru tarafından işlevler arasındaki bağımlılıkları çözmek için kullanılan kural, herhangi iki işlevin, bunlardan biri en az bir ortak değişkeni değiştirdiğinde çalıştırılmasının, itme sırasına göre serileştirilmesidir.

• Yeni bir değişken oluşturmak için, NewVar() API.

• Bir değişkeni silmek için, PushDelete API.

İşleyişini basit bir örnekle anlayalım -

Farz edelim ki F1 ve F2 olmak üzere iki fonksiyonumuz var ve her ikisi de değişkeni yani V2'yi değiştiriyorlar. Bu durumda, F1'den sonra F2'ye basılırsa, F2'nin F1'den sonra yürütülmesi garanti edilir. Öte yandan, F1 ve F2'nin her ikisi de V2 kullanıyorsa, gerçek yürütme sırası rastgele olabilir.

İt ve Bekle

Push ve wait yürütme motorunun iki kullanışlı API'sidir.

Aşağıdakilerin iki önemli özelliği Push API:

• Tüm Push API'leri eşzamansızdır, yani API çağrısı, itilen işlevin bitmiş olup olmadığına bakılmaksızın hemen geri döner.

• Push API, iş parçacığı açısından güvenli değildir, bu, bir seferde yalnızca bir iş parçacığının motor API çağrıları yapması gerektiği anlamına gelir.

Şimdi Wait API hakkında konuşursak, aşağıdaki noktalar bunu temsil eder -

• Bir kullanıcı belirli bir işlevin tamamlanmasını beklemek isterse, kapanışa bir geri arama işlevi eklemelidir. Dahil edildikten sonra, işlevin sonundaki işlevi çağırın.

• Öte yandan, bir kullanıcı belirli bir değişkeni içeren tüm fonksiyonların bitmesini beklemek isterse, kullanmalıdır WaitForVar(var) API.

• Birisi tüm itilen işlevlerin bitmesini beklemek isterse, WaitForAll () API.

• Fonksiyonların bağımlılıklarını belirtmek için kullanılır, bir simge gibidir.

Operatörler

Apache MXNet'teki Operatör, gerçek hesaplama mantığının yanı sıra yardımcı bilgiler içeren ve sistemin optimizasyonu gerçekleştirmesine yardımcı olan bir sınıftır.

Operatör arayüzü

Forward sözdizimi aşağıdaki gibi olan çekirdek operatör arayüzüdür:

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;

Yapısı OpContext, içinde tanımlanmıştır Forward() Şöyleki:

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

OpContextOperatörün durumunu (ister tren ister test aşamasında olsun), operatörün hangi cihazda çalıştırılması gerektiğini ve ayrıca talep edilen kaynakları açıklar. iki daha kullanışlı yürütme motoru API'si.

Yukarıdan Forward çekirdek arayüz, istenen kaynakları aşağıdaki gibi anlayabiliriz -

• in_data ve out_data giriş ve çıkış tensörlerini temsil eder.

• req hesaplamanın sonucunun nasıl yazıldığını gösterir out_data.

OpReqType şu şekilde tanımlanabilir -

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

Gibi Forward operatör, isteğe bağlı olarak uygulayabiliriz Backward arayüz aşağıdaki gibidir -

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

Çeşitli görevler

Operator arayüz, kullanıcıların aşağıdaki görevleri yapmasına izin verir -

• Kullanıcı yerinde güncellemeleri belirleyebilir ve bellek ayırma maliyetini düşürebilir

• Daha temiz hale getirmek için, kullanıcı bazı dahili argümanları Python'dan gizleyebilir.

• Kullanıcı, tensörler ve çıkış tensörleri arasındaki ilişkiyi tanımlayabilir.

• Hesaplama yapmak için, kullanıcı sistemden ek geçici alan elde edebilir.

Operatör Özelliği

Evrişimli sinir ağında (CNN), bir evrişimin birkaç uygulamaya sahip olduğunun farkındayız. Bunlardan en iyi performansı elde etmek için, bu birkaç evrişim arasında geçiş yapmak isteyebiliriz.

Apache MXNet'in operatör semantik arayüzünü uygulama arayüzünden ayırmasının nedeni budur. Bu ayrılık şeklinde yapılırOperatorProperty Aşağıdakilerden oluşan sınıf−

InferShape - InferShape arayüzünün aşağıda belirtildiği gibi iki amacı vardır:

• İlk amaç, sisteme her bir giriş ve çıkış tensörünün boyutunu söylemektir, böylece alan daha önce tahsis edilebilir. Forward ve Backward aramak.

• İkinci amaç, çalıştırmadan önce herhangi bir hata olmadığından emin olmak için bir boyut kontrolü yapmaktır.

Sözdizimi aşağıda verilmiştir -

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

Request Resource- Sisteminiz cudnnConvolutionForward gibi işlemler için hesaplama çalışma alanını yönetebiliyorsa ne olur? Sisteminiz, alanı yeniden kullanma ve daha pek çok optimizasyon gerçekleştirebilir. Burada MXNet bunu iki arayüzün yardımıyla kolayca başarır achieve

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

Ama ya ForwardResource ve BackwardResourceboş olmayan diziler döndürülsün mü? Bu durumda, sistem ilgili kaynakları aşağıdakiler aracılığıyla sunar:ctx parametresindeki Forward ve Backward arayüzü Operator.

Backward dependency - Apache MXNet, geriye dönük bağımlılıkla başa çıkmak için aşağıdaki iki farklı operatör imzasına sahiptir -

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

Burada dikkat edilmesi gereken iki önemli nokta -

• FullyConnectedForward'daki out_data, FullyConnectedBackward tarafından kullanılmaz ve

• PoolingBackward requires all the arguments of PoolingForward.

That is why for FullyConnectedForward, the out_data tensor once consumed could be safely freed because the backward function will not need it. With the help of this system got a to collect some tensors as garbage as early as possible.

In place Option − Apache MXNet provides another interface to the users to save the cost of memory allocation. The interface is appropriate for element-wise operations in which both input and output tensors have the same shape.

Following is the syntax for specifying the in-place update −

Example for Creating an Operator

With the help of OperatorProperty we can create an operator. To do so, follow the steps given below −

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

Step 1

Create Operator

First implement the following interface in OperatorProperty:

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

The example is given below −

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

Step 2

Parameterize Operator

If you are going to implement a convolution operator, it is mandatory to know the kernel size, the stride size, padding size, and so on. Why, because these parameters should be passed to the operator before calling any Forward or backward interface.

For this, we need to define a ConvolutionParam structure as below −

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

Now, we need to put this in ConvolutionOpProperty and pass it to the operator as follows −

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

Step 3

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

At last, we need to register the Operator Property Class and the Parameter Class to MXNet. It can be done with the help of following macros −

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

In the above macro, the first argument is the name string and the second is the property class name.

This chapter provides information about the unified operator application programming interface (API) in Apache MXNet.

SimpleOp

SimpleOp is a new unified operator API which unifies different invoking processes. Once invoked, it returns to the fundamental elements of operators. The unified operator is specially designed for unary as well as binary operations. It is because most of the mathematical operators attend to one or two operands and more operands make the optimization, related to dependency, useful.

We will be understanding its SimpleOp unified operator working with the help of an example. In this example, we will be creating an operator functioning as a smooth l1 loss, which is a mixture of l1 and l2 loss. We can define and write the loss as given below −

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

Here, in above example,

• .* stands for element-wise multiplication

• f, f’ is the smooth l1 loss function which we are assuming is in mshadow.

It looks impossible to implement this particular loss as a unary or binary operator but MXNet provides its users automatic differentiation in symbolic execution which simplifies the loss to f and f’ directly. That’s why we can certainly implement this particular loss as a unary operator.

Defining Shapes

As we know MXNet’s mshadow library requires explicit memory allocation hence we need to provide all data shapes before any calculation occurs. Before defining functions and gradient, we need to provide input shape consistency and output shape as follows:

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

The function mxnet::Tshape is used to check input data shape and designated output data shape. In case, if you do not define this function then the default output shape would be same as input shape. For example, in case of binary operator the shape of lhs and rhs is by default checked as the same.

Now let’s move on to our smooth l1 loss example. For this, we need to define an XPU to cpu or gpu in the header implementation smooth_l1_unary-inl.h. The reason is to reuse the same code in smooth_l1_unary.cc and smooth_l1_unary.cu.

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

As in our smooth l1 loss example, the output has the same shape as the source, we can use the default behavior. It can be written as follows −

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

Defining Functions

We can create a unary or binary function with one input as follows −

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

Following is the RunContext ctx struct which contains the information needed during runtime for execution −

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

Now, let’s see how we can write the computation results in 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
};

Now, let’s move on to our smooth l1 loss example. For this, we will use UnaryFunction to define the function of this operator as follows:

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

Defining Gradients

Except Input, TBlob, and OpReqType are doubled, Gradients functions of binary operators have similar structure. Let’s check out below, where we created a gradient function with various types of 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);

As defined above Input0, Input, OutputValue, and OutputGrad all share the structure of GradientFunctionArgument. It is defined as follows −

struct GradFunctionArgument {
   TBlob data;
}

Now let’s move on to our smooth l1 loss example. For this to enable the chain rule of gradient we need to multiply out_grad from the top to the result of 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)));
   });
}

Register SimpleOp to MXNet

Once we created the shape, function, and gradient, we need to restore them into both an NDArray operator as well as into a symbolic operator. For this, we can use the registration macro as follows −

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

The SimpleOpInplaceOption can be defined as follows −

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

Now let’s move on to our smooth l1 loss example. For this, we have a gradient function that relies on input data so that the function cannot be written in place.

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

As we know some operations might need the following −

• A scalar as input such as a gradient scale

• A set of keyword arguments controlling behavior

• A temporary space to speed up calculations.

The benefit of using EnvArguments is that it provides additional arguments and resources to make calculations more scalable and efficient.

Example

First let’s define the struct as below −

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

Next, we need to request additional resources like mshadow::Random<xpu> and temporary memory space from EnvArguments.resource. It can be done as follows −

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

Now, the registration will request the declared resource request from mxnet::ResourceManager. After that, it will place the resources in std::vector<Resource> resource in EnvAgruments.

We can access the resources with the help of following code −

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

If you see in our smooth l1 loss example, a scalar input is needed to mark the turning point of a loss function. That’s why in the registration process, we use set_enable_scalar(true), and env.scalar in function and gradient declarations.

Building Tensor Operation

Here the question arises that why we need to craft tensor operations? The reasons are as follows −

• Computation utilizes the mshadow library and we sometimes do not have functions readily available.

• If an operation is not done in an element-wise way such as softmax loss and gradient.

Example

Here, we are using the above smooth l1 loss example. We will be creating two mappers namely the scalar cases of smooth l1 loss and gradient:

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

This chapter is about the distributed training in Apache MXNet. Let us start by understanding what are the modes of computation in MXNet.

Modes of Computation

MXNet, a multi-language ML library, offers its users the following two modes of computation −

Imperative mode

This mode of computation exposes an interface like NumPy API. For example, in MXNet, use the following imperative code to construct a tensor of zeros on both CPU as well as GPU −

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

As we see in the above code, MXNets specifies the location where to hold the tensor, either in CPU or GPU device. In above example, it is at location 0. MXNet achieve incredible utilisation of the device, because all the computations happen lazily instead of instantaneously.

Symbolic mode

Although the imperative mode is quite useful, but one of the drawbacks of this mode is its rigidity, i.e. all the computations need to be known beforehand along with pre-defined data structures.

On the other hand, Symbolic mode exposes a computation graph like TensorFlow. It removes the drawback of imperative API by allowing MXNet to work with symbols or variables instead of fixed/pre-defined data structures. Afterwards, the symbols can be interpreted as a set of operations as follows −

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

Kinds of Parallelism

Apache MXNet supports distributed training. It enables us to leverage multiple machines for faster as well as effective training.

Following are the two ways in which, we can distribute the workload of training a NN across multiple devices, CPU or GPU device −

Data Parallelism

In this kind of parallelism, each device stores a complete copy of the model and works with a different part of the dataset. Devices also update a shared model collectively. We can locate all the devices on a single machine or across multiple machines.

Model Parallelism

It is another kind of parallelism, which comes handy when models are so large that they do not fit into device memory. In model parallelism, different devices are assigned the task of learning different parts of the model. The important point here to note is that currently Apache MXNet supports model parallelism in a single machine only.

Working of distributed training

The concepts given below are the key to understand the working of distributed training in Apache MXNet −

Types of processes

Processes communicates with each other to accomplish the training of a model. Apache MXNet has the following three processes −

Worker

The job of worker node is to perform training on a batch of training samples. The Worker nodes will pull weights from the server before processing every batch. The Worker nodes will send gradients to the server, once the batch is processed.

Server

MXNet can have multiple servers for storing the model’s parameters and to communicate with the worker nodes.

Scheduler

The role of the scheduler is to set up the cluster, which includes waiting for messages that each node has come up and which port the node is listening to. After setting up the cluster, the scheduler lets all the processes know about every other node in the cluster. It is because the processes can communicate with each other. There is only one scheduler.

KV Store

KV stores stands for Key-Value store. It is critical component used for multi-device training. It is important because, the communication of parameters across devices on single as well as across multiple machines is transmitted through one or more servers with a KVStore for the parameters. Let’s understand the working of KVStore with the help of following points −

• Each value in KVStore is represented by a key and a value.

• Each parameter array in the network is assigned a key and the weights of that parameter array is referred by value.

• After that, the worker nodes push gradients after processing a batch. They also pull updated weights before processing a new batch.

KVStore sunucusu kavramı yalnızca dağıtılmış eğitim sırasında vardır ve dağıtılmış modu çağrı yapılarak etkinleştirilir. mxnet.kvstore.create kelimeyi içeren bir dize bağımsız değişkenine sahip işlev dist -

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

Anahtarların Dağıtımı

Tüm sunucuların tüm parametreler dizisini veya anahtarlarını depolaması gerekli değildir, ancak bunlar farklı sunucular arasında dağıtılır. Anahtarların farklı sunucular arasında bu şekilde dağıtılması KVStore tarafından şeffaf bir şekilde gerçekleştirilir ve hangi sunucunun belirli bir anahtarı sakladığına dair karar rastgele verilir.

KVStore, yukarıda tartışıldığı gibi, anahtar her çekildiğinde isteğinin karşılık gelen değere sahip olan sunucuya gönderilmesini sağlar. Ya bir anahtarın değeri büyükse? Bu durumda, farklı sunucular arasında paylaşılabilir.

Eğitim verilerini böl

Kullanıcılar olarak, her makinenin, özellikle veri paralel modunda dağıtılmış eğitim çalıştırırken, veri setinin farklı bölümleri üzerinde çalışmasını istiyoruz. Kullanabileceğimiz tek bir işçi üzerinde veri paralel eğitimi için veri yineleyicisi tarafından sağlanan bir grup örneği bölmeyi biliyoruz.mxnet.gluon.utils.split_and_load ve daha sonra, partinin her bir parçasını, onu daha fazla işleyecek olan cihaza yükleyin.

Öte yandan, dağıtılmış eğitim durumunda, başlangıçta veri setini şu şekilde bölmeliyiz: nher işçinin farklı bir parça alması için farklı parçalar. Bir kez aldıktan sonra, her işçi kullanabilirsplit_and_loadveri kümesinin bu bölümünü tek bir makinedeki farklı cihazlara yeniden bölmek için. Tüm bunlar veri yineleyici aracılığıyla gerçekleşir.mxnet.io.MNISTIterator ve mxnet.io.ImageRecordIter MXNet'te bu özelliği destekleyen iki yineleyicidir.

Ağırlıklar güncelleniyor

Ağırlıkları güncellemek için KVStore aşağıdaki iki modu destekler -

• İlk yöntem, degradeleri toplar ve bu degradeleri kullanarak ağırlıkları günceller.

• İkinci yöntemde, sunucu yalnızca degradeleri toplar.

Gluon kullanıyorsanız, yukarıda belirtilen yöntemler arasında geçiş yaparak seçim yapma seçeneği vardır. update_on_kvstoredeğişken. Bunu oluşturarak anlayalımtrainer aşağıdaki gibi nesne -

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)

Dağıtık Eğitim Modları

KVStore oluşturma dizesi dist kelimesini içeriyorsa, bu, dağıtılmış eğitimin etkinleştirildiği anlamına gelir. Aşağıda, farklı KVStore türleri kullanılarak etkinleştirilebilecek farklı dağıtılmış eğitim modları verilmiştir -

dist_sync

Adından da anlaşılacağı gibi, eşzamanlı dağıtılmış eğitimi belirtir. Bunda, tüm çalışanlar her partinin başlangıcında aynı senkronize model parametre setini kullanır.

Bu modun dezavantajı, her partiden sonra sunucunun, model parametrelerini güncellemeden önce her bir çalışandan gradyan almayı beklemesi gerekmesidir. Bu, bir işçi düştüğünde, tüm işçilerin ilerlemesini durduracağı anlamına gelir.

dist_async

Adından da anlaşılacağı gibi, eşzamanlı dağıtılmış eğitimi belirtir. Bu durumda, sunucu bir çalışandan degradeler alır ve deposunu anında günceller. Sunucu, daha fazla çekmeye yanıt vermek için güncellenmiş depoyu kullanır.

Avantaj, karşılaştırıldığında dist_sync mode, bir partiyi işlemeyi bitiren bir işçi, geçerli parametreleri sunucudan çekebilir ve bir sonraki partiyi başlatabilir. Diğer işçi önceki partiyi işlemeyi henüz bitirmemiş olsa bile işçi bunu yapabilir. Ayrıca dist_sync modundan daha hızlıdır, çünkü senkronizasyon maliyeti olmadan yakınsaması daha fazla zaman alabilir.

dist_sync_device

Bu mod aynıdır dist_syncmodu. Tek fark, her düğümde birden fazla GPU kullanıldığındadist_sync_device degradeleri toplar ve GPU'daki ağırlıkları güncellerken, dist_sync CPU belleğindeki gradyanları toplar ve ağırlıkları günceller.

GPU ve CPU arasındaki pahalı iletişimi azaltır. Bu yüzden daha hızlıdist_sync. Dezavantajı, GPU'daki bellek kullanımını artırmasıdır.

dist_async_device

Bu mod aynı şekilde çalışır dist_sync_device mod, ancak eşzamansız modda.

Bu bölümde Apache MXNet'te bulunan Python Paketlerini öğreneceğiz.

Önemli MXNet Python paketleri

MXNet, tek tek tartışacağımız aşağıdaki önemli Python paketlerine sahiptir -

• Autograd (Otomatik Farklılaşma)

• NDArray

• KVStore

• Gluon

• Visualization

Önce şununla başlayalım: Autograd Apache MXNet için Python paketi.

Otomatik sınıflandırma

Autograd duruyor automatic differentiationdegradeleri kayıp metriğinden her bir parametreye geri yaymak için kullanılır. Geri yayılımın yanı sıra, gradyanları verimli bir şekilde hesaplamak için dinamik bir programlama yaklaşımı kullanır. Aynı zamanda ters mod otomatik farklılaştırma olarak da adlandırılır. Bu teknik, birçok parametrenin tek bir kayıp ölçüsünü etkilediği 'fan girişi' durumlarında çok etkilidir.

Gradyan nedir?

Gradyanlar, sinir ağı eğitimi sürecinin temelleridir. Temel olarak, performansını iyileştirmek için ağın parametrelerini nasıl değiştireceğimizi anlatıyorlar.

Sinir ağlarının (NN) toplamlar, çarpımlar, evrişimler gibi operatörlerden oluştuğunu biliyoruz. Bu operatörler hesaplamaları için evrişim çekirdeklerindeki ağırlıklar gibi parametreleri kullanırlar. Bu parametreler için en uygun değerleri bulmalıyız ve gradyanlar bize yolu gösterir ve bizi çözüme götürür.

Bir parametreyi değiştirmenin ağın performansı üzerindeki etkisiyle ilgileniyoruz ve gradyanlar bize, bağlı olduğu bir değişkeni değiştirdiğimizde belirli bir değişkenin ne kadar arttığını veya azaldığını söylüyor. Performans genellikle en aza indirmeye çalıştığımız bir kayıp ölçütü kullanılarak tanımlanır. Örneğin, regresyon için en aza indirmeye çalışabilirizL2 Tahminlerimiz ile kesin değer arasındaki kayıp, oysa sınıflandırma için en aza indirebiliriz cross-entropy loss.

Kaybı referans alarak her parametrenin gradyanını hesapladıktan sonra, stokastik gradyan inişi gibi bir optimizasyon aracı kullanabiliriz.

Degradeler nasıl hesaplanır?

Degradeleri hesaplamak için aşağıdaki seçeneklerimiz var -

• Symbolic Differentiation- İlk seçenek, her gradyan için formülleri hesaplayan Sembolik Farklılaşma'dır. Bu yöntemin dezavantajı, ağ derinleştikçe ve operatörler daha karmaşık hale geldikçe inanılmaz derecede uzun formüllere yol açmasıdır.

• Finite Differencing- Diğer bir seçenek de, her parametrede küçük farklılıklar deneyen ve kayıp ölçütünün nasıl tepki verdiğini gören sonlu farklılaştırmayı kullanmaktır. Bu yöntemin dezavantajı, hesaplama açısından pahalı olması ve sayısal kesinliği zayıf olmasıdır.

• Automatic differentiation- Yukarıdaki yöntemlerin dezavantajlarının çözümü, degradeleri kayıp ölçüsünden her bir parametreye geri yaymak için otomatik farklılaştırma kullanmaktır. Yayılma, gradyanları verimli bir şekilde hesaplamak için dinamik bir programlama yaklaşımı sağlar. Bu yöntem aynı zamanda ters mod otomatik farklılaştırma olarak da adlandırılır.

Otomatik Farklılaştırma (autograd)

Burada autograd'ın işleyişini ayrıntılı olarak anlayacağız. Temelde şu iki aşamada çalışır -

Stage 1 - Bu aşamaya ‘Forward Pass’eğitim. Adından da anlaşılacağı gibi, bu aşamada, ağ tarafından tahminler yapmak ve kayıp ölçüsünü hesaplamak için kullanılan operatörün kaydını oluşturur.

Stage 2 - Bu aşamaya ‘Backward Pass’eğitim. Adından da anlaşılacağı gibi, bu aşamada bu kayıt üzerinden geriye doğru çalışır. Geriye doğru, her operatörün kısmi türevlerini, ağ parametresine kadar değerlendirir.

Autograd'ın avantajları

Otomatik Farklılaştırma (autograd) kullanmanın avantajları aşağıdadır -

• Flexible- Ağımızı tanımlarken bize sağladığı esneklik, autograd kullanmanın en büyük faydalarından biridir. İşlemleri her yinelemede değiştirebiliriz. Bunlar, statik grafik gerektiren çerçevelerde uygulanması çok daha karmaşık olan dinamik grafikler olarak adlandırılır. Autograd, bu gibi durumlarda bile, gradyanları doğru şekilde geri yayabilir.

• Automatic- Autograd otomatiktir, yani geri yayılım prosedürünün karmaşıklığı sizin için onun tarafından halledilir. Sadece hangi gradyanları hesaplamakla ilgilendiğimizi belirtmemiz gerekiyor.

• Efficient - Autogard, eğimleri çok verimli bir şekilde hesaplar.

• Can use native Python control flow operators- if condition ve while döngüsü gibi yerel Python kontrol akışı operatörlerini kullanabiliriz. Otomatik sınıflandırma, gradyanları verimli ve doğru bir şekilde geri yaymaya devam edebilecektir.

MXNet Gluon'da otomatik derecelendirmeyi kullanma

Burada bir örnek yardımıyla nasıl kullanabileceğimizi göreceğiz. autograd MXNet Gluon'da.

Uygulama Örneği

Aşağıdaki örnekte, iki katmanlı regresyon modelini uygulayacağız. Uygulamadan sonra, ağırlık parametrelerinin her birine göre kaybın gradyanını otomatik olarak hesaplamak için autograd kullanacağız -

Öncelikle autogrard'ı ve diğer gerekli paketleri aşağıdaki gibi içe aktarın -

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

Şimdi ağı şu şekilde tanımlamamız gerekiyor -

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

Şimdi kaybı şu şekilde tanımlamamız gerekiyor -

loss_function = L2Loss()

Ardından, kukla verileri aşağıdaki gibi oluşturmamız gerekiyor -

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

Şimdi, ağ üzerinden ilk ileri geçişimiz için hazırız. Gradyanları hesaplayabilmemiz için autograd'ın hesaplama grafiğini kaydetmesini istiyoruz. Bunun için ağ kodunu şu kapsamda çalıştırmamız gerekiyor:autograd.record bağlam aşağıdaki gibidir -

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

Şimdi, faiz miktarı üzerinden geriye doğru yöntemi çağırarak başladığımız geri geçişe hazırız. Örneğimizdeki ilgi konusu kayıptır, çünkü parametrelere göre kaybın gradyanını hesaplamaya çalışıyoruz -

loss.backward()

Şimdi, iyileştirici tarafından geliştirilmiş performans için parametre değerini güncellemek üzere kullanılacak ağın her parametresi için gradyanlarımız var. 1. katmanın gradyanlarını aşağıdaki gibi kontrol edelim -

N_net[0].weight.grad()

Output

Çıktı aşağıdaki gibidir−

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

Eksiksiz uygulama örneği

Aşağıda tam uygulama örneği verilmiştir.

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

Bu bölümde, MXNet'in çok boyutlu dizi formatını tartışacağız. ndarray.

NDArray ile verileri işleme

İlk olarak, verileri NDArray ile nasıl işleyebileceğimize bakacağız. Aşağıdakiler aynı önkoşullardır -

Önkoşullar

Verileri bu çok boyutlu dizi formatıyla nasıl işleyebileceğimizi anlamak için aşağıdaki ön koşulları yerine getirmemiz gerekir:

• Python ortamında yüklü MXNet

• Python 2.7.x veya Python 3.x

Uygulama Örneği

Aşağıda verilen bir örnek yardımıyla temel işlevselliği anlayalım -

Öncelikle, MXNet ve ndarray'i MXNet'ten aşağıdaki gibi içe aktarmamız gerekir -

import mxnet as mx
from mxnet import nd

Gerekli kitaplıkları içe aktardıktan sonra, aşağıdaki temel işlevlere geçeceğiz:

Bir python listesi ile basit bir 1-D dizisi

Example

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

Output

Çıktı aşağıda belirtildiği gibidir -

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

Bir python listeli 2 boyutlu bir dizi

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

Çıktı aşağıda belirtildiği gibidir -

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

Herhangi bir başlatma olmadan bir NDArray oluşturma

Burada 3 satır ve 4 sütunlu bir matris oluşturacağız. .emptyişlevi. Ayrıca kullanacağız.full diziye doldurmak istediğiniz değer için ek bir operatör alacak olan işlev.

Example

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

Output

Çıktı aşağıda verilmiştir -

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

.Zeros işlevli tüm sıfırların matrisi

Example

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

Output

Çıktı aşağıdaki gibidir -

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

.Ones işlevine sahip olanların matrisi

Example

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

Output

Çıktı aşağıda belirtilmiştir -

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

Değerleri rastgele örneklenen dizi oluşturma

Example

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

Output

Çıktı aşağıda verilmiştir -

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

Her NDArray'in boyutunu bulma

Example

y.shape

Output

Çıktı aşağıdaki gibidir -

(3, 4)

Her NDArray'in boyutunu bulma

Example

y.size

Output

12

Her NDArray'in veri türünü bulma

Example

y.dtype

Output

numpy.float32

NDArray İşlemleri

Bu bölümde size MXNet'in dizi işlemlerini tanıtacağız. NDArray, çok sayıda standart matematiksel ve yerinde işlemleri destekler.

Standart Matematiksel İşlemler

Aşağıdakiler, NDArray tarafından desteklenen standart matematiksel işlemlerdir -

Eleman bilge ekleme

Öncelikle, MXNet ve ndarray'i MXNet'ten aşağıdaki gibi içe aktarmamız gerekir:

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

Çıktı burada verilmiştir -

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

Eleman bazında çarpma

Example

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

Output

Aşağıdaki çıktıyı göreceksiniz−

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

Üs alma

Example

nd.exp(x)

Output

Kodu çalıştırdığınızda aşağıdaki çıktıyı göreceksiniz:

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

Matris-matris ürününü hesaplamak için matris devri

Example

nd.dot(x, y.T)

Output

Aşağıda verilen kodun çıktısıdır -

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

Yerinde İşlemler

Yukarıdaki örnekte her seferinde bir işlem çalıştırdığımızda, sonucunu barındırmak için yeni bir bellek ayırdık.

Örneğin, eğer A = A + B yazarsak, A'nın işaret ettiği matrisin referansını kaldırıp bunun yerine yeni tahsis edilmiş belleğe işaret edeceğiz. Python'un id () işlevini kullanarak aşağıda verilen örnekle anlayalım -

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

Output

Yürütme üzerine, aşağıdaki çıktıyı alacaksınız -

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

Aslında, sonucu önceden tahsis edilmiş bir diziye aşağıdaki gibi de atayabiliriz -

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

Çıktı aşağıda gösterilmiştir -

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

Yukarıdaki çıktıdan, x + y'nin sonucu z'ye kopyalamadan önce saklamak için yine de geçici bir tampon ayıracağını görebiliriz. Şimdi, belleği daha iyi kullanmak ve geçici arabellekten kaçınmak için işlemleri yerinde gerçekleştirebiliriz. Bunu yapmak için, her operatörün desteklediği out anahtar kelime argümanını aşağıdaki gibi belirleyeceğiz -

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

Yukarıdaki programı çalıştırdığınızda, aşağıdaki sonucu alacaksınız -

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

NDArray Bağlamları

Apache MXNet'te, her dizinin bir bağlamı vardır ve bir bağlam CPU olabilir, oysa diğer bağlamlar birkaç GPU olabilir. Çalışmayı birden çok sunucuya dağıttığımızda işler daha da kötüye gidebilir. Bu nedenle, dizileri bağlamlara akıllıca atamamız gerekiyor. Cihazlar arasında veri aktarımı için harcanan zamanı en aza indirecektir.

Örneğin, bir diziyi aşağıdaki gibi başlatmayı deneyin -

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

Output

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Copyto () yöntemini aşağıdaki gibi kullanarak verilen NDArray'i bir bağlamdan başka bir bağlama kopyalayabiliriz -

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

NumPy dizisi ve NDArray karşılaştırması

Hepimiz NumPy dizilerine aşinayız ancak Apache MXNet, NDArray adlı kendi dizi uygulamasını sunar. Aslında, başlangıçta NumPy'ye benzer olacak şekilde tasarlanmıştı, ancak önemli bir fark var -

Temel fark, hesaplamaların NumPy ve NDArray'de çalıştırılma biçimindedir. MXNet'teki her NDArray manipülasyonu, eşzamansız ve engellemesiz bir şekilde yapılır; bu, c = a * b gibi bir kod yazdığımızda, işlevinExecution Engine, hesaplamayı başlatacak.

Burada a ve b'nin her ikisi de NDArray'lardır. Kullanmanın yararı, işlevin hemen geri dönmesi ve önceki hesaplamanın henüz tamamlanmadığı gerçeğine rağmen kullanıcı iş parçacığının çalışmaya devam edebilmesidir.

Yürütme Motorunun Çalışması

Yürütme motorunun çalışmasından bahsedersek, hesaplama grafiğini oluşturur. Hesaplama grafiği bazı hesaplamaları yeniden sıralayabilir veya birleştirebilir, ancak her zaman bağımlılık sırasını yerine getirir.

Örneğin, programlama kodunda daha sonra yapılan 'X' ile başka bir manipülasyon varsa, Yürütme Motoru, 'X'in sonucu mevcut olduğunda bunları yapmaya başlayacaktır. Yürütme motoru, sonraki kodun yürütülmesini başlatmak için geri aramaların yazılması gibi kullanıcılar için bazı önemli işleri gerçekleştirecektir.

Apache MXNet'te, NDArray yardımıyla, hesaplamanın sonucunu elde etmek için sadece sonuçtaki değişkene erişmemiz gerekir. Hesaplama sonuçları ortaya çıkan değişkene atanana kadar kodun akışı engellenecektir. Bu şekilde, zorunlu programlama modunu desteklerken kod performansını artırır.

NDArray'i NumPy Dizisine Dönüştürme

MXNet'te NDArray'i NumPy Array'e nasıl dönüştürebileceğimizi öğrenelim.

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

Bazen, mevcut operatörleri kullanarak daha üst düzey bir operatör oluşturabiliriz. Bunun en iyi örneklerinden biri,np.full_like()NDArray API'sinde bulunmayan operatör. Aşağıdaki gibi mevcut operatörlerin bir kombinasyonu ile kolayca değiştirilebilir:

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

Çıktıyı aşağıdaki gibi alacağız -

True

Finding similar operator with different name and/or signature

Tüm operatörler arasında, bazılarının biraz farklı isimleri var, ancak işlevsellik açısından benzerler. Buna bir örneknd.ravel_index() ile np.ravel()fonksiyonlar. Aynı şekilde, bazı operatörlerin benzer adları olabilir, ancak farklı imzaları vardır. Buna bir örneknp.split() ve nd.split() benzerdir.

Bunu aşağıdaki programlama örneğiyle anlayalım:

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

Çıktı aşağıda belirtilmiştir -

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

Aramaları engellemenin etkisini en aza indirme

Bazı durumlarda ikisini de kullanmalıyız .asnumpy() veya .asscalar()yöntemlerini kullanır, ancak bu sonuç alınana kadar MXNet'i yürütmeyi engellemeye zorlar. Engellenen bir aramanın etkisini arayarak en aza indirebiliriz.asnumpy() veya .asscalar() Şu anda yöntemler, düşündüğümüzde bu değerin hesaplanması zaten yapılmıştır.

Uygulama Örneği

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

Çıktı aşağıda belirtilmiştir:

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

Bir diğer en önemli MXNet Python paketi Gluon'dur. Bu bölümde, bu paketi tartışacağız. Gluon, DL projeleri için açık, özlü ve basit bir API sağlar. Apache MXNet'in eğitim hızından ödün vermeden DL modellerinin prototipini oluşturmasını, oluşturmasını ve eğitmesini sağlar.

Bloklar

Bloklar, daha karmaşık ağ tasarımlarının temelini oluşturur. Bir sinir ağında, sinir ağının karmaşıklığı arttıkça, tek nöron katmanlarını tasarlamaktan tüm katmanlara geçmemiz gerekir. Örneğin, ResNet-152 gibi NN tasarımı, aşağıdakilerden oluşan oldukça adil bir düzenlilik derecesine sahiptir:blocks tekrarlanan katmanların.

Misal

Aşağıda verilen örnekte, kodu çok katmanlı bir algılayıcı için basit bir blok, yani blok yazacağız.

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

Bu, aşağıdaki çıktıyı üretir:

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

Katmanları tanımlamadan bir veya daha fazla katmanın bloklarını tanımlamaya geçmek için gereken adımlar -

Step 1 - Blok verileri girdi olarak alır.

Step 2- Şimdi, bloklar durumu parametreler biçiminde saklayacaktır. Örneğin, yukarıdaki kodlama örneğinde blok iki gizli katman içerir ve bunun için parametreleri depolamak için bir yere ihtiyacımız var.

Step 3- Sonraki blok, ileri yayılma gerçekleştirmek için ileri işlevini çağıracaktır. İleri hesaplama olarak da adlandırılır. İlk ileri çağrının bir parçası olarak, bloklar parametreleri tembel bir şekilde başlatır.

Step 4- Sonunda bloklar geriye doğru işlevi çağıracak ve gradyanı girdilerine göre hesaplayacaktır. Genellikle bu adım otomatik olarak gerçekleştirilir.

Sıralı Blok

Sıralı bir blok, verilerin bir dizi bloktan aktığı özel bir blok türüdür. Bunda, her blok bir önceki bloğun çıkışına uygulanır ve ilk blok giriş verisinin kendisine uygulanır.

Bakalım nasıl sequential sınıf çalışmaları -

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

Çıktı burada verilmiştir -

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

Özel Blok

Yukarıda tanımlandığı gibi sıralı blok ile birleştirmenin ötesine kolayca geçebiliriz. Ancak, özelleştirme yapmak istersek,Blocksınıf ayrıca bize gerekli işlevselliği sağlar. Blok sınıfının nn modülünde sağlanan bir model yapıcısı vardır. İstediğimiz modeli tanımlamak için bu model yapıcısını miras alabiliriz.

Aşağıdaki örnekte, MLP class geçersiz kılar __init__ ve Block sınıfının ileri fonksiyonları.

Nasıl çalıştığını görelim.

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

Kodu çalıştırdığınızda aşağıdaki çıktıyı göreceksiniz:

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

Özel Katmanlar

Apache MXNet'in Gluon API'si, makul sayıda önceden tanımlanmış katmanla birlikte gelir. Ancak yine de bir noktada yeni bir katmana ihtiyaç olduğunu görebiliriz. Gluon API'ye kolayca yeni bir katman ekleyebiliriz. Bu bölümde sıfırdan nasıl yeni bir katman oluşturabileceğimizi göreceğiz.

En Basit Özel Katman

Gluon API'de yeni bir katman oluşturmak için, en temel işlevselliği sağlayan Block sınıfından miras alan bir sınıf oluşturmamız gerekir. Önceden tanımlanmış tüm katmanları doğrudan ondan veya diğer alt sınıflar aracılığıyla miras alabiliriz.

Yeni katmanı oluşturmak için uygulanması gereken tek örnek yöntem şudur: forward (self, x). Bu yöntem, katmanımızın ileriye doğru yayılma sırasında tam olarak ne yapacağını tanımlar. Daha önce de tartışıldığı gibi, bloklar için geri yayılma geçişi Apache MXNet tarafından otomatik olarak yapılacaktır.

Misal

Aşağıdaki örnekte yeni bir katman tanımlayacağız. Ayrıca uygulayacağızforward() giriş verilerini [0, 1] aralığına sığdırarak normalleştirme yöntemi.

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

Yukarıdaki programı çalıştırdığınızda, aşağıdaki sonucu alacaksınız -

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

Hibridizasyon

Apache MXNet tarafından ileri hesaplamanın sembolik bir grafiğini oluşturmak için kullanılan bir işlem olarak tanımlanabilir. Hibridizasyon, MXNet'in hesaplamalı sembolik grafiği optimize ederek hesaplama performansını artırmasına olanak tanır. Doğrudan miras almak yerineBlockAslında, mevcut katmanları uygularken bir bloğun bir HybridBlock.

Bunun nedenleri aşağıdadır -

• Allows us to write custom layers: HybridBlock, hem zorunlu hem de sembolik programlamada daha fazla kullanılabilecek özel katmanlar yazmamızı sağlar.

• Increase computation performance- HybridBlock, MXNet'in hesaplama performansını artırmasına izin veren hesaplamalı sembolik grafiği optimize eder.

Misal

Bu örnekte, yukarıda oluşturulan örnek katmanımızı HybridBlock kullanarak yeniden yazacağız:

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

Çıktı aşağıda belirtilmiştir:

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

Hibridizasyonun GPU'daki hesaplamayla hiçbir ilgisi yoktur ve hem CPU hem de GPU'da hibritleştirilmiş ve hibritlenmemiş ağlar eğitilebilir.

Blok ve HybridBlock arasındaki fark

Karşılaştırırsak Block Sınıf ve HybridBlock, göreceğiz HybridBlock zaten var forward() yöntem uygulandı. HybridBlock tanımlar hybrid_forward()katmanları oluştururken uygulanması gereken yöntem. F argümanı, arasındaki temel farkı yaratırforward() ve hybrid_forward(). MXNet topluluğunda, F argümanına arka uç denir. F şuna da başvurabilir:mxnet.ndarray API (zorunlu programlama için kullanılır) veya mxnet.symbol API (Sembolik programlama için kullanılır).

Bir ağa özel katman nasıl eklenir?

Özel katmanları ayrı ayrı kullanmak yerine, bu katmanlar önceden tanımlanmış katmanlarla kullanılır. İkisini de kullanabilirizSequential veya HybridSequentialsıralı bir sinir ağından kapsayıcılar. Daha önce de tartışıldığı gibi,Sequential konteyner, Blok'tan devralır ve HybridSequential miras kalmak HybridBlock sırasıyla.

Misal

Aşağıdaki örnekte, özel bir katmana sahip basit bir sinir ağı oluşturacağız. ÇıkışDense (5) katman girdisi olacak NormalizationHybridLayer. ÇıktısıNormalizationHybridLayer girdisi olacak Dense (1) katman.

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

Aşağıdaki çıktıyı göreceksiniz -

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

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

Özel katman parametreleri

Bir sinir ağında, bir katmanın kendisiyle ilişkili bir dizi parametresi vardır. Bunları bazen bir katmanın iç durumu olan ağırlıklar olarak adlandırıyoruz. Bu parametreler farklı roller oynar -

• Bazen geri yayılım adımı sırasında öğrenmek istediklerimiz bunlar.

• Bazen bunlar sadece ileri geçiş sırasında kullanmak istediğimiz sabitlerdir.

Programlama konseptinden bahsedersek, bir bloğun bu parametreleri (ağırlıkları) saklanır ve ParameterDict bunların başlatılmasına, güncellenmesine, kaydedilmesine ve yüklenmesine yardımcı olan sınıf.

Misal

Aşağıdaki örnekte, aşağıdaki iki parametre setini tanımlayacağız -

• Parameter weights- Bu eğitilebilir ve inşaat aşamasında şekli bilinmemektedir. İleriye doğru yayılmanın ilk çalıştırmasında çıkarsanacaktır.

• Parameter scale- Bu, değeri değişmeyen bir sabittir. Parametre ağırlıklarının tersine, şekli yapım sırasında belirlenir.

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

Bu bölüm python paketleri KVStore ve görselleştirme ile ilgilidir.

KVStore paketi

KV mağazaları, Anahtar-Değer deposu anlamına gelir. Çoklu cihaz eğitimi için kullanılan kritik bir bileşendir. Bu önemlidir, çünkü parametrelerin tek tek ve birden çok makinedeki cihazlar arasında iletişimi, parametreler için bir KVStore ile bir veya daha fazla sunucu üzerinden iletilir.

Aşağıdaki noktaların yardımıyla KVStore'un çalışmasını anlayalım:

• KVStore'daki her bir değer, bir key ve bir value.

• Ağdaki her parametre dizisine bir key ve bu parametre dizisinin ağırlıkları, value.

• Bundan sonra, işçi düğümleri pushbir partiyi işledikten sonra degradeler. Onlar ayrıcapull yeni bir partiyi işlemeden önce güncellenmiş ağırlıklar.

Basit bir ifadeyle, KVStore'un her bir cihazın verileri içeri itip veri çekebildiği bir veri paylaşımı yeri diyebiliriz.

Veri İtme ve Çıkarma

KVStore, GPU'lar ve bilgisayarlar gibi farklı cihazlar arasında paylaşılan tek bir nesne olarak düşünülebilir, burada her bir cihaz veri içeri itebilir ve veri çekebilir.

Aşağıda, verileri içeri itmek ve verileri dışarı çekmek için cihazların izlemesi gereken uygulama adımları verilmiştir:

Uygulama adımları

Initialisation- İlk adım, değerleri sıfırlamaktır. Burada örneğimiz için, bir çift (int, NDArray) çiftini KVStrore'a başlatacağız ve bundan sonra değerleri dışarı çekeceğiz -

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

Bu, aşağıdaki çıktıyı üretir -

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

Push, Aggregate, and Update - Bir kez başlatıldığında, KVStore'a yeni bir değeri anahtara aynı şekle sokabiliriz -

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

Output

Çıktı aşağıda verilmiştir -

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

İtme için kullanılan veriler, GPU'lar veya bilgisayarlar gibi herhangi bir cihazda saklanabilir. Aynı anahtara birden fazla değer de itebiliriz. Bu durumda, KVStore önce tüm bu değerleri toplayacak ve ardından birleştirilmiş değeri aşağıdaki gibi aktaracaktır -

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

Aşağıdaki çıktıyı göreceksiniz -

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

Uyguladığınız her gönderim için KVStore, itilen değeri önceden depolanan değerle birleştirir. Bir güncelleyici yardımı ile yapılacaktır. Burada varsayılan güncelleyici ASSIGN'dır.

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

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Aşağıda verilen kodun çıktısıdır -

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

Pull - Push gibi, değeri tek bir aramayla birkaç cihaza aşağıdaki gibi çekebiliriz -

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

Output

Çıktı aşağıda belirtilmiştir -

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

Eksiksiz Uygulama Örneği

Aşağıda tam uygulama örneği verilmiştir -

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

Anahtar / Değer Çiftlerini İşleme

Yukarıda uyguladığımız tüm işlemler tek bir anahtar içerir, ancak KVStore ayrıca a list of key-value pairs -

Tek bir cihaz için

Aşağıda, tek bir cihaz için anahtar / değer çiftlerinin bir listesi için bir KVStore arayüzünü gösteren bir örnek verilmiştir -

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

Aşağıdaki çıktıyı alacaksınız -

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

Birden çok cihaz için

Aşağıda, birden çok cihaz için anahtar / değer çiftlerinin bir listesi için bir KVStore arayüzünü gösteren bir örnek verilmiştir -

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

Aşağıdaki çıktıyı göreceksiniz -

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

Görselleştirme paketi

Görselleştirme paketi, sinir ağını (NN) düğümlerden ve kenarlardan oluşan bir hesaplama grafiği olarak temsil etmek için kullanılan Apache MXNet paketidir.

Sinir ağını görselleştirin

Aşağıdaki örnekte kullanacağız mx.viz.plot_networksinir ağını görselleştirmek için. Bunun ön koşulları aşağıdakilerdir -

Prerequisites

• Jupyter not defteri

• Graphviz kütüphanesi

Uygulama Örneği

Aşağıdaki örnekte, doğrusal matris faktörizasyonu için örnek bir NN görselleştireceğiz -

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)

Bu bölüm Apache MXNet'te bulunan ndarray kitaplığını açıklamaktadır.

Mxnet.ndarray

Apache MXNet'in NDArray kitaplığı, tüm matematiksel hesaplamalar için temel DS'yi (veri yapıları) tanımlar. NDArray'in iki temel görevi aşağıdaki gibidir -

• Çok çeşitli donanım yapılandırmalarında hızlı yürütmeyi destekler.

• Mevcut donanım genelinde birden çok işlemi otomatik olarak paralel hale getirir.

Aşağıda verilen örnek, normal bir Python listesinden 1-D ve 2-D 'dizi' kullanarak bir NDArray'in nasıl oluşturulabileceğini gösterir -

import mxnet as mx
from mxnet import nd

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

Output

Çıktı aşağıda verilmiştir:

[ 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

Bu, aşağıdaki çıktıyı üretir -

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

Şimdi MXNet'in ndarray API'sinin sınıfları, işlevleri ve parametreleri hakkında ayrıntılı olarak tartışalım.

Sınıflar

Aşağıdaki tablo MXNet'in ndarray API sınıflarını içerir -

Sınıf	Tanım
CachedOp (sym [, bayraklar])	Önbelleğe alınan operatör tanıtıcısı için kullanılır.
NDArray (tutamaç [, yazılabilir])	Çok boyutlu, homojen bir sabit boyutlu öğeler dizisini temsil eden bir dizi nesnesi olarak kullanılır.

Fonksiyonlar ve parametreleri

Aşağıda, mxnet.ndarray API tarafından kapsanan bazı önemli işlevler ve parametreleri verilmiştir -

Fonksiyon ve Parametreleri	Tanım
Activation([veri, hareket_türü, çıkış, ad])	Girişe eleman olarak bir aktivasyon fonksiyonu uygular. Relu, sigmoid, tanh, softrelu, softsign aktivasyon fonksiyonlarını destekler.
BatchNorm([veriler, gama, beta, hareketli_ortalama,…])	Toplu normalleştirme için kullanılır. Bu işlev, bir veri grubunu ortalama ve varyansa göre normalleştirir. Ölçekli gama ve ofset beta uygular.
BilinearSampler([veriler, ızgara, cudnn_off,…])	Bu işlev, giriş özelliği haritasına çift doğrusal örnekleme uygular. Aslında “Mekansal Trafo Ağları” nın anahtarıdır. OpenCV'de yeniden eşleme işlevine aşina iseniz, bu işlevin kullanımı buna oldukça benzer. Tek fark, geriye doğru geçişe sahip olmasıdır.
BlockGrad ([veri, çıkış, ad])	Adından da anlaşılacağı gibi, bu işlev gradyan hesaplamasını durdurur. Temel olarak, girdilerin birikmiş gradyanının bu operatörden geriye doğru akmasını durdurur.
cast ([data, dtype, out, name])	Bu işlev, girdinin tüm öğelerini yeni bir türe dönüştürecektir.

Uygulama Örnekleri

Aşağıdaki örnekte, verileri iki kez uzaklaştırmak ve verileri yatay olarak -1 piksel kaydırmak için BilinierSampler () işlevini kullanacağız -

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

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz:

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

Yukarıdaki çıktı, verilerin iki kez uzaklaştırılmasını gösterir.

Verileri -1 piksel kaydırmanın örneği aşağıdaki gibidir -

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

Çıktı aşağıda belirtilmiştir -

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

Benzer şekilde, aşağıdaki örnek cast () işlevinin kullanımını gösterir -

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

Output

Yürütme üzerine, aşağıdaki çıktıyı alacaksınız -

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

ndarray.contrib

Contrib NDArray API, ndarray.contrib paketinde tanımlanmıştır. Genellikle yeni özellikler için birçok yararlı deneysel API sağlar. Bu API, topluluk için yeni özellikleri deneyebilecekleri bir yer olarak çalışır. Özelliğe katkıda bulunan kişi de geri bildirimi alacaktır.

Fonksiyonlar ve parametreleri

Aşağıda, bazı önemli işlevler ve bunların kapsadığı parametreler yer almaktadır. mxnet.ndarray.contrib API -

Fonksiyon ve Parametreleri	Tanım
rand_zipfian(true_class, num_sampled,…)	Bu işlev, yaklaşık bir Zipfian dağılımından rastgele örnekler alır. Bu işlevin temel dağılımı Zipfian dağılımıdır. Bu işlev rastgele olarak num_sampled adayları örneklemektedir ve örneklenen_candidates'in elemanları yukarıda verilen temel dağılımdan çekilmektedir.
foreach(gövde, veri, init_states)	Adından da anlaşılacağı gibi, bu işlev 0 boyutunda NDArray'ler üzerinden kullanıcı tanımlı hesaplama ile bir for döngüsü çalıştırır. Bu işlev bir for döngüsünü simüle eder ve body, for döngüsünün bir yinelemesi için hesaplamaya sahiptir.
while_loop (koşul, işlev, döngü_vars [,…])	Adından da anlaşılacağı gibi, bu işlev kullanıcı tanımlı hesaplama ve döngü koşuluyla bir while döngüsü çalıştırır. Bu işlev, koşul yerine getirilirse tam anlamıyla özelleştirilmiş hesaplama yapan bir while döngüsünü simüle eder.
cond(pred, then_func, else_func)	Adından da anlaşılacağı gibi, bu işlev kullanıcı tanımlı koşulu ve hesaplamayı kullanarak eğer-ise-değilse çalıştırır. Bu işlev, belirtilen koşula göre iki özelleştirilmiş hesaplamadan birini yapmayı seçen, benzer bir dalı simüle eder.
isinf(veri)	Bu işlev, NDArray öğesinin sonsuz bir öğe içerip içermediğini belirlemek için öğe bazlı bir kontrol gerçekleştirir.
getnnz([veri, eksen, çıkış, ad])	Bu işlev bize bir seyrek tensör için saklanan değerlerin sayısını verir. Aynı zamanda açık sıfırlar da içerir. Yalnızca CPU'da CSR matrisini destekler.
yeniden hesaplama ([veriler, min_aralık, maks_aralık,…])	Bu fonksiyon, çalışma zamanında veya kalibrasyondan hesaplanan minimum ve maksimum eşikleri kullanarak int32'de ve karşılık gelen eşiklerde nicelenen belirli verileri int8'e talep eder.

Uygulama Örnekleri

Aşağıdaki örnekte, yaklaşık bir Zipfian dağılımından rastgele örnekler çizmek için rand_zipfian işlevini kullanacağız -

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

Aşağıdaki çıktıyı göreceksiniz -

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

Example

exp_count_true

Output

Çıktı aşağıda verilmiştir:

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

Example

exp_count_sample

Output

Bu, aşağıdaki çıktıyı üretir:

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

Aşağıdaki örnekte, işlevi kullanacağız while_loop kullanıcı tanımlı hesaplama ve döngü koşulu için bir while döngüsü çalıştırmak için:

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

Çıktı aşağıda gösterilmiştir -

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

Example

States

Output

Bu, aşağıdaki çıktıyı üretir -

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

ndarray.image

Image NDArray API, ndarray.image paketinde tanımlanmıştır. Adından da anlaşılacağı gibi, genellikle görüntüler ve özellikleri için kullanılır.

Fonksiyonlar ve parametreleri

Aşağıda, kapsam dahilindeki bazı önemli işlevler ve parametreleri verilmiştir. mxnet.ndarray.image API-

Fonksiyon ve Parametreleri	Tanım
adjust_lighting([veri, alfa, çıkış, ad])	Adından da anlaşılacağı gibi, bu işlev, girişin aydınlatma seviyesini ayarlar. AlexNet tarzını takip eder.
crop([veri, x, y, genişlik, yükseklik, çıkış, ad])	Bu işlevin yardımıyla, bir görüntü NDArray biçimini (Y x G x C) veya (N x Y x G x C) kullanıcı tarafından verilen boyuta kırpabiliriz.
normalize([veri, ortalama, std, çıkış, ad])	Bir şekil tensörünü (C x H x W) veya (N x C x H x W) ile normalize edecektir. mean ve standard deviation(SD).
random_crop ([veri, xrange, yrange, genişlik,…])	Crop () 'ya benzer şekilde, kullanıcı tarafından verilen boyuta göre bir görüntü NDArray (Y x G x C) veya (N x Y x G x C) rasgele kırpılır. Src boyutundan küçükse, sonucu daha yüksek örnekleyecektir.
random_lighting([veri, alfa_std, çıkış, ad])	Adından da anlaşılacağı gibi, bu işlev PCA sesini rasgele ekler. Aynı zamanda AlexNet tarzını da takip eder.
random_resized_crop([veriler, xrange, yrange,…])	Ayrıca, belirli bir boyuta göre rastgele bir NDArray şekil (Y x G x C) veya (N x Y x G x C) resmi kırpar. Src boyuttan küçükse, sonucu daha yüksek örnekleyecektir. Alan ve en boy oranını da rastgele hale getirecektir.
resize([veri, boyut, tutma_ oranı, ara değer,…])	Adından da anlaşılacağı gibi, bu işlev bir görüntü NDArray (Y x G x C) veya (N x Y x G x C) kullanıcı tarafından verilen boyuta yeniden boyutlandıracaktır.
to_tensor([veri, çıkış, ad])	[0, 255] aralığındaki değerlere sahip bir görüntü NDArray şekil dizisini (Y x G x C) veya (N x Y x G x C) bir tensör ND şekil dizisine (C x Y x G) veya ( N x C x H x W) [0, 1] aralığındaki değerlerle.

Uygulama Örnekleri

Aşağıdaki örnekte, [0, 255] aralığındaki değerlere sahip görüntü NDŞekil dizisini (Y x G x D) veya (N x Y x G x D) tensör NDArray'e dönüştürmek için to_tensor işlevini kullanacağız. şekil (C x Y x G) veya (N x C x Y x G) [0, 1] aralığındaki değerlerle.

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

Aşağıdaki çıktıyı göreceksiniz -

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

Kodu çalıştırdığınızda, aşağıdaki çıktıyı göreceksiniz -

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

Aşağıdaki örnekte, işlevi kullanacağız normalize bir şekil tensörünü (C x H x W) veya (N x C x H x W) ile normalleştirmek için mean ve 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

Bu, aşağıdaki çıktıyı üretir -

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

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

ndarray.random

Random NDArray API, ndarray.random paketinde tanımlanmıştır. Adından da anlaşılacağı gibi, MXNet'in rastgele dağıtım üreticisi NDArray API'sidir.

Fonksiyonlar ve parametreleri

Aşağıda, bazı önemli işlevler ve bunların kapsadığı parametreler yer almaktadır. mxnet.ndarray.random API -

Fonksiyon ve Parametreleri	Tanım
tekdüze ([düşük, yüksek, şekil, dtype, ctx, dışarı])	Düzgün bir dağılımdan rastgele örnekler üretir.
normal ([loc, scale, shape, dtype, ctx, out])	Normal (Gauss) bir dağılımdan rastgele örnekler üretir.
randn (* şekil, ** kwargs)	Normal (Gauss) bir dağılımdan rastgele örnekler üretir.
üstel ([ölçek, şekil, dtype, ctx, dışarı])	Üstel bir dağılımdan örnekler üretir.
gama ([alfa, beta, şekil, dtype, ctx, çıkış])	Bir gama dağılımından rastgele örnekler üretir.
multinomial (veri [, şekil, get_prob, çıkış, dtype])	Birden çok çok terimli dağılımdan eşzamanlı örnekleme üretir.
negatif_binom ([k, p, şekil, dtype, ctx, dışarı])	Negatif bir binom dağılımından rastgele örnekler oluşturur.
generalized_negative_binomial ([mu, alfa;…])	Genelleştirilmiş bir negatif binom dağılımından rastgele örnekler üretir.
karıştır (veri, ** kwargs)	Öğeleri rastgele karıştırır.
randint (düşük, yüksek [, şekil, dtype, ctx, dışarı])	Ayrık tekdüze bir dağılımdan rastgele örnekler üretir.
üssel_like ([veriler, lam, çıkış, ad])	Giriş dizisi şekline göre üstel bir dağılımdan rastgele örnekler üretir.
gamma_like ([veri, alfa, beta, çıkış, ad])	Girdi dizisi şekline göre bir gama dağılımından rastgele örnekler üretir.
generalized_negative_binomial_like ([veriler;…])	Giriş dizisi şekline göre genelleştirilmiş bir negatif binom dağılımından rastgele örnekler üretir.
negatif_binom_like ([veri, k, p, çıkış, ad])	Girdi dizisi şekline göre negatif bir binom dağılımından rastgele örnekler üretir.
normal_like ([veri, konum, ölçekleme, çıkış, ad])	Girdi dizisi şekline göre normal (Gauss) bir dağılımdan rastgele örnekler üretir.
poisson_like ([veriler, lam, çıkış, ad])	Giriş dizisi şekline göre bir Poisson dağılımından rastgele örnekler üretir.
uniform_like ([veri, düşük, yüksek, çıkış, ad])	Giriş dizisi şekline göre tek tip bir dağılımdan rastgele örnekler üretir.

Uygulama Örnekleri

Aşağıdaki örnekte, tek tip bir dağılımdan rastgele örnekler alacağız. Bunun için işlevi kullanacakuniform().

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

Output

Çıktı aşağıda belirtilmiştir -

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

Example

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

Output

Çıktı aşağıda verilmiştir -

[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

Aşağıdaki çıktıyı göreceksiniz -

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

Aşağıdaki örnekte, genelleştirilmiş bir negatif iki terimli dağılımdan rastgele örnekler alacağız. Bunun için işlevi kullanacağızgeneralized_negative_binomial().

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

Output

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Example

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

Output

Çıktı burada verilmiştir -

[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

Aşağıda verilen kodun çıktısıdır -

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

ndarray.utils

NDArray API yardımcı programı, ndarray.utils paketinde tanımlanmıştır. Adından da anlaşılacağı gibi, NDArray ve BaseSparseNDArray için yardımcı program işlevleri sağlar.

Fonksiyonlar ve parametreleri

Aşağıda, bazı önemli işlevler ve bunların kapsadığı parametreler yer almaktadır. mxnet.ndarray.utils API -

Fonksiyon ve Parametreleri	Tanım
sıfırlar (şekil [, ctx, dtype, stype])	Bu işlev, verilen şekil ve türde sıfırlarla dolu yeni bir dizi döndürecektir.
boş (şekil [, ctx, dtype, stype])	Girişleri başlatmadan yeni bir şekil ve tip dizisi döndürür.
dizi (kaynak_dizi [, ctx, dtype])	Adından da anlaşılacağı gibi, bu işlev herhangi bir nesneden dizi arayüzünü açığa çıkaran bir dizi oluşturur.
yük (isim)	Dosyadan bir dizi yükleyecektir.
load_frombuffer (buf)	Adından da anlaşılacağı gibi, bu işlev bir dizi sözlüğünü veya bir arabellekten liste yükleyecektir.
kaydet (isim, veri)	Bu işlev, dizilerin bir listesini veya dizinin bir dizisini dosyaya kaydeder.

Uygulama Örnekleri

Aşağıdaki örnekte, sıfırlarla dolu yeni bir şekil ve tip dizisi döndüreceğiz. Bunun için işlevi kullanacağızzeros().

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

Output

Bu, aşağıdaki çıktıyı üretir -

<CSRNDArray 1x2 @cpu(0)>

Example

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

Output

Aşağıdaki çıktıyı alacaksınız -

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

Aşağıdaki örnekte, bir dizi listesi ve bir dizeler sözlüğü kaydedeceğiz. Bunun için işlevi kullanacağızsave().

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

Yürütme üzerine, aşağıdaki çıktıyı alacaksınız -

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

Çıktı aşağıda gösterilmiştir -

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

Önceki bölümlerde daha önce tartıştığımız gibi, MXNet Gluon, DL projeleri için açık, özlü ve basit bir API sağlar. Apache MXNet'in eğitim hızından ödün vermeden DL modellerinin prototipini oluşturmasını, oluşturmasını ve eğitmesini sağlar.

Çekirdek Modüller

Apache MXNet Python uygulama programlama arayüzü (API) gluon'un temel modüllerini öğrenelim.

gluon.nn

Gluon, gluon.nn modülünde çok sayıda yerleşik NN katmanı sağlar. Çekirdek modül denmesinin nedeni budur.

Yöntemler ve parametreleri

Aşağıda, bazı önemli yöntemler ve bunların parametreleri aşağıda verilmiştir. mxnet.gluon.nn çekirdek modül -

Yöntemler ve Parametreleri	Tanım
Aktivasyon (aktivasyon, ** kwargs)	Adından da anlaşılacağı gibi, bu yöntem girdiye bir etkinleştirme işlevi uygular.
OrtHavuz1D ([havuz_boyutu, adımlar, dolgu,…])	Bu, geçici veriler için ortalama bir havuzlama işlemidir.
OrtHavuz2D ([havuz_boyutu, adımlar, dolgu,…])	Bu, uzamsal veriler için ortalama havuzlama işlemidir.
OrtHavuz3D ([havuz_boyutu, adımlar, dolgu,…])	Bu, 3B veriler için ortalama havuzlama işlemidir. Veriler uzamsal veya mekansal-zamansal olabilir.
BatchNorm ([eksen, momentum, epsilon, merkez,…])	Toplu normalleştirme katmanını temsil eder.
BatchNormReLU ([eksen, momentum, epsilon,…])	Aynı zamanda toplu normalleştirme katmanını temsil eder, ancak Relu aktivasyon işlevine sahiptir.
Blok ([önek, parametreler])	Tüm sinir ağı katmanları ve modelleri için temel sınıfı verir.
Dönş1D (kanallar, kernel_size [, adımlar,…])	Bu yöntem, 1-D evrişim katmanı için kullanılır. Örneğin, zamansal evrişim.
Conv1DTranspose (kanallar, kernel_size [,…])	Bu yöntem, Aktarılmış 1 Boyutlu evrişim katmanı için kullanılır.
Conv2D (kanallar, kernel_size [, strides,…])	Bu yöntem, 2D evrişim katmanı için kullanılır. Örneğin, görüntüler üzerinde uzamsal evrişim).
Conv2DTranspose (kanallar, kernel_size [,…])	Bu yöntem, Transpoze 2D evrişim katmanı için kullanılır.
Conv3D (kanallar, kernel_size [, adımlar,…])	Bu yöntem, 3B evrişim katmanı için kullanılır. Örneğin, hacimler üzerinde uzamsal evrişim.
Conv3DTranspose (kanallar, kernel_size [,…])	Bu yöntem, Transpoze 3D evrişim katmanı için kullanılır.
Yoğun (birimler [, etkinleştirme, kullanım_biyasları,…])	Bu yöntem, düzenli olarak yoğun şekilde bağlanmış NN katmanınızı temsil eder.
Bırakma (oran [, eksenler])	Adından da anlaşılacağı gibi, yöntem girdiye Dropout uygular.
ELU (a)	Bu yöntem, Üstel Doğrusal Birim (ELU) için kullanılır.
Gömme (input_dim, output_dim [, dtype,…])	Negatif olmayan tam sayıları, sabit boyutlu yoğun vektörlere dönüştürür.
Düzleştir (** kwargs)	Bu yöntem, girişi 2-D'ye düzleştirir.
GELU (** kwargs)	Bu yöntem Gauss Üstel Doğrusal Birim (GELU) için kullanılır.
GlobalAvgPool1D ([düzen])	Bu yöntemin yardımıyla, zamansal veriler için global ortalama havuzlama işlemi yapabiliriz.
GlobalAvgPool2D ([düzen])	Bu yöntemin yardımıyla, konumsal veriler için küresel ortalama havuzlama işlemi yapabiliriz.
GlobalAvgPool3D ([düzen])	Bu yöntemin yardımıyla 3 boyutlu veriler için global ortalama havuzlama işlemi yapabiliyoruz.
GlobalMaxPool1D ([düzen])	Bu yöntemin yardımıyla 1 boyutlu veriler için global maks. Havuzlama işlemi yapabiliriz.
GlobalMaxPool2D ([düzen])	Bu yöntemin yardımıyla 2 boyutlu veriler için global maks. Havuzlama işlemi yapabiliriz.
GlobalMaxPool3D ([düzen])	Bu yöntemin yardımıyla 3 boyutlu veriler için global maks. Havuzlama işlemi yapabiliriz.
GroupNorm([num_groups, epsilon, center, …])	This method applies group normalization to the n-D input array.
HybridBlock([prefix, params])	This method supports forwarding with both Symbol and NDArray.
HybridLambda(function[, prefix])	With the help of this method we can wrap an operator or an expression as a HybridBlock object.
HybridSequential([prefix, params])	It stacks HybridBlocks sequentially.
InstanceNorm([axis, epsilon, center, scale, …])	This method applies instance normalisation to the n-D input array.

Implementation Examples

In the example below, we are going to use Block() which gives the base class for all neural network layers and models.

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

You will see the following output −

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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;

In the example below, we are going to use HybridBlock() that supports forwarding with both Symbol and 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

The output is mentioned below −

[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 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 provides a large number of build-in recurrent neural network (RNN) layers in gluon.rnn module. That is the reason, it is called the core module.

Methods and their parameters

Following are some of the important methods and their parameters covered by mxnet.gluon.nn core module:

Methods and its Parameters	Definition
BidirectionalCell(l_cell, r_cell[, …])	It is used for Bidirectional Recurrent Neural Network (RNN) cell.
DropoutCell(rate[, axes, prefix, params])	This method will apply dropout on the given input.
GRU(hidden_size[, num_layers, layout, …])	It applies a multi-layer gated recurrent unit (GRU) RNN to a given input sequence.
GRUCell(hidden_size[, …])	It is used for Gated Rectified Unit (GRU) network cell.
HybridRecurrentCell([prefix, params])	This method supports hybridize.
HybridSequentialRNNCell([prefix, params])	With the help of this method we can sequentially stack multiple HybridRNN cells.
LSTM(hidden_size[, num_layers, layout, …])0	It applies a multi-layer long short-term memory (LSTM) RNN to a given input sequence.
LSTMCell(hidden_size[, …])	It is used for Long-Short Term Memory (LSTM) network cell.
ModifierCell(base_cell)	It is the Base class for modifier cells.
RNN(hidden_size[, num_layers, activation, …])	It applies a multi-layer Elman RNN with tanh or ReLU non-linearity to a given input sequence.
RNNCell(hidden_size[, activation, …])	It is used for Elman RNN recurrent neural network cell.
RecurrentCell([prefix, params])	It represents the abstract base class for RNN cells.
SequentialRNNCell([prefix, params])	With the help of this method we can sequentially stack multiple RNN cells.
ZoneoutCell(base_cell[, zoneout_outputs, …])	This method applies Zoneout on the base cell.

Implementation Examples

In the example below, we are going to use GRU() which applies a multi-layer gated recurrent unit (GRU) RNN to a given input sequence.

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

This produces the following output −

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

This produces the following output −

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

In the example below we are going to use LSTM() which applies a long-short term memory (LSTM) RNN to a given input sequence.

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

The output is mentioned below −

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

When you run the code, you will see the following output −

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

Training Modules

The training modules in Gluon are as follows −

gluon.loss

In mxnet.gluon.loss module, Gluon provides pre-defined loss function. Basically, it has the losses for training neural network. That is the reason it is called the training module.

Methods and their parameters

Following are some of the important methods and their parameters covered by mxnet.gluon.loss training module:

Methods and its Parameters	Definition
Loss(weight, batch_axis, **kwargs)	This acts as the base class for loss.
L2Loss([weight, batch_axis])	It calculates the mean squared error (MSE) between label and prediction(pred).
L1Loss([weight, batch_axis])	It calculates the mean absolute error (MAE) between label and pred.
SigmoidBinaryCrossEntropyLoss([…])	This method is used for the cross-entropy loss for binary classification.
SigmoidBCELoss	This method is used for the cross-entropy loss for binary classification.
SoftmaxCrossEntropyLoss([axis, …])	It computes the softmax cross-entropy loss (CEL).
SoftmaxCELoss	It also computes the softmax cross entropy loss.
KLDivLoss([from_logits, axis, weight, …])	It is used for the Kullback-Leibler divergence loss.
CTCLoss([layout, label_layout, weight])	It is used for connectionist Temporal Classification Loss (TCL).
HuberLoss([rho, weight, batch_axis])	It calculates smoothed L1 loss. The smoothed L1 loss will be equal to L1 loss if absolute error exceeds rho but is equal to L2 loss otherwise.
HingeLoss([margin, weight, batch_axis])	This method calculates the hinge loss function often used in SVMs:
SquaredHingeLoss([margin, weight, batch_axis])	This method calculates the soft-margin loss function used in SVMs:
LogisticLoss([weight, batch_axis, label_format])	This method calculates the logistic loss.
TripletLoss([margin, weight, batch_axis])	This method calculates triplet loss given three input tensors and a positive margin.
PoissonNLLLoss([weight, from_logits, …])	The function calculates the Negative Log likelihood loss.
CosineEmbeddingLoss([weight, batch_axis, margin])	The function computes the cosine distance between the vectors.
SDMLLoss([smoothing_parameter, weight, …])	This method calculates Batchwise Smoothed Deep Metric Learning (SDML) Loss given two input tensors and a smoothing weight SDM Loss. It learns similarity between paired samples by using unpaired samples in the minibatch as potential negative examples.

Example

As we know that mxnet.gluon.loss.loss will calculate the MSE(Mean Squared Error) between label and prediction (pred). It is done with the help of following formula:

gluon.parameter

mxnet.gluon.parameter is a container that holds the parameters i.e. weights of the Blocks.

Methods and their parameters

Following are some of the important methods and their parameters covered by mxnet.gluon.parameter training module −

Methods and its Parameters	Definition
cast(dtype)	This method will cast data and gradient of this Parameter to a new data type.
data([ctx])	This method will return a copy of this parameter on one context.
grad([ctx])	This method will return a gradient buffer for this parameter on one context.
initialize([init, ctx, default_init, …])	This method will initialize parameter and gradient arrays.
list_ctx()	This method will return a list of contexts this parameter is initialized on.
list_data()	This method will return copies of this parameter on all contexts. It will be done in the same order as creation.
list_grad()	This method will return gradient buffers on all contexts. This will be done in the same order as values().
list_row_sparse_data(row_id)	This method will return copies of the ‘row_sparse’ parameter on all contexts. This will be done in the same order as creation.
reset_ctx(ctx)	This method will re-assign Parameter to other contexts.
row_sparse_data(row_id)	This method will return a copy of the ‘row_sparse’ parameter on the same context as row_id’s.
set_data(data)	This method will set this parameter’s value on all contexts.
var()	This method will return a symbol representing this parameter.
zero_grad()	This method will set the gradient buffer on all contexts to 0.

Implementation Example

In the example below, we will initialize parameters and the gradients arrays by using initialize() method as follows −

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

Output

The output is mentioned below −

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

Example

weight.grad()

Output

The output is given below −

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

Example

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

Output

You will see the following output −

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

Example

weight.data(mx.gpu(1))

Output

When you execute the above code, you should see the following output −

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

gluon.trainer

mxnet.gluon.trainer applies an Optimizer on a set of parameters. It should be used together with autograd.

Methods and their parameters

Following are some of the important methods and their parameters covered by mxnet.gluon.trainer training module −

Methods and its Parameters	Definition
allreduce_grads()	This method will reduce the gradients from different contexts for each parameter (weight).
load_states(fname)	As name implies, this method will load trainer states.
save_states(fname)	As name implies, this method will save trainer states.
set_learning_rate(lr)	This method will set a new learning rate of the optimizer.
step(batch_size[, ignore_stale_grad])	This method will make one step of parameter update. It should be called after autograd.backward() and outside of record() scope.
update(batch_size[, ignore_stale_grad])	This method will also make one step of parameter update. It should be called after autograd.backward() and outside of record() scope and after trainer.update().

Data Modules

The data modules of Gluon are explained below −

gluon.data

Gluon provides a large number of build-in dataset utilities in gluon.data module. That is the reason it is called the data module.

Classes and their parameters

Following are some of the important methods and their parameters covered by mxnet.gluon.data core module. These methods are typically related to Datasets, Sampling, and DataLoader.

Dataset

Methods and its Parameters	Definition
ArrayDataset(*args)	This method represents a dataset which combines two or more than two dataset-like objects. For example, Datasets, lists, arrays, etc.
BatchSampler(sampler, batch_size[, last_batch])	This method wraps over another Sampler. Once wrapped it returns the mini batches of samples.
DataLoader(dataset[, batch_size, shuffle, …])	Similar to BatchSampler but this method loads data from a dataset. Once loaded it returns the mini batches of data.
This represents the abstract dataset class.
FilterSampler(fn, dataset)	This method represents the samples elements from a Dataset for which fn (function) returns True.
RandomSampler(length)	This method represents samples elements from [0, length) randomly without replacement.
RecordFileDataset(filename)	It represents a dataset wrapping over a RecordIO file. The extension of the file is .rec.
Sampler	This is the base class for samplers.
SequentialSampler(length[, start])	It represents the sample elements from the set [start, start+length) sequentially.
It represents the sample elements from the set [start, start+length) sequentially.	This represents the simple Dataset wrapper especially for lists and arrays.

Uygulama Örnekleri

Aşağıdaki örnekte kullanacağız gluon.data.BatchSampler()Başka bir örnekleyiciyi saran API. Mini örnek gruplarını döndürür.

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

Çıktı aşağıda belirtilmiştir -

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

gluon.data.vision.datasets

Gluon, çok sayıda önceden tanımlanmış görüntü veri kümesi işlevi sağlar gluon.data.vision.datasets modül.

Sınıflar ve parametreleri

MXNet bize sınıfları ve parametreleri aşağıda verilen yararlı ve önemli veri kümeleri sağlar -

Sınıflar ve Parametreleri	Tanım
MNIST ([kök, tren, dönüşüm])	Bu bize elle yazılmış rakamları sağlayan kullanışlı bir veri setidir. MNIST veri kümesinin url'si http://yann.lecun.com/exdb/mnist şeklindedir.
FashionMNIST ([kök, tren, dönüşüm])	Bu veri seti, Zalando'nun moda ürünlerinden oluşan makale resimlerinden oluşur. Orijinal MNIST veri kümesinin yerine geçmesidir. Bu veri setini https://github.com/zalandoresearch/fashion-mnist adresinden edinebilirsiniz.
CIFAR10 ([kök, tren, dönüşüm])	Bu, https://www.cs.toronto.edu/~kriz/cifar.html adresinden alınan bir görüntü sınıflandırma veri kümesidir. Bu veri setinde her örnek, şekilli bir görüntüdür (32, 32, 3).
CIFAR100 ([kök, ince_etiket, eğit, dönüşüm])	Bu, https://www.cs.toronto.edu/~kriz/cifar.html adresinden alınan CIFAR100 görüntü sınıflandırma veri kümesidir. Ayrıca her bir örneği bir şekle sahip bir görüntüye sahiptir (32, 32, 3).
ImageRecordDataset (dosya adı [, bayrak, dönüşüm])	Bu veri kümesi, görüntüleri içeren bir RecordIO dosyası üzerine sarılıyor. Bunda her bir örnek, karşılık gelen etiketiyle birlikte bir görüntüdür.
ImageFolderDataset (kök [, bayrak, dönüşüm])	Bu, bir klasör yapısında depolanan görüntü dosyalarını yüklemek için bir veri kümesidir.
ImageListDataset ([kök, imglist, işaret])	Bu, bir giriş listesi ile belirtilen görüntü dosyalarını yüklemek için bir veri kümesidir.

Misal

Aşağıdaki örnekte, bir giriş listesi tarafından belirtilen resim dosyalarını yüklemek için kullanılan ImageListDataset () kullanımını göstereceğiz -

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

Yardımcı Modüller

Gluon'daki yardımcı program modülleri aşağıdaki gibidir -

gluon.utils

Gluon, gluon.utils modülünde çok sayıda yerleşik paralelleştirme yardımcı programı iyileştirici sağlar. Eğitim için çeşitli araçlar sağlar. Yardımcı modül olarak adlandırılmasının nedeni budur.

Fonksiyonlar ve parametreleri

Aşağıda adı verilen bu yardımcı program modülünde bulunan işlevler ve parametreleri yer almaktadır. gluon.utils −

Fonksiyonlar ve Parametreleri	Tanım
bölünmüş_veriler (veriler, dilim_sayısı [, batch_axis,…])	Bu işlev genellikle veri paralelliği için kullanılır ve her dilim bir cihaza, yani GPU'ya gönderilir. Bir NDArray'inum_slice boyunca dilimler batch_axis.
split_and_load (veri, ctx_list [, batch_axis,…])	Bu işlev bir NDArray öğesini len(ctx_list) boyunca dilimler batch_axis. Yukarıdaki split_data () işlevinden tek farkı, her dilimi aynı zamanda bir içeriğe de yüklemesidir. ctx_list.
clip_global_norm (diziler, maks_norm [,…])	Bu işlevin görevi, NDArray'leri, 2-normlarının toplamı daha küçük olacak şekilde yeniden ölçeklendirmektir. max_norm.
check_sha1 (dosya adı, sha1_hash)	Bu fonksiyon, dosya içeriğinin sha1 hash değerinin beklenen hash ile eşleşip eşleşmediğini kontrol edecektir.
indir (url [, yol, üzerine yaz, sha1_hash,…])	Adın da belirttiği gibi, bu işlev belirli bir URL'yi indirecektir.
replace_file (src, dst)	Bu işlev atomik os.replace. Linux ve OSX ile yapılacaktır.

Bu bölüm, MXNet'teki otomatik yükseltme ve başlatıcı API ile ilgilidir.

mxnet.autograd

Bu, MXNet'in NDArray için otomatik yükseltme API'sidir. Aşağıdaki sınıfa sahiptir -

Sınıf: İşlev ()

Autograd'da özelleştirilmiş farklılaştırma için kullanılır. Olarak yazılabilirmxnet.autograd.Function. Herhangi bir nedenle, kullanıcı varsayılan zincir kuralı tarafından hesaplanan degradeleri kullanmak istemezse, hesaplama için farklılaşmayı özelleştirmek için mxnet.autograd İşlev sınıfını kullanabilir. Forward () ve Backward () olmak üzere iki yöntemi vardır.

Aşağıdaki noktaların yardımıyla bu sınıfın işleyişini anlayalım:

• Öncelikle ileri yöntemde hesaplamamızı tanımlamamız gerekir.

• Ardından, geriye dönük yöntemde özelleştirilmiş farklılaşmayı sağlamamız gerekir.

• Artık gradyan hesaplaması sırasında, kullanıcı tanımlı geriye dönük işlev yerine, mxnet.autograd, kullanıcı tarafından tanımlanan geri işlevini kullanacaktır. Ayrıca ileri ve geri bazı işlemler için numpy dizisine ve geri dönüş yapabiliriz.

Example

Mxnet.autograd.function sınıfını kullanmadan önce, aşağıdaki gibi ileri ve geri yöntemlerle kararlı bir sigmoid işlevi tanımlayalım -

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)

Şimdi, fonksiyon sınıfı aşağıdaki gibi kullanılabilir -

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

Kodu çalıştırdığınızda, aşağıdaki çıktıyı göreceksiniz -

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

Yöntemler ve parametreleri

Mxnet.autogard.function sınıfının yöntemleri ve parametreleri aşağıdadır -

Yöntemler ve Parametreleri	Tanım
ileri (kafalar [, head_grads, keep_graph,…])	Bu yöntem ileri hesaplama için kullanılır.
geriye (kafalar [, head_grads, keep_graph,…])	Bu yöntem, geriye dönük hesaplama için kullanılır. Önceden işaretlenmiş değişkenlere göre kafaların gradyanlarını hesaplar. Bu yöntem, forward'ın çıktısı kadar çok girdi alır. Ayrıca ileriye doğru girişler kadar çok sayıda NDArray döndürür.
get_symbol (x)	Bu yöntem, kaydedilen hesaplama geçmişini geri almak için kullanılır. Symbol.
grad (kafalar, değişkenler [, head_grads,…])	Bu yöntem, değişkenlere göre kafa gradyanlarını hesaplar. Degradeler hesaplandıktan sonra, variable.grad içinde depolanmak yerine, yeni NDArray'ler olarak döndürülür.
is_recording ()	Bu yöntemin yardımıyla kaydetme ve kaydetmeme durumlarını alabiliriz.
is_training ()	Bu yöntemin yardımıyla eğitim ve tahmin konusunda durum alabiliriz.
mark_variables (değişkenler, gradyanlar [, grad_reqs])	Bu yöntem, otomatik sınıflandırma için gradyan hesaplamak için NDArray'leri değişkenler olarak işaretleyecektir. Bu yöntem, bir değişkendeki .attach_grad () işleviyle aynıdır, ancak tek fark, bu çağrı ile gradyanı herhangi bir değere ayarlayabilmemizdir.
duraklat ([tren_modu])	Bu yöntem, hesaplanacak degradelere ihtiyaç duymayan kodlar için 'with' ifadesinde kullanılacak bir kapsam bağlamı döndürür.
tahmin_modu ()	Bu yöntem, ileri geçiş davranışının çıkarım moduna ayarlandığı ve kayıt durumlarını değiştirmeden 'with' ifadesinde kullanılacak bir kapsam bağlamı döndürür.
kayıt ([tren_modu])	Bir dönecek autograd 'with' ifadesinde kullanılacak kapsam bağlamını kaydeder ve degradelerin hesaplanması gereken kodu yakalar.
set_recording (is_recording)	İs_recoring () 'e benzer şekilde, bu yöntemin yardımıyla kaydetme ve kaydetmeme durumlarını alabiliriz.
set_training (is_training)	İs_traininig () 'ye benzer şekilde, bu yöntemin yardımıyla durumu eğitim veya tahmin olarak ayarlayabiliriz.
train_mode ()	Bu yöntem, ileri geçiş davranışının eğitim moduna ayarlandığı ve kayıt durumlarını değiştirmeden 'with' ifadesinde kullanılacak bir kapsam içeriği döndürecektir.

Uygulama Örneği

Aşağıdaki örnekte, değişkenlere göre kafa gradyanını hesaplamak için mxnet.autograd.grad () yöntemini kullanacağız -

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

Çıktı aşağıda belirtilmiştir -

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

'With' ifadesinde kullanılacak bir kapsam döndürmek için mxnet.autograd.predict_mode () yöntemini kullanabiliriz -

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

mxnet.intializer

Bu, tartı başlatıcı için MXNet'in API'sidir. Aşağıdaki sınıflara sahiptir -

Sınıflar ve parametreleri

Aşağıdaki yöntemler ve parametreleri mxnet.autogard.function sınıf:

Sınıflar ve Parametreleri	Tanım
Çift Doğrusal ()	Bu sınıfın yardımıyla, yukarı örnekleme katmanları için ağırlığı başlatabiliriz.
Sabit değer)	Bu sınıf, ağırlıkları belirli bir değerde başlatır. Değer, skaler olabileceği gibi ayarlanacak parametrenin şekline uyan NDArray olabilir.
FusedRNN (init, num_hidden, num_layers, mod)	Adından da anlaşılacağı gibi, bu sınıf, kaynaşmış Tekrarlayan Sinir Ağı (RNN) katmanları için parametreleri başlatır.
InitDesc	Başlatma modeli için tanımlayıcı görevi görür.
Başlatıcı (** kwargs)	Bu, bir başlatıcının temel sınıfıdır.
LSTMBias ([Forgot_bias])	Bu sınıf, bir LSTMCell'in tüm önyargılarını 0.0'a başlatır, ancak önyargısı özel bir değere ayarlanan unutma geçidi hariç.
Yükle (param [, default_init, ayrıntılı])	Bu sınıf, dosya veya sözlükten veri yükleyerek değişkenleri başlatır.
MSRAPrelu ([faktör_türü, eğim])	Adından da anlaşılacağı gibi, bu sınıf ağırlığı bir MSRA belgesine göre başlatın.
Karışık (desenler, başlatıcılar)	Birden çok başlatıcı kullanarak parametreleri başlatır.
Normal ([sigma])	Normal () sınıfı, ortalama sıfır ve standart sapma (SD) ile normal bir dağılımdan örneklenen rastgele değerlerle ağırlıkları başlatır. sigma.
Bir()	Parametrenin ağırlıklarını bire ilklendirir.
Ortogonal ([ölçek, rand_türü])	Adından da anlaşılacağı gibi, bu sınıf, ağırlığı ortogonal matris olarak başlatır.
Tek tip ([ölçek])	Ağırlıkları, belirli bir aralıktan homojen bir şekilde örneklenen rastgele değerlerle başlatır.
Xavier ([rnd_type, faktör_type, büyüklük])	Aslında ağırlıklar için "Xavier" başlatmayı gerçekleştiren bir başlatıcı döndürür.
Sıfır()	Parametrenin ağırlıklarını sıfır olarak başlatır.

Uygulama Örneği

Aşağıdaki örnekte, mxnet.init.Normal () sınıfını bir başlatıcı oluşturup parametrelerini alacağız -

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

Output

Çıktı aşağıda verilmiştir -

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

Example

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

Output

Çıktı aşağıda gösterilmiştir -

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

Aşağıdaki örnekte, birden çok başlatıcı kullanarak parametreleri başlatmak için mxnet.initializer.Mixed () sınıfını kullanacağız -

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

Çıktı aşağıda gösterilmiştir -

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

Bu bölümde, MXNet'te Symbol olarak adlandırılan bir arayüz hakkında bilgi edineceğiz.

Mxnet.ndarray

Apache MXNet'in Symbol API'si, sembolik programlama için bir arayüzdür. Symbol API, aşağıdakilerin kullanımına sahiptir -

• Hesaplamalı grafikler

• Azaltılmış bellek kullanımı

• Kullanım öncesi fonksiyon optimizasyonu

Aşağıda verilen örnek, MXNet'in Symbol API'sini kullanarak nasıl basit bir ifade oluşturulabileceğini göstermektedir -

Normal bir Python listesinden 1-D ve 2-D 'dizi' kullanan bir NDArray -

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

Aşağıdaki çıktıyı göreceksiniz -

<Symbol _plus0>

Example

(x, y, z)

Output

Çıktı aşağıda verilmiştir -

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

Şimdi MXNet'in ndarray API'sinin sınıfları, işlevleri ve parametreleri hakkında ayrıntılı olarak tartışalım.

Sınıflar

Aşağıdaki tablo, MXNet'in Symbol API sınıflarını içerir -

Sınıf	Tanım
Sembol (tutamaç)	Bu sınıf, yani sembol, Apache MXNet'in sembolik grafiğidir.

Fonksiyonlar ve parametreleri

Aşağıda, mxnet.Symbol API tarafından kapsanan bazı önemli işlevler ve parametreleri verilmiştir -

Fonksiyon ve Parametreleri	Tanım
Etkinleştirme ([veri, hareket_türü, çıkış, ad])	Girişe eleman olarak bir aktivasyon fonksiyonu uygular. Desteklerrelu, sigmoid, tanh, softrelu, softsign aktivasyon fonksiyonları.
BatchNorm ([veri, gama, beta, hareketli_ortalama,…])	Toplu normalleştirme için kullanılır. Bu işlev, bir veri grubunu ortalama ve varyansa göre normalleştirir. Bir ölçek uygulargamma ve ofset beta.
BilinearSampler ([veri, ızgara, cudnn_off,…])	Bu işlev, giriş özelliği haritasına çift doğrusal örnekleme uygular. Aslında “Mekansal Trafo Ağları” nın anahtarıdır. OpenCV'de yeniden eşleme işlevine aşina iseniz, bu işlevin kullanımı buna oldukça benzer. Tek fark, geriye doğru geçişe sahip olmasıdır.
BlockGrad ([veri, çıkış, ad])	Adından da anlaşılacağı gibi, bu işlev gradyan hesaplamasını durdurur. Temel olarak, girdilerin birikmiş gradyanının bu operatörden geriye doğru akmasını durdurur.
cast ([data, dtype, out, name])	Bu işlev, girdinin tüm öğelerini yeni bir türe dönüştürecektir.
Bu işlev, girdinin tüm öğelerini yeni bir türe dönüştürecektir.	Bu işlev, adı belirtildiği gibi, verilen şekil ve türde sıfırlarla dolu yeni bir simge döndürür.
olanlar (şekil [, dtype])	Bu işlev, adı belirtildiği gibi, verilen şekil ve türde olanlarla dolu yeni bir sembol döndürür.
dolu (şekil, değer [, dtype])	Bu işlev, ad belirtildiği gibi, verilen değerle doldurulmuş, belirli bir şekil ve türde yeni bir dizi döndürür. val.
arange (başlat [, durdur, adım, tekrarla,…])	Belirli bir aralık içinde eşit aralıklı değerleri döndürür. Değerler, yarı açık aralık [başlatma, durdurma) içinde oluşturulur, bu da aralığın aşağıdakileri içerdiği anlamına gelir:start ama hariç tutar stop.
boşluk (başlangıç, bitiş, sayı [, bitiş noktası, ad,…])	Belirli bir aralıkta eşit aralıklı sayılar döndürür. Düzen () işlevine benzer şekilde, değerler yarı açık aralık [başlat, durdur) içinde oluşturulur, bu da aralığın aşağıdakileri içerdiği anlamına gelir:start ama hariç tutar stop.
histogram (a [, bölmeler, aralık])	Adından da anlaşılacağı gibi, bu fonksiyon giriş verilerinin histogramını hesaplayacaktır.
güç (taban, exp)	Adından da anlaşılacağı gibi, bu işlev, öğenin öğe bazında sonucunu döndürür: base eleman güçlerine yükseltildi expöğesi. Her iki giriş, yani taban ve exp, Sembol veya skaler olabilir. Burada yayına izin verilmediğini unutmayın. Kullanabilirsinizbroadcast_pow yayın özelliğini kullanmak istiyorsanız.
SoftmaxActivation ([veri, mod, ad, öznitelik, çıkış])	Bu işlev, girişe softmax etkinleştirmesini uygular. İç katmanlar için tasarlanmıştır. Aslında kullanımdan kaldırıldı, kullanabilirizsoftmax() yerine.

Uygulama Örnekleri

Aşağıdaki örnekte işlevi kullanacağız power() exp elemanından güçlere yükseltilen temel elemanın eleman bazlı sonucunu döndürecektir:

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

Output

Aşağıdaki çıktıyı göreceksiniz -

243

Example

x = mx.sym.Variable('x')
y = mx.sym.Variable('y')
z = mx.sym.power(x, 3)
z.eval(x=mx.nd.array([1,2]))[0].asnumpy()

Output

Bu, aşağıdaki çıktıyı üretir -

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

Example

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

Output

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Çıktı aşağıda belirtilmiştir -

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

Aşağıda verilen örnekte, fonksiyonu kullanacağız SoftmaxActivation() (or softmax()) girdiye uygulanacak ve iç katmanlara yöneliktir.

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

Aşağıdaki çıktıyı göreceksiniz -

[[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, symbol.contrib paketinde tanımlanmıştır. Genellikle yeni özellikler için birçok yararlı deneysel API sağlar. Bu API, topluluk için yeni özellikleri deneyebilecekleri bir yer olarak çalışır. Özelliğe katkıda bulunan kişi de geri bildirimi alacaktır.

Fonksiyonlar ve parametreleri

Aşağıda, bazı önemli işlevler ve bunların kapsadığı parametreler yer almaktadır. mxnet.symbol.contrib API -

Fonksiyon ve Parametreleri	Tanım
rand_zipfian (true_classes, num_sampled;…)	Bu işlev, yaklaşık bir Zipfian dağılımından rastgele örnekler alır. Bu işlevin temel dağılımı Zipfian dağılımıdır. Bu işlev rastgele olarak num_sampled adayları örneklemektedir ve örneklenen_candidates'in elemanları yukarıda verilen temel dağılımdan çekilmektedir.
foreach (gövde, veri, init_states)	Adından da anlaşılacağı gibi, bu işlev 0 boyutunda NDArrays üzerinden kullanıcı tanımlı hesaplama ile bir döngü çalıştırır. Bu işlev bir for döngüsünü simüle eder ve body, for döngüsünün bir yinelemesi için hesaplamaya sahiptir.
while_loop (koşul, işlev, döngü_vars [,…])	Adından da anlaşılacağı gibi, bu işlev kullanıcı tanımlı hesaplama ve döngü koşuluyla bir while döngüsü çalıştırır. Bu işlev, koşul yerine getirilirse tam anlamıyla özelleştirilmiş hesaplama yapan bir while döngüsünü simüle eder.
koşul (ön, sonra_fonksiyon, başka_fonksiyon)	Adından da anlaşılacağı gibi, bu işlev kullanıcı tanımlı koşulu ve hesaplamayı kullanarak eğer-ise-değilse çalıştırır. Bu işlev, belirtilen koşula göre iki özelleştirilmiş hesaplamadan birini yapmayı seçen, benzer bir dalı simüle eder.
getnnz ([veri, eksen, çıkış, ad])	Bu işlev bize bir seyrek tensör için saklanan değerlerin sayısını verir. Aynı zamanda açık sıfırlar da içerir. Yalnızca CPU'da CSR matrisini destekler.
yeniden hesaplama ([veriler, min_aralık, maks_aralık,…])	Bu işlev, int32 ve karşılık gelen eşiklerde nicelenen belirli verileri, çalışma zamanında veya kalibrasyondan hesaplanan minimum ve maksimum eşikleri kullanarak int8'e yeniden hesaplar.
index_copy ([eski_tensör, dizin_vektörü,…])	Bu işlev, bir 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 ([sorgular,…])	Bu operatör, kodlayıcı-kod çözücü olarak çok başlı dikkat kullanımında sorguların ve anahtarların projeksiyonları arasındaki matris çarpımını hesaplar. Koşul, girdilerin düzeni izleyen sorgu projeksiyonlarının bir tensörü olmasıdır: (seq_length, batch_size, num_heads *, head_dim).

Uygulama Örnekleri

Aşağıdaki örnekte, yaklaşık bir Zipfian dağılımından rastgele örnekler çizmek için rand_zipfian işlevini kullanacağız -

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

Aşağıdaki çıktıyı göreceksiniz -

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

Example

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

Output

Çıktı aşağıda belirtilmiştir -

array([0.57336551])

Example

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

Output

Aşağıdaki çıktıyı göreceksiniz -

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

Aşağıdaki örnekte işlevi kullanacağız while_loop kullanıcı tanımlı hesaplama ve döngü koşulu için bir while döngüsü çalıştırmak için -

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

Çıktı aşağıda verilmiştir:

[<Symbol _while_loop0>]

Example

Print(States)

Output

Bu, aşağıdaki çıktıyı üretir -

[<Symbol _while_loop0>, <Symbol _while_loop0>]

Aşağıdaki örnekte işlevi kullanacağız index_copy new_tensor öğelerini old_tensor'a kopyalar.

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

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Symbol.image

Image Symbol API, symbol.image paketinde tanımlanır. Adından da anlaşılacağı gibi, genellikle görüntüler ve özellikleri için kullanılır.

Fonksiyonlar ve parametreleri

Aşağıda, bazı önemli işlevler ve bunların kapsadığı parametreler yer almaktadır. mxnet.symbol.image API -

Fonksiyon ve Parametreleri	Tanım
Adjust_lighting ([veri, alfa, çıkış, ad])	Adından da anlaşılacağı gibi, bu işlev, girişin aydınlatma seviyesini ayarlar. AlexNet tarzını takip eder.
kırpma ([veri, x, y, genişlik, yükseklik, dışarı, ad])	Bu işlevin yardımıyla, bir görüntü NDArray (Y x G x C) veya (N x Y x G x C) kullanıcı tarafından verilen boyuta göre kırpılabilir.
normalize ([veri, ortalama, std, çıkış, ad])	Bir şekil tensörünü (C x Y x G) veya (N x C x Y x G) ile normalize edecektir. mean ve standard deviation(SD).
random_crop ([veri, xrange, yrange, genişlik,…])	Crop () 'ya benzer şekilde, kullanıcı tarafından verilen boyuta göre bir görüntü NDArray (Y x G x C) veya (N x Y x G x C) rasgele kırpılır. Sonucu, eğersrc daha küçük size.
random_lighting([veri, alfa_std, çıkış, ad])	Adından da anlaşılacağı gibi, bu işlev PCA sesini rasgele ekler. Aynı zamanda AlexNet tarzını da takip eder.
random_resized_crop ([veriler, xrange, yrange,…])	Ayrıca, belirli bir boyuta göre rastgele bir NDArray şekil (Y x G x C) veya (N x Y x G x C) resmi kırpar. Src boyutundan küçükse, sonucu daha yüksek örnekleyecektir. Alanı ve en boy oranını da rastgele hale getirecektir.
yeniden boyutlandırma ([veri, boyut, tutma_ oranı, ara değer,…])	Adından da anlaşılacağı gibi, bu işlev bir görüntü NDArray (Y x G x C) veya (N x Y x G x C) kullanıcı tarafından verilen boyuta yeniden boyutlandıracaktır.
to_tensor ([veri, çıkış, ad])	[0, 255] aralığındaki değerlere sahip bir görüntü NDArray şekil dizisini (Y x G x C) veya (N x Y x G x C) bir tensör ND şekil dizisine (C x Y x G) veya ( N x C x H x W) [0, 1] aralığındaki değerlerle.

Uygulama Örnekleri

Aşağıdaki örnekte, [0, 255] aralığındaki değerlere sahip görüntü NDŞekil dizisini (Y x G x D) veya (N x Y x G x D) tensör NDArray'e dönüştürmek için to_tensor işlevini kullanacağız. şekil (C x Y x G) veya (N x C x Y x G) [0, 1] aralığındaki değerlerle.

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

Çıktı aşağıda belirtilmiştir -

<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

Çıktı aşağıda belirtilmiştir:

<Symbol to_tensor5>

Aşağıdaki örnekte, bir şekil tensörünü (C x Y x G) veya (N x C x Y x G) normalize etmek için normalize () işlevini kullanacağız. mean ve 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

Aşağıda verilen kodun çıktısıdır -

<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

Çıktı aşağıda gösterilmiştir -

<Symbol normalize1>

Symbol.random

Random Symbol API, symbol.random paketinde tanımlanmıştır. Adından da anlaşılacağı gibi, MXNet'in rastgele dağıtım üreticisi Symbol API'sidir.

Fonksiyonlar ve parametreleri

Aşağıda, bazı önemli işlevler ve bunların kapsadığı parametreler yer almaktadır. mxnet.symbol.random API -

Fonksiyon ve Parametreleri	Tanım
tekdüze ([düşük, yüksek, şekil, dtype, ctx, dışarı])	Düzgün bir dağılımdan rastgele örnekler üretir.
normal ([loc, scale, shape, dtype, ctx, out])	Normal (Gauss) bir dağılımdan rastgele örnekler üretir.
randn (* şekil, ** kwargs)	Normal (Gauss) bir dağılımdan rastgele örnekler üretir.
poisson ([lam, şekil, dtype, ctx, dışarı])	Poisson dağılımından rastgele örnekler üretir.
üstel ([ölçek, şekil, dtype, ctx, dışarı])	Üstel bir dağılımdan örnekler üretir.
gama ([alfa, beta, şekil, dtype, ctx, çıkış])	Bir gama dağılımından rastgele örnekler üretir.
multinomial (veri [, şekil, get_prob, çıkış, dtype])	Birden çok çok terimli dağılımdan eşzamanlı örnekleme üretir.
negatif_binom ([k, p, şekil, dtype, ctx, dışarı])	Negatif bir binom dağılımından rastgele örnekler oluşturur.
generalized_negative_binomial ([mu, alfa;…])	Genelleştirilmiş bir negatif binom dağılımından rastgele örnekler üretir.
karıştır (veri, ** kwargs)	Öğeleri rastgele karıştırır.
randint (düşük, yüksek [, şekil, dtype, ctx, dışarı])	Ayrık tekdüze bir dağılımdan rastgele örnekler üretir.
üssel_like ([veriler, lam, çıkış, ad])	Giriş dizisi şekline göre üstel bir dağılımdan rastgele örnekler üretir.
gamma_like ([veri, alfa, beta, çıkış, ad])	Girdi dizisi şekline göre bir gama dağılımından rastgele örnekler üretir.
generalized_negative_binomial_like ([veriler;…])	Girdi dizisi şekline göre genelleştirilmiş bir negatif binom dağılımından rastgele örnekler üretir.
negatif_binom_like ([veri, k, p, çıkış, ad])	Girdi dizisi şekline göre negatif bir binom dağılımından rastgele örnekler üretir.
normal_like ([veri, konum, ölçekleme, çıkış, ad])	Giriş dizisi şekline göre normal (Gauss) bir dağılımdan rastgele örnekler üretir.
poisson_like ([veriler, lam, çıkış, ad])	Giriş dizisi şekline göre bir Poisson dağılımından rastgele örnekler üretir.
uniform_like ([veri, düşük, yüksek, çıkış, ad])	Girdi dizisi şekline göre tek tip bir dağılımdan rastgele örnekler üretir.

Uygulama Örnekleri

Aşağıdaki örnekte, shuffle () işlevini kullanarak öğeleri rastgele karıştıracağız. Diziyi ilk eksen boyunca karıştıracaktır.

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

Aşağıdaki çıktıyı göreceksiniz:

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

Example

y.eval(x=data)

Output

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Aşağıdaki örnekte, genelleştirilmiş bir negatif iki terimli dağılımdan rastgele örnekler alacağız. Bunun için işlevi kullanacakgeneralized_negative_binomial().

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

Output

Çıktı aşağıda verilmiştir -

<Symbol _random_generalized_negative_binomial0>

Symbol.sparse

Sparse Symbol API, mxnet.symbol.sparse paketinde tanımlanmıştır. Adından da anlaşılacağı gibi, seyrek sinir ağı grafikleri ve CPU üzerinde otomatik farklılaşma sağlar.

Fonksiyonlar ve parametreleri

Aşağıda, önemli fonksiyonlardan bazıları (Sembol oluşturma rutinleri, Sembol Manipülasyon rutinleri, Matematiksel fonksiyonlar, Trigonometrik fonksiyon, Hyberbolik fonksiyonlar, Azaltma fonksiyonları, Yuvarlama, Yetkiler, Sinir Ağı) ve bunların parametreleri yer almaktadır. mxnet.symbol.sparse API -

Fonksiyon ve Parametreleri	Tanım
ElementWiseSum (* args, ** kwargs)	Bu fonksiyon tüm girdi argümanlarını akıllıca ekleyecektir. Örneğin, _ (1,2,… = 1 + 2 + ⋯ +). Burada, add_n'in, add'yi n kez çağırmaktan potansiyel olarak daha verimli olduğunu görebiliriz.
Gömme ([veri, ağırlık, girdi_dim,…])	Tamsayı endekslerini vektör temsilleriyle yani düğünlerle eşleştirecektir. Aslında kelimeleri, kelime düğünleri olarak adlandırılan yüksek boyutlu uzayda gerçek değerli vektörlere eşler.
LinearRegressionOutput ([veri, etiket,…])	Geriye doğru yayılma sırasında kayıp karesi için hesaplar ve optimize eder, ileriye doğru yayılma sırasında sadece çıktı verisi verir.
LogisticRegressionOutput ([veri, etiket,…])	Girişe sigmoid işlevi de denen bir lojistik işlevi uygular. Fonksiyon 1/1 + exp (−x) olarak hesaplanır.
MAERegressionOutput ([veri, etiket,…])	Bu operatör, girdinin ortalama mutlak hatasını hesaplar. MAE, aslında mutlak hatanın beklenen değerine karşılık gelen bir risk metriğidir.
abs ([veriler, ad, öznitelik, çıkış])	Adından da anlaşılacağı gibi, bu işlev girdinin eleman bazında mutlak değerini döndürecektir.
adagrad_update ([ağırlık, grad, geçmiş, lr,…])	İçin bir güncelleme işlevidir AdaGrad optimizer.
adam_update ([ağırlık, derece, ortalama, var, lr,…])	İçin bir güncelleme işlevidir Adam optimizer.
add_n (* değiştirgeler, ** kwargs)	Adından da anlaşılacağı gibi, tüm girdi argümanlarını eleman bazında ekleyecektir.
arccos ([veriler, ad, öznitelik, çıkış])	Bu işlev, girdi dizisinin eleman bazında ters kosinüsünü döndürür.
nokta ([lhs, rhs, devrik_a, devrik_b,…])	Adından da anlaşılacağı gibi, iki dizinin iç çarpımını verecektir. Girdi dizisi boyutuna bağlı olacaktır: 1-D: vektörlerin iç çarpımı 2-D: matris çarpımı ND: İlk girdinin son ekseni ve ikinci girdinin ilk ekseni üzerindeki toplam çarpım.
elemwise_add ([lhs, rhs, ad, öznitelik, çıkış])	Adından da anlaşılacağı gibi add argümanlar öğesi bilge.
elemwise_div ([lhs, rhs, name, attr, out])	Adından da anlaşılacağı gibi divide argümanlar öğesi bilge.
elemwise_mul ([lhs, rhs, ad, öznitelik, çıkış])	Adından da anlaşılacağı gibi Multiply argümanlar öğesi bilge.
elemwise_sub ([lhs, rhs, ad, öznitelik, çıkış])	Adından da anlaşılacağı gibi, bağımsız değişkenleri akıllıca çıkaracaktır.
exp ([veri, ad, attr, dışarı])	Bu fonksiyon, verilen girdinin eleman bazında üstel değerini döndürecektir.
sgd_update ([ağırlık, derece, lr, wd,…])	Stokastik Gradyan İniş iyileştirici için bir güncelleme işlevi olarak işlev görür.
sigmoid ([veri, ad, öznitelik, çıkış])	Adından da anlaşılacağı gibi hesaplayacak sigmoid x öğesinin bilge.
işaret ([veri, ad, öznitelik, çıkış])	Verilen girdinin eleman bilge işaretini döndürecektir.
günah ([veri, ad, öznitelik, çıkış])	Adından da anlaşılacağı gibi, bu işlev verilen girdi dizisinin eleman bilge sinüsünü hesaplayacaktır.

Uygulama Örneği

Aşağıdaki örnekte, kullanarak öğeleri rastgele karıştıracağız. ElementWiseSum()işlevi. Tamsayı endekslerini vektör temsilleriyle, yani kelime düğünleriyle eşler.

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

Apache MXNet'in modül API'si bir FeedForward modeli gibidir ve Torch modülüne benzer şekilde oluşturmak daha kolaydır. Aşağıdaki sınıflardan oluşur -

BaseModule ([günlükçü])

Bir modülün temel sınıfını temsil eder. Bir modül, hesaplama bileşeni veya hesaplama makinesi olarak düşünülebilir. Bir modülün görevi, ileri ve geri geçişleri gerçekleştirmektir. Ayrıca bir modeldeki parametreleri de günceller.

Yöntemler

Aşağıdaki tablo aşağıdakilerden oluşan yöntemleri göstermektedir: BaseModule class-

Bu yöntem, tüm cihazlardan durumları alacak

Yöntemler	Tanım
geri ([out_grads])	Adından da anlaşılacağı gibi bu yöntem, backward hesaplama.
bağla (veri_şekilleri [, etiket_şekilleri,…])	Yürütücüler oluşturmak için sembolleri bağlar ve modül ile hesaplama yapmadan önce gereklidir.
sığdır (tren_verisi [, eval_data, eval_metric,…])	Bu yöntem, modül parametrelerini eğitir.
ileri (data_batch [, is_train])	Adından da anlaşılacağı gibi, bu yöntem İleri hesaplamayı uygular. Bu yöntem, farklı toplu iş boyutları veya farklı görüntü boyutları gibi çeşitli şekillere sahip veri toplu işlerini destekler.
ileri_geri (data_batch)	Adından da anlaşılacağı gibi, hem ileri hem de geri çağıran kullanışlı bir işlevdir.
get_input_grads ([merge_multi_context])	Bu yöntem, önceki geriye dönük hesaplamada hesaplanan girdilere gradyanları alacaktır.
get_outputs ([merge_multi_context])	Adından da anlaşılacağı gibi, bu yöntem önceki ileri hesaplamanın çıktılarını alacaktır.
get_params ()	Cihazda hesaplama yapmak için kullanılan gerçek parametrelerin potansiyel olarak kopyaları olan parametreleri alır.
get_states ([merge_multi_context])
init_optimizer ([kvstore, optimize edici,…])	Bu yöntem, optimize edicileri kurar ve başlatır. Ayrıca başlatırkvstore eğitim dağıtmak için.
init_params ([başlatıcı, arg_params,…])	Adından da anlaşılacağı gibi, bu yöntem parametreleri ve yardımcı durumları başlatacaktır.
install_monitor (mon)	Bu yöntem monitörü tüm uygulayıcılara kuracaktır.
iter_predict (eval_data [, sayı_batch, sıfırla,…])	Bu yöntem tahminler üzerinde yinelenecektir.
load_params (isim)	Adından da anlaşılacağı gibi, model parametrelerini dosyadan yükleyecektir.
tahmin (eval_data [, sayı_batch,…])	Tahmini çalıştıracak ve çıktıları da toplayacaktır.
hazırla (data_batch [, sparse_row_id_fn])	Operatör, belirli bir veri grubunu işlemek için modülü hazırlar.
save_params (isim)	Adın da belirttiği gibi, bu işlev model parametrelerini dosyaya kaydedecektir.
puan (eval_data, eval_metric [, sayı_batch;…])	Tahmini çalıştırır eval_data ve verilenlere göre performansı da değerlendirir. eval_metric.
set_params (arg_params, aux_params [,…])	Bu yöntem parametre ve yardımcı durum değerlerini atayacaktır.
set_states ([durumlar, değer])	Bu yöntem, adından da anlaşılacağı gibi, durumlar için değer belirler.
Güncelleme()	Bu yöntem, verilen parametreleri kurulu optimize ediciye göre günceller. Ayrıca, önceki ileri-geri toplu işlemde hesaplanan degradeleri de günceller.
update_metric (eval_metric, etiketler [, pre_sliced])	Bu yöntem, adından da anlaşılacağı gibi, son ileri hesaplamanın çıktıları üzerindeki değerlendirme ölçüsünü değerlendirir ve biriktirir.
geri ([out_grads])	Adından da anlaşılacağı gibi bu yöntem, backward hesaplama.
bağla (veri_şekilleri [, etiket_şekilleri,…])	Grupları kurar ve uygulayıcıyı varsayılan paket anahtarı için bağlar. Bu yöntem, birBucketingModule.
ileri (data_batch [, is_train])	Adından da anlaşılacağı gibi, bu yöntem İleri hesaplamayı uygular. Bu yöntem, farklı toplu iş boyutları veya farklı görüntü boyutları gibi çeşitli şekillere sahip veri toplu işlerini destekler.
get_input_grads ([merge_multi_context])	Bu yöntem, önceki geriye dönük hesaplamada hesaplanan girdilere gradyanları alacaktır.
get_outputs ([merge_multi_context])	Adından da anlaşılacağı gibi, bu yöntem önceki ileri hesaplamadan çıktılar alacaktır.
get_params ()	Mevcut parametreleri, özellikle cihazda hesaplama yapmak için kullanılan gerçek parametrelerin potansiyel olarak kopyaları olanları alır.
get_states ([merge_multi_context])	Bu yöntem, tüm cihazlardan durumları alacaktır.
init_optimizer ([kvstore, optimize edici,…])	Bu yöntem, optimize edicileri kurar ve başlatır. Ayrıca başlatırkvstore eğitim dağıtmak için.
init_params ([başlatıcı, arg_params,…])	Adından da anlaşılacağı gibi, bu yöntem parametreleri ve yardımcı durumları başlatacaktır.
install_monitor (mon)	Bu yöntem monitörü tüm uygulayıcılara kuracaktır.
yük (önek, epoch [, sym_gen,…])	Bu yöntem, önceden kaydedilmiş kontrol noktasından bir model oluşturacaktır.
load_dict ([sym_dict, sym_gen,…])	Bu yöntem, bir sözlük (dict) eşlemesinden bir model oluşturacaktır. bucket_keysembollere. Ayrıca paylaşırarg_params ve aux_params.
hazırla (data_batch [, sparse_row_id_fn])	Operatör, belirli bir veri grubunu işlemek için modülü hazırlar.
save_checkpoint (önek, epoch [, remove_amp_cast])	Bu yöntem, adından da anlaşılacağı gibi, BucketingModule'daki tüm paketler için geçerli ilerlemeyi kontrol noktasına kaydeder. Eğitim sırasında kaydetmek için epoch_end_callback olarak mx.callback.module_checkpoint'in kullanılması önerilir.
set_params (arg_params, aux_params [,…])	Adın da belirttiği gibi, bu işlev parametreleri ve yardımcı durum değerlerini atayacaktır.
set_states ([durumlar, değer])	Bu yöntem, adından da anlaşılacağı gibi, durumlar için değer belirler.
switch_bucket (paket_anahtar, veri_şekilleri [,…])	Farklı bir kovaya geçecektir.
Güncelleme()	Bu yöntem, verilen parametreleri kurulu optimize ediciye göre günceller. Ayrıca, önceki ileri-geri toplu işlemde hesaplanan degradeleri de günceller.
update_metric (eval_metric, etiketler [, pre_sliced])	Bu yöntem, adından da anlaşılacağı gibi, son ileri hesaplamanın çıktıları üzerindeki değerlendirme ölçüsünü değerlendirir ve biriktirir.

Öznitellikler

Aşağıdaki tablo, aşağıdaki yöntemlerde bulunan öznitelikleri göstermektedir. BaseModule sınıf -

Öznitellikler	Tanım
data_names	Bu modülün gerektirdiği veriler için isim listesinden oluşur.
data_shapes	Bu modüle veri girişlerini belirten (isim, şekil) çiftlerinin listesinden oluşur.
label_shapes	Bu modüle etiket girişlerini belirten (isim, şekil) çiftlerinin listesini gösterir.
output_names	Bu modülün çıktılarının isim listesinden oluşur.
output_shapes	Bu modülün çıktılarını belirten (isim, şekil) çiftlerinin listesinden oluşur.
sembol	Ad belirtildiği gibi, bu öznitelik bu modülle ilişkili sembolü alır.

data_shapes: Şu adresteki bağlantıya başvurabilirsiniz https://mxnet.apache.orgdetaylar için. output_shapes: Daha Fazla

output_shapes: Daha fazla bilgi şu adreste mevcuttur: https://mxnet.apache.org/api/python

BucketingModule (sym_gen […])

Temsil eder Bucketingmodule Değişen uzunluktaki girdilerle verimli bir şekilde başa çıkmaya yardımcı olan bir Modül sınıfı.

Yöntemler

Aşağıdaki tablo aşağıdakilerden oluşan yöntemleri göstermektedir: BucketingModule class -

Öznitellikler

Aşağıdaki tablo, aşağıdaki yöntemlerde bulunan öznitelikleri göstermektedir. BaseModule class -

Öznitellikler	Tanım
data_names	Bu modülün gerektirdiği veriler için isim listesinden oluşur.
data_shapes	Bu modüle veri girişlerini belirten (isim, şekil) çiftlerinin listesinden oluşur.
label_shapes	Bu modüle etiket girişlerini belirten (isim, şekil) çiftlerinin listesini gösterir.
output_names	Bu modülün çıktılarının isim listesinden oluşur.
output_shapes	Bu modülün çıktılarını belirten (isim, şekil) çiftlerinin listesinden oluşur.
Sembol	Ad belirtildiği gibi, bu öznitelik bu modülle ilişkili sembolü alır.

data_shapes - Bağlantıya şu adresten başvurabilirsiniz: https://mxnet.apache.org/api/python/docs daha fazla bilgi için.

output_shapes− Bağlantıya şu adresten başvurabilirsiniz: https://mxnet.apache.org/api/python/docs daha fazla bilgi için.

Modül (sembol [, veri_ adları, etiket_adları,…])

Temel bir modülü temsil eder. symbol.

Yöntemler

Aşağıdaki tablo aşağıdakilerden oluşan yöntemleri göstermektedir: Module class -

Yöntemler	Tanım
geri ([out_grads])	Adından da anlaşılacağı gibi bu yöntem, backward hesaplama.
bağla (veri_şekilleri [, etiket_şekilleri,…])	Yürütücüler oluşturmak için sembolleri bağlar ve modül ile hesaplama yapmadan önce gereklidir.
borrow_optimizer (paylaşılan_module)	Adından da anlaşılacağı gibi, bu yöntem optimize ediciyi paylaşılan bir modülden ödünç alır.
ileri (data_batch [, is_train])	Adından da anlaşılacağı gibi bu yöntem, Forwardhesaplama. Bu yöntem, farklı toplu iş boyutları veya farklı görüntü boyutları gibi çeşitli şekillere sahip veri toplu işlerini destekler.
get_input_grads ([merge_multi_context])	Bu yöntem, önceki geriye dönük hesaplamada hesaplanan girdilere gradyanları alacaktır.
get_outputs ([merge_multi_context])	Adından da anlaşılacağı gibi, bu yöntem önceki ileri hesaplamanın çıktılarını alacaktır.
get_params ()	Cihazda hesaplama yapmak için kullanılan gerçek parametrelerin potansiyel olarak kopyaları olan parametreleri alır.
get_states ([merge_multi_context])	Bu yöntem, tüm cihazlardan durumları alacak
init_optimizer ([kvstore, optimize edici,…])	Bu yöntem, optimize edicileri kurar ve başlatır. Ayrıca başlatırkvstore eğitim dağıtmak için.
init_params ([başlatıcı, arg_params,…])	Adından da anlaşılacağı gibi, bu yöntem parametreleri ve yardımcı durumları başlatacaktır.
install_monitor (mon)	Bu yöntem monitörü tüm uygulayıcılara kuracaktır.
yük (önek, epoch [, sym_gen,…])	Bu yöntem, önceden kaydedilmiş kontrol noktasından bir model oluşturacaktır.
load_optimizer_states (fname)	Bu yöntem, bir dosyadan bir iyileştirici, yani güncelleme durumunu yükleyecektir.
hazırla (data_batch [, sparse_row_id_fn])	Operatör, belirli bir veri grubunu işlemek için modülü hazırlar.
yeniden şekillendirme (veri_şekilleri [, etiket_şekilleri])	Bu yöntem, adından da anlaşılacağı gibi, modülü yeni giriş şekilleri için yeniden şekillendirir.
save_checkpoint (önek, dönem [,…])	Mevcut ilerlemeyi kontrol noktasına kaydeder.
save_optimizer_states (fname)	Bu yöntem, optimize edici veya güncelleyici durumunu bir dosyaya kaydeder.
set_params (arg_params, aux_params [,…])	Adın da belirttiği gibi, bu işlev parametreleri ve yardımcı durum değerlerini atayacaktır.
set_states ([durumlar, değer])	Bu yöntem, adından da anlaşılacağı gibi, durumlar için değer belirler.
Güncelleme()	Bu yöntem, verilen parametreleri kurulu optimize ediciye göre günceller. Ayrıca, önceki ileri-geri toplu işlemde hesaplanan degradeleri de günceller.
update_metric (eval_metric, etiketler [, pre_sliced])	Bu yöntem, adından da anlaşılacağı gibi, son ileri hesaplamanın çıktıları üzerindeki değerlendirme ölçüsünü değerlendirir ve biriktirir.

Öznitellikler

Aşağıdaki tablo, aşağıdaki yöntemlerde bulunan öznitelikleri göstermektedir. Module class -

Öznitellikler	Tanım
data_names	Bu modülün gerektirdiği veriler için isim listesinden oluşur.
data_shapes	Bu modüle veri girişlerini belirten (isim, şekil) çiftlerinin listesinden oluşur.
label_shapes	Bu modüle etiket girişlerini belirten (isim, şekil) çiftlerinin listesini gösterir.
output_names	Bu modülün çıktılarının isim listesinden oluşur.
output_shapes	Bu modülün çıktılarını belirten (isim, şekil) çiftlerinin listesinden oluşur.
label_names	Bu modülün gerektirdiği etiketler için isim listesinden oluşur.

data_shapes: Bağlantıyı ziyaret edin https://mxnet.apache.org/api/python/docs/api/module daha fazla detay için.

output_shapes: Burada verilen bağlantı https://mxnet.apache.org/api/python/docs/api/module/index.html başka önemli bilgiler sunacak.

PythonLossModule ([ad, veri_ adları,…])

Bu sınıfın temeli mxnet.module.python_module.PythonModule. PythonLossModule sınıfı, modül API'lerinin tamamını veya çoğunu boş işlevler olarak uygulayan uygun bir modül sınıfıdır.

Yöntemler

Aşağıdaki tablo aşağıdakilerden oluşan yöntemleri göstermektedir: PythonLossModule sınıf:

Yöntemler	Tanım
geri ([out_grads])	Adından da anlaşılacağı gibi bu yöntem, backward hesaplama.
ileri (data_batch [, is_train])	Adından da anlaşılacağı gibi bu yöntem, Forwardhesaplama. Bu yöntem, farklı toplu iş boyutları veya farklı görüntü boyutları gibi çeşitli şekillere sahip veri toplu işlerini destekler.
get_input_grads ([merge_multi_context])	Bu yöntem, önceki geriye dönük hesaplamada hesaplanan girdilere gradyanları alacaktır.
get_outputs ([merge_multi_context])	Adından da anlaşılacağı gibi, bu yöntem önceki ileri hesaplamanın çıktılarını alacaktır.
install_monitor (mon)	Bu yöntem monitörü tüm uygulayıcılara kuracaktır.

PythonModule ([data_names, label_names…])

Bu sınıfın temeli mxnet.module.base_module.BaseModule şeklindedir. PythonModule sınıfı, modül API'lerinin tümünü veya çoğunu boş işlevler olarak uygulayan uygun bir modül sınıfıdır.

Yöntemler

Aşağıdaki tablo aşağıdakilerden oluşan yöntemleri göstermektedir: PythonModule sınıf -

Yöntemler	Tanım
bağla (veri_şekilleri [, etiket_şekilleri,…])	Yürütücüler oluşturmak için sembolleri bağlar ve modül ile hesaplama yapmadan önce gereklidir.
get_params ()	Cihazda hesaplama yapmak için kullanılan gerçek parametrelerin potansiyel olarak kopyaları olan parametreleri alır.
init_optimizer ([kvstore, optimize edici,…])	Bu yöntem, optimize edicileri kurar ve başlatır. Ayrıca başlatırkvstore eğitim dağıtmak için.
init_params ([başlatıcı, arg_params,…])	Adından da anlaşılacağı gibi, bu yöntem parametreleri ve yardımcı durumları başlatacaktır.
Güncelleme()	Bu yöntem, verilen parametreleri kurulu optimize ediciye göre günceller. Ayrıca, önceki ileri-geri toplu işlemde hesaplanan degradeleri de günceller.
update_metric (eval_metric, etiketler [, pre_sliced])	Bu yöntem, adından da anlaşılacağı gibi, son ileri hesaplamanın çıktıları üzerindeki değerlendirme ölçüsünü değerlendirir ve biriktirir.

Öznitellikler

Aşağıdaki tablo, aşağıdaki yöntemlerde bulunan öznitelikleri göstermektedir. PythonModule sınıf -

Öznitellikler	Tanım
data_names	Bu modülün gerektirdiği veriler için isim listesinden oluşur.
data_shapes	Bu modüle veri girişlerini belirten (isim, şekil) çiftlerinin listesinden oluşur.
label_shapes	Bu modüle etiket girişlerini belirten (isim, şekil) çiftlerinin listesini gösterir.
output_names	Bu modülün çıktılarının isim listesinden oluşur.
output_shapes	Bu modülün çıktılarını belirten (isim, şekil) çiftlerinin listesinden oluşur.

data_shapes - Bağlantıyı izle https://mxnet.apache.org detaylar için.

output_shapes - Daha fazla ayrıntı için, şu adresteki bağlantıyı ziyaret edin: https://mxnet.apache.org

Sıralı Modül ([günlükçü])

Bu sınıfın temeli mxnet.module.base_module.BaseModule şeklindedir. SequentialModule sınıfı ayrıca ikiden (birden fazla) modülü birbirine zincirleyebilen bir kap modülüdür.

Yöntemler

Aşağıdaki tablo aşağıdakilerden oluşan yöntemleri göstermektedir: SequentialModule sınıf

Yöntemler	Tanım
ekle (modül, ** kwargs)	Bu, bu sınıfın en önemli işlevidir. Zincire bir modül ekler.
geri ([out_grads])	Adından da anlaşılacağı gibi bu yöntem geriye dönük hesaplamayı gerçekleştirir.
bağla (veri_şekilleri [, etiket_şekilleri,…])	Yürütücüler oluşturmak için sembolleri bağlar ve modül ile hesaplama yapmadan önce gereklidir.
ileri (data_batch [, is_train])	Adından da anlaşılacağı gibi, bu yöntem İleri hesaplamayı uygular. Bu yöntem, farklı toplu iş boyutları veya farklı görüntü boyutları gibi çeşitli şekillere sahip veri toplu işlerini destekler.
get_input_grads ([merge_multi_context])	Bu yöntem, önceki geriye dönük hesaplamada hesaplanan girdilere gradyanları alacaktır.
get_outputs ([merge_multi_context])	Adından da anlaşılacağı gibi, bu yöntem önceki ileri hesaplamanın çıktılarını alacaktır.
get_params ()	Cihazda hesaplama yapmak için kullanılan gerçek parametrelerin potansiyel olarak kopyaları olan parametreleri alır.
init_optimizer ([kvstore, optimize edici,…])	Bu yöntem, optimize edicileri kurar ve başlatır. Ayrıca başlatırkvstore eğitim dağıtmak için.
init_params ([başlatıcı, arg_params,…])	Adından da anlaşılacağı gibi, bu yöntem parametreleri ve yardımcı durumları başlatacaktır.
install_monitor (mon)	Bu yöntem monitörü tüm uygulayıcılara kuracaktır.
Güncelleme()	Bu yöntem, verilen parametreleri kurulu optimize ediciye göre günceller. Ayrıca, önceki ileri-geri toplu işlemde hesaplanan degradeleri de günceller.
update_metric (eval_metric, etiketler [, pre_sliced])	Bu yöntem, adından da anlaşılacağı gibi, son ileri hesaplamanın çıktıları üzerindeki değerlendirme ölçüsünü değerlendirir ve biriktirir.

Öznitellikler

Aşağıdaki tablo, BaseModule sınıfının yöntemlerinde bulunan öznitelikleri gösterir -

Öznitellikler	Tanım
data_names	Bu modülün gerektirdiği veriler için isim listesinden oluşur.
data_shapes	Bu modüle veri girişlerini belirten (isim, şekil) çiftlerinin listesinden oluşur.
label_shapes	Bu modüle etiket girişlerini belirten (isim, şekil) çiftlerinin listesini gösterir.
output_names	Bu modülün çıktılarının isim listesinden oluşur.
output_shapes	Bu modülün çıktılarını belirten (isim, şekil) çiftlerinin listesinden oluşur.
output_shapes	Bu modülün çıktılarını belirten (isim, şekil) çiftlerinin listesinden oluşur.

data_shapes - Burada verilen bağlantı https://mxnet.apache.org özelliği çok ayrıntılı olarak anlamanıza yardımcı olacaktır.

output_shapes - adresinde bulunan bağlantıyı takip edin https://mxnet.apache.org/api detaylar için.

Uygulama Örnekleri

Aşağıdaki örnekte, bir mxnet modül.

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

Çıktı aşağıda belirtilmiştir -

<Symbol softmax>

Example

print(mod)

Output

Çıktı aşağıda gösterilmiştir -

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

Aşağıdaki bu örnekte, ileri hesaplama uygulayacağız

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

Yukarıdaki kodu çalıştırdığınızda, aşağıdaki çıktıyı görmelisiniz -

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

Aşağıda verilen kodun çıktısıdır -

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