Parhaat käytännöt TensorFlow 1.x -kiihdytyskoulutukseen Amazon SageMakerissa

Nykyään monet asiakkaat käyttävät TensorFlowia kouluttaakseen syväoppimismalleja napsautussuhteensa suhteen mainonnassa ja personointisuosituksissa verkkokaupassa. Kun asiakkaiden käyttäytyminen muuttuu, he voivat kerätä suuria määriä uutta dataa joka päivä. Mallin iterointi on yksi datatieteilijöiden päivittäisistä töistä, mutta he kohtaavat ongelman, joka kestää liian kauan harjoitella suuria tietojoukkoja.

Amazon Sage Maker on täysin hallittu koneoppimisalusta (ML), joka voi auttaa datatieteilijöitä keskittymään malleihin infrastruktuurin sijaan, ja joka tukee omat algoritmeja ja kehyksiä, kuten TensorFlow ja PyTorch. SageMaker tarjoaa joustavia hajautettuja koulutusvaihtoehtoja, jotka mukautuvat tiettyihin työnkulkuihisi. Koska monilla datatieteilijöillä ei ehkä ole kokemusta kiihdytysharjoitusprosessista, tässä viestissä näytämme sinulle nopean syväoppimisen mallikoulutuksen kannalta tärkeitä tekijöitä sekä TensorFlow 1.x:n kiihdytyskoulutuksen parhaat käytännöt SageMakerissa. Meillä on myös mallikoodi DeepFM jaettu koulutus SageMakerissa GitHub repo.

On monia tekijöitä, jotka sinun tulee ottaa huomioon CPU/GPU-käytön maksimoimiseksi, kun suoritat TensorFlow-skriptiä SageMakerissa, kuten infrastruktuuri, kiihdytintyyppi, hajautettu koulutusmenetelmä, tietojen latausmenetelmä, sekoitettu tarkkuusharjoittelu ja paljon muuta.

Keskustelemme parhaista käytännöistä seuraavilla aloilla:

• Nopeuta harjoittelua yhdellä kertaa
• Nopeuta harjoittelua useissa tapauksissa
• Dataputket
• Automaattinen sekoitettu tarkkuusharjoittelu

Nopeuta harjoittelua yhdellä kertaa

Kun suoritat TensorFlow-skriptiä yhdessä esiintymässä, voit valita tietokoneelle optimoidun sarjan, kuten Amazonin elastinen laskentapilvi (Amazon EC2) C5-sarja tai kiihdytetty laskentasarja, jossa on useita GPU:ita yhdessä tapauksessa, kuten p3.8xlarge, p3.16xlarge, p3dn.24xlarge ja p4d.24xlarge.

Tässä osiossa käsittelemme strategioita useille prosessoreille yhdessä esiintymässä ja hajautettua koulutusta useiden GPU:iden kanssa yhdessä esiintymässä.

Useita suorittimia yhdessä esiintymässä

Tässä osiossa keskustelemme manuaalisesti operaattorien rinnakkaisuuden asettamisesta prosessorilaitteissa, tornimenetelmästä, TensorFlow MirroredStrategysta ja Horovodista.

Operaattoreiden rinnakkaisuuden manuaalinen asettaminen prosessorilaitteille

TensorFlow valitsee automaattisesti sopivan määrän säikeitä rinnakkaistaakseen toiminnan laskennan harjoitusprosessissa. Voit kuitenkin asettaa intra_op kierteet pool ja inter_op TensorFlow'n tarjoamat rinnakkaisuusasetukset ja käytä MKL-DNN:n ympäristömuuttujia OS-säikeen sitomisen määrittämiseen. Katso seuraava koodi:

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

Ympäristömuuttuja KMP_AFFINITY MKL-DNN:stä on asetettu granularity=fine,compact,1,0 oletuksena. Kun sekä TensorFlow:n sisä- että inter on asetettu nykyisen ilmentymän vCPU:iden enimmäismäärään, suorittimen käytön yläraja on melkein sama kuin koulutusesiintymän fyysisten ytimien lukumäärä.

