TensorFlow 1.x kiirenduskoolituse parimad tavad rakenduses Amazon SageMaker

Tänapäeval kasutavad paljud kliendid TensorFlow'd, et koolitada sügavaid õppimismudeleid nende reklaamide klikkimise määra ja e-kaubanduse isikupärastamise soovituste jaoks. Kuna nende klientide käitumine muutub, võivad nad iga päev koguda suuri koguseid uusi andmeid. Mudelite iteratsioon on üks andmeteadlase igapäevatööst, kuid nad seisavad silmitsi probleemiga, et suurte andmekogumite treenimine võtab liiga kaua aega.

Amazon SageMaker on täielikult hallatav masinõppe (ML) platvorm, mis võib aidata andmeteadlastel keskenduda infrastruktuuri asemel mudelitele, toetades oma algoritme ja raamistikke, nagu TensorFlow ja PyTorch. SageMaker pakub paindlikke hajutatud koolitusvõimalusi, mis kohanduvad teie konkreetsete töövoogudega. Kuna paljudel andmeteadlastel võib puududa kiirenduskoolitusprotsessi kogemus, näitame selles postituses teile kiire süvaõppe mudelitreeningu jaoks olulisi tegureid ja SageMakeri TensorFlow 1.x kiirenduskoolituse parimaid tavasid. Meil on ka näidiskood DeepFM jagas koolitust SageMakeri kohta GitHub repo.

TensorFlow skripti SageMakeris käitamisel CPU/GPU kasutuse maksimeerimiseks peaksite arvestama paljude teguritega, näiteks infrastruktuur, kiirendi tüüp, hajutatud treeningmeetod, andmete laadimise meetod, segatäppiskoolitus ja palju muud.

Arutame parimaid tavasid järgmistes valdkondades:

• Kiirendage koolitust ühel eksemplaril
• Kiirendage koolitust mitmel juhul
• Andmekanalid
• Automaatne segatreening täpsusega

Kiirendage koolitust ühel eksemplaril

Kui käivitate TensorFlow skripti ühel eksemplaril, võite valida arvutile optimeeritud seeria, näiteks Amazon Elastic Compute Cloud (Amazon EC2) C5-seeria või kiirendatud andmetöötlusseeria, millel on mitu GPU-d ühes eksemplaris, näiteks p3.8xlarge, p3.16xlarge, p3dn.24xlarge ja p4d.24xlarge.

Selles jaotises käsitleme strateegiaid mitme CPU jaoks ühel eksemplaril ja hajutatud koolitust mitme GPU-ga ühel eksemplaril.

Mitu protsessorit ühel eksemplaril

Selles jaotises käsitleme operaatorite paralleelsuse käsitsi seadistamist protsessoriseadmetes, tornmeetodit, TensorFlow MirroredStrategy ja Horovod.

Operaatorite paralleelsuse käsitsi seadistamine protsessoriseadmetes

TensorFlow valib automaatselt sobiva arvu lõime, et paralleelstada operatsioonide arvutamine treeningprotsessis. Siiski saate määrata intra_op niidid basseini ja inter_op Paralleelsuse sätted, mida pakub TensorFlow, ja kasutage OS-i lõime sidumise määramiseks MKL-DNN-i keskkonnamuutujaid. Vaadake järgmist 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'

Keskkonna muutuja KMP_AFFINITY MKL-DNN on seatud granularity=fine,compact,1,0 vaikimisi. Pärast nii TensorFlow sise- kui ka interjööri määramist praeguse eksemplari maksimaalsele vCPU-de arvule on protsessori kasutuse ülempiir peaaegu sama, mis koolituseksemplari füüsiliste tuumade arv.

Kui määrate os.environ["KMP_AFFINITY"]= "verbose,disabled", ei ole OS-i lõim seotud riistvaralise hüperlõimega ja protsessori kasutus võib ületada füüsiliste tuumade arvu.

