Bagikan melalui

Beberapa GPU dan Mesin

  • Artikel

1. Pendahuluan

CNTK saat ini mendukung empat algoritma SGD paralel:

  1. DataParallelSGD
  2. BlockMomentumSGD
  3. ModelAveragingSGD
  4. DataParallelASGD
Prasyarat

Untuk menjalankan pelatihan paralel, pastikan implementasi Message Passing Interface (MPI) diinstal:

  • Di Windows, instal versi 7 (7.0.12437.6) Microsoft MPI (MS-MPI), implementasi Microsoft dari standar Antarmuka Penerusan Pesan, dari halaman unduhan ini, ditandai sebagai "Versi 7" di judul halaman. Klik tombol Unduh, lalu pilih run-time (MSMpiSetup.exe).

  • Di Linux, instal OpenMPI versi 1.10.x. Silakan ikuti instruksi di sini untuk membangunnya sendiri.

2. Mengonfigurasi Pelatihan Paralel di CNTK di Python

Untuk menggunakan SGD paralel data di Python, pengguna perlu membuat dan meneruskan pelajar terdistribusi ke pelatih:

from cntk import distributed
...

learner = cntk.learner.momentum_sgd(...)    # create local learner
distributed_after = epoch_size              # number of samples to warm start with
distributed_learner = distributed.data_parallel_distributed_learner(
    learner = learner,
    num_quantization_bits = 32,              # non-quantized gradient accumulation
    distributed_after = 0)                   # no warm start 
...
minibatch_source = MinibatchSource(...) 
...
trainer = Trainer(z, ce, pe, distributed_learner)
...
session = training_session(trainer=trainer, mb_source=minibatch_source, ...)
session.train()
...
distributed.Communicator.finalize()       # must be called to finalize MPI in case of successful distributed training

Untuk perulangan pelatihan yang ditentukan pengguna (bukan training_session), pengguna perlu meneruskan num_data_partitions dan partition_index ke MinibatchSource.next_minibatch() metode sehingga simpul MPI yang berbeda akan membaca data dari partisi data yang berbeda (setelah distributed_after sampel dibaca).

Harap dicatat bahwa Communicator.finalize() harus dipanggil hanya jika pelatihan terdistribusi berhasil diselesaikan. Jika pekerja terdistribusi gagal, metode ini tidak boleh dipanggil.

Untuk contoh yang berfungsi penuh, silakan lihat contoh ConvNet.

3. Mengonfigurasi Pelatihan Paralel di CNTK di BrainScript

Untuk mengaktifkan pelatihan paralel di CNTK BrainScript, pertama-tama perlu mengaktifkan sakelar berikut dalam file konfigurasi atau di baris perintah:

parallelTrain = true

Kedua, SGD blok dalam file konfigurasi harus berisi sub-blok bernama ParallelTrain dengan argumen berikut:

  1. parallelizationMethod: (wajib) nilai yang sah adalah DataParallelSGD, , BlockMomentumSGDdan ModelAveragingSGD.

    Ini menentukan algoritma paralel mana yang akan digunakan.

  2. distributedMBReading : (opsional) menerima nilai Boolean: true atau false; defaultnya adalah false

    Disarankan untuk mengaktifkan pembacaan minibatch terdistribusi untuk meminimalkan biaya I/O di setiap pekerja. Jika Anda menggunakan pembaca Format Teks CNTK, Pembaca Gambar, atau Pembaca Data Komposit, distributedMBReading harus diatur ke true.

  3. parallelizationStartEpoch: (opsional) menerima nilai bilangan bulat; defaultnya adalah 1.

    Ini menentukan mulai dari zaman mana, algoritma pelatihan paralel digunakan; sebelum itu semua pekerja melakukan pelatihan yang sama, tetapi hanya satu pekerja yang diizinkan untuk menyimpan model. Opsi ini dapat berguna jika pelatihan paralel memerlukan beberapa tahap "warm-start".

  4. syncPerfStats: (opsional) menerima nilai bilangan bulat; defaultnya adalah 0.

    Ini menentukan seberapa sering statistik performa akan dicetak. Statistik tersebut mencakup waktu yang dihabiskan untuk komunikasi dan/atau komputasi dalam periode sinkronisasi, yang dapat berguna untuk memahami penyempitan algoritma pelatihan paralel.

    0 berarti tidak ada statistik yang akan dicetak. Nilai lain menentukan seberapa sering statistik akan dicetak. Misalnya, syncPerfStats=5 berarti statistik akan dicetak setelah setiap 5 sinkronisasi.

  5. Sub-blok yang menentukan detail setiap algoritma pelatihan paralel. Nama sub-blok harus sama dengan parallelizationMethod. (wajib)

Python memberikan lebih banyak fleksibilitas dan penggunaan ditunjukkan di bawah ini untuk metode paralelisasi yang berbeda.

4. Menjalankan Pelatihan Paralel dengan CNTK

Paralelisasi dalam CNTK diimplementasikan dengan MPI.

4.1 Menjalankan Pelatihan Paralel dengan BrainScript

Mengingat salah satu konfigurasi BrainScript pelatihan paralel di atas, perintah berikut dapat digunakan untuk memulai pekerjaan MPI paralel:

  • Pelatihan paralel pada komputer yang sama dengan Linux:

    mpiexec --npernode $num_workers  $cntk  configFile=$config

  • Pelatihan paralel pada komputer yang sama dengan Windows:

    mpiexec -n %num_workers%  %cntk%  configFile=%config%

  • Pelatihan paralel di beberapa simpul komputasi dengan Linux:

    Langkah 1: Buat file host $hostfile menggunakan editor favorit Anda

    # Comments are allowed after pound sign
name_of_node1 slots=4 # we want 4 workers on node1
name_of_node2 slots=2 # we want 2 workers on node2

Di mana name_of_node(n) hanyalah nama DNS atau alamat IP simpul pekerja.

Step 2: Execute your workload
```
mpiexec -hostfile $hostfile  $cntk  configFile=$config
```

  • Pelatihan paralel di beberapa simpul komputasi dengan Windows:

    mpiexec --hosts %num_nodes% %name_of_node1% %num_workers_on_node1%  ...  %cntk%  configFile=%config%

di mana $cntk harus merujuk ke jalur CNTK yang dapat dieksekusi ($x adalah cara shell Linux untuk mengganti variabel lingkungan, yang setara dengan %x% dalam shell Windows).

4.2 Menjalankan Pelatihan Paralel dengan Python

Contoh pelatihan terdistribusi untuk CNTK v2 dengan Python dapat ditemukan di sini:

Mengingat skrip training.py Python CNTK v2, perintah berikut dapat digunakan untuk memulai pekerjaan MPI paralel:

  • Pelatihan paralel pada komputer yang sama dengan Linux:

    mpiexec --npernode $num_workers python training.py

  • Pelatihan paralel pada komputer yang sama dengan Windows:

    mpiexec -n %num_workers% python training.py

  • Pelatihan paralel di beberapa simpul komputasi dengan Linux:

    Langkah 1: Buat file host $hostfile menggunakan editor favorit Anda

    # Comments are allowed after pound sign
name_of_node1 slots=4 # we want 4 workers on node1
name_of_node2 slots=2 # we want 2 workers on node2

Di mana name_of_node(n) hanyalah nama DNS atau alamat IP simpul pekerja.

Step 2: Execute your workload
```
mpiexec -hostfile $hostfile python training.py
```

  • Pelatihan paralel di beberapa simpul komputasi dengan Windows:

    mpiexec --hosts %num_nodes% %name_of_node1% %num_workers_on_node1%  ...  python training.py

5 pelatihan Data-Parallel dengan SGD 1-bit

CNTK mengimplementasikan teknik SGD 1-bit [1]. Teknik ini memungkinkan untuk mendistribusikan setiap minibatch atas K pekerja. Gradien parsial yang dihasilkan kemudian ditukar dan diagregasi setelah setiap minibatch. "1 bit" mengacu pada teknik yang dikembangkan di Microsoft untuk mengurangi jumlah data yang ditukar dengan setiap nilai gradien menjadi satu bit.

5.1 Algoritma "1-bit SGD"

Secara langsung bertukar gradien parsial setelah setiap minibatch memerlukan bandwidth komunikasi yang dilarang. Untuk mengatasi hal ini, SGD 1-bit secara agresif mengukur setiap nilai gradien... ke satu bit (!) per nilai. Praktis, ini berarti bahwa nilai gradien besar terpotong, sementara nilai kecil secara artifisial meningkat. Luar biasa, ini tidak membahayakan konvergensi jika, dan hanya jika, trik digunakan.

Caranya adalah bahwa untuk setiap minibatch, algoritma membandingkan gradien terukur (yang dipertukarkan antara pekerja) dengan nilai gradien asli (yang seharusnya ditukar). Perbedaan antara keduanya ( kesalahan kuantisasi) dihitung dan diingat sebagai residu. Sisa ini kemudian ditambahkan ke minibatch berikutnya .

Sebagai konsekuensinya, meskipun kuantisasi agresif, setiap nilai gradien akhirnya ditukar dengan akurasi penuh; hanya pada penundaan. Eksperimen menunjukkan bahwa, selama model ini dikombinasikan dengan awal yang hangat (model benih yang dilatih pada subset kecil data pelatihan tanpa paralelisasi), teknik ini telah terbukti menyebabkan hilangnya akurasi yang tidak atau sangat kecil, sambil memungkinkan percepatan tidak terlalu jauh dari linier (faktor pembatasnya adalah bahwa GPU menjadi tidak efisien ketika komputasi pada sub-batch yang terlalu kecil).

Untuk efisiensi maksimum, teknik harus dikombinasikan dengan penskalaan minibatch otomatis, di mana sesekali, pelatih mencoba meningkatkan ukuran minibatch. Mengevaluasi subset kecil dari periode data yang akan datang, pelatih akan memilih ukuran minibatch terbesar yang tidak membahayakan konvergensi. Di sini, sangat berguna bahwa CNTK menentukan tingkat pembelajaran dan hiperparameter momentum dengan cara agnostik ukuran minibatch.

5.2 Menggunakan SGD 1-bit di BrainScript

SGD 1-bit sendiri tidak memiliki parameter selain mengaktifkannya dan setelah itu epoch harus dimulai. Selain itu, penskala minibatch otomatis harus diaktifkan. Ini dikonfigurasi dengan menambahkan parameter berikut ke blok SGD:

SGD = [
    ...
    ParallelTrain = [
        DataParallelSGD = [
            gradientBits = 1
        ]
        parallelizationStartEpoch = 2  # warm start: don't use 1-bit SGD for first epoch
    ]
    AutoAdjust = [
        autoAdjustMinibatch = true       # enable automatic growing of minibatch size
        minibatchSizeTuningFrequency = 3 # try to enlarge after this many epochs
    ]
]

Perhatikan bahwa Data-Parallel SGD juga dapat digunakan tanpa kuantisasi 1-bit. Namun, dalam skenario umum, terutama skenario di mana setiap parameter model diterapkan hanya sekali seperti untuk DNN feed-forward, ini tidak akan efisien karena kebutuhan bandwidth komunikasi yang tinggi.

Bagian 2.2.3 di bawah ini menunjukkan hasil SGD 1-bit pada tugas ucapan, dibandingkan dengan metode SGD Block-Momentum yang dijelaskan berikutnya. Kedua metode tidak memiliki atau hampir tidak ada kehilangan akurasi pada kecepatan mendekati linier.

5.3 Menggunakan SGD 1-bit di Python

Untuk menggunakan SGD paralel data di Python, secara opsional dengan SGD 1-bit, pengguna perlu membuat dan meneruskan pelajar terdistribusi ke pelatih:

from cntk import distributed
...

learner = cntk.learner.momentum_sgd(...)    # create local learner
distributed_after = epoch_size              # number of samples to warm start with
distributed_learner = distributed.data_parallel_distributed_learner(
    learner = learner,
    num_quantization_bits = 1,              # change to 32 for non-quantized gradient accumulation
    distributed_after = distributed_after)  # warm start: no parallelization is used for the first 'distributed_after' samples
...
minibatch_source = MinibatchSource(...) 
...
trainer = Trainer(z, ce, pe, distributed_learner)
...
session = training_session(trainer=trainer, mb_source=minibatch_source, ...)
session.train()
...
distributed.Communicator.finalize()       # must be called to finalize MPI in case of successful distributed training

Mengubah num_quantization_bits menjadi 32 selama pembuatan distributed_learner membuatnya menggunakan SGD Data-Parallel yang tidak terukur. Tidak perlu memulai dengan hangat dalam kasus ini.

6 Block-Momentum SGD

Block-Momentum SGD adalah implementasi dari "pembaruan dan pemfilteran model blockwise", atau BMUF, algoritma, Momentum Blok pendek [2].

6.1 Algoritma SGD Block-Momentum

Gambar berikut meringkas prosedur dalam algoritma Block-Momentum.

Bm

6.2 Mengonfigurasi Block-Momentum SGD di BrainScript

Untuk menggunakan Block-Momentum SGD, harus memiliki sub-blok bernama BlockMomentumSGD di SGD blok dengan opsi berikut:

  1. syncPeriod. Ini mirip syncPeriod dengan di ModelAveragingSGD, yang menentukan seberapa sering sinkronisasi model dilakukan. Nilai default untuk BlockMomentumSGD adalah 120.000.

  2. resetSGDMomentum. Ini berarti setelah setiap titik sinkronisasi, gradien yang dihaluskan yang digunakan dalam SGD lokal akan ditetapkan sebagai 0. Nilai default variabel ini adalah true.

  3. useNesterovMomentum. Ini berarti pembaruan momentum gaya Nesterov diterapkan pada tingkat blok. Lihat [2] untuk detail selengkapnya. Nilai default variabel ini adalah true.

Momentum blok dan tingkat pembelajaran blok biasanya secara otomatis ditetapkan sesuai dengan jumlah pekerja yang digunakan, yaitu,

block_momentum = 1.0 - 1.0/num_of_workers
block_learning_rate = 1.0

Pengalaman kami menunjukkan bahwa pengaturan ini sering menghasilkan konvergensi yang sama dengan algoritma SGD standar hingga 64 GPU, yang merupakan eksperimen terbesar yang kami lakukan. Dimungkinkan juga untuk menentukan parameter ini secara manual menggunakan opsi berikut:

  • blockMomentumAsTimeConstant menentukan konstanta waktu filter low-pass dalam pembaruan model tingkat blok. Ini dihitung sebagai:

    blockMomentumAsTimeConstant = -syncPeriod / log(block_momentum)
# or inversely
block_momentum = exp(-syncPeriod/blockMomentumAsTimeConstant)

  • blockLearningRate menentukan tingkat pembelajaran blok.

Berikut ini adalah contoh bagian konfigurasi SGD Block-Momentum:

learningRatesPerSample=0.0005
# 0.0005 is the optimal learning rate for single-GPU training.
# Use it for BlockMomentumSGD as well
ParallelTrain = [
    parallelizationMethod = BlockMomentumSGD
    distributedMBReading = true
    syncPerfStats = 5
    BlockMomentumSGD=[
        syncPeriod = 120000
        resetSGDMomentum = true
        useNesterovMomentum = true
    ]
]

6.3 Menggunakan Block-Momentum SGD di BrainScript

1. Menyetel ulang parameter pembelajaran

  • Untuk mencapai throughput serupa per pekerja, perlu untuk meningkatkan jumlah sampel dalam minibatch yang proporsional dengan jumlah pekerja. Ini dapat dicapai dengan menyesuaikan minibatchSize atau nbruttsineachrecurrentiter, tergantung pada apakah pengacakan mode bingkai digunakan.

  • Tidak perlu menyesuaikan tingkat pembelajaran (tidak seperti Model-Averaging SGD, lihat di bawah).

  • Disarankan untuk menggunakan Block-Momentum SGD dengan model yang dimulai dengan hangat. Pada tugas pengenalan ucapan kami, konvergensi yang wajar dicapai ketika mulai dari model benih yang dilatih pada data 24 jam (8,6 juta sampel) hingga 120 jam (43,2 juta sampel) menggunakan SGD standar.

2. Eksperimen ASR

Kami menggunakan Block-Momentum SGD dan algoritma SGD Data-Parallel (1-bit) untuk melatih DNN dan LSTM pada tugas pengenalan ucapan 2600 jam, dan membandingkan akurasi pengenalan kata vs. faktor-faktor mempercepat. Tabel dan gambar berikut menunjukkan hasilnya (*).

compare

(*): Faktor kecepatan puncak: untuk SGD 1-bit, diukur dengan faktor kecepatan maksimum (dibandingkan dengan garis besar SGD) yang dicapai dalam satu minibatch; untuk Momentum Blok, diukur dengan kecepatan maksimum yang dicapai dalam satu blok; Faktor kecepatan rata-rata: waktu yang berlalu dalam garis besar SGD dibagi dengan waktu yang berlalu yang diamati. Kedua metrik ini diperkenalkan karena latensi dalam I/O dapat sangat memengaruhi pengukuran faktor kecepatan rata-rata, terutama ketika sinkronisasi dilakukan pada tingkat batch mini. Pada saat yang sama faktor kecepatan maksimum relatif kuat.

3. Peringatan

  • Disarankan untuk mengatur resetSGDMomentum ke true; jika tidak, sering mengarah pada divergensi kriteria pelatihan. Mengatur ulang momentum SGD ke 0 setelah setiap sinkronisasi model pada dasarnya memotong kontribusi dari minibatche terakhir. Oleh karena itu, disarankan untuk tidak menggunakan momentum SGD besar. Misalnya, untuk syncPeriod 120.000, kami mengamati kehilangan akurasi yang signifikan jika momentum yang digunakan untuk SGD adalah 0,99. Mengurangi momentum SGD menjadi 0,9, 0,5 atau bahkan menonaktifkannya sama sekali memberikan akurasi serupa karena dapat dicapai oleh algoritma SGD standar.

  • Block-Momentum penundaan SGD dan mendistribusikan pembaruan model dari satu blok di blok berikutnya. Oleh karena itu, perlu untuk memastikan bahwa sinkronisasi model dilakukan cukup sering dalam pelatihan. Pemeriksaan cepat adalah menggunakan blockMomentumAsTimeConstant. Disarankan agar jumlah sampel pelatihan unik, N, harus memenuhi persamaan berikut:

    N >= blockMomentumAsTimeConstant * num_of_workers ~= syncPeriod * num_of_workers^2

Perkiraan berasal dari fakta-fakta berikut: (1) Momentum Blok sering ditetapkan sebagai (1-1/num_of_workers); (2) log(1-1/num_of_workers)~=-num_of_workers.

6.4 Menggunakan Block-Momentum di Python

Untuk mengaktifkan Block-Momentum di Python, mirip dengan SGD 1-bit, pengguna perlu membuat dan meneruskan pembelajar terdistribusi momentum blok kepada pelatih:

from cntk import distributed
...

learner = cntk.learner.momentum_sgd(...)    # create local learner
distributed_learner = cntk.distributed.block_momentum_distributed_learner(learner, block_size=block_size)
...
minibatch_source = MinibatchSource(...) 
...
trainer = Trainer(z, ce, pe, distributed_learner)
...
session = training_session(trainer=trainer, mb_source=minibatch_source, ...)
session.train()
...
distributed.Communicator.finalize()         # must be called to finalize MPI in case of successful distributed training

Untuk contoh yang berfungsi penuh, silakan lihat contoh ConvNet.

7 Model-Averaging SGD

Model-Averaging SGD adalah implementasi dari algoritma rata-rata model yang dirinci dalam [3,4] tanpa menggunakan gradien alami. Idenya di sini adalah untuk membiarkan setiap pekerja memproses subset data, tetapi rata-rata parameter model dari setiap pekerja setelah periode yang ditentukan.

Model-Averaging SGD umumnya menyatu lebih lambat dan lebih optimal, dibandingkan dengan SGD 1-bit dan SGD Block-Momentum, sehingga tidak lagi direkomendasikan.

Untuk menggunakan Model-Averaging SGD, harus memiliki sub-blok bernama ModelAveragingSGD di SGD blok dengan opsi berikut:

  • syncPeriod menentukan jumlah sampel yang perlu diproses setiap pekerja sebelum rata-rata model dilakukan. Nilai defaultnya adalah 40.000.

7.1 Menggunakan Model-Averaging SGD di BrainScript

Untuk membuat SGD Model-Averaging efektif dan efisien secara maksimal, pengguna perlu menyempurnakan beberapa hyper-parameter:

  • minibatchSize atau nbruttsineachrecurrentiter. Misalkan n pekerja berpartisipasi dalam konfigurasi SGD Model-Averaging, implementasi pembacaan terdistribusi saat ini akan memuat 1/n-th minibatch ke setiap pekerja. Oleh karena itu, untuk memastikan setiap pekerja menghasilkan throughput yang sama dengan SGD standar, perlu untuk memperbesar ukuran nminibatch -fold. Untuk model yang dilatih menggunakan pengacakan mode bingkai, ini dapat dicapai dengan memperbesar minibatchSize berdasarkan n waktu; untuk model dilatih menggunakan pengacakan mode urutan, seperti RNN, beberapa pembaca perlu meningkatkannya nbruttsineachrecurrentiter dengan n.

  • learningRatesPerSample. Pengalaman kami menunjukkan bahwa untuk mendapatkan konvergensi yang sama dengan SGD standar, perlu untuk meningkatkan learningRatesPerSample berdasarkan n waktu. Penjelasan dapat ditemukan di [2]. Karena tingkat pembelajaran ditingkatkan, perawatan ekstra diperlukan untuk memastikan pelatihan tidak menyimpang --dan ini sebenarnya peringatan utama Model-Averaging SGD. Anda dapat menggunakan AutoAdjust pengaturan untuk memuat ulang model terbaik sebelumnya jika peningkatan kriteria pelatihan diamati.

  • awal yang hangat. Ditemukan bahwa Model-Averaging SGD biasanya menyatu lebih baik jika dimulai dari model benih yang dilatih oleh algoritma SGD standar (tanpa paralelisasi). Pada tugas pengenalan ucapan kami, konvergensi yang wajar dicapai ketika mulai dari model benih yang dilatih pada data 24 jam (8,6 juta sampel) hingga 120 jam (43,2 juta sampel) menggunakan SGD standar.

Berikut ini adalah contoh bagian ModelAveragingSGD konfigurasi:

learningRatesPerSample = 0.002
# increase the learning rate by 4 times for 4-GPU training.
# learningRatesPerSample = 0.0005
# 0.0005 is the optimal learning rate for single-GPU training.
ParallelTrain = [
    parallelizationMethod = ModelAveragingSGD
    distributedMBReading = true
    syncPerfStats = 20
    ModelAveragingSGD = [
        syncPeriod=40000
    ]
]

7.2 Menggunakan Model-Averaging SGD di Python

Ini adalah pekerjaan yang sedang berlangsung.

8 Data-Parallel Pelatihan dengan Server Parameter

Server parameter adalah kerangka kerja yang banyak digunakan dalam pembelajaran mesin terdistribusi [5][6][7]. Manfaat terpenting yang dibawanya adalah pelatihan paralel asinkron dengan banyak pekerja. Ini memperkenalkan server parameter sebagai penyimpanan model terdistribusi. Alih-alih secara langsung memanfaatkan primitif AllReduce untuk menyinkronkan pembaruan parameter di antara pekerja, kerangka kerja server parameter memberi pengguna antarmuka seperti "Tambahkan" dan "Dapatkan" untuk memungkinkan pekerja lokal memperbarui dan mengambil parameter global dari server parameter. Dengan cara ini, pekerja lokal tidak perlu menunggu satu sama lain selama proses pelatihan yang menghemat banyak waktu terutama ketika jumlah pekerja besar.

Selain itu, karena server parameter adalah kerangka kerja terdistribusi yang menyimpan parameter model, pekerja hanya dapat mengambil parameter yang mereka butuhkan selama proses pelatihan mini-batch, ini membawa fleksibilitas yang sangat baik dalam metode pelatihan terdistribusi desain dan juga meningkatkan efisiensi saat melakukan pelatihan dengan pembaruan model yang jarang. Dalam rilis ini, kami akan fokus pada pelatihan paralel asinkron terlebih dahulu, nantinya kami akan memberikan lebih banyak pengenalan tentang cara memanfaatkan kerangka kerja server parameter untuk pelatihan model yang efisien dengan pembaruan yang jarang.

8.1 Menggunakan Data-Parallel ASGD

  • Untuk menggunakan server parameter untuk SGD Asinkron (abbr. sebagai ASGD), Anda harus membangun CNTK dengan Multiverso yang didukung, Multiverso adalah kerangka kerja server parameter umum untuk tugas pembelajaran mesin terdistribusi yang dikembangkan oleh tim Microsoft Research Asia.
  • Clone Code: silakan klon kode di bawah folder akar CNTK dengan menggunakan:
   git submodule update --init Source/Multiverso
  • Linux: silakan buat dengan --asgd=yes dalam proses konfigurasi.
  • Windows: harap tambahkan CNTK_ENABLE_ASGD ke lingkungan sistem Anda dan atur nilainya ke true
  • awal yang hangat. Dalam beberapa kasus, lebih baik memiliki pelatihan model asinkron yang dimulai dari model benih (yang dilatih oleh algoritma SGD standar). Dalam arti tertentu, SGD Asinkron membawa lebih banyak kebisingan untuk pelatihan karena pembaruan yang tertunda dari asinkronisme di antara pekerja. Beberapa model sangat sensitif terhadap kebisingan seperti itu di awal, yang dapat mengakibatkan perbedaan pelatihan model. Dalam keadaan seperti itu, awal yang hangat diperlukan.

8.2 Mengonfigurasi Data-Parallel ASGD di BrainScript

  • Untuk menggunakan Data-Parallel ASGD di CNTK, perlu memiliki DataParallelASGD sub-blok di blok SGD dengan opsi berikut

    • syncPeriodPerWorkers. Ini menentukan jumlah sampel yang perlu diproses setiap pekerja sebelum berkomunikasi dengan server parameter. Nilai defaultnya adalah 256. Disarankan sebagai ukuran minibatch. Jelas bahwa sinkronisasi yang sering ditingkatkan akan menyebabkan biaya komunikasi tinggi yang signifikan. Dalam pengujian kami, tidak perlu mengatur nilai menjadi 1 dalam banyak kasus.
    • usePipeline. Ini menentukan apakah menyalakan alur pengambilan model dan komputasi lokal. Mengaktifkan alur akan secara signifikan meningkatkan throughput keseluruhan pelatihan karena akan menyembunyikan beberapa atau semua biaya komunikasi. Namun, terkadang mungkin memperlambat tingkat konverge karena lebih banyak penundaan akan diperkenalkan dengan menambahkan alur. Secara keseluruhan, waktu jam akan disimpan dalam banyak kasus dengan alur.
    • AdjustLearningRateAtBeginning. Menurut makalah yang baru-baru ini diterbitkan [5], PELATIHAN ASGD kurang stabil, dan diperlukan menggunakan tingkat pembelajaran yang jauh lebih kecil untuk menghindari ledakan kehilangan pelatihan sesekali, oleh karena itu proses pembelajaran menjadi kurang efisien. Namun, kami menemukan bahwa menggunakan tingkat pembelajaran yang lebih rendah tidak diperlukan untuk semua tugas. Dan untuk tugas-tugas tersebut sensitif di awal, kami memulai pelatihan dengan tingkat pembelajaran kecil, dan secara bertahap memperbesarnya pada tahap awal proses pelatihan sampai mencapai tingkat pembelajaran awal yang digunakan dalam SGD normal. Dengan cara ini, akurasi akhir akan cocok dengan SGD sementara dengan kecepatan ASGD. Jadi kami menyediakan opsi ini bagi pengguna ASGD untuk memanfaatkan trik ini. Ini adalah sub-blok di DataParallelASGD dengan dua parameter: adjustCoefficient dan adjustNBMiniBatch. Logikanya adalah bahwa tingkat pembelajaran dimulai dari adjustCoefficient dari tingkat pembelajaran awal SGD, dan meningkat dengan adjustCoefficient dari tingkat pembelajaran awal SGD setiap mini-batch adjustNBMiniBatch .

Berikut ini adalah contoh bagian DataParallelASGD konfigurasi:

   learningRatesPerSample = 0.0005

   ParallelTrain = [
       parallelizationMethod = DataParallelASGD
       distributedMBReading = true
       syncPerfStats = 20
       DataParallelASGD = [
           syncPeriodPerWorker=256
           usePipeline = true
           AdjustLearningRateAtBeginning = [
               adjustCoefficient = 0.2
               adjustNBMiniBatch = 1024
               # Learning rate will be adjusted to original one after ((1 / adjustCoefficient) * adjustNBMiniBatch) samples
               # which is 5120 in this case
           ]
       ]
   ]

8.3 Mengonfigurasi Data-Parallel ASGD di Python

Ini adalah pekerjaan yang sedang berlangsung.

8.4 Eksperimen

Gambar berikut menunjukkan eksperimen untuk menguji ASGD dengan himpunan data CIFAR-10. Model yang digunakan dalam eksperimen ini adalah ResNet 20 lapisan. Algoritma asinkron mengurangi biaya menunggu semua simpul pekerja. ASGD, dalam hal ini, jelas lebih cepat daripada algoritma sinkron, seperti MA dan SSGD. *Dalam eksperimen, semua mode paralel menyinkronkan parameter setiap iterasi (pembaruan mini-batch). Dan untuk SSGD, kami menggunakan pembaruan parameter 32-bit. Algoritma asinkron mendapatkan keuntungan signifikan dalam hal throughput pelatihan yang diukur oleh kecepatan pemrosesan sampel, terutama ketika nomor simpul kerja naik hingga 16.

Bandingkan Gambar 2.4 kecepatan untuk metode pelatihan yang berbeda

Referensi

[1] F. Seide, Hao Fu, Jasha Droppo, Gang Li, dan Dong Yu, "penurunan gradien stochastic 1-bit dan aplikasinya untuk pelatihan DNN ucapan terdistribusi paralel data," dalam Proceedings of Interspeech, 2014.

[2] K. Chen dan Q. Huo, "Pelatihan mesin pembelajaran mendalam yang dapat diskalakan dengan pelatihan blok inkremental dengan pengoptimalan paralel intra-blok dan pemfilteran pembaruan model blokir," dalam Proses ICASSP, 2016.

[3] M. Zinkevich, M. Weimer, L. Li, dan A. J. Smola, "Penurunan gradien stochastic paralel," dalam Proses Kemajuan di NIPS, 2010, pp. 2595–2603.

[4] D. Povey, X. Zhang, dan S. Khudanpur, "Pelatihan paralel DNN dengan gradien alami dan parameter rata-rata," dalam Proses Konferensi Internasional tentang Representasi Pembelajaran, 2014.

[5] Chen J, Monga R, Bengio S, dkk. Mengunjungi Kembali SGD Sinkron Terdistribusi. ICLR, 2016.

[6] Dean Jeffrey, Greg Corrado, Rajat Monga, Kai Chen, Matthieu Devin, Mark Mao, Andrew Senior dkk. Jaringan dalam terdistribusi skala besar. Sebelumnya dalam sistem pemrosesan informasi neural, pp. 1223-1231. 2012.

[7] Li Mu, Li Zhou, Zichao Yang, Aaron Li, Fei Xia, David G. Andersen, dan Alexander Smola. "Server parameter untuk pembelajaran mesin terdistribusi." Dalam Lokakarya BIG Learning NIPS, vol. 6, p. 2. 2013.