Jos asetat os.environ["KMP_AFFINITY"]= "verbose,disabled", käyttöjärjestelmäsäie ei ole sidottu laitteiston hypersäikeeseen, ja suorittimen käyttö voi ylittää fyysisten ytimien määrän.

Mitä tulee TensorFlow-sisäisen rinnakkaisuuden, TensorFlow-suuntaisuuden ja MKL-DNN-säikeiden lukumäärän asetuksiin, näiden kolmen parametrin erilaiset yhdistelmät johtavat erilaisiin harjoitusnopeuksiin. Siksi sinun on testattava jokainen tapaus löytääksesi parhaan yhdistelmän. Yleinen tilanne on asettaa kolme parametria (intra_op_parallelism_threads ja inter_op_parallelism_threads TensorFlow'lle, os.environ['OMP_NUM_THREADS'] MKL-DNN) puoleen vCPU:iden määrästä (fyysinen ydin) tai vCPU:iden kokonaismäärästä.

Torni menetelmä

Mallin replikoimiseksi GPU:iden kautta jokainen grafiikkasuoritin saa oman eteenpäin kulkevan esiintymän. Eteenpäin heiton esiintymää kutsutaan a torni. Tornimenetelmää käytetään lähes aina GPU-laitteissa. Vertaaksemme harjoitusnopeutta muihin menetelmiin, käytämme tässä myös tornimenetelmää CPU-laitteellemme.

Jos et aseta CPU-laitetta manuaalisesti, TensorFlow ei käytä tornimenetelmää gradienttien keskiarvon laskemiseen, joten sinun ei tarvitse skaalata eräkokoa tällaisissa tapauksissa.

1. Aseta CPU-laite manuaalisesti:

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. Käyttää replicate_model_fn kääriä 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. Käyttää TowerOptimizer kääriä optimizer:

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

4. Kääri model_fn:

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

5. Skaalaa eräkoko (NUM_CPU – 1).

Tarkastellaan eroa prosessorin käyttöasteessa tornitilan ollessa käytössä. Seuraava kuva näyttää ml.c5.18xlarge-instanssin suorittimen käytön seuraavalla kokoonpanolla:

Ei tornia + LibSVM-data + putkitila + MKL-DNN:n estosidonna + TensorFlow-sisäinen/inter op -rinnakkaisasetus instanssin vCPU:iden enimmäismäärälle

Seuraava kuva näyttää ml.c5.18xlarge -esiintymän suorittimen käytön seuraavalla kokoonpanolla:

Torni, jossa on asetettu CPU-laite + LibSVM-data + putkitila + MKL-DNN:n estosidonta + TensorFlow-sisäinen/inter op -rinnakkaisasetus instanssin vCPU:iden enimmäismäärään

Prosessorin käyttö on korkeampaa tornimenetelmää käytettäessä ja se ylittää fyysisten ytimien määrän.

TensorFlow MirroredStrategy

TensorFlow MirroredStrategy tarkoittaa synkronista harjoittelua useiden replikoiden kesken yhdellä koneella. Tätä strategiaa käytetään yleensä harjoitteluun yhdellä koneella, jossa on useita GPU:ita. Harjoittelunopeuden vertaamiseksi toiseen menetelmään käytämme MirroredStrategya prosessorilaitteellamme.

TensorFlow MirroredStrategya käytettäessä, jos et aseta CPU-laitetta, TensorFlow käyttää vain yhtä CPU:ta yksittäisenä työntekijänä, mikä on resurssien tuhlausta. Suosittelemme CPU-laitteen manuaalista asetusta, koska se vähentää toimintaa /CPU:0, Joten /CPU:0 laitetta ei käytetä tässä kopiona. Katso seuraava koodi:

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)

