Effektiv TensorFlow 2.0: bedste praksis og hvad der er ændret

Indsendt af TensorFlow Team

I en nylig artikel nævnte vi, at TensorFlow 2.0 er blevet redesignet med fokus på udviklerens produktivitet, enkelhed og brugervenlighed.

For at se nærmere på hvad der er ændret og lære om bedste praksis skal du tjekke den nye effektiv Effektiv TensorFlow 2.0-guide (offentliggjort på GitHub). Denne artikel giver en hurtig oversigt over det indhold, du finder der. Hvis et af disse emner interesserer dig, skal du gå til guiden for at lære mere!

Et kort resumé af større ændringer

Der er mange ændringer i TensorFlow 2.0 for at gøre brugerne mere produktive, herunder fjerne redundante API'er, gøre API'er mere konsistente (Unified RNNs, Unified Optimizers) og bedre integrere med Python-runtime med ivrig udførelse.

Mange RFC'er (tjek dem ud, hvis du er ny!) Har forklaret de ændringer og tanker, der er gået i at skabe TensorFlow 2.0. Denne vejledning præsenterer en vision for, hvordan udvikling i TensorFlow 2.0 skal se ud. Det antages, at du har en vis fortrolighed med TensorFlow 1.x.

API-oprydning

Mange API'er er enten væk eller flyttet i TF 2.0, og nogle er blevet erstattet med deres 2,0 ækvivalenter - tf.summary, tf.keras.metrics og tf.keras.optimizers. Den nemmeste måde at anvende disse omdøb automatisk på er at bruge v2-opgraderingskriptet.

Ivrig henrettelse

TensorFlow 1.X kræver, at brugerne manuelt syer et abstrakt syntaks-træ (grafen) ved at foretage tf. * API-opkald. Det kræver, at brugerne manuelt sammenstiller det abstrakte syntaks-træ ved at sende et sæt output-tensors og input-tensors til et session.run () -opkald. I modsætning hertil udfører TensorFlow 2.0 ivrigt (som Python normalt gør), og i 2.0 skal grafer og sessioner føles som implementeringsdetaljer.

Ikke flere globale

TensorFlow 1.X var meget afhængige af implicit globale navneområder. Når du ringede til tf.Variable (), blev den sat i standardgrafen, og den ville forblive der, selvom du mistede sporet af Python-variablen, der peger på den. Du kunne derefter gendanne den tf. Variable, men kun hvis du kendte navnet, det var blevet oprettet med. Dette var vanskeligt at gøre, hvis du ikke havde kontrol over variabelens oprettelse. Som et resultat spredte sig alle mulige mekanismer til at forsøge at hjælpe brugerne med at finde deres variabler igen.

TensorFlow 2.0 eliminerer alle disse mekanismer (Variables 2.0 RFC) til fordel for standardmekanismen: Hold styr på dine variabler! Hvis du mister oversigten over et tf. Variabelt, bliver det opsamlet affald. Se vejledningen for flere detaljer.

Funktioner, ikke sessioner

Et session.run () -opkald er næsten som et funktionsopkald: Du specificerer input og den funktion, der skal kaldes, og du får tilbage et sæt output. I TensorFlow 2.0 kan du dekorere en Python-funktion vha. Tf.function () for at markere den til JIT-kompilering, så TensorFlow kører den som en enkelt graf (Funktioner 2.0 RFC).

Denne mekanisme giver TensorFlow 2.0 mulighed for at få alle fordelene ved graftilstand:

  • Ydeevne: Funktionen kan optimeres (node-beskæring, kernefusion, osv.)
  • Portabilitet: Funktionen kan eksporteres / genimporteres (SavedModel 2.0 RFC), så brugerne kan genbruge og dele modulære TensorFlow-funktioner.

Med kraften til frit at sprede Python og TensorFlow-kode, kan du drage fuld fordel af Pythons ekspressivitet. Men bærbar TensorFlow kører i sammenhænge uden en Python-tolk - mobil, C ++ og JS. For at hjælpe brugerne med at undgå at skulle omskrive deres kode, når de tilføjer @ tf.function, konverterer AutoGraph en undergruppe af Python-konstruktioner til deres TensorFlow-ækvivalenter.

Se vejledningen for flere detaljer.

Anbefalinger til idiomatisk TensorFlow 2.0

Refaktor din kode i mindre funktioner