Seoses TensorFlow siseparalleelsuse, TensorFlow interparalleelsuse ja MKL-DNN lõimede arvu sätetega annavad nende kolme parameetri erinevad kombinatsioonid erineva treeningkiiruse. Seetõttu peate iga juhtumit testima, et leida parim kombinatsioon. Levinud olukord on määrata kolm parameetrit (intra_op_parallelism_threads ja inter_op_parallelism_threads TensorFlow jaoks, os.environ['OMP_NUM_THREADS'] MKL-DNN jaoks) poole võrra vCPU-de arvust (füüsiline tuum) või vCPU-de koguarvust.

Torni meetod

Mudeli kopeerimiseks GPU-de kaudu saab iga GPU oma edasipääsu eksemplari. Edasipääsu eksemplari nimetatakse a torn. GPU-seadmete puhul kasutatakse peaaegu alati torni meetodit. Treeningu kiiruse võrdlemiseks teiste meetoditega kasutame siin ka oma CPU seadme jaoks torni meetodit.

Kui te CPU-seadet käsitsi ei seadista, ei kasuta TensorFlow gradientide keskmistamiseks torni meetodit, seega ei pea te sellistel juhtudel partii suurust skaleerima.

1. Seadistage CPU seade käsitsi:

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. Kasutama replicate_model_fn mähkida 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. Kasutama TowerOptimizer mähkida optimizer:

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

4. Mähi oma model_fn:

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

5. Muutke partii suurus (NUM_CPU – 1).

Vaatame CPU kasutuse erinevust tornirežiimi aktiveerimisel. Järgmine joonis näitab ml.c5.18xlarge eksemplari CPU kasutust järgmise konfiguratsiooniga:

Torni puudub + LibSVM-i andmed + torurežiim + MKL-DNN-i keelamine sidumine + TensorFlow sise-/interoperparalleelsuse seadistus eksemplari vCPU-de maksimaalsele arvule

Järgmine joonis näitab eksemplari ml.c5.18xlarge protsessori kasutamist järgmise konfiguratsiooniga:

Seadistatud CPU-seadmega torn + LibSVM-i andmed + torurežiim + MKL-DNN-i keelake sidumine + TensorFlow intra/inter op paralleelsuse säte eksemplari vCPU-de maksimaalsele arvule

Protsessori kasutus on tornimeetodi kasutamisel suurem ja ületab füüsiliste tuumade arvu.

TensorFlow MirroredStrategy

TensorFlow MirroredStrategy tähendab sünkroonset treenimist mitme koopia vahel ühes masinas. Seda strateegiat kasutatakse tavaliselt mitme GPU-ga ühe masinaga treenimiseks. Treeningkiiruse võrdlemiseks mõne teise meetodiga kasutame oma protsessori jaoks MirroredStrategy.

TensorFlow MirroredStrategy kasutamisel, kui te CPU-seadet ei määra, kasutab TensorFlow lihtsalt ühte CPU-d ühe töötajana, mis on ressursside raiskamine. Soovitame CPU-seadet käsitsi seadistada, kuna see vähendab sisselülitamist /CPU:0, Nii /CPU:0 seadet ei kasutata siin koopiana. Vaadake järgmist 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)

MirroredStrategy kasutamisel peate partii suurust skaleerima; Näiteks skaleerige partii suurus GPU-seadmete arvu kordseks.

Alamstrateegia jaoks, kui määrate CPU-seadme, kui te ei määra cross_device_ops parameeter tf.distribute.MirroredStrategy(), TensorFlow kasutab ReductionToOneDevice alamstrateegia vaikimisi. Kui aga määrate HierarchicalCopyAllReduce alamstrateegiana teeb TensorFlow lihtsalt vähendamise tööd /CPU:0. Kui kasutate TensorFlow andmestiku API ja levitamise strateegiat koos, tuleks funktsiooni funktsioonide ja siltide asemel tagastada andmestiku objekt input_fn.

Tavaliselt on TensorFlow MirroredStrategy protsessoritreeningul aeglasem kui tornmeetod, seega ei soovita me kasutada MirroredStrategyt mitme protsessoriga ühe hosti puhul.

Horovod