Sinun täytyy skaalata eräkoko, kun käytät MirroredStrategya; esimerkiksi skaalata eräkoko GPU-laitteiden lukumäärän kerrannaiseksi.

Alistrategialle, kun asetat CPU-laitteen, jos et aseta cross_device_ops parametri sisään tf.distribute.MirroredStrategy(), TensorFlow käyttää ReductionToOneDevice oletuksena alistrategia. Jos kuitenkin asetat HierarchicalCopyAllReduce alistrategiana TensorFlow tekee vain vähennystyön /CPU:0. Kun käytät TensorFlow-tietojoukon API:a ja jaat strategiaa yhdessä, datajoukkoobjekti tulee palauttaa funktion ominaisuuksien ja tunnisteiden sijaan input_fn.

Yleensä TensorFlow MirroredStrategy on hitaampi kuin tornimenetelmä CPU-koulutuksessa, joten emme suosittele MirroredStrategyn käyttöä usean suorittimen yksittäisessä isännässä.

Horovod

Horovod on hajautettu syväoppimisen koulutuskehys TensorFlowille, Kerasille, PyTorchille ja Apache MXNetille. Horovodin tavoitteena on tehdä hajautetusta syväoppimisesta nopeaa ja helppokäyttöistä.

Siellä on parametri distribution SageMaker Python SDK Estimator API:ssa, jota voit käyttää Horovodin hajautetun koulutuksen ilmoittamiseen. SageMaker huolehtii infrastruktuurista ja suorittaa komentosarjasi MPI:n avulla. Katso seuraava koodi:

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

Kun valitset GPU-esiintymän, kuten ml.p3.8xlarge, sinun on kiinnitettävä jokainen GPU jokaiselle työntekijälle:

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

Mallin lähentymisen nopeuttamiseksi skaalaa oppimisaste työntekijöiden lukumäärän mukaan Horovodin virallisen dokumentaation mukaan. Reaalimaailman projekteissa oppimisnopeutta tulisi kuitenkin skaalata jossain määrin, mutta ei työntekijöiden lukumäärän mukaan, mikä johtaa huonoon mallin suorituskykyyn. Jos esimerkiksi alkuperäinen oppimisaste on 0.001, skaalaamme oppimisasteen arvoon 0.0015, vaikka työntekijöitä olisi neljä tai enemmän.

Yleensä vain ensisijainen (Horovod rank 0) tallentaa tarkistuspisteen ja mallin sekä arviointitoiminnon. Sinun ei tarvitse skaalata eräkokoa, kun käytät Horovodia. SageMaker tarjoaa Putkitila datan suoratoistamiseen Amazonin yksinkertainen tallennuspalvelu (Amazon S3) koulutustapahtumiin. Kun otat Pipe-tilan käyttöön, ota huomioon, että saman isännän eri työntekijöiden on käytettävä eri kanavia virheiden välttämiseksi. Tämä johtuu siitä, että ensimmäinen työntekijäprosessi lukee FIFO-/kanavatiedot ja muut saman ilmentymän työntekijäprosessit jumiutuvat, koska he eivät pysty lukemaan tietoja samasta FIFO-/kanavasta, joten Horovod ei toimi kunnolla. Voit välttää tämän ongelman asettamalla kanavat työntekijöiden lukumäärän mukaan. Varmista ainakin, että saman isännän eri työntekijät käyttävät eri kanavia; eri isäntäkoneen työntekijät voivat käyttää samaa kanavaa.

Kun käytät Horovodia, saatat kohdata seuraavan virheen:

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