Et almindeligt brugsmønster i TensorFlow 1.X var “køkkenvask” -strategien, hvor foreningen af ​​alle mulige beregninger blev præemptivt lagt, og derefter blev valgte tensorer evalueret via session.run (). I TensorFlow 2.0 skal brugerne refaktorere deres kode til mindre funktioner, der kaldes efter behov. Generelt er det ikke nødvendigt at dekorere hver af disse mindre funktioner med funktionen tf. Brug kun tf.function til at dekorere beregninger på højt niveau - for eksempel et træningstrin eller din model fremad.

Brug Keras-lag og -modeller til at administrere variabler

Keras-modeller og lag tilbyder de behagelige variabler og egenskaber, der kan trænes, der kan rekvisitivt samle alle afhængige variabler. Dette gør det nemt at administrere variabler lokalt, hvor de bruges.

Keras-lag / modeller arver fra tf.train.Checkpointable og er integreret med @ tf.function, hvilket gør det muligt direkte at kontrollere eller eksportere SavedModels fra Keras-objekter. Du behøver ikke nødvendigvis at bruge Keras’s.fit () API for at drage fordel af disse integrationer.

Se vejledningen for flere detaljer.

Kombiner tf.data.Datasets og @ tf.function

Når du itererer med træningsdata, der passer ind i hukommelsen, er du velkommen til at bruge regelmæssig Python-iteration. Ellers er tf.data.Dataset den bedste måde at streame træningsdata fra disken. Datasæt er iterables (ikke iteratorer), og fungerer lige som andre Python-iterables i ivrig tilstand. Du kan fuldt ud udnytte datasyn async-forudindhentnings- / streamingfunktioner ved at indpakke din kode i tf.function (), som erstatter Python-iteration med de ækvivalente grafoperationer ved hjælp af AutoGraph.

@ tf.function
def train (model, datasæt, optimizer):
 for x, y i datasæt:
  med tf.GradientTape () som tape:
   forudsigelse = model (x)
   tab = tab_fn (forudsigelse, y)
  gradients = tape.gradients (tab, model.trainable_variables)
  optimizer.apply_gradients (gradients, model.trainable_variables)

Hvis du bruger Keras .fit () API, behøver du ikke at bekymre dig om datasæt-iteration.

model.compile (optimizer = optimizer, tab = loss_fn)
model.fit (datasæt)

Udnyt AutoGraph med Python-kontrolstrøm

AutoGraph giver en måde at konvertere datafhængig kontrolstrøm til graf-modeækvivalenter som tf.cond og tf.while_loop.

Et almindeligt sted, hvor dataafhængig kontrolstrøm vises, er i sekvensmodeller. tf.keras.layers.RNN indpakker en RNN-celle, så du enten kan statisk eller dynamisk rulle gentagelsen. For demonstrationens skyld kan du implementere dynamisk oprullering som følger:

klasse DynamicRNN (tf.keras.Model):
def __init __ (self, rnn_cell):
 super (DynamicRNN, self) .__ init __ (self)
 self.cell = rnn_cell
def call (selv, input_data):
 # [batch, tid, funktioner] -> [tid, batch, funktioner]
 input_data = tf.transpose (input_data, [1, 0, 2])
 output = tf.TensorArray (tf.float32, input_data.shape [0])
 tilstand = self.cell.zero_state (input_data.shape [1], dtype = tf.float32)
 for i i tf.range (input_data.shape [0]):
  output, state = self.cell (input_data [i], state)
  output = outputs.write (i, output)
 returner tf.transpose (output.stack (), [1, 0, 2]), tilstand

Se vejledningen for flere detaljer.

Brug tf.metrics til at samle data og tf.summary til at logge dem

Endelig kommer et komplet sæt tf.summary symboler snart. Du kan få adgang til 2.0-versionen af ​​tf.summary med:

fra tensorflow.python.ops import Summary_ops_v2

Se vejledningen for flere detaljer.

Næste skridt

Denne artikel gav en hurtig oversigt over effektiv TF 2.0-guide (hvis du er interesseret i disse emner, kan du gå der for at lære mere!) For at lære mere om TensorFlow 2.0 anbefaler vi også disse nylige artikler:

  • Bidrag til TensorFlow: SIG'er, RFC'er, test og dokumenter.
  • Hvad er symboliske og imperative API'er i TensorFlow 2.0?
  • Standardisering af Keras: Vejledning om API'er på højt niveau i TensorFlow 2.0

Og stem venligst ind til TensorFlow-udviklermødet den 6. og 7. marts. Som altid vil alle samtalerne blive uploadet til YouTube for folk, der ikke kan gøre det personligt.