Hvordan erstatter Keras-modeller TensorFlow-estimatorer?

/ / Udgivet i Kunstig intelligens, EITC/AI/GCML Google Cloud Machine Learning, Første trin i maskinindlæring, Almindelige og enkle estimatorer

Overgangen fra TensorFlow-estimatorer til Keras-modeller repræsenterer en betydelig udvikling i arbejdsgangen og paradigmet for oprettelse, træning og implementering af maskinlæringsmodeller, især inden for TensorFlow- og Google Cloud-økosystemerne. Denne ændring er ikke blot et skift i API-præferencer, men afspejler bredere tendenser inden for tilgængelighed, fleksibilitet og integration af moderne deep learning-praksisser.

Baggrund: TensorFlow-estimatorer

TensorFlow-estimatorer blev introduceret for at standardisere processen med træning, evaluering og implementering af maskinlæringsmodeller. Estimator API'en gav en abstraktion på højt niveau til distribueret træning, nem implementering på forskellige platforme (herunder Google Cloud AI Platform) og indbygget understøttelse af en række maskinlæringsopgaver såsom klassificering, regression og endda brugerdefineret modellering.

Estimator-arbejdsgangen involverer typisk:

– Definition af en inputfunktion til at læse data.
– At skrive en `model_fn` for at indkapsle modellogikken, tabene og optimeringsværktøjerne.
– Instantiering af et `Estimator`-objekt.
– Kaldmetoder som `.train()`, `.evaluate()` og `.predict()`.

Estimatorer sørgede for en klar adskillelse mellem datainput, modelkonstruktion og udførelse, hvilket var særligt værdifuldt for skalerbar træning og visning. De håndterede også en stor del af den standardkode, der kræves til distribueret træning og checkpoint-styring.

Estimator API'en havde dog flere begrænsninger:

– Det var mindre intuitivt for begyndere, især dem der ikke er involveret i dybdegående læring.
– Tilpasning af modeller (især for dynamiske arkitekturer) var besværlig.
– Integration med nye funktioner (som brugerdefinerede lag eller tab), der blev introduceret i deep learning-fællesskabet, var langsommere og mere kompleks.

Keras-modellernes fremgang

Keras blev oprindeligt udviklet som et uafhængigt, brugervenligt neuralt netværksbibliotek. Det lagde vægt på enkelhed og hurtig prototyping via en præcis og konsistent API. Da TensorFlow indførte Keras som sin officielle API på højt niveau med udgivelsen af ​​TensorFlow 2.x, signalerede det en anerkendelse af den værdi, Keras bragte til fællesskabet.

Vigtigste fordele ved Keras-modeller

1. Enkelhed og læsbarhedKeras-modeller er generelt lettere at forstå og skrive, hvilket reducerer den kognitive belastning for praktikere og forskere.
2. FleksibilitetKeras' funktionelle og underklassificerende API'er muliggør konstruktion af komplekse og dynamiske modeller, såsom dem, der kræves til sekvensmodellering, opmærksomhedsmekanismer eller generative modeller.
3. Integration med moderne dyb læringsøkosystemKeras-modeller kan nemt inkorporere brugerdefinerede lag, metrikker, tab og tilbagekald, hvilket gør det nemt at integrere de seneste forskningsfremskridt.
4. End-to-end arbejdsgangeMed Keras er dataforbehandling, modeloprettelse, træning, evaluering og implementering tæt integreret.
5. Indbygget understøttelse i TensorFlow 2.xMed "ivrig execution" som standard er fejlfinding og modelinspektion mere ligetil.

Keras som standard API på højt niveau i TensorFlow

Fra og med TensorFlow 2.x er Keras (`tf.keras`) den foretrukne og anbefalede API på højt niveau til definition og træning af modeller. Dette skift afspejles i dokumentationen, fællesskabssupport og løbende funktionsudvikling. Selvom estimatorer stadig understøttes for bagudkompatibilitet og visse use cases, fokuserer nye funktioner og forbedringer på Keras API'en.

Eksempel: Simpel klassificering med estimator vs. Keras

Brug af estimator:

python
import tensorflow as tf

def model_fn(features, labels, mode):
    net = tf.layers.dense(features['x'], 10, activation=tf.nn.relu)
    logits = tf.layers.dense(net, 3, activation=None)
    predicted_classes = tf.argmax(logits, 1)

    if mode == tf.estimator.ModeKeys.PREDICT:
        predictions = {
            'class_ids': predicted_classes[:, tf.newaxis],
            'probabilities': tf.nn.softmax(logits),
            'logits': logits,
        }
        return tf.estimator.EstimatorSpec(mode, predictions=predictions)

    loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

    if mode == tf.estimator.ModeKeys.TRAIN:
        optimizer = tf.train.AdamOptimizer()
        train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())
        return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)

    eval_metric_ops = {
        'accuracy': tf.metrics.accuracy(labels=labels, predictions=predicted_classes)
    }
    return tf.estimator.EstimatorSpec(
        mode, loss=loss, eval_metric_ops=eval_metric_ops)

estimator = tf.estimator.Estimator(model_fn=model_fn)
# Data input functions omitted for brevity.

Brug af Keras:

python
import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(10, activation='relu', input_shape=(input_dim,)),
    keras.layers.Dense(3, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5, batch_size=32)

Som set ovenfor er Keras-koden mere præcis og tilgængelig og understøtter hurtig iteration og eksperimentering.

Sådan erstatter Keras estimatorer i Google Cloud Machine Learning-workflows

1. Træning og implementering

På Google Cloud AI Platform (nu Vertex AI) har brugerne historisk set brugt Estimators til distribueret træning og servering. Med indførelsen af ​​Keras som standard understøtter platformen fuldt ud Keras-modeller til både træning og implementering:

- Distribueret træningKeras-modeller kan trænes på tværs af flere GPU'er eller TPU'er ved hjælp af `tf.distribute` API'en. Dette er fuldt kompatibelt med Google Clouds distribuerede infrastruktur.
- Modeleksport og -visningKeras-modeller kan gemmes i TensorFlow SavedModel-formatet, som er standarden for visning af modeller på Google Cloud.
- Tuning af hyperparameterKeras-modeller integreres med Google Clouds hyperparameter-tuningtjenester, hvilket giver brugerne mulighed for at optimere deres modeller effektivt.

2. Datainput-rørledninger

Keras integreres problemfrit med `tf.data` pipelines, hvilket muliggør skalerbar og effektiv dataindlæsning, forbehandling og augmentation. Dette gør det muligt for praktikere at håndtere store datasæt og komplekse forbehandlingstrin med minimal kode.

3. Brugerdefinerede modelarkitekturer

Hvor det kan være besværligt at oprette brugerdefinerede lag, tab og træningsløkker i Estimator API'en, tilbyder Keras intuitive mekanismer til underklassificering af modeller og lag, hvilket gør det muligt for forsknings- og produktionsteams at implementere avancerede arkitekturer med større lethed.

4. Overvågning og tilbagekald

Keras understøtter en bred vifte af callbacks – værktøjer, der muliggør overvågning af træning, justering af læringshastigheder, lagring af checkpoints, tidlig stop og integration med TensorBoard.

5. Integration af fællesskaber og økosystemer

Mange populære datasæt, prætrænede modeller og forskningsbidrag distribueres nu som Keras-kompatibel kode. Dette gør det nemmere for Google Cloud-brugere at udnytte banebrydende forskning i deres arbejdsgange.

Migrering fra estimatorer til Keras: Overvejelser

Organisationer eller enkeltpersoner med eksisterende kodebaser bygget op omkring Estimators kan overgå til Keras med varierende grad af indsats, afhængigt af modellens kompleksitet og brugerdefineret kode. TensorFlow leverer migreringsvejledninger og værktøjer til at lette denne proces.

- Brugerdefineret modellogikBrugerdefineret `model_fn`-logik i estimatorer oversættes ofte til brugerdefinerede Keras-modelklasser.
- Distribuerede træningsstrategierDistribueret træning med Keras bruger `tf.distribute` API'en, som er mere fleksibel og kraftfuld sammenlignet med Estimatorens distributionsstrategier.
- Servering og eksportKeras-modeller gemt i SavedModel-formatet kan serveres med TensorFlow Serving eller implementeres på Vertex AI uden yderligere ændringer.

Eksempel: Implementering af en Keras-model på Google Cloud Vertex AI

1. Definer og træn modellen

python
    import tensorflow as tf
    from tensorflow import keras

    model = keras.Sequential([
        keras.layers.Dense(64, activation='relu', input_shape=(32,)),
        keras.layers.Dense(10, activation='softmax')
    ])
    model.compile(optimizer='adam',
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    model.fit(x_train, y_train, epochs=10, batch_size=32)

2. Eksporter modellen

python
    model.save('saved_model/')

3. Upload til Google Cloud Storage

    gsutil cp -r saved_model gs://my-bucket/path/to/model/

4. Implementer på Vertex AI
Ved hjælp af Google Cloud Console eller `gcloud` CLI kan modellen implementeres til forudsigelsestjenester.

Denne arbejdsgang fremhæver den strømlinede natur ved at bruge Keras i moderne maskinlæringspipelines.

Håndtering af begrænsninger og sikring af bagudkompatibilitet

Selvom Keras dækker en bred vifte af maskinlæringsbehov, kan visse ældre arbejdsgange eller specifikke krav (f.eks. nogle distribuerede træningsfunktioner på lavt niveau) stadig nødvendiggøre brugen af ​​estimatorer. Den løbende udvikling i TensorFlow og Google Cloud Machine Learning-økosystemet er dog rettet mod yderligere at forbedre Keras' muligheder, sikre funktionsparitet og understøtte migrering.

Didaktisk værdi og pædagogisk effekt

Dette skift mod Keras har dybtgående konsekvenser for undervisning og læring af maskinlæring:

- Sænket adgangsbarriereKeras' klare og præcise syntaks giver studerende og nybegyndere mulighed for at fokusere på kernebegreber i stedet for standardkode.
- Hurtig prototyping og eksperimenteringMuligheden for hurtigt at ændre arkitekturer og træningsparametre understøtter erfaringsbaseret læring.
- Tilpasning til industristandarderKeras bruges i vid udstrækning i både akademisk forskning og industrielle applikationer, så det at lære det forbereder brugerne til opgaver i den virkelige verden.
- Problemfri progressionEleverne kan starte med simple sekventielle modeller og gradvist bevæge sig til mere avancerede brugerdefinerede underklasser uden at ændre frameworks.

Økosystem og fremtidige retninger

Det bredere TensorFlow-økosystem (herunder TensorFlow Hub, TensorFlow Lite, TensorFlow Extended og TensorFlow Serving) har indført Keras som sin primære modelgrænseflade, hvilket sikrer, at modeller bygget med Keras er bærbare på tværs af forskellige platforme – cloud, mobil, web og edge-enheder.

Forskningsværktøjer, vejledninger og uddannelsesmæssigt indhold er nu i høj grad centreret omkring Keras, hvilket yderligere forstærker dets status som standard for nye projekter.

Eksempler, der illustrerer Keras' nøglefunktioner

Brugerdefinerede træningsløkker

Keras understøtter både `.fit()`-metoden på højt niveau og brugerdefinerede træningsløkker ved hjælp af `tf.GradientTape`:

python
class MyModel(tf.keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.dense1 = tf.keras.layers.Dense(64, activation='relu')
        self.dense2 = tf.keras.layers.Dense(10, activation='softmax')
    def call(self, inputs):
        x = self.dense1(inputs)
        return self.dense2(x)

model = MyModel()
optimizer = tf.keras.optimizers.Adam()
loss_fn = tf.keras.losses.CategoricalCrossentropy()

for epoch in range(epochs):
    for x_batch, y_batch in train_dataset:
        with tf.GradientTape() as tape:
            logits = model(x_batch)
            loss = loss_fn(y_batch, logits)
        gradients = tape.gradient(loss, model.trainable_weights)
        optimizer.apply_gradients(zip(gradients, model.trainable_weights))

Dette niveau af fleksibilitet var udfordrende at opnå med estimatorer.

Integration med tf.data

Effektive datapipelines kan konstrueres som følger:

python
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(32)

model.fit(train_dataset, epochs=5)

Denne integration understøtter databehandling og -forøgelse i stor skala.

Modelserialisering og portabilitet

Keras-modeller kan eksporteres til SavedModel-formatet, hvilket muliggør:

– Implementering med TensorFlow-visning
– Konvertering til TensorFlow Lite til mobile og indlejrede enheder
– Deling med TensorFlow Hub eller Model Garden

Tuning af hyperparameter

Keras-modeller integreres direkte med automatiserede hyperparameter-tuningværktøjer, såsom Keras Tuner og Google Clouds Vertex AI Vizier.

{{EJS15}}
Nøgleforskelle: Estimator vs. Keras i praksis
FeatureTensorFlow EstimatorKeras-model (tf.keras)
API-stilFunktionel via `model_fn`, ofte ordrigObjektorienteret, præcis
TilpasningBegrænset, via brugerdefineret model_fn-logikHøj, via funktionel og underklassificering
DatainputKræver brugerdefinerede inputfunktionerIntegreret med `tf.data`
Distribueret træningIndbygget, men mindre fleksibelFleksibel via `tf.distribute`
ModeleksportSavedModel, ofte flere trinGemtModel, gemt på én linje
Integration med økosystemNoget isoleretFuld integration
Støtte til lokalsamfund og forskningfaldendeUdbredt
DebuggingStatiske grafer, mindre intuitiveIvrig udførelse, nemmere fejlfinding
Ofte stillede spørgsmål: Spørgsmål vedrørende overgang
Kan gamle Estimator-modeller bruges med Keras?
 Selvom Estimator-modeller og Keras-modeller er forskellige, tilbyder TensorFlow værktøjer til at konvertere eller pakke Estimator-modeller til brug i servering af arbejdsgange. Keras anbefales dog til nyudvikling.
Er der anvendelsesscenarier, hvor estimatorer foretrækkes?
 I sjældne tilfælde, der involverer ældre distribuerede træningsworkflows eller specialiserede krav, kan estimatorer stadig anvendes. Ikke desto mindre bliver disse scenarier stadig sjældnere, efterhånden som Keras' muligheder udvides.
Hvordan understøtter Keras store arbejdsbyrder i produktionsklassen?
 Keras integrerer med TensorFlows ydeevnefunktioner, herunder træning med blandet præcision, distributionsstrategier og optimerede inputpipelines, hvilket gør det velegnet til virksomhedsbrug.
Understøtter Keras ikke-neurale netværksmodeller?
 Keras er primært designet til neurale netværk. For visse klassiske ML-algoritmer (f.eks. tilfældige skove, boosting) foretrækkes andre biblioteker (såsom scikit-learn eller TensorFlow Decision Forests).
Didaktisk anbefaling
For både begyndere og professionelle anbefales det kraftigt at investere tid i at lære Keras. Tutorials, lærebøger og MOOC'er bruger nu Keras som standarden for deep learning-uddannelse. Forståelse af Keras API sikrer kompatibilitet med moderne bedste praksis inden for maskinlæring og cloud-implementering.
Andre seneste spørgsmål og svar vedr EITC/AI/GCML Google Cloud Machine Learning:
Se flere spørgsmål og svar i EITC/AI/GCML Google Cloud Machine Learning
Flere spørgsmål og svar:
Tagged under: , , , , , , , , , ,