Mahdollinen syy tähän ongelmaan on, että tietty arvo (kuten arvo 0) toimii hitaammin tai tekee enemmän töitä kuin muut arvot, ja tämä saa muut rivit odottamaan pitkään. Vaikka sijoitus 0 joutuu joskus tekemään enemmän työtä kuin muut sijoitukset, on huomattava, että sijoitus 0 ei saisi tehdä paljon pitkään aikaan. Esimerkiksi validointijoukon mallin arvioinnissa ja tarkistuspisteiden tallentamisessa koulutuksen aikana, jos on väistämätöntä, että nämä toiminnot kestävät kauan, mikä voi aiheuttaa virheitä, yksi kiertotapa on antaa kaikkien työntekijöiden tehdä samat työt kuin 0 (tarkistuspisteet). säästäminen, arviointi ja niin edelleen).

Tietojen jakaminen on yksi tärkeimmistä asioista, joka on otettava huomioon hajautettua koulutusta käytettäessä. Voit käyttää TensorFlow'ta dataset.shard() käsikirjoituksessasi. SageMaker tarjoaa myös tietojoukon sirpaleominaisuuden tulokanava asettamalla distribution=S3shardbykey tietojoukon kanavassa. Katso seuraava koodi:

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

Seuraavassa kuvassa näkyy tulos käytettäessä Horovodia (ml.c5.18xlarge, Horovod + LibSVM + oletussisäinen käyttö ja inter op -asetus), jota voit verrata tornimenetelmään.

Hajautettu koulutus useilla GPU:illa yhdessä tapauksessa

On normaalia aloittaa hajautettu koulutus useilla GPU:illa yhdessä esiintymässä, koska datatieteilijöiden tarvitsee hallita vain yhtä ilmentymää ja hyödyntää GPU:iden välistä nopeaa vuorovaikutusta. SageMaker-koulutustyöt tukevat useita ilmentymätyyppejä, joissa on useita GPU:ita yhdessä esiintymässä, kuten ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge ja ml.p4d.24xlarge. Menetelmä on sama kuin useita suorittimia yhdessä esiintymässä, mutta skriptiin on tehty muutamia muutoksia.

Torni menetelmä

Tornimenetelmä on tässä melkein sama kuin moniprosessorikoulutuksessa. Eräkoko on skaalattava käytössä olevien grafiikkasuorittimien määrän mukaan.

TensorFlow MirroredStrategy

Kohteen oletusalistrategia MirroredStrategy is NcclAllReduce. Eräkoko on skaalattava käytössä olevien grafiikkasuorittimien määrän mukaan. Katso seuraava koodi:

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

Nopeuta harjoittelua useissa tapauksissa

Skaalaus on aina vaihtoehto harjoitusnopeuden parantamiseksi. Yhä useammat datatieteilijät valitsevat tämän oletusvaihtoehdoksi hajautetun koulutuksen osalta. Tässä osiossa käsittelemme hajautetun koulutuksen strategioita useiden isäntien kanssa.

Useita suorittimia, joissa on useita esiintymiä

On olemassa neljä päämenetelmää useiden CPU:iden käyttämiseen useissa esiintymissä, kun hajautettu koulutus otetaan käyttöön:

• • Parametripalvelin ilman manuaalista operaattorin rinnakkaisasetusta CPU-laitteissa
  • Parametripalvelin, joka asettaa manuaalisesti operaattorien rinnakkaisuuden CPU-laitteissa
  • Parametripalvelin tornilla (CPU-laitteiden asetus manuaalisesti ja asetus allow_soft_placement=True in tf.ConfigProto)
  • Horovod

Kun käytät parametripalvelinta tf.estimator API, tarkistuspisteen polun on oltava jaettava polku, kuten Amazon S3 tai paikallinen polku Amazon elastinen tiedostopalvelu (Amazon EFS) kartoitus konttiin. Parametripalvelimelle sisään tf.keras, tarkistuspisteen polku voidaan asettaa paikalliseksi poluksi. Horovodille tarkistuspisteen polku voidaan asettaa koulutusesiintymän paikalliseksi poluksi.

