Amazon SageMaker'da TensorFlow 1.x hızlandırma eğitimi için en iyi uygulamalar

Günümüzde pek çok müşteri, e-ticarette reklam ve kişiselleştirme önerilerinde tıklama oranlarına yönelik derin öğrenme modellerini eğitmek için TensorFlow'u kullanıyor. Müşterilerinin davranışları değiştikçe her gün büyük miktarda yeni veri biriktirebilirler. Model yinelemesi bir veri bilimcinin günlük işlerinden biridir, ancak büyük veri kümeleri üzerinde eğitim almanın çok uzun sürmesi sorunuyla karşı karşıyadırlar.

Amazon Adaçayı Yapıcı TensorFlow ve PyTorch gibi kendi algoritmalarını ve çerçevelerini yerel olarak destekleyen, veri bilimcilerinin altyapı yerine modellere odaklanmasına yardımcı olabilecek, tam olarak yönetilen bir makine öğrenimi (ML) platformudur. SageMaker, özel iş akışlarınıza uyum sağlayan esnek, dağıtılmış eğitim seçenekleri sunar. Birçok veri bilimcinin hızlandırma eğitimi sürecinde deneyimi olmayabilir; bu yazıda size hızlı derin öğrenme modeli eğitimi için önemli olan faktörleri ve SageMaker'da TensorFlow 1.x için hızlandırma eğitiminin en iyi uygulamalarını gösteriyoruz. Ayrıca örnek kodumuz da var DerinFM SageMaker hakkında eğitim dağıtıldı GitHub repo.

TensorFlow betiğinizi SageMaker'da çalıştırdığınızda CPU/GPU kullanımını en üst düzeye çıkarmak için dikkate almanız gereken altyapı, hızlandırıcı türü, dağıtılmış eğitim yöntemi, veri yükleme yöntemi, karma hassas eğitim ve daha fazlası gibi birçok faktör vardır.

Aşağıdaki alanlardaki en iyi uygulamaları tartışıyoruz:

• Tek bir örnekte eğitimi hızlandırın
• Birden çok örnekte eğitimi hızlandırın
• Veri ardışık düzenleri
• Otomatik karma hassas eğitim

Tek bir örnekte eğitimi hızlandırın

TensorFlow betiğinizi tek bir örnekte çalıştırırken, aşağıdakiler gibi bilgisayar için optimize edilmiş bir dizi seçebilirsiniz: Amazon Elastik Bilgi İşlem Bulutu (Amazon EC2) C5 serisi veya p3.8xlarge, p3.16xlarge, p3dn.24xlarge ve p4d.24xlarge gibi tek bir örnekte birden fazla GPU'ya sahip hızlandırılmış bilgi işlem serisi.

Bu bölümde, tek bir örnekte birden fazla CPU'ya yönelik stratejileri ve tek bir örnekte birden fazla GPU ile dağıtılmış eğitimi tartışıyoruz.

Tek bir örnekte birden fazla CPU

Bu bölümde CPU cihazlarında operatörlerin paralelliğini manuel olarak ayarlamayı, tower yöntemini, TensorFlow MirroredStrategy'yi ve Horovod'u tartışıyoruz.

CPU cihazlarında operatörlerin paralelliğini manuel olarak ayarlama

TensorFlow, eğitim sürecinde işlem hesaplamasını paralelleştirmek için uygun sayıda iş parçacığını otomatik olarak seçer. Ancak, intra_op iş parçacığı havuzu ve inter_op TensorFlow tarafından sağlanan paralellik ayarları ve işletim sistemi iş parçacığının bağlamasını ayarlamak için MKL-DNN'nin ortam değişkenlerini kullanın. Aşağıdaki koda bakın:

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

ortam değişkeni KMP_AFFINITY MKL-DNN'nin değeri şu şekilde ayarlandı: granularity=fine,compact,1,0 varsayılan olarak. TensorFlow'un hem içi hem de arası geçerli örneğin maksimum vCPU sayısına ayarlandıktan sonra CPU kullanımının üst sınırı, eğitim örneğinin fiziksel çekirdek sayısıyla hemen hemen aynıdır.