Horovod on hajutatud süvaõppe koolitusraamistik TensorFlow, Keras, PyTorch ja Apache MXNet jaoks. Horovodi eesmärk on muuta hajutatud süvaõpe kiireks ja hõlpsasti kasutatavaks.

Seal on parameeter distribution SageMaker Python SDK prognoosija API-s, mida saate kasutada Horovodi hajutatud koolituse avaldamiseks. SageMaker loob infrastruktuuri ja käivitab teie skripti MPI-ga. Vaadake järgmist 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' 
} 
}

GPU eksemplari (nt ml.p3.8xlarge) valimisel peate iga töötaja jaoks iga GPU kinnitama.

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

Mudeli ühtlustamise kiirendamiseks skaleerige õppemäär vastavalt Horovodi ametlikule dokumentatsioonile töötajate arvu järgi. Kuid reaalmaailma projektides peaksite õppimiskiirust mingil määral skaleerima, kuid mitte töötajate arvu järgi, mis toob kaasa mudeli halva jõudluse. Näiteks kui algne õppimismäär on 0.001, skaleerime õppimismäära 0.0015-ni, isegi kui töötajate arv on neli või rohkem.

Üldiselt salvestab kontrollpunkti ja mudeli ning hindamistoimingu ainult esmane (Horovodi auaste 0). Horovodi kasutamisel ei pea te partii suurust skaleerima. SageMaker pakub Toru režiim kust andmeid voogesitada Amazoni lihtne salvestusteenus (Amazon S3) koolituseksemplarideks. Kui lubate torurežiimi, pidage meeles, et sama hosti erinevad töötajad peavad vigade vältimiseks kasutama erinevaid kanaleid. Selle põhjuseks on asjaolu, et esimene töötaja protsess loeb FIFO/kanali andmeid ja teised samal eksemplaril olevad töötaja protsessid hanguvad, kuna nad ei saa lugeda andmeid samast FIFO-st/kanalist, mistõttu Horovod ei tööta korralikult. Selle probleemi vältimiseks määrake kanalid vastavalt töötajate arvule eksemplari kohta. Vähemalt veenduge, et sama hosti erinevad töötajad tarbiksid erinevaid kanaleid; sama kanalit saavad kasutada erineva hosti töötajad.

Horovodi kasutamisel võib tekkida järgmine tõrge:

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

Selle probleemi võimalikuks põhjuseks on see, et teatud auaste (nt auaste 0) töötab aeglasemalt või teeb rohkem töid kui teised auastmed, mistõttu teised auastmed ootavad pikka aega. Kuigi auaste 0 peab mõnikord tegema rohkem tööd kui teised auastmed, tuleb märkida, et auaste 0 ei tohiks pikka aega palju teha. Näiteks valideerimiskomplekti mudeli hindamiseks ja kontrollpunktide salvestamiseks koolituse ajal, kui on vältimatu, et need toimingud võtavad kaua aega, mis võib põhjustada vigu, on üheks lahenduseks lasta kõigil töötajatel teha sama tööd nagu 0-s (kontrollpunktid). salvestamine, hindamine ja nii edasi).

Andmete jagamine on üks olulisemaid asju, mida hajutatud koolituse kasutamisel arvestada. Võite kasutada TensorFlow dataset.shard() oma stsenaariumis. SageMaker pakub ka andmestiku killu funktsiooni sisendite kanal seadistades distribution=S3shardbykey andmestiku kanalis. Vaadake järgmist 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())

Järgmisel joonisel on näha tulemus Horovodi kasutamisel (ml.c5.18xlarge, Horovod + LibSVM + vaikimisi intra op ja inter op seade), mida saate võrrelda torni meetodiga.

Jaotatud koolitus mitme GPU-ga ühel eksemplaril

On normaalne alustada hajutatud koolitust mitme GPU-ga ühel eksemplaril, kuna andmeteadlased peavad haldama ainult ühte eksemplari ja kasutama ära GPU-de vahelist kiiret ühendust. SageMakeri koolitustööd toetavad mitut eksemplari tüüpi, millel on mitu GPU-d ühel eksemplaril, näiteks ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge ja ml.p4d.24xlarge. Meetod on sama kui mitu protsessorit ühes eksemplaris, kuid skriptis on mõned muudatused.