Käytettäessä parametripalvelinta ja tf.estimator API, jolla on tarkistuspistepolku Amazon S3:een, jos malli on melko suuri, saatat kohdata virheen, jossa ensisijainen on jumissa tarkistuspisteen tallentamisessa S3:een. Voit käyttää SageMakerin sisäänrakennettua säilöä TensorFlow 1.15 tai TensorFlow 1.15.2 tai käyttää Amazon EFS:ää jaon tarkistuspistepoluna.

Käytettäessä parametripalvelinta useille koneille, kunkin parametripalvelinprosessin parametrikuormitus saattaa olla epätasapainoinen (varsinkin kun upotustaulukon muuttujia on suhteellisen suuria), mikä voi aiheuttaa virheitä. Voit tarkistaa kunkin sirpaleen tarkistuspisteen tiedostokoon Amazon S3:ssa määrittääksesi, ovatko parametripalvelimen parametrit tasapainossa, koska jokainen parametripalvelin vastaa tarkistuspistetiedoston sirpaletta. Tällaisten ongelmien välttämiseksi voit yrittää jakaa kunkin parametripalvelimen parametrit tasaisesti osiointitoiminnolla:

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

Yksi GPU, jossa on useita esiintymiä

SageMaker-koulutustyöt tukevat esiintymiä, joissa on vain yksi grafiikkasuoritin, kuten ml.p3.xlarge-, ml.g4dn- ja ml.g5-sarjat. Tässä skenaariossa käytetään kahta päämenetelmää: parametripalvelimet ja Horovod.

SageMakerin sisäänrakennettu parametripalvelimen hajautettu koulutusmenetelmä on käynnistää parametripalvelinprosessi ja työntekijäprosessi jokaiselle koulutusesiintymälle (jokainen parametripalvelin on vastuussa vain osasta mallin parametreja), joten oletusarvo on usean koneen yksi- GPU koulutus. SageMakerin sisäänrakennettu parametripalvelimen hajautettu koulutus on asynkroninen gradienttipäivitysmenetelmä. Vähentääksesi asynkronisten päivitysten vaikutusta harjoituksen lähentymiseen, on suositeltavaa vähentää oppimisnopeutta. Jos haluat käyttää kaikkia esiintymän GPU:ita, sinun on käytettävä parametripalvelimien ja tornimenetelmän yhdistelmää.

Horovodille, juuri valmiiksi processes_per_host=1 SageMaker Python Estimator -sovellusliittymän jakeluparametrissa.

Useita GPU:ita useilla esiintymillä

Parametripalvelimissa ja tornimenetelmässä koodimuutokset ovat periaatteessa samat kuin tornimenetelmä yksittäiselle esiintymälle, jossa on useita GPU:ita, eikä GPU-laitteita tarvitse asettaa manuaalisesti.

Aseta Horovodissa jakeluparametrissa process_per_host kunkin koulutusesiintymän GPU:iden lukumääräksi. Jos käytät putkitilaa, työntekijöiden määrän esiintymää kohti on vastattava kanavien määrää.

Dataputket

Keskustelemamme infrastruktuurin lisäksi on otettava huomioon toinen tärkeä asia: dataputki. Dataputkella tarkoitetaan tapaa, jolla lataat tietoja ja muunnat tietoja ennen kuin ne syötetään hermoverkkoihin. CPU:ta käytetään tietojen valmisteluun, kun taas GPU:ta käytetään tietojen laskemiseen CPU:sta. Koska GPU on kallis resurssi, enemmän GPU:n joutoaikaa on tehotonta; hyvä dataputki koulutustyössäsi voisi parantaa GPU:n ja CPU:n käyttöä.

Kun yrität optimoida TensorFlow-tietojen syöttöputkea, harkitse siinä käytettyä API-järjestystä TensorFlow-tietojoukot, harjoitustietojen koko (paljon pieniä tiedostoja tai useita suuria tiedostoja), eräkoko ja niin edelleen.