Ayarlarsanız os.environ["KMP_AFFINITY"]= "verbose,disabled", işletim sistemi iş parçacığı donanım hiper iş parçacığına bağlı değildir ve CPU kullanımı fiziksel çekirdek sayısını aşabilir.

TensorFlow iç paralellik, TensorFlow ara paralellik ve MKL-DNN iş parçacığı sayısı ayarlarıyla ilgili olarak, bu üç parametrenin farklı kombinasyonları farklı eğitim hızlarıyla sonuçlanır. Bu nedenle en iyi kombinasyonu bulmak için her durumu test etmeniz gerekir. Yaygın bir durum üç parametrenin ayarlanmasıdır (intra_op_parallelism_threads ve inter_op_parallelism_threads TensorFlow için, os.environ['OMP_NUM_THREADS'] MKL-DNN için) vCPU sayısının (fiziksel çekirdek) veya toplam vCPU sayısının yarısına kadar.

Kule yöntemi

Bir modeli GPU'lar üzerinden çoğaltmak için her GPU, kendi ileri geçiş örneğini alır. İleri pas örneğine denir kule. Kule yöntemi neredeyse her zaman GPU aygıtları için kullanılır. Eğitim hızını diğer yöntemlerle karşılaştırmak için burada CPU cihazımız için tower yöntemini de kullanıyoruz.

CPU cihazını manuel olarak ayarlamazsanız TensorFlow, eğimlerin ortalamasını almak için kule yöntemini kullanmaz; dolayısıyla bu gibi durumlarda toplu iş boyutunu ölçeklendirmenize gerek kalmaz.

1. CPU cihazını manuel olarak ayarlayın:

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. kullanım replicate_model_fn sarmak için 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. kullanım TowerOptimizer sarmak için optimizer:

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

4. Sarın model_fn:

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

5. Toplu iş boyutunu (NUM_CPU – 1) olarak ölçeklendirin.

Kule modu etkinken CPU kullanımındaki farka bakalım. Aşağıdaki şekilde ml.c5.18xlarge örneğinin CPU kullanımı aşağıdaki yapılandırmayla gösterilmektedir:

Tower yok + LibSVM verileri + kanal modu + MKL-DNN bağlamayı devre dışı bırakma + örneğin maksimum vCPU sayısına TensorFlow intra/inter op paralellik ayarı

Aşağıdaki şekilde ml.c5.18xlarge örneğinin CPU kullanımı aşağıdaki yapılandırmayla gösterilmektedir:

Ayarlanmış CPU cihazı + LibSVM verileri + kanal modu + MKL-DNN devre dışı bırakma bağlaması + maksimum örnek vCPU sayısına TensorFlow intra/inter op paralellik ayarı içeren Tower

Kule yöntemi kullanıldığında CPU kullanımı daha yüksektir ve fiziksel çekirdek sayısını aşar.

TensorFlow MirroredStrateji Oyunları

TensorFlow MirroredStrategy, tek bir makinede birden fazla kopya arasında eşzamanlı eğitim anlamına gelir. Bu strateji genellikle birden fazla GPU'ya sahip bir makinede eğitim için kullanılır. Eğitim hızını başka bir yöntemle karşılaştırmak için CPU cihazımız için MirroredStrategy'yi kullanıyoruz.

TensorFlow MirroredStrategy kullanırken, CPU cihazını ayarlamazsanız, TensorFlow tek bir çalışan olarak yalnızca bir CPU kullanır, bu da kaynak israfıdır. CPU cihazını manüel olarak ayarlamanızı öneririz çünkü cihaz, bir azaltma işlemi gerçekleştirecektir. /CPU:0Böylece /CPU:0 cihaz burada kopya olarak kullanılmıyor. Aşağıdaki koda bakın:

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)