Torni meetod

Torni meetod on siin peaaegu sama, mis mitme protsessoriga koolitusel. Peate partii suurust skaleerima vastavalt kasutatavate GPU-de arvule.

TensorFlow MirroredStrategy

Vaikimisi alamstrateegia MirroredStrategy is NcclAllReduce. Peate partii suurust skaleerima vastavalt kasutatavate GPU-de arvule. Vaadake järgmist koodi:

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

Kiirendage koolitust mitmel juhul

Vähendamine on alati võimalus treeningkiiruse parandamiseks. Üha enam andmeteadlasi valib selle hajutatud koolituse vaikevalikuks. Selles jaotises käsitleme mitme hostiga hajutatud koolituse strateegiaid.

Mitu protsessorit mitme eksemplariga

Mitme CPU kasutamiseks mitme eksemplariga hajutatud koolituse lubamisel on neli peamist meetodit.

• • Parameetriserver ilma protsessoriseadmetes operaatorite paralleelsust käsitsi seadistamata
  • Parameetriserver operaatorite paralleelsuse käsitsi seadistamisega protsessoriseadmetes
  • Torniga parameetriserver (CPU seadmete käsitsi seadistamine ja seadistamine allow_soft_placement=True in tf.ConfigProto)
  • Horovod

Kui kasutate parameetriserverit tf.estimator API, kontrollpunkti tee peab olema jagatav tee, näiteks Amazon S3 või kohalik tee Amazon elastne failiteenus (Amazon EFS) kaardistamine konteineriga. Parameetriserveri jaoks sisse tf.keras, saab kontrollpunkti tee määrata kohalikule teele. Horovodi puhul saab kontrollpunkti teeks määrata koolituseksemplari kohaliku tee.

Kui kasutate parameetriserverit ja tf.estimator API kontrollpunkti teega Amazon S3-le, kui mudel on üsna suur, võite ilmneda viga, et esmane on jäänud kontrollpunkti S3 salvestamisel kinni. Võite kasutada SageMakeri sisseehitatud konteinerit TensorFlow 1.15 või TensorFlow 1.15.2 või kasutada aktsia kontrollpunkti teena Amazon EFS-i.

Kui kasutate parameetriserverit mitme hosti jaoks, võib iga parameetriserveri protsessi parameetrite koormus olla tasakaalustamata (eriti kui on suhteliselt suured manustamistabeli muutujad), mis võib põhjustada vigu. Saate kontrollida Amazon S3 iga killu kontrollpunkti faili suurust, et teha kindlaks, kas parameetriserveri parameetrid on tasakaalus, sest iga parameetriserver vastab kontrollpunkti faili killule. Selliste probleemide vältimiseks võite kasutada partitsioonifunktsiooni, et proovida iga parameetriserveri parameetreid ühtlaselt jaotada:

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

Üks GPU mitme eksemplariga

SageMakeri koolitustööd toetavad eksemplare, millel on ainult üks GPU, nagu seeriad ml.p3.xlarge, ml.g4dn ja ml.g5. Selles stsenaariumis kasutatakse kahte peamist meetodit: parameetriserverid ja Horovod.

SageMakeri sisseehitatud parameetriserveri hajutatud koolitusmeetod on parameetriserveri protsessi ja töötaja protsessi käivitamine iga koolituseksemplari jaoks (iga parameetriserver vastutab ainult osa mudeli parameetrite eest), seega on vaikimisi mitme masinaga ühe- GPU koolitus. SageMakeri sisseehitatud parameetriserveri hajutatud koolitus on asünkroonse gradiendi värskendamise meetod. Asünkroonsete värskenduste mõju vähendamiseks koolituse lähenemisele on soovitatav õppekiirust vähendada. Kui soovite kasutada eksemplari kõiki GPU-sid, peate kasutama parameetriserverite ja tornimeetodi kombinatsiooni.

Horovodi jaoks, lihtsalt seadke processes_per_host=1 SageMaker Python Estimator API jaotusparameetris.

Mitu GPU-d mitme eksemplariga