Katsotaanpa GPU:n ja CPU:n välistä vuorovaikutusta harjoittelun aikana. Seuraavissa kuvissa verrataan vuorovaikutuksia putkilinjan kanssa ja ilman sitä.

Parempi putkisto voisi lyhentää GPU:n joutoaikaa. Harkitse seuraavia vinkkejä:

• Käytä yksinkertaista funktiologiikkaa poimiessasi ominaisuuksia ja tarroja
• Esihaku näytteet muistiin
• Vähennä tarpeettomia levy-I/O- ja verkko-I/O-määriä
• Tallenna käsitellyt ominaisuudet ja tarrat välimuistiin
• Vähennä CPU:n ja GPU:n välisten replikointiaikojen määrää
• Pyydä eri työntekijöitä käsittelemään koulutustietojoukon eri osia
• Lyhennä TensorFlow-tietojoukon API:n kutsumisaikoja

TensorFlow tarjoaa tietojoukkomuotoihin liittyvän muunnos-API:n, ja muunnos-API:n järjestys TensorFlow'ssa vaikuttaa harjoitusnopeuteen paljon. TensorFlow-datajoukon API:n paras kutsujärjestys on testattava. Seuraavassa on joitain perusperiaatteita:

• Käytä vektoroitua karttaa. Tämä tarkoittaa, että kutsu ensin TensorFlow-datajoukon eräsovellusliittymä ja sitten datajoukkokartan API. Karttatoiminnon mukautettu jäsennystoiminto, kuten decode_tfrecord mallikoodissa jäsentää pienen erän tietoja. Päinvastoin, kartta ensin ja sitten erä on skalaarikartta, ja mukautettu jäsennystoiminto käsittelee vain yhden näytteen.
• Käytä TensorFlow-tietojoukon välimuistisovellusliittymää ominaisuuksien ja tunnisteiden välimuistiin tallentamiseen. Aseta TensorFlow-tietojoukon välimuistin API ennen TensorFlow-tietojoukon toistamissovellusliittymää, muuten RAM-muistin käyttö lisääntyy lineaarisesti aikakausi kerrallaan. Jos tietojoukko on yhtä suuri kuin RAM, älä käytä TensorFlow-tietojoukon välimuistisovellusliittymää. Jos sinun on käytettävä TensorFlow-tietojoukon välimuistisovellusliittymää ja sekoitussovellusliittymää, harkitse seuraavaa järjestystä: luo TensorFlow-tietojoukkoobjekti -> välimuistin API -> shuffle API -> batch API -> map API -> toista API -> esihaku API.
• Käytä tfrecord tietojoukkomuotoa enemmän kuin LibSVM-muotoa.
• Tiedostotila tai putkitila riippuu tietojoukon muodosta ja tiedostojen määrästä. The tfrecorddataset API voi asettaa num_parallel_reads lukea useita tiedostoja rinnakkain ja asettaa buffer_size optimoidaksesi tietojen lukemisen, kun taas pipemodedataset API:lla ei ole tällaisia ​​asetuksia. Pipe-tila sopii paremmin tilanteisiin, joissa yksittäinen tiedosto on suuri ja tiedostojen kokonaismäärä on pieni. Suosittelemme käyttämään SageMaker-käsittelytyötä esikäsittelytyön tekemiseen, kuten useiden tiedostojen liittämiseen suurempaan tiedostoon otsikoiden mukaan, otantamenetelmän käyttämistä tietojoukon tasapainottamiseksi ja tasapainotetun tietojoukon sekoittamista.

Katso seuraava koodinäyte:

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-instanssien koulutukseen, rinnakkaisuuden asettamiseen intra op, inter op, ja MKL-DNN:n ympäristömuuttuja on hyvä lähtökohta.

Automaattinen sekoitettu tarkkuusharjoittelu