MirroredStrategy'yi kullanırken toplu iş boyutunu ölçeklendirmeniz gerekir; örneğin, toplu iş boyutunu GPU cihazı sayısının katlarına ölçeklendirin.

CPU aygıtını ayarladığınızda alt strateji için, cross_device_ops içinde parametre tf.distribute.MirroredStrategy()TensorFlow şunları kullanır: ReductionToOneDevice varsayılan olarak alt strateji. Ancak ayarlarsanız HierarchicalCopyAllReduce Alt strateji olarak TensorFlow sadece azaltma işini yapıyor /CPU:0. TensorFlow veri kümesi API'sini ve dağıtım stratejisini birlikte kullandığınızda, işlevdeki özellikler ve etiketler yerine veri kümesi nesnesi döndürülmelidir. input_fn.

Genellikle TensorFlow MirroredStrategy, CPU eğitiminde tower yönteminden daha yavaştır, bu nedenle MirroredStrategy'nin çoklu CPU'lu tek bir ana bilgisayarda kullanılmasını önermiyoruz.

Horovod

Horovod TensorFlow, Keras, PyTorch ve Apache MXNet için dağıtılmış bir derin öğrenme eğitim çerçevesidir. Horovod'un amacı, dağıtılmış derin öğrenmeyi hızlı ve kullanımı kolay hale getirmektir.

Bir parametre var distribution Horovod dağıtılmış eğitimini belirtmek için kullanabileceğiniz SageMaker Python SDK Tahmincisi API'sinde. SageMaker altyapıyı hazırlar ve komut dosyanızı MPI ile çalıştırır. Aşağıdaki koda bakın:

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

Ml.p3.8xlarge gibi bir GPU örneği seçerken her GPU'yu her çalışan için sabitlemeniz gerekir:

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

Model yakınsamasını hızlandırmak için öğrenme oranını Horovod resmi belgelerine göre çalışan sayısına göre ölçeklendirin. Ancak gerçek dünya projelerinde, öğrenme oranını bir dereceye kadar ölçeklendirmeniz gerekir, ancak çalışan sayısına göre değil, bu da kötü model performansına neden olur. Örneğin, orijinal öğrenme oranı 0.001 ise, çalışan sayısı dört veya daha fazla olsa bile öğrenme oranını 0.0015'e ölçeklendiririz.

Genellikle yalnızca birincil (Horovod sıralaması 0) denetim noktası ve modelinin yanı sıra değerlendirme işlemini de kaydeder. Horovod'u kullanırken parti boyutunu ölçeklendirmenize gerek yoktur. SageMaker teklifleri Boru modu veri akışı sağlamak için Amazon Basit Depolama Hizmeti (Amazon S3) eğitim örneklerine aktarın. Pipe modunu etkinleştirdiğinizde, hataları önlemek için aynı ana bilgisayardaki farklı çalışanların farklı kanalları kullanması gerektiğini unutmayın. Bunun nedeni, ilk çalışan işlemin FIFO/kanal verilerini okuması ve aynı örnekteki diğer çalışan işlemlerin aynı FIFO/kanaldan veri okuyamamaları nedeniyle askıda kalması ve dolayısıyla Horovod'un düzgün çalışmamasıdır. Bu sorunu önlemek için kanalları, örnek başına çalışan sayısına göre ayarlayın. En azından aynı ana bilgisayardaki farklı çalışanların farklı kanalları kullandığından emin olun; aynı kanal farklı bir ana bilgisayardaki çalışanlar tarafından kullanılabilir.

Horovod'u kullanırken aşağıdaki hatayla karşılaşabilirsiniz:

“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.”