Parameetriserverite ja tornimeetodi puhul on koodimuudatused põhimõtteliselt samad, mis mitme GPU-ga ühe eksemplari tornmeetodi puhul ning GPU-seadmeid pole vaja käsitsi seadistada.

Horovodi puhul määrake jaotusparameetris process_per_host iga koolituseksemplari GPU-de arvule. Kui kasutate torurežiimi, peab töötajate arv eksemplari kohta vastama kanalite arvule.

Andmekanalid

Lisaks arutatud infrastruktuurile tuleb arvestada veel ühe olulise asjaga: andmetorustikuga. Andmekonveier viitab sellele, kuidas laadite andmeid ja teisendate andmeid enne nende edastamist närvivõrkudesse. CPU-d kasutatakse andmete ettevalmistamiseks, samas kui GPU-d kasutatakse CPU-st andmete arvutamiseks. Kuna GPU on kallis ressurss, on pikem GPU jõudeaeg ebaefektiivne; hea andmeside teie koolitustöös võib parandada GPU ja CPU kasutamist.

Kui proovite optimeerida oma TensorFlow andmesisestuskonveieri, võtke arvesse API järjekorda, mida kasutatakse TensorFlow andmestikud, treeningandmete suurus (palju väikeseid faile või mitu suurt faili), partii suurus jne.

Vaatame GPU ja CPU interaktsiooni treeningu ajal. Järgmised joonised võrdlevad koostoimeid torujuhtmega ja ilma.

Parem konveier võib vähendada GPU jõudeaega. Kaaluge järgmisi näpunäiteid:

• Kasutage funktsioonide ja siltide eraldamisel lihtsat funktsiooniloogikat
• Proovide eellaadimine mällu
• Vähendage ketta sisend-/väljundit ja võrgu sisend-/väljundit
• Hoidke töödeldud funktsioonid ja sildid mällu vahemällu
• Vähendage CPU ja GPU vahelise replikatsiooni kordade arvu
• Paluge erinevatel töötajatel koolitusandmestiku erinevate osadega tegeleda
• Vähendage TensorFlow andmestiku API kutsumise aega

TensorFlow pakub andmekoguvormingutega seotud teisendus-API-d ja TensorFlow teisendus-API järjekord mõjutab palju treeningkiirust. Testida tuleb TensorFlow andmestiku API kutsumise parimat järjekorda. Järgmised on mõned põhiprintsiibid.

• Kasutage vektorkaarti. See tähendab, et kõigepealt helistage TensorFlow andmestiku partii API-le ja seejärel andmestiku kaardi API-le. Kaardifunktsioonis pakutav kohandatud sõelumisfunktsioon, nt decode_tfrecord näidiskoodis analüüsib väikese andmepaketi. Vastupidi, esmalt kaardistamine ja seejärel partii on skalaarkaart ja kohandatud parserifunktsioon töötleb ainult ühte näidist.
• Funktsioonide ja siltide vahemällu salvestamiseks kasutage TensorFlow andmestiku vahemälu API-t. Asetage TensorFlow andmestiku vahemälu API enne TensorFlow andmestiku kordus-API-d, vastasel juhul suureneb RAM-i kasutamine lineaarselt epohhhaaval. Kui andmestik on sama suur kui RAM, ärge kasutage TensorFlow andmestiku vahemälu API-t. Kui teil on vaja kasutada TensorFlow andmestiku vahemälu API-t ja segamis-API-d, kaaluge järgmise järjestuse kasutamist: loo TensorFlow andmekomplekti objekt -> vahemälu API -> segamise API -> partii API -> kaardi API -> korrake API -> eellaadimise API.
• Kasuta tfrecord andmestiku vormingus rohkem kui LibSVM-vormingus.
• Failirežiim või torurežiim sõltub teie andmestiku vormingust ja failide hulgast. The tfrecorddataset API saab määrata num_parallel_reads mitme faili paralleelseks lugemiseks ja seadistamiseks buffer_size andmete lugemise optimeerimiseks, samas kui pipemodedataset API-l pole selliseid sätteid. Torurežiim sobib rohkem olukordades, kus üks fail on suur ja failide koguarv väike. Soovitame eeltöötlustööde tegemiseks kasutada SageMakeri töötlemistööd, nagu näiteks mitme faili ühendamine suuremaks failiks vastavalt siltidele, proovivõtumeetodi kasutamine andmestiku tasakaalustatumaks muutmiseks ja tasakaalustatud andmestiku segamine.