Viimeinen asia, josta keskustelemme, on automaattinen sekoitettu tarkkuusharjoittelu, joka voi kiihdyttää nopeutta ja johtaa mallin suorituskykyyn. Tätä kirjoittaessa Nvidia V100 GPU (P3-instanssi) ja A100 (P4dn-instanssi) tukevat Tensor-ydintä. Voit ottaa käyttöön sekatarkkuuskoulutuksen TensorFlow'ssa, kun käytät tämäntyyppisiä ilmentymiä. Versiosta 1.14 alkaen TensorFlow on tukenut automaattista sekoitettua tarkkuusharjoitusta. Voit kääriä alkuperäisen optimoijasi seuraavalla lauseella:

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

Jos malli on pieni ja grafiikkasuorittimen käyttöaste on alhainen, automaattisesta sekatarkkuuskoulutuksesta ei ole hyötyä. Jos malli on suuri, automaattinen sekoitettu tarkkuusharjoittelu voi nopeuttaa harjoitusnopeutta.

Yhteenveto

Kun aloitat syväoppimismallin harjoittelun SageMakerissa, harkitse seuraavia vinkkejä nopeamman harjoitusnopeuden saavuttamiseksi:

• Kokeile ensin usean suorittimen, yhden esiintymän menetelmää tai yhden GPU:n yhden esiintymän menetelmää. Jos CPU/GPU-käyttöaste on erittäin korkea (esimerkiksi yli 90 %), siirry seuraavaan vaiheeseen.
• Kokeile useampia suorittimia yhdessä isännässä tai useampia GPU:ita yhdessä isännässä. Jos käyttöaste on lähellä suorittimen tai grafiikkasuorittimen enimmäiskäyttöä, siirry seuraavaan vaiheeseen.
• Kokeile useita suorittimia tai useita GPU:ita useilla isännillä.
• Sinun on muokattava koodeja, kun käytät parametripalvelimia tai Horovodia. Koodin muutos ei ole sama TensorFlow-istuntopohjaisessa sovellusliittymässä, tf.estimator API ja tf.keras API. Parametripalvelin tai Horovod voi näyttää erilaisia ​​harjoitusnopeuksia eri koulutustapauksissa ja -tehtävissä, joten kokeile molempia tapoja, jos sinulla on aikaa ja budjettia parhaan valinnassa.

Pidä mielessä seuraavat neuvot:

• Tarkista käyttöaste ennen skaalausta, optimoi dataputkisto ja aseta CPU ja GPU päällekkäin aikajanalla.
• Skaalaa ensin ja sitten pienennä.
• Jos et pysty lisäämään GPU-käyttöäsi kaikkien menetelmien jälkeen, kokeile suoritinta. On monia tapauksia (etenkin napsautussuhteen sijoitusmallissa), joissa CPU-ilmentymän koulutuksen kokonaisharjoitusaika on lyhyempi ja kustannustehokkaampi kuin GPU-instanssikoulutuksen.

Meillä on myös koodinäyte GitHub repo, jossa näytämme kaksi näytettä DeepFM-jaetuista harjoituksista SageMakerissa. Toinen on TensorFlow-parametripalvelin CPU-esiintymissä, toinen on Horovod GPU-esiintymissä.

Tietoja Tekijät

Yuhui Liang on vanhempi koneoppimisratkaisujen arkkitehti. Hän on keskittynyt koneoppimisen edistämiseen ja soveltamiseen ja on vahvasti mukana monissa asiakkaiden koneoppimisprojekteissa. Hänellä on rikas kokemus syväoppimisesta hajautetusta koulutuksesta, suositusjärjestelmistä ja laskennallisesta mainonnasta.

Shishuai Wang on vanhempi koneoppimisratkaisujen arkkitehti. Hän työskentelee AWS-asiakkaiden kanssa auttaakseen heitä ottamaan käyttöön koneoppimisen laajassa mittakaavassa. Hän nauttii elokuvien katselusta ja matkustamisesta ympäri maailmaa.