Bu sorunun olası nedeni belli bir rütbenin (rank 0 gibi) diğer rütbelere göre daha yavaş çalışması veya daha fazla iş yapması, bu da diğer rütbelerin uzun süre beklemesine neden olmasıdır. Her ne kadar rütbe 0 bazen diğer rütbelere göre daha fazla iş yapmak zorunda kalsa da, rütbe 0'ın uzun süre pek bir şey yapmaması gerektiğini unutmamak gerekir. Örneğin, doğrulama kümesindeki model değerlendirmesi ve eğitim sırasında kontrol noktalarının kaydedilmesi için, bu işlemlerin uzun sürmesi kaçınılmazsa, bu da hatalara neden olabilir, geçici çözümlerden biri, tüm çalışanların rütbe 0 (kontrol noktaları) ile aynı işi yapmasına izin vermektir. kaydetme, değerlendirme vb.).

Veri paylaşımı, dağıtılmış eğitimi kullanırken dikkate alınması gereken en önemli şeylerden biridir. TensorFlow'u kullanabilirsiniz dataset.shard() senaryonuzda. SageMaker ayrıca bir veri kümesi parçacığı özelliği de sunar. giriş kanalı ayarlayarak distribution=S3shardbykey veri kümesi kanalında. Aşağıdaki koda bakın:

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

Aşağıdaki şekil, kule yöntemiyle karşılaştırabileceğiniz Horovod (ml.c5.18xlarge, Horovod + LibSVM + varsayılan intra op ve inter op ayarı) kullanıldığında ortaya çıkan sonucu gösterir.

Tek bir örnekte birden fazla GPU ile dağıtılmış eğitim

Veri bilimcilerin yalnızca bir örneği yönetmesi ve GPU'lar arasındaki yüksek hızlı bağlantının avantajından yararlanması gerektiğinden, dağıtılmış eğitime tek bir örnekte birden fazla GPU ile başlamak normaldir. SageMaker eğitim işleri, ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge ve ml.p4d.24xlarge gibi tek bir örnekte birden fazla GPU'ya sahip birden fazla örnek türünü destekler. Yöntem, tek bir örnekte birden fazla CPU kullanılmasıyla aynıdır ancak komut dosyasında birkaç değişiklik vardır.

Kule yöntemi

Buradaki kule yöntemi, çoklu CPU eğitimindekiyle hemen hemen aynıdır. Toplu iş boyutunu kullanılan GPU sayısına göre ölçeklendirmeniz gerekir.

TensorFlow MirroredStrateji Oyunları

Varsayılan alt strateji MirroredStrategy is NcclAllReduce. Toplu iş boyutunu kullanılan GPU sayısına göre ölçeklendirmeniz gerekir. Aşağıdaki koda bakın:

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

Birden çok örnekte eğitimi hızlandırın

Ölçeklendirme her zaman eğitim hızını artırmak için bir seçenektir. Giderek daha fazla veri bilimci, dağıtılmış eğitim açısından bunu varsayılan seçenek olarak seçiyor. Bu bölümde birden fazla ana bilgisayarla dağıtılmış eğitim stratejilerini tartışıyoruz.

Birden çok örneğe sahip birden çok CPU

Dağıtılmış eğitimi etkinleştirirken birden çok CPU'yu birden çok örnekle kullanmanın dört ana yöntemi vardır:

• • CPU cihazlarında operatörlerin paralelliğini manuel olarak ayarlamadan parametre sunucusu
  • Operatörlerin CPU cihazlarındaki paralelliğini manuel olarak ayarlayan parametre sunucusu
  • Kuleli parametre sunucusu (CPU cihazlarının manuel olarak ayarlanması ve allow_soft_placement=True in tf.ConfigProto)
  • Horovod

Bir parametre sunucusu kullanıldığında tf.estimator API, kontrol noktasının yolu Amazon S3 veya yerel API yolu gibi paylaşılabilir bir yol olmalıdır. Amazon Elastik Dosya Hizmeti (Amazon EFS) kapsayıcıyla eşleme. Bir parametre sunucusu için tf.keras, denetim noktası yolu yerel yola ayarlanabilir. Horovod için kontrol noktası yolu, eğitim örneğinin yerel yoluna ayarlanabilir.

Bir parametre sunucusu kullanıldığında ve tf.estimator Amazon S3'e giden kontrol noktası yolu ile API, model oldukça büyükse, birincil kontrol noktasının S3'e kaydedilmesinde takılı kalması hatasıyla karşılaşabilirsiniz. SageMaker'ın yerleşik konteyneri TensorFlow 1.15 veya TensorFlow 1.15.2'yi kullanabilir veya paylaşımın kontrol noktası yolu olarak Amazon EFS'yi kullanabilirsiniz.

Birden fazla ana bilgisayar için bir parametre sunucusu kullanıldığında, her bir parametre sunucusu işlemindeki parametre yükü dengesiz olabilir (özellikle nispeten büyük yerleştirme tablosu değişkenleri olduğunda), bu da hatalara neden olabilir. Her parametre sunucusu, kontrol noktası dosyasının bir parçasına karşılık geldiğinden, parametre sunucusundaki parametrelerin dengeli olup olmadığını belirlemek için Amazon S3'teki her bir parçanın kontrol noktasının dosya boyutunu kontrol edebilirsiniz. Bu tür sorunları önlemek için, her parametre sunucusunun parametrelerinin eşit şekilde dağıtılmasını sağlamak üzere bölümleyici işlevini kullanabilirsiniz:

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

Birden çok örneğe sahip tek GPU

SageMaker eğitim işleri, ml.p3.xlarge, ml.g4dn ve ml.g5 serisi gibi yalnızca tek GPU'ya sahip örnekleri destekler. Bu senaryoda kullanılan iki ana yöntem vardır: parametre sunucuları ve Horovod.

SageMaker'ın yerleşik parametre sunucusu dağıtılmış eğitim yöntemi, her eğitim örneği için bir parametre sunucusu süreci ve bir çalışma süreci başlatmaktır (her parametre sunucusu, model parametrelerinin yalnızca bir kısmından sorumludur), dolayısıyla varsayılan, çok makineli tekli sistemdir. GPU eğitimi. SageMaker'ın yerleşik parametre sunucusu dağıtılmış eğitimi, eşzamansız bir degrade güncelleme yöntemidir. Eşzamansız güncellemelerin eğitim yakınsaması üzerindeki etkisini azaltmak için öğrenme oranının azaltılması önerilir. Örnekteki tüm GPU'ları kullanmak istiyorsanız parametre sunucuları ve tower yönteminin bir kombinasyonunu kullanmanız gerekir.

Horovod için ayarlamanız yeterli processes_per_host=1 SageMaker Python Tahmincisi API'sinin dağıtım parametresinde.

Birden çok örneğe sahip birden çok GPU

Parametre sunucuları ve kule yöntemi için kod değişiklikleri temel olarak birden fazla GPU'ya sahip tek bir örnek için kule yöntemiyle aynıdır ve GPU aygıtlarını manuel olarak ayarlamaya gerek yoktur.

Horovod için dağıtım parametresindeki Process_per_Host değerini her eğitim örneğinin GPU sayısına ayarlayın. Pipe modunu kullanıyorsanız örnek başına çalışan sayısının kanal sayısıyla eşleşmesi gerekir.

Veri ardışık düzenleri

Tartıştığımız altyapıya ek olarak dikkate alınması gereken başka bir önemli konu daha var: veri hattı. Veri hattı, verileri sinir ağlarına beslenmeden önce nasıl yüklediğinizi ve verileri nasıl dönüştürdüğünüzü ifade eder. CPU veri hazırlamak için kullanılırken GPU, CPU'dan gelen verileri hesaplamak için kullanılır. GPU pahalı bir kaynak olduğundan, daha fazla GPU boşta kalma süresi verimsizdir; Eğitim işinizde iyi bir veri hattı GPU ve CPU kullanımını iyileştirebilir.

TensorFlow veri giriş hattınızı optimize etmeye çalışırken, kullanılan API sırasını göz önünde bulundurun. TensorFlow veri kümeleri, eğitim veri boyutu (çok sayıda küçük dosya veya birkaç büyük dosya), toplu iş boyutu vb.

Eğitim sırasında GPU ve CPU arasındaki etkileşime bakalım. Aşağıdaki şekiller boru hattı olan ve olmayan etkileşimleri karşılaştırmaktadır.

Daha iyi bir işlem hattı GPU'nun boşta kalma süresini azaltabilir. Aşağıdaki ipuçlarını göz önünde bulundurun:

• Özellikleri ve etiketleri çıkarırken basit fonksiyon mantığını kullanın
• Örnekleri belleğe önceden getir
• Gereksiz disk G/Ç'sini ve ağ G/Ç'sini azaltın
• İşlenen özellikleri ve etiketleri bellekte önbelleğe alın
• CPU ve GPU arasındaki çoğaltma sayısını azaltın
• Farklı çalışanların eğitim veri setinin farklı bölümleriyle ilgilenmesini sağlayın
• TensorFlow veri kümesi API'sini çağırma sürelerini azaltın

TensorFlow, veri kümesi formatlarıyla ilgili bir dönüştürme API'si sağlar ve TensorFlow'daki dönüştürme API'sinin sırası, eğitim hızını büyük ölçüde etkiler. TensorFlow veri kümesi API'sini çağırmanın en iyi sırasının test edilmesi gerekir. Aşağıda bazı temel ilkeler yer almaktadır:

• Vektörleştirilmiş bir harita kullanın. Bu, önce TensorFlow veri kümesi toplu API'sini, ardından veri kümesi eşleme API'sini çağırmak anlamına gelir. Harita işlevinde sağlanan özel ayrıştırma işlevi, örneğin decode_tfrecord örnek kodda, küçük bir veri kümesini ayrıştırır. Bunun tersine, önce harita, sonra toplu iş skaler bir haritadır ve özel ayrıştırıcı işlevi yalnızca bir örneği işler.
• Özellikleri ve etiketleri önbelleğe almak için TensorFlow veri kümesi önbellek API'sini kullanın. TensorFlow veri kümesi önbellek API'sini TensorFlow veri kümesi tekrarlama API'sinin önüne koyun, aksi takdirde RAM kullanımı doğrusal olarak dönem dönem artar. Veri kümesi RAM kadar büyükse TensorFlow veri kümesi önbellek API'sini kullanmayın. TensorFlow veri kümesi önbellek API'sini kullanmanız ve API'yi karıştırmanız gerekiyorsa, aşağıdaki sırayı kullanmayı düşünün: TensorFlow veri kümesi nesnesi oluşturun -> önbellek API'si -> karıştırma API'si -> toplu API -> harita API'si -> API'yi tekrarla -> API'yi önceden getir.
• Kullan tfrecord veri kümesi biçimi LibSVM biçiminden daha fazla.
• Dosya modu veya Boru modu, veri kümenizin biçimine ve dosya miktarına bağlıdır. tfrecorddataset API ayarlayabilir num_parallel_reads birden fazla dosyayı paralel olarak okumak ve ayarlamak için buffer_size Verilerin okunmasını optimize etmek için pipemodedataset API'nin bu tür ayarları yoktur. Boru modu, tek bir dosyanın büyük ve toplam dosya sayısının az olduğu durumlar için daha uygundur. Birden fazla dosyayı etiketlere göre daha büyük bir dosyada birleştirmek, veri kümesini daha dengeli hale getirmek için bir örnekleme yöntemi kullanmak ve dengeli veri kümesini karıştırmak gibi ön işleme işini yapmak için bir SageMaker işleme işi kullanmanızı öneririz.

Aşağıdaki kod örneğine bakın:

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)

CPU örneklerine ilişkin eğitim için paralelliğin ayarlanması intra op, inter opve MKL-DNN'nin ortam değişkeni iyi bir başlangıç ​​noktasıdır.

Otomatik karma hassas eğitim

Tartıştığımız son şey, hızı artırabilen ve model performansıyla sonuçlanabilen otomatik karma hassas eğitimdir. Bu yazının yazıldığı an itibariyle, Nvidia V100 GPU (P3 örneği) ve A100 (P4dn örneği) Tensor çekirdeğini desteklemektedir. Bu tür örnekleri kullanırken TensorFlow'da karma duyarlık eğitimini etkinleştirebilirsiniz. TensorFlow, 1.14 sürümünden itibaren otomatik karma hassas eğitimi desteklemektedir. Orijinal optimize edicinizi sarmak için aşağıdaki ifadeyi kullanabilirsiniz:

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

Model küçükse ve GPU kullanımı düşükse otomatik karma hassas eğitimin hiçbir avantajı yoktur. Model büyükse, otomatik karma hassas eğitim, eğitim hızını hızlandırabilir.

Sonuç

SageMaker'da derin öğrenme modeli eğitiminize başladığınızda, daha hızlı bir eğitim hızı elde etmek için aşağıdaki ipuçlarını göz önünde bulundurun:

• Önce çoklu CPU, tek örnek yöntemini veya tek GPU, tek örnek yöntemini deneyin. CPU/GPU kullanımı çok yüksekse (örneğin %90'dan fazla), bir sonraki adıma geçin.
• Tek ana bilgisayarda daha fazla CPU veya tek ana bilgisayarda daha fazla GPU deneyin. Kullanım CPU veya GPU'ların maksimum kullanımına yakınsa bir sonraki adıma geçin.
• Birden çok CPU'yu veya birden çok ana bilgisayara sahip birden çok GPU'yu deneyin.
• Parametre sunucularını veya Horovod'u kullanırken kodları değiştirmeniz gerekir. Kod değişikliği TensorFlow oturum tabanlı API için aynı değildir, tf.estimator API ve tf.keras API'dir. Bir parametre sunucusu veya Horovod, farklı eğitim durumları ve görevlerinde farklı eğitim hızları gösterebilir; bu nedenle en iyi olanı belirlemek için zamanınız ve bütçeniz varsa her iki yöntemi de deneyin.

Aşağıdaki tavsiyeyi aklınızda bulundurun:

• Ölçeklendirmeden önce kullanımı kontrol edin, veri hattınızı optimize edin ve zaman çizelgesinde CPU ile GPU'nun çakışmasını sağlayın.
• Önce ölçeği büyütün, sonra genişletin.
• Tüm yöntemlere rağmen GPU kullanımınızı artıramıyorsanız CPU'yu deneyin. CPU örneği eğitiminin toplam eğitim süresinin GPU örneği eğitiminden daha kısa ve daha uygun maliyetli olduğu birçok durum (özellikle tıklama oranı sıralama modeli için) vardır.

Ayrıca bir kod örneğimiz de var. GitHub repoBurada SageMaker'da DeepFM dağıtılmış eğitiminin iki örneğini gösteriyoruz. Biri CPU bulut sunucularındaki TensorFlow parametre sunucusu, diğeri ise GPU bulut sunucularındaki Horovod.

Yazarlar Hakkında

Yuhui Liang Kıdemli Makine Öğrenimi Çözümleri Mimarıdır. Makine öğreniminin tanıtımına ve uygulanmasına odaklanmıştır ve birçok müşterinin makine öğrenimi projelerinde derinden yer almaktadır. Derin öğrenme dağıtılmış eğitimi, öneri sistemleri ve hesaplamalı reklamcılık konusunda zengin bir deneyime sahiptir.

Shishuai Wang Kıdemli Makine Öğrenimi Çözümleri Mimarıdır. Makine öğrenimini geniş ölçekte benimsemelerine yardımcı olmak için AWS müşterileriyle birlikte çalışıyor. Film izlemeyi ve dünyayı dolaşmayı seviyor.