Vaadake järgmist koodinäidist:

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)

Protsessori eksemplaride treenimiseks, paralleelsuse seadmiseks intra op, inter op, ja MKL-DNN-i keskkonnamuutuja on hea lähtepunkt.

Automaatne segatreening täpsusega

Viimane asi, mida arutame, on automaatne segatreening, mis võib kiirendada kiirust ja tulemuseks on mudeli jõudlus. Selle kirjutamise seisuga toetavad Nvidia V100 GPU (P3 eksemplar) ja A100 (P4dn eksemplar) Tensori tuuma. Seda tüüpi eksemplaride kasutamisel saate TensorFlow's lubada kombineeritud täppiskoolituse. Alates versioonist 1.14 on TensorFlow toetanud automaatset segatreeningut. Algse optimeerija pakkimiseks võite kasutada järgmist avaldust.

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

Kui mudel on väike ja graafikaprotsessorit on vähe kasutatud, pole automaatse segatäppisõppe eeliseid. Kui mudel on suur, võib automaatne segatreening treeningkiirust kiirendada.

Järeldus

Kui alustate SageMakeris süvaõppemudeli koolitust, kaaluge kiirema treeningkiiruse saavutamiseks järgmisi näpunäiteid.

• Proovige esmalt mitme protsessoriga ühe eksemplari meetodit või ühe GPU ühe eksemplari meetodit. Kui CPU/GPU kasutus on väga kõrge (näiteks üle 90%), liikuge järgmise sammu juurde.
• Proovige rohkem protsessoreid ühes hostis või rohkem GPU-sid ühes hostis. Kui kasutusaste on CPU-de või GPU-de maksimaalse kasutuse lähedal, liikuge järgmise sammu juurde.
• Proovige mitut protsessorit või mitut GPU-d mitme hostiga.
• Parameetriserverite või Horovodi kasutamisel peate koode muutma. Koodi modifikatsioon ei ole TensorFlow seansipõhise API puhul sama, tf.estimator API ja tf.keras API. Parameetriserver või Horovod võivad erinevatel koolitusjuhtumitel ja -ülesannetel näidata erinevat treeningkiirust, seega proovige mõlemat meetodit, kui teil on aega ja eelarvet parima väljaselgitamiseks.

Pidage meeles järgmisi nõuandeid:

• Enne skaleerimist kontrollige kasutust, optimeerige andmekonveierit ning tehke CPU ja GPU ajateljel kattumine.
• Esmalt suurendage, seejärel vähendage.
• Kui te ei saa pärast kõiki meetodeid GPU kasutust suurendada, proovige CPU-d. On palju juhtumeid (eriti klikkimise määra järjestusmudeli puhul), kus CPU eksemplari koolituse kogukoolitusaeg on lühem ja kuluefektiivsem kui GPU eksemplari koolitus.

Meil on ka koodinäidis GitHub repo, kus näitame SageMakeris kahte DeepFM-i hajutatud koolituse näidist. Üks on TensorFlow parameetriserver CPU eksemplaridel, teine ​​on Horovod GPU eksemplaridel.

Autoritest

Yuhui Liang on vanem masinõppelahenduste arhitekt. Ta on keskendunud masinõppe edendamisele ja rakendamisele ning on sügavalt seotud paljude klientide masinõppeprojektidega. Tal on rikkalik kogemus süvaõppe hajutatud koolituse, soovitussüsteemide ja arvutireklaamide alal.

Shishuai Wang on vanem masinõppelahenduste arhitekt. Ta teeb koostööd AWS-i klientidega, et aidata neil masinõpet laialdaselt kasutusele võtta. Talle meeldib filme vaadata ja maailmas ringi reisida.