Tensorflow SavedModel für NLP UseCase

[servus_97]

Hallo zusammen,

ich habe aktuell ein Anliegen und verzweifle etwas daran :/


Ich habe eine eigene Klasse geschrieben, welches eine Vorhersage für Texte macht, also ein Simples NLP Use Case.
Mein Anliegen ist, dass das Training schon lange dauert und ich das trainierte Modell speichern möchte, um immer wieder darauf zugreifen zu können, ohne es wieder von vorne trainieren zu müssen.

Code: Alles auswählen

 def train_model(self,
                  optimzer=tf.keras.optimizers.Adam(1e-5), 
                  loss= tf.keras.losses.CategoricalCrossentropy(from_logits=True),
                  metrics = tf.metrics.CategoricalAccuracy()):    
    train_labels, _, valid_labels, train_features, _, valid_features, _ = self._label_binarizer()
    
    classify_model = self._build_classifier_model()
                                            
    classify_model.compile(optimizer=optimzer,
                           loss=loss,
                           metrics=metrics)
    history = classify_model.fit(x= train_features, y= train_labels, 
                                validation_data = (valid_features, valid_labels),
                                batch_size= self.batch_size,
                                epochs= self.epoch,
                                steps_per_epoch = 70
                                #callbacks = [cp_callback]
                                #callbacks = [save_callback, lr_scheduler, self.CustomCallback()]
                                )
    
   # classify_model.save("/content/drive/MyDrive/NLP_UseCase/data/checkpoint/classify_model.h5")
    model_version = "0001"
    model_name = "/content/drive/MyDrive/NLP_UseCase/data/checkpoint/classify_model"
    model_path = os.path.join(model_name, model_version)
    tf.saved_model.save(classify_model,model_path)

    return history, classify_model


  def predict(self,input):
    hist, classify_model = self.train_model()
    _, _, _, _, _, _, binarizer = self._label_binarizer()    
    result = tf.nn.softmax(classify_model(tf.constant(input)))
    intents = binarizer.inverse_transform(result.numpy())

    def predict_print(input,result):
      result_for_printing = [f'input: {input[i]:<30} : estimated intent: {result[i]}' for i in range(len(input))]
      print(*result_for_printing, sep='\n')
      print() 

    predict_print(input, intents)

    #return intents

Wenn ich jetzt mein Code laufen lasse und die Klassenmethode aufrufe bekommen ich:

Code: Alles auswählen

classify_model = nlp.train_model()

Ausgabe:
(<keras.callbacks.History at 0x7f5699b18a10>,
<keras.engine.functional.Functional at 0x7f5699bcbe50>)

Und wenn ich jetzt bspw auf einem anderen Notebook das Modell lade:

Code: Alles auswählen

model_na = "/content/drive/MyDrive/NLP_UseCase/data/checkpoint/classify_model"
model_ver = "0001"
model_pfad = os.path.join(model_na, model_ver)

saved_model = tf.saved_model.load(model_pfad)

Erhalte ich:

Code: Alles auswählen

saved_model
<tensorflow.python.saved_model.load.Loader._recreate_base_user_object.<locals>._UserObject at 0x7f56949a9590>

Wie wäre es jetzt möglich, dass ich daraus ein "keras.callback" erhalte, um dann die Klassenmethode "predict()" aufrufen, um die Vorhersagen machen zu können.


Ich hoffe echt, dass ihr mein Problem verstehen konntet

Beste Grüße

[ThomasL]

Die Doku zu tf.saved_model.save() und .load() findest du ja hier:
https://www.tensorflow.org/api_docs/pyt ... model/save
https://www.tensorflow.org/api_docs/pyt ... model/load

Ich habe diese nie benutzt, sondern immer mit den Keras Funktionen gearbeitet.
https://www.tensorflow.org/api_docs/pyt ... save_model
https://www.tensorflow.org/api_docs/pyt ... load_model

[servus_97]

Danke dir für die Links. Die hatte ich mir zuvor schon angeschaut, leider ohne Erfolg.

[ThomasL]

Ich habe mir deinen Code mal genauer angeschaut. Eventuell ist dein Problem

Code: Alles auswählen

classify_model = nlp.train_model()

classify_model ist danach ein Tupel, (wie hier erkenntlich)

Code: Alles auswählen

Ausgabe:
(<keras.callbacks.History at 0x7f5699b18a10>,
<keras.engine.functional.Functional at 0x7f5699bcbe50>)

da die Methode train_model() ja per

Code: Alles auswählen

return history, classify_model

dir die Trainingshistory und das Model zurück liefern. Also muss der Aufruf von train_model() so erfolgen:

Code: Alles auswählen

history, classify_model = nlp.train_model()

[servus_97]

Hey, danke dir

Das war mein Fehler in der Beschreibung. Nachdem ich das Modell abgespeichert habe, durch:

Code: Alles auswählen

model_version = "0002"
model_name ="../model"
model_path = os.path.join(model_name, model_version)
tf.saved_model.save(classify_model, model_path)

erhalte ich in dem Ordner "0002":
- saved_model.pb
- Ordner "assets" und Ordner "variables"

Jetzt gehe ich mal davon aus, dass mein trainiertes Modell in der Datei "saved_model.pb" hinterlegt ist.

Jetzt würde ich mein vortrainiertes Modell in einem anderen Notebook öffnen und direkt die "predict" Funktion benutzen.

Hierfür benutze ich den Code:

Code: Alles auswählen

model_version = "0002"
model_name ="../model"
model_path = os.path.join(model_name, model_version)
classify_model = tf.saved_model.load(model_path) 

Jedoch ist es nun aber kein Keras Modul mehr sondern ein "tensorflow.python.save_model.load.Loader._...."

Wie kann ich jetzt von hier aus, die "predict" Methode ausführen ? oder ist das so gar nicht machbar und ich rede Unsinn ?

LG

[ThomasL]

Ich habe gerade nicht die Zeit mir die tf.saved_model.save() und .load() genau anzuschauen, was die da wie abspeichern.
Musst du die denn verwenden? Wenn nicht, empfehle ich dir die Keras Methoden (siehe Links).
Haben bei mir immer und über Systemgrenzen hinweg funktioniert.