Praktik terbaik untuk pelatihan akselerasi TensorFlow 1.x di Amazon SageMaker

Saat ini, banyak pelanggan menggunakan TensorFlow untuk melatih model pembelajaran mendalam untuk rasio klik-tayang mereka dalam periklanan dan rekomendasi personalisasi di e-niaga. Saat perilaku klien mereka berubah, mereka dapat mengumpulkan data baru dalam jumlah besar setiap hari. Iterasi model adalah salah satu pekerjaan sehari-hari seorang ilmuwan data, tetapi mereka menghadapi masalah karena terlalu lama berlatih pada kumpulan data yang besar.

Amazon SageMaker adalah platform pembelajaran mesin (ML) yang terkelola sepenuhnya yang dapat membantu ilmuwan data untuk fokus pada model, bukan infrastruktur, dengan dukungan asli untuk algoritma dan kerangka kerja seperti TensorFlow dan PyTorch. SageMaker menawarkan opsi pelatihan terdistribusi fleksibel yang menyesuaikan dengan alur kerja spesifik Anda. Karena banyak ilmuwan data mungkin kurang berpengalaman dalam proses pelatihan akselerasi, dalam postingan ini kami menunjukkan kepada Anda faktor-faktor yang penting untuk pelatihan model deep learning cepat dan praktik terbaik pelatihan akselerasi untuk TensorFlow 1.x di SageMaker. Kami juga memiliki kode sampel dari Deep FM mendistribusikan pelatihan tentang SageMaker tentang GitHub repo.

Ada banyak faktor yang harus Anda pertimbangkan untuk memaksimalkan penggunaan CPU/GPU saat menjalankan skrip TensorFlow di SageMaker, seperti infrastruktur, jenis akselerator, metode pelatihan terdistribusi, metode pemuatan data, pelatihan presisi campuran, dan banyak lagi.

Kami membahas praktik terbaik di bidang berikut:

• Percepat pelatihan pada satu instance
• Percepat pelatihan di banyak instance
• Pipa data
• Pelatihan presisi campuran otomatis

Percepat pelatihan pada satu instance

Saat menjalankan skrip TensorFlow pada satu instans, Anda dapat memilih seri yang dioptimalkan untuk komputer seperti: Cloud komputasi elastis Amazon (Amazon EC2) seri C5, atau seri komputasi yang dipercepat dengan beberapa GPU dalam satu instans seperti p3.8xlarge, p3.16xlarge, p3dn.24xlarge, dan p4d.24xlarge.

Di bagian ini, kami membahas strategi untuk beberapa CPU pada satu instans, dan mendistribusikan pelatihan dengan beberapa GPU pada satu instans.

Beberapa CPU pada satu instance

Di bagian ini, kita membahas pengaturan paralelisme operator secara manual pada perangkat CPU, metode tower, TensorFlow MirroredStrategy, dan Horovod.

Menyetel paralelisme operator secara manual pada perangkat CPU

TensorFlow secara otomatis memilih jumlah utas yang sesuai untuk memparalelkan perhitungan operasi dalam proses pelatihan. Namun, Anda dapat mengatur intra_op kumpulan benang dan inter_op pengaturan paralelisme yang disediakan oleh TensorFlow dan menggunakan variabel lingkungan MKL-DNN untuk menyetel pengikatan untuk utas OS. Lihat kode berikut:

# Set parallelism of intra_op and inter_op
num_cpus = int(os.environ['SM_NUM_CPUS'])
config = tf.ConfigProto(allow_soft_placement=True, device_count={'CPU': num_cpus}, intra_op_parallelism_threads=num_cpus, inter_op_parallelism_threads=num_cpus)
run_config = tf.estimator.RunConfig().replace(session_config = config)

# Use Intel MKL-DNN Setting to accelerate training speed
os.environ["KMP_AFFINITY"]= "verbose,disabled"
os.environ['OMP_NUM_THREADS'] = str(num_cpus)
os.environ['KMP_SETTINGS'] = '1'

Variabel lingkungan KMP_AFFINITY dari MKL-DNN diatur ke granularity=fine,compact,1,0 secara default. Setelah menyetel intra dan antar TensorFlow ke jumlah maksimum vCPU instans saat ini, batas atas penggunaan CPU hampir sama dengan jumlah inti fisik instans pelatihan.

Jika Anda mengatur os.environ["KMP_AFFINITY"]= "verbose,disabled", utas OS tidak terikat ke utas hiper perangkat keras, dan penggunaan CPU dapat melebihi jumlah inti fisik.

Mengenai pengaturan paralelisme intra TensorFlow, antar paralelisme TensorFlow, dan jumlah utas MKL-DNN, kombinasi yang berbeda dari ketiga parameter ini menghasilkan kecepatan pelatihan yang berbeda. Oleh karena itu, Anda perlu menguji setiap kasus untuk menemukan kombinasi terbaik. Situasi umum adalah untuk mengatur tiga parameter (intra_op_parallelism_threads dan inter_op_parallelism_threads untuk TensorFlow, os.environ['OMP_NUM_THREADS'] untuk MKL-DNN) hingga setengah jumlah vCPU (inti fisik) atau jumlah total vCPU.

Metode menara

Untuk mereplikasi model melalui GPU, setiap GPU mendapatkan instance forward pass-nya sendiri. Contoh dari forward pass disebut a menara. Metode menara hampir selalu digunakan untuk perangkat GPU. Untuk membandingkan kecepatan pelatihan dengan metode lain, di sini kami juga menggunakan metode menara untuk perangkat CPU kami.

Jika Anda tidak menyetel perangkat CPU secara manual, TensorFlow tidak menggunakan metode menara untuk menghitung rata-rata gradien, sehingga Anda tidak perlu menskalakan ukuran batch dalam kasus seperti itu.

1. Atur perangkat CPU secara manual:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))

2. penggunaan replicate_model_fn untuk membungkus model_fn:

DeepFM = tf.estimator.Estimator(model_fn=tf.contrib.estimator.replicate_model_fn(model_fn, devices=device_list), model_dir=FLAGS.model_dir, params=model_params, config=config)

3. penggunaan TowerOptimizer untuk membungkus optimizer:

optimizer = tf.contrib.estimator.TowerOptimizer(optimizer)

4. Bungkus Anda model_fn:

with tf.variable_scope(‘deepfm_model’, reuse=tf.AUTO_REUSE)

5. Skala ukuran batch ke (NUM_CPU – 1).

Mari kita lihat perbedaan penggunaan CPU dengan mode menara diaktifkan. Gambar berikut menunjukkan penggunaan CPU instance ml.c5.18xlarge dengan konfigurasi berikut:

Tidak ada Tower + data LibSVM + mode pipa + penonaktifan pengikatan MKL-DNN + pengaturan paralelisme intra/inter op TensorFlow ke jumlah maksimum vCPU instance

Gambar berikut menunjukkan penggunaan CPU instance ml.c5.18xlarge dengan konfigurasi berikut:

Menara dengan perangkat CPU yang disetel + data LibSVM + mode pipa + penonaktifan pengikatan MKL-DNN + pengaturan paralelisme intra/inter op TensorFlow ke jumlah maksimum vCPU instans

Penggunaan CPU lebih tinggi saat menggunakan metode menara, dan melebihi jumlah inti fisik.

Strategi Cermin TensorFlow

TensorFlow MirroredStrategy berarti pelatihan sinkron di beberapa replika di satu mesin. Strategi ini biasanya digunakan untuk pelatihan pada satu mesin dengan beberapa GPU. Untuk membandingkan kecepatan pelatihan dengan metode lain, kami menggunakan MirroredStrategy untuk perangkat CPU kami.

Saat menggunakan TensorFlow MirroredStrategy, jika Anda tidak menyetel perangkat CPU, TensorFlow hanya menggunakan satu CPU sebagai pekerja tunggal, yang merupakan pemborosan sumber daya. Kami merekomendasikan pengaturan perangkat CPU secara manual, karena itu akan melakukan operasi pengurangan pada /CPU:0, sehingga /CPU:0 perangkat tidak digunakan sebagai replika di sini. Lihat kode berikut:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))
mirrored_strategy = tf.distribute.MirroredStrategy(devices=devices_list)
	else:
mirrored_strategy = tf.distribute.MirroredStrategy()

# Set strategy to config:
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
eval_distribute=mirrored_strategy,
session_config = config)

Anda perlu menskalakan ukuran batch saat menggunakan MirroredStrategy; misalnya, skala ukuran batch ke kelipatan jumlah perangkat GPU.

Untuk sub-strategi saat Anda mengatur perangkat CPU, jika Anda tidak mengatur cross_device_ops parameter dalam tf.distribute.MirroredStrategy(), TensorFlow menggunakan ReductionToOneDevice sub-strategi secara default. Namun, jika Anda mengatur HierarchicalCopyAllReduce sebagai sub-strategi, TensorFlow hanya melakukan pekerjaan pengurangan /CPU:0. Saat Anda menggunakan API kumpulan data TensorFlow dan mendistribusikan strategi bersama-sama, objek kumpulan data harus dikembalikan, bukan fitur dan label dalam fungsi input_fn.

Biasanya, TensorFlow MirroredStrategy lebih lambat daripada metode menara pada pelatihan CPU, jadi kami tidak menyarankan penggunaan MirroredStrategy pada host tunggal multi-CPU.

Horovod

Horovod adalah framework pelatihan deep learning terdistribusi untuk TensorFlow, Keras, PyTorch, dan Apache MXNet. Tujuan Horovod adalah membuat pembelajaran mendalam terdistribusi menjadi cepat dan mudah digunakan.

Ada parameter distribution di SageMaker Python SDK Estimator API, yang dapat Anda gunakan untuk menyatakan pelatihan terdistribusi Horovod. SageMaker menyediakan infrastruktur dan menjalankan skrip Anda dengan MPI. Lihat kode berikut:

hvd_processes_per_host = 4
distribution = {'mpi': { 
'enabled': True, 
'processes_per_host': hvd_processes_per_host,
'custom_mpi_options': '-verbose --NCCL_DEBUG=INFO -x OMPI_MCA_btl_vader_single_copy_mechanism=none' 
} 
}

Saat memilih instans GPU seperti ml.p3.8xlarge, Anda perlu menyematkan setiap GPU untuk setiap pekerja:

config = tf.ConfigProto()
config.gpu_options.visible_device_list = str(hvd.local_rank())

Untuk mempercepat konvergensi model, skalakan tingkat pembelajaran dengan jumlah pekerja menurut dokumentasi resmi Horovod. Namun, dalam proyek dunia nyata, Anda harus menskalakan tingkat pembelajaran sampai batas tertentu, tetapi tidak dengan jumlah pekerja, yang menghasilkan kinerja model yang buruk. Misalnya, jika tingkat pembelajaran awal adalah 0.001, kami menskalakan tingkat pembelajaran menjadi 0.0015, bahkan jika jumlah pekerja adalah empat atau lebih.

Umumnya, hanya yang utama (peringkat Horovod 0) yang menyimpan pos pemeriksaan dan model serta operasi evaluasi. Anda tidak perlu menskalakan ukuran batch saat menggunakan Horovod. SageMaker menawarkan Mode pipa untuk mengalirkan data dari Layanan Penyimpanan Sederhana Amazon (Amazon S3) ke dalam instance pelatihan. Saat Anda mengaktifkan mode Pipa, ketahuilah bahwa pekerja yang berbeda pada host yang sama perlu menggunakan saluran yang berbeda untuk menghindari kesalahan. Ini karena proses pekerja pertama membaca data FIFO/saluran, dan proses pekerja lain pada instans yang sama akan hang karena mereka tidak dapat membaca data dari FIFO/saluran yang sama, sehingga Horovod tidak bekerja dengan baik. Untuk menghindari masalah ini, atur saluran sesuai dengan jumlah pekerja per instance. Setidaknya pastikan bahwa pekerja yang berbeda pada host yang sama mengkonsumsi saluran yang berbeda; saluran yang sama dapat dikonsumsi oleh pekerja di host yang berbeda.

Saat menggunakan Horovod, Anda mungkin mengalami kesalahan berikut:

“One or more tensors were submitted to be reduced, gathered or broadcasted by subset of ranks and are waiting for remainder of ranks for more than 60 seconds. This may indicate that different ranks are trying to submit different tensors or that only subset of ranks is submitting tensors, which will cause deadlock.”

Kemungkinan penyebab masalah ini adalah peringkat tertentu (seperti peringkat 0) bekerja lebih lambat atau melakukan lebih banyak pekerjaan daripada peringkat lain, dan ini menyebabkan peringkat lain menunggu lama. Meskipun peringkat 0 terkadang harus melakukan lebih banyak pekerjaan daripada peringkat lainnya, perlu dicatat bahwa peringkat 0 seharusnya tidak melakukan banyak hal untuk waktu yang lama. Misalnya, untuk evaluasi model pada set validasi dan menyimpan pos pemeriksaan selama pelatihan, jika tidak dapat dihindari bahwa operasi ini akan memakan waktu lama, yang dapat menyebabkan kesalahan, salah satu solusinya adalah membiarkan semua pekerja melakukan pekerjaan yang sama seperti peringkat 0 (pos pemeriksaan tabungan, evaluasi, dan sebagainya).

Pecahan data adalah salah satu hal terpenting untuk dipertimbangkan saat menggunakan pelatihan terdistribusi. Anda dapat menggunakan TensorFlow dataset.shard() dalam naskah Anda. SageMaker juga menawarkan fitur pecahan dataset di saluran masukan dengan mengatur distribution=S3shardbykey dalam saluran kumpulan data. Lihat kode berikut:

dataset = PipeModeDataset(channel, record_format='TFRecord')

number_host = len(FLAGS.hosts)

if FLAGS.enable_data_multi_path : # If there are multi channels mapping with different S3 path
    if FLAGS.enable_s3_shard == False :
        if number_host > 1:
            index = hvd.rank() // FLAGS.worker_per_host
            dataset = dataset.shard(number_host, index)
else :
    if FLAGS.enable_s3_shard :
        dataset = dataset.shard(FLAGS.worker_per_host, hvd.local_rank())
    else :
        dataset = dataset.shard(hvd.size(), hvd.rank())

Gambar berikut menunjukkan hasil saat menggunakan Horovod (ml.c5.18xlarge, Horovod + LibSVM + pengaturan intra op dan inter op default), yang dapat Anda bandingkan dengan metode menara.

Pelatihan terdistribusi dengan beberapa GPU dalam satu instans

Adalah normal untuk memulai pelatihan terdistribusi dengan beberapa GPU pada satu instans karena ilmuwan data hanya perlu mengelola satu instans dan memanfaatkan interlink berkecepatan tinggi antar GPU. Tugas pelatihan SageMaker mendukung beberapa jenis instans yang memiliki beberapa GPU pada satu instans, seperti ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge, dan ml.p4d.24xlarge. Metodenya sama dengan beberapa CPU dalam satu instance, tetapi dengan beberapa perubahan dalam skrip.

Metode menara

Metode menara di sini hampir sama dengan pelatihan multi-CPU. Anda perlu menskalakan ukuran batch sesuai dengan jumlah GPU yang digunakan.

Strategi Cermin TensorFlow

Sub-strategi default dari MirroredStrategy is NcclAllReduce. Anda perlu menskalakan ukuran batch sesuai dengan jumlah GPU yang digunakan. Lihat kode berikut:

mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
				eval_distribute=mirrored_strategy)

Percepat pelatihan di banyak instance

Scaling out selalu menjadi pilihan untuk meningkatkan kecepatan latihan. Semakin banyak ilmuwan data memilih ini sebagai opsi default sehubungan dengan pelatihan terdistribusi. Di bagian ini, kami membahas strategi untuk pelatihan terdistribusi dengan banyak host.

Beberapa CPU dengan banyak instance

Ada empat metode utama untuk menggunakan beberapa CPU dengan beberapa instans saat mengaktifkan pelatihan terdistribusi:

• • Server parameter tanpa mengatur paralelisme operator secara manual pada perangkat CPU
  • Server parameter dengan pengaturan paralelisme operator secara manual pada perangkat CPU
  • Server parameter dengan menara (mengatur perangkat CPU secara manual, dan mengatur allow_soft_placement=True in tf.ConfigProto)
  • Horovod

Saat menggunakan server parameter di tf.estimator API, jalur pos pemeriksaan harus jalur yang dapat dibagikan seperti Amazon S3 atau jalur lokal Layanan File Amazon Elastis (Amazon EFS) pemetaan ke wadah. Untuk server parameter di tf.keras, jalur pos pemeriksaan dapat diatur ke jalur lokal. Untuk Horovod, jalur pos pemeriksaan dapat diatur ke jalur lokal dari instance pelatihan.

Saat menggunakan server parameter dan tf.estimator API dengan jalur pos pemeriksaan ke Amazon S3, jika modelnya cukup besar, Anda mungkin menemukan kesalahan utama macet saat menyimpan pos pemeriksaan ke S3. Anda dapat menggunakan penampung bawaan SageMaker TensorFlow 1.15 atau TensorFlow 1.15.2 atau menggunakan Amazon EFS sebagai jalur pos pemeriksaan berbagi.

Saat menggunakan server parameter untuk beberapa host, beban parameter pada setiap proses server parameter mungkin tidak seimbang (terutama bila ada variabel tabel embedding yang relatif besar), yang dapat menyebabkan kesalahan. Anda dapat memeriksa ukuran file setiap pos pemeriksaan pecahan di Amazon S3 untuk menentukan apakah parameter pada server parameter seimbang, karena setiap server parameter sesuai dengan pecahan file pos pemeriksaan. Untuk menghindari masalah seperti itu, Anda dapat menggunakan fungsi partisi untuk mencoba membuat parameter setiap server parameter terdistribusi secara merata:

with tf.variable_scope('deepfm_model', reuse=tf.AUTO_REUSE, partitioner = tf.fixed_size_partitioner(num_shards=len(FLAGS.hosts))):

GPU tunggal dengan banyak instans

Tugas pelatihan SageMaker mendukung instans yang hanya memiliki satu GPU, seperti seri ml.p3.xlarge, ml.g4dn, dan ml.g5. Ada dua metode utama yang digunakan dalam skenario ini: server parameter dan Horovod.

Metode pelatihan terdistribusi server parameter bawaan dari SageMaker adalah memulai proses server parameter dan proses pekerja untuk setiap instance pelatihan (setiap server parameter hanya bertanggung jawab untuk sebagian dari parameter model), jadi defaultnya adalah multi-mesin tunggal- pelatihan GPU. Pelatihan terdistribusi server parameter bawaan SageMaker adalah metode pembaruan gradien asinkron. Untuk mengurangi dampak pembaruan asinkron pada konvergensi pelatihan, sebaiknya kurangi kecepatan pembelajaran. Jika Anda ingin menggunakan semua GPU pada instans, Anda perlu menggunakan kombinasi server parameter dan metode menara.

Untuk Horovod, atur saja processes_per_host=1 dalam parameter distribusi SageMaker Python Estimator API.

Beberapa GPU dengan banyak instance

Untuk server parameter dan metode menara, perubahan kode pada dasarnya sama dengan metode menara untuk satu instance dengan beberapa GPU, dan tidak perlu menyetel perangkat GPU secara manual.

Untuk Horovod, setel processes_per_host dalam parameter distribusi ke jumlah GPU dari setiap instance pelatihan. Jika Anda menggunakan mode Pipa, jumlah pekerja per instans harus sesuai dengan jumlah saluran.

Pipa data

Selain infrastruktur yang telah kita bahas, ada hal penting lain yang perlu dipertimbangkan: jalur pipa data. Pipa data mengacu pada cara Anda memuat data dan mengubah data sebelum dimasukkan ke jaringan saraf. CPU digunakan untuk menyiapkan data, sedangkan GPU digunakan untuk menghitung data dari CPU. Karena GPU adalah sumber daya yang mahal, lebih banyak waktu idle GPU tidak efisien; saluran data yang baik dalam tugas pelatihan Anda dapat meningkatkan penggunaan GPU dan CPU.

Saat Anda mencoba mengoptimalkan jalur input data TensorFlow, pertimbangkan urutan API yang digunakan dalam Kumpulan data TensorFlow, ukuran data pelatihan (banyak file kecil atau beberapa file besar), ukuran batch, dan sebagainya.

Mari kita lihat interaksi antara GPU dan CPU selama pelatihan. Gambar berikut membandingkan interaksi dengan dan tanpa pipeline.

Pipeline yang lebih baik dapat mengurangi waktu idle GPU. Simak tips berikut ini:

• Gunakan logika fungsi sederhana dalam mengekstraksi fitur dan label
• Ambil sampel terlebih dahulu ke memori
• Kurangi I/O disk yang tidak perlu dan I/O jaringan
• Cache fitur dan label yang diproses dalam memori
• Kurangi jumlah waktu replikasi antara CPU dan GPU
• Minta pekerja yang berbeda menangani bagian yang berbeda dari kumpulan data pelatihan
• Kurangi waktu pemanggilan API set data TensorFlow

TensorFlow menyediakan API transformasi yang terkait dengan format kumpulan data, dan urutan API transformasi di TensorFlow sangat memengaruhi kecepatan pelatihan. Urutan terbaik untuk memanggil API set data TensorFlow perlu diuji. Berikut ini adalah beberapa prinsip dasar:

• Gunakan peta vektor. Ini berarti memanggil API kumpulan dataset TensorFlow terlebih dahulu, lalu API peta kumpulan data. Fungsi penguraian khusus yang disediakan dalam fungsi peta, seperti decode_tfrecord dalam kode sampel, mem-parsing kumpulan data mini. Sebaliknya, petakan terlebih dahulu dan kemudian batch adalah peta skalar, dan fungsi pengurai khusus hanya memproses satu sampel.
• Gunakan API cache set data TensorFlow untuk menyimpan fitur dan label dalam cache. Letakkan API cache set data TensorFlow sebelum API pengulangan set data TensorFlow, jika tidak, penggunaan RAM akan meningkat secara linier setiap periode. Jika set data sebesar RAM, jangan gunakan API cache set data TensorFlow. Jika Anda perlu menggunakan API cache set data TensorFlow dan API acak, pertimbangkan untuk menggunakan urutan berikut: buat objek set data TensorFlow -> API cache -> API acak -> API batch -> API peta -> API ulangi -> API prefetch.
• Gunakan tfrecord format dataset lebih dari format LibSVM.
• Mode file atau mode Pipa bergantung pada format kumpulan data dan jumlah file Anda. Itu tfrecorddataset API dapat mengatur num_parallel_reads untuk membaca banyak file secara paralel dan mengatur buffer_size untuk mengoptimalkan pembacaan data, sedangkan pipemodedataset API tidak memiliki pengaturan seperti itu. Mode pipa lebih cocok untuk situasi di mana satu file besar dan jumlah total file kecil. Sebaiknya gunakan pekerjaan pemrosesan SageMaker untuk melakukan pekerjaan prapemrosesan, seperti menggabungkan beberapa file ke file yang lebih besar menurut label, menggunakan metode pengambilan sampel untuk membuat kumpulan data lebih seimbang, dan mengacak kumpulan data seimbang.

Lihat contoh kode berikut:

def decode_tfrecord(batch_examples):
        # The feature definition here should BE consistent with LibSVM TO TFRecord process.
        features = tf.parse_example(batch_examples,
                                           features={
                                               "label": tf.FixedLenFeature([], tf.float32),
                                               "ids": tf.FixedLenFeature(dtype=tf.int64, shape=[FLAGS.field_size]),
                                               "values": tf.FixedLenFeature(dtype=tf.float32, shape=[FLAGS.field_size]) 
                                           })
        
        batch_label = features["label"]
        batch_ids = features["ids"]
        batch_values = features["values"]
        
        return {"feat_ids": batch_ids, "feat_vals": batch_values}, batch_label


    def decode_libsvm(line):
        columns = tf.string_split([line], ' ')
        labels = tf.string_to_number(columns.values[0], out_type=tf.float32)
        splits = tf.string_split(columns.values[1:], ':')
        id_vals = tf.reshape(splits.values,splits.dense_shape)
        feat_ids, feat_vals = tf.split(id_vals,num_or_size_splits=2,axis=1)
        feat_ids = tf.string_to_number(feat_ids, out_type=tf.int32)
        feat_vals = tf.string_to_number(feat_vals, out_type=tf.float32)
        return {"feat_ids": feat_ids, "feat_vals": feat_vals}, labels

if FLAGS.pipe_mode == 0:
        dataset = tf.data.TFRecordDataset(filenames)
    else :
        # Enter Pipe mode
        dataset = PipeModeDataset(channel, record_format='TFRecord')
        
    if FLAGS.enable_s3_shard == False:
        host_rank = FLAGS.hosts.index(FLAGS.current_host)
        number_host = len(FLAGS.hosts)
        dataset = dataset.shard(number_host, host_rank)
    
    dataset = dataset.batch(batch_size, drop_remainder=True) # Batch size to use
    dataset = dataset.map(decode_tfrecord,
                          num_parallel_calls=tf.data.experimental.AUTOTUNE) 

    if num_epochs > 1:
        dataset = dataset.repeat(num_epochs)
    dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)

Untuk pelatihan tentang instans CPU, menyetel paralelisme dari intra op, inter op, dan variabel lingkungan MKL-DNN adalah titik awal yang baik.

Pelatihan presisi campuran otomatis

Hal terakhir yang kita bahas adalah pelatihan presisi campuran otomatis, yang dapat mempercepat kecepatan dan menghasilkan kinerja model. Pada tulisan ini, GPU Nvidia V100 (instance P3) dan A100 (instance P4dn) mendukung inti Tensor. Anda dapat mengaktifkan pelatihan presisi campuran di TensorFlow saat menggunakan jenis instans tersebut. Mulai dari versi 1.14, TensorFlow telah mendukung pelatihan presisi campuran otomatis. Anda dapat menggunakan pernyataan berikut untuk membungkus pengoptimal asli Anda:

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

Jika modelnya kecil dan penggunaan GPU rendah, tidak ada keuntungan dari pelatihan presisi campuran otomatis. Jika modelnya besar, pelatihan presisi campuran otomatis dapat mempercepat kecepatan pelatihan.

Kesimpulan

Saat Anda memulai pelatihan model pembelajaran mendalam di SageMaker, pertimbangkan tips berikut untuk mencapai kecepatan pelatihan yang lebih cepat:

• Coba metode multi-CPU, metode instance tunggal atau GPU tunggal, metode instance tunggal terlebih dahulu. Jika penggunaan CPU/GPU sangat tinggi (misalnya lebih dari 90%), lanjutkan ke langkah berikutnya.
• Coba lebih banyak CPU di satu host atau lebih banyak GPU di satu host. Jika pemanfaatan mendekati pemanfaatan maksimum CPU atau GPU, lanjutkan ke langkah berikutnya.
• Coba beberapa CPU atau beberapa GPU dengan banyak host.
• Anda perlu mengubah kode saat menggunakan server parameter atau Horovod. Modifikasi kode tidak sama untuk API berbasis sesi TensorFlow, tf.estimator API, dan tf.keras API. Server parameter atau Horovod mungkin menunjukkan kecepatan pelatihan yang berbeda dalam kasus dan tugas pelatihan yang berbeda, jadi cobalah kedua metode tersebut jika Anda memiliki waktu dan anggaran untuk menentukan yang terbaik.

Ingatlah nasihat berikut:

• Periksa penggunaan sebelum penskalaan, optimalkan saluran data Anda, dan buat CPU dan GPU tumpang tindih di timeline.
• Pertama-tama perbesar, lalu perkecil.
• Jika Anda tidak dapat meningkatkan penggunaan GPU setelah semua metode, coba CPU. Ada banyak kasus (terutama untuk model peringkat rasio klik-tayang) di mana total waktu pelatihan pelatihan instans CPU lebih pendek dan lebih hemat biaya daripada pelatihan instans GPU.

Kami juga memiliki contoh kode di GitHub repo, tempat kami menampilkan dua sampel pelatihan terdistribusi DeepFM di SageMaker. Salah satunya adalah server parameter TensorFlow pada instans CPU, yang lainnya adalah Horovod pada instans GPU.

Tentang Penulis

Yuhui Liang adalah Arsitek Solusi Pembelajaran Mesin Sr. Dia berfokus pada promosi dan penerapan pembelajaran mesin, dan sangat terlibat dalam banyak proyek pembelajaran mesin pelanggan. Dia memiliki pengalaman yang kaya dalam pelatihan terdistribusi pembelajaran mendalam, sistem rekomendasi, dan periklanan komputasi.

Shisuai Wang adalah Arsitek Solusi Pembelajaran Mesin Sr. Dia bekerja dengan pelanggan AWS untuk membantu mereka mengadopsi pembelajaran mesin dalam skala besar. Dia menikmati menonton film dan berkeliling dunia.