Utilizzare TensorFlow per le spiegazioni

Quando lavori con modelli TensorFlow addestrati personalizzati, hai bisogno di informazioni specifiche per salvare il modello e configurare le spiegazioni.

Se vuoi utilizzare Vertex Explainable AI con un modello tabulare AutoML, non è necessario eseguire alcuna configurazione; Vertex AI configura automaticamente il modello per Vertex Explainable AI. Salta questo documento e leggi l'articolo Ottenere spiegazioni.

Questa guida fornisce le informazioni necessarie per addestrare un modello TensorFlow, per assicurarsi che sia utilizzabile con Vertex Explainable AI. Nello specifico, la guida tratta i seguenti argomenti:

  • Trovare i nomi dei tensori di input e di output durante l'addestramento che devi specificare quando configuri una risorsa Model per Vertex Explainable AI. Ciò include la creazione e l'individuazione dei tensori appropriati per Vertex Explainable AI in casi speciali in cui quelli tipici non funzionano.

  • Esportazione del modello TensorFlow come SaveModel di TensorFlow compatibile con Vertex Explainable AI.

  • Trovare i nomi dei tensori di input e di output da un modello savedModel di TensorFlow già esportato. Ciò può essere utile se non hai accesso al codice di addestramento del modello.

Trovare i nomi dei tensori di input e di output durante l'addestramento

Quando usi un container predefinito TensorFlow per la gestione delle previsioni, devi conoscere i nomi dei tensori di input e di output del modello. Devi specificare questi nomi come parte di un messaggio ExplanationMetadata quando configuri un Model per Vertex Explainable AI

Se il tuo modello TensorFlow soddisfa i seguenti criteri, puoi utilizzare il "metodo di base" descritto nella sezione successiva per determinare i nomi di questi tensori durante l'addestramento:

  • I valori inseriti non sono in formato seriale
  • Ogni input nell'elemento SignatureDef del modello contiene direttamente il valore della caratteristica (può trattarsi di valori numerici o stringhe)
  • Gli output sono valori numerici, trattati come dati numerici. Sono esclusi gli ID classe, che sono considerati dati categorici.

Se il tuo modello non soddisfa questi criteri, leggi la sezione Regolazione del codice di addestramento e ricerca dei nomi dei tensori in casi speciali.

Il metodo di base

Durante l'addestramento, stampa l'attributo name dei tensori di input e di output del modello. Nell'esempio seguente, il campo name del livello Keras produce il nome del tensore sottostante necessario per ExplanationMetadata:

bow_inputs = tf.keras.layers.Input(shape=(2000,))
merged_layer = tf.keras.layers.Dense(256, activation="relu")(bow_inputs)
predictions = tf.keras.layers.Dense(10, activation="sigmoid")(merged_layer)
model = tf.keras.Model(inputs=bow_inputs, outputs=predictions)
print('input_tensor_name:', bow_inputs.name)
print('output_tensor_name:', predictions.name)

L'esecuzione di questo codice Python stampa il seguente output:

input_tensor_name: input_1:0
output_tensor_name: dense_1/Sigmoid:0

Puoi quindi utilizzare input_1:0 come nome del tensore di input e dense_1/Sigmod:0 come nome del tensore di output quando configuri Model per le spiegazioni.

Modifica il codice di addestramento e trova i nomi dei tensori in casi speciali

In alcuni casi comuni, i tensori di input e di output di ExplanationMetadata non devono essere uguali a quelli della pubblicazioneSignatureDef:

  • Hai input serializzati
  • Il grafico include operazioni di pre-elaborazione
  • Gli output di pubblicazione non sono probabilità, logit o altri tipi di tensori in virgola mobile

In questi casi, devi adottare approcci diversi per trovare i tensori di input e di output corretti. L'obiettivo generale è trovare i tensori relativi ai valori delle caratteristiche che vuoi spiegare per gli input e i tensori relativi ai logit (pre-attivazione), alle probabilità (post-attivazione) o a qualsiasi altra rappresentazione per gli output.

Casi speciali per tensori di input

Gli input nei metadati della spiegazione sono diversi da quelli della pubblicazione SignatureDef se utilizzi un input serializzato per il feed del modello o se il grafico include operazioni di pre-elaborazione.

Input serializzati

I SaveModel di TensorFlow possono accettare una varietà di input complessi, tra cui:

  • Messaggi tf.Example in serie
  • Stringhe JSON
  • Stringhe Base64 codificate (per rappresentare i dati immagine)

Se il tuo modello accetta input seriali come questi, l'utilizzo diretto di questi tensori come input per le spiegazioni non funzionerà o potrebbe produrre risultati incomprensibili. Dovrai invece individuare i tensori di input successivi che si inseriscono nelle colonne delle caratteristiche all'interno del modello.

Quando esporti il modello, puoi aggiungere un'operazione di analisi al grafico TensorFlow chiamando una funzione di analisi nella funzione di input di elaborazione. Le funzioni di analisi sono elencate nel modulo tf.io. Queste funzioni di analisi di solito restituiscono tensori in risposta e sono scelte migliori per i metadati della spiegazione.

Ad esempio, potresti utilizzare tf.parse_example() durante l'esportazione del modello. Recupera un messaggio tf.Example serializzato e restituisce un dizionario dei tensori che si alimentano alle colonne delle caratteristiche. Puoi utilizzarlo per compilare i metadati della spiegazione. Se alcuni di questi output sono tf.SparseTensor, ovvero una tupla denominata costituita da 3 tensori, dovresti ottenere i nomi degli indici, dei valori e dei tensori dense_shape e compilare i campi corrispondenti nei metadati.

L'esempio seguente mostra come ottenere il nome del tensore di input dopo un'operazione di decodifica:

float_pixels = tf.map_fn(
    lambda img_string: tf.io.decode_image(
        img_string,
        channels=color_depth,
        dtype=tf.float32
    ),
    features,
    dtype=tf.float32,
    name='input_convert'
  )

print(float_pixels.name)
Pre-elaborazione degli input

Se il grafico del modello contiene alcune operazioni di pre-elaborazione, è possibile che tu voglia ottenere spiegazioni sui tensori dopo la fase di pre-elaborazione. In questo caso, puoi ottenere i nomi di questi tensori utilizzando la proprietà name di tf.Tensor e inserirli nei metadati della spiegazione:

item_one_hot = tf.one_hot(item_indices, depth,
    on_value=1.0, off_value=0.0,
    axis=-1, name="one_hot_items:0")
print(item_one_hot.name)

Il nome del tensore decodificato diventa input_pixels:0.

Casi speciali per tensori di output

Nella maggior parte dei casi, gli output nell'elemento SignatureDef di pubblicazione sono probabilità o logit.

Se il modello attribuisce le probabilità, ma vuoi spiegare i valori dei logit, devi trovare i nomi dei tensori di output appropriati che corrispondano ai logit.

Se l'elemento SignatureDef di pubblicazione ha output che non sono probabilità o logit, fai riferimento all'operazione delle probabilità nel grafico di addestramento. Questo scenario è improbabile per i modelli Keras. In questo caso, puoi utilizzare TensorBoard (o altri strumenti di visualizzazione di grafici) per individuare i nomi corretti dei tensori di output.

Considerazioni speciali per i gradienti integrati

Se vuoi utilizzare il metodo di attribuzione delle funzionalità dei gradienti integrati di Vertex Explainable AI, devi assicurarti che gli input siano differenziabili rispetto all'output.

I metadati di spiegazione separano logicamente le caratteristiche di un modello dai relativi input. Quando utilizzi gradienti integrati con un tensore di input non differenziabile rispetto al tensore di output, devi fornire anche la versione codificata (e differenziabile) di questa funzionalità.

Utilizza il seguente approccio se disponi di tensori di input non differenziabili o se nel grafico sono presenti operazioni non differenziabili:

  1. Codifica gli input non differenziabili come input differenziabili.
  2. Imposta input_tensor_name sul nome del tensore di input originale non differenziabile e imposta encoded_tensor_name sul nome della versione codificata e differenziabile.

File di metadati spiegazione con codifica

Ad esempio, considera un modello che ha una caratteristica categorica con un tensore di input denominato zip_codes:0. Poiché i dati di input includono codici postali sotto forma di stringhe, il tensore di input zip_codes:0 non è differenziabile. Se anche il modello pre-elabora questi dati per ottenere una rappresentazione di codifica one-hot dei codici postali, il tensore di input dopo la pre-elaborazione diventa differenziabile. Per distinguerlo dal tensore di input originale, puoi assegnargli il nome zip_codes_embedding:0.

Per utilizzare i dati di entrambi i tensori di input nella richiesta di spiegazioni, imposta ExplanationMetadata come segue quando configuri Model per le spiegazioni:

  • Imposta il tasto funzionalità di input su un nome significativo, ad esempio zip_codes.
  • Imposta input_tensor_name sul nome del tensore originale, zip_codes:0.
  • Imposta encoded_tensor_name sul nome del tensore dopo la codifica one-hot, zip_codes_embedding:0.
  • Imposta encoding su COMBINED_EMBEDDING.
{
    "inputs": {
      "zip_codes": {
        "input_tensor_name": "zip_codes:0",
        "encoded_tensor_name": "zip_codes_embedding:0",
        "encoding": "COMBINED_EMBEDDING"
      }
    },
    "outputs": {
      "probabilities": {
        "output_tensor_name": "dense/Softmax:0"
      }
    }
}

In alternativa, puoi impostare input_tensor_name sul nome del tensore di input codificato e differenziabile e omettere il tensore originale non differenziabile. Il vantaggio di fornire entrambi i tensori è che le attribuzioni possono essere effettuate a singoli valori di codice postale anziché sulla sua rappresentazione di codifica one-hot. In questo esempio, escludi il tensore originale (zip_codes:0) e imposti input_tensor_name su zip_codes_embedding:0. Questo approccio non è consigliato perché sarebbe difficile ragionare sulle attribuzioni delle funzionalità risultanti.

Codifica

Per attivare la codifica per il tuo Model, specifica le impostazioni di codifica come mostrato nell'esempio precedente.

La funzionalità di codifica consente di invertire il processo dai dati codificati ai dati di input per le attribuzioni, eliminando la necessità di post-elaborare manualmente le attribuzioni restituite. Consulta l'elenco delle codifiche supportate da Vertex Explainable AI.

Per la codifica COMBINED_EMBEDDING, il tensore di input è codificato in un array 1D.

Ad esempio:

  • Input: ["This", "is", "a", "test"]
  • Input codificato: [0.1, 0.2, 0.3, 0.4]

Esporta i SaveModel di TensorFlow per Vertex Explainable AI

Dopo aver addestrato un modello TensorFlow, esportalo come savedModel. Il modello TensorFlow saveModel contiene il modello TensorFlow addestrato, insieme alle firme in serie, alle variabili e agli altri asset necessari per eseguire il grafico. Ogni SignatureDef in savedModel identifica una funzione nel grafico che accetta input tensori e produce output tensore.

Per assicurarti che il modello savedModel sia compatibile con Vertex Explainable AI, segui le istruzioni riportate in una delle sezioni seguenti, a seconda che utilizzi TensorFlow 2 o TensorFlow 1.

TensorFlow 2

Se utilizzi TensorFlow 2.x, utilizza tf.saved_model.save per salvare il modello. Puoi specificare le firme di input quando salvi il modello. Se hai una sola firma di input, Vertex Explainable AI utilizza la funzione di pubblicazione predefinita per le richieste di spiegazioni. Se hai più di una firma di input, devi specificare la firma della funzione di pubblicazione predefinita quando salvi il modello:

tf.saved_model.save(m, model_dir, signatures={
    'serving_default': serving_fn,
    'xai_model': model_fn # Required for XAI
    })

In questo caso, Vertex Explainable AI utilizza la firma della funzione del modello che hai salvato con la chiave xai_model per la richiesta di spiegazioni. Utilizza la stringa esatta xai_model per la chiave.

Se utilizzi una funzione di pre-elaborazione, devi specificare anche le firme per la funzione di pre-elaborazione e la funzione del modello. Devi utilizzare le stringhe esatte xai_preprocess e xai_model come chiavi:

tf.saved_model.save(m, model_dir, signatures={
    'serving_default': serving_fn,
    'xai_preprocess': preprocess_fn, # Required for XAI
    'xai_model': model_fn # Required for XAI
    })

In questo caso, Vertex Explainable AI utilizza la funzione di pre-elaborazione e la funzione del modello per le richieste di spiegazione. Assicurati che l'output della funzione di pre-elaborazione corrisponda all'input previsto dalla funzione del modello.

Scopri di più su come specificare le firme di pubblicazione in TensorFlow.

TensorFlow 1.15

Se utilizzi TensorFlow 1.15, non utilizzare tf.saved_model.save. Vertex Explainable AI non supporta i modelli TensorFlow 1 salvati con questo metodo

Se crei e addestra il tuo modello in Keras, devi convertirlo in uno strumento di stima TensorFlow e quindi esportarlo in un SaveModel. Questa sezione è incentrata sul salvataggio di un modello.

Dopo aver creato, compilato, addestrato e valutato il modello Keras, devi:

  • Converti il modello Keras in TensorFlow Estimator utilizzando tf.keras.estimator.model_to_estimator
  • Fornisci una funzione di input di elaborazione, utilizzando tf.estimator.export.build_raw_serving_input_receiver_fn
  • Esporta il modello come savedModel utilizzando tf.estimator.export_saved_model.
# Build, compile, train, and evaluate your Keras model
model = tf.keras.Sequential(...)
model.compile(...)
model.fit(...)
model.predict(...)

## Convert your Keras model to an Estimator
keras_estimator = tf.keras.estimator.model_to_estimator(keras_model=model, model_dir='export')

## Define a serving input function appropriate for your model
def serving_input_receiver_fn():
  ...
  return tf.estimator.export.ServingInputReceiver(...)

## Export the SavedModel to Cloud Storage, using your serving input function
export_path = keras_estimator.export_saved_model(
  'gs://' + 'YOUR_BUCKET_NAME',
  serving_input_receiver_fn
).decode('utf-8')

print("Model exported to: ", export_path)

Ottieni i nomi dei tensori da SignatureDef di un savedModel

Puoi utilizzare un valore SignatureDef di TensorFlow savedModel per preparare i metadati della spiegazione, a condizione che soddisfino i criteri del "metodo di base" descritto in una sezione precedente. Ciò può essere utile se non hai accesso al codice di addestramento che ha generato il modello.

Per ispezionare SignatureDef di SaveModel, puoi utilizzare l'interfaccia a riga di comando SalvatiModel. Scopri di più su come utilizzare l'interfaccia a riga di comando SavingModel.

Considera l'esempio SignatureDef seguente:

The given SavedModel SignatureDef contains the following input(s):
  inputs['my_numpy_input'] tensor_info:
      dtype: DT_FLOAT
      shape: (-1, 1)
      name: x:0
The given SavedModel SignatureDef contains the following output(s):
  outputs['probabilities'] tensor_info:
      dtype: DT_FLOAT
      shape: (-1, 1)
      name: dense/Softmax:0
Method name is: tensorflow/serving/predict

Il grafico ha un tensore di input denominato x:0 e un tensore di output denominato dense/Softmax:0. Quando configuri Model per le spiegazioni, utilizza x:0 come nome del tensore di input e dense/Softmax:0 come nome del tensore di output nel messaggio ExplanationMetadata.

Passaggi successivi