Informazioni su input e output per le spiegazioni

Prima di richiedere spiegazioni, devi inviare un file di metadati delle spiegazioni per configurare la richiesta. Questo file di metadati deve includere il tuo gli input e gli output del modello. Inoltre, include impostazioni facoltative, come basi di input e impostazioni di visualizzazione per i dati immagine.

Specificare gli input e gli output del modello consente di selezionare particolari funzioni per la tua richiesta di spiegazioni, senza che tu debba modificare un modello di machine learning. Puoi utilizzare l'SDK Explainable AI per farlo automaticamente quando crei un nuovo modello. Se non utilizzi l'SDK Explainable AI, dovrai identificare manualmente gli input e gli output.

Questa guida si concentra su come identificare manualmente i tensori di input e di output per aiutarti a preparare il file dei metadati della spiegazione.

Input e output nei metadati della spiegazione

Per preparare i metadati della spiegazione, devi specificare gli input e gli output per il tuo modello in un file denominato explanation_metadata.json:

{
  "inputs": {
    string <input feature key>: {
      "input_tensor_name": string,
  },
  "outputs": {
    string <output value key>:  {
      "output_tensor_name": string
    },
  },
  "framework": "tensorflow"
}

All'interno degli oggetti inputs e outputs del file, devi fornire i nomi dei tensori di input e di output per la richiesta di spiegazioni.

  • I tasti per ogni input e output ("chiave di funzionalità di input" e "chiave valore output" nell'esempio precedente) ti consentono di assegnare nomi significativi a ciascun tensore. Nell'esempio seguente, la chiave della funzionalità di input è degrees_celsius, mentre la la chiave del valore di output è probabilities.
  • Per i valori in ogni metadato input e output, devi specificare il valore nome effettivo del tensore come input_tensor_name o output_tensor_name. Nell'esempio seguente, input_tensor_name è x:0 e il valore output_tensor_name è dense/Softmax:0.
{
    "inputs": {
      "degrees_celsius": {
        "input_tensor_name": "x:0",
      }
    },
    "outputs": {
      "probabilities": {
        "output_tensor_name": "dense/Softmax:0"
      }
    },
  "framework": "tensorflow"
}

I nomi effettivi dei tensori sono formattati come name:index.

Trovare i tensori di input e output

Dopo aver addestrato un modello TensorFlow, esportalo come SavedModel. Il file SavedModel di TensorFlow contiene il modello TensorFlow addestrato, oltre a firme, variabili e altri asset serializzati necessari per eseguire il grafico. Ogni SignatureDef identifica una funzione nel grafo che accetta input di tensori e produce output di tensori. Analogamente, il file dei metadati definisce gli input e gli output del grafico per l'attribuzione delle caratteristiche richiesta ad AI Explanations.

Spesso, i tensori di input e di output specificati nel file di metadati della spiegazione mappano esattamente alle firme che definisci quando salvi il modello. In tal caso, trovare i nomi dei tensori di input e output è relativamente semplice. Tuttavia, in alcuni casi, gli input o gli output che vuoi spiegare potrebbero essere diversi da quelli definiti al momento del salvataggio del modello.

Gli input e output delle spiegazioni sono gli stessi di quelli impostati nelle la pubblicazione SignatureDef se:

  • Gli input non sono in formato serializzato
  • Ogni input nell'SignatureDef contiene il valore della caratteristica direttamente (può essere valori numerici o stringhe)
  • Gli output sono valori numerici, trattati come dati numerici. Il corso è escluso Gli ID, che sono considerati dati categorici.

In questi casi, puoi ottenere i nomi dei tensori di input e di output durante la creazione del modello. In alternativa, puoi ispezionare il SignatureDef del tuo SavedModel con la CLI SavedModel per trovare i nomi dei tensori di input e output.

Per tutti i casi che non soddisfano i criteri precedenti, vi sono altri approcci che puoi adottare per individuare i tensori di input e output corretti.

Recupero dei nomi dei tensori durante l'addestramento

Durante l'addestramento è più semplice accedere ai nomi dei tensori di input e output. Puoi salvare questi valori nel file dei metadati della spiegazione, mentre il programma o l'ambiente ha ancora accesso alle variabili impostate durante la creazione del modello. In questo esempio, il campo name dello strato Keras produce la parte sottostante il nome del tensore necessario per i metadati della spiegazione:

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 = keras.Model(inputs=bow_inputs, outputs=predictions)
print('input_tensor_name:', bow_inputs.name)
print('output_tensor_name:', predictions.name)

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

Per un esempio pratico, consulta blocchi note di esempio.

Recupero dei nomi di tensori dalle definizioni di firma

Dato che i valori SignatureDef e i metadati di spiegazione identificano entrambi gli input del tensore e output, puoi utilizzare SignatureDef per preparare la tua spiegazione di metadati, a condizione che soddisfi le criteri menzionati in precedenza.

Considera l'esempio seguente SignatureDef:

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 grafo ha un tensore di input denominato x:0 e un tensore di output denominato dense/Softmax:0. Entrambi i tensori hanno anche nomi significativi: my_numpy_input e probabilities rispettivamente. Per richiedere spiegazioni per probabilities rispetto a my_numpy_input, puoi creare un come segue:

{
    "inputs": {
      "my_numpy_input": {
        "input_tensor_name": "x:0",
      }
    },
    "outputs": {
      "probabilities": {
        "output_tensor_name": "dense/Softmax:0"
      }
    },
  "framework": "tensorflow"
}

Per ispezionare il SignatureDef del tuo SavedModel, puoi utilizzare la CLI di SavedModel. Scopri di più su come utilizzare l'interfaccia a riga di comando SavedModel.

Gestione delle discrepanze di input e output

Esistono alcuni casi comuni in cui i tensori di input e di output nei metadati dell'evidenziazione non devono essere uguali a quelli di pubblicazioneSignatureDef:

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

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

Discrepanze negli input

Gli input nei metadati della spiegazione sono diversi da quelli di pubblicazioneSignatureDef se utilizzi un input serializzato per alimentare il modello o se il grafico include operazioni di preelaborazione.

Input serializzati

I SavedModels di TensorFlow possono accettare una serie di input complessi, tra cui:

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

Se il tuo modello accetta input serializzati come questi, l'utilizzo diretto di questi tensori come input per le spiegazioni non funzionerà o potrebbe produrre risultati non significativi. Devi invece individuare i tensori di input successivi che vengono inseriti nelle colonne di funzionalità all'interno del modello.

Quando esporti il modello, puoi aggiungere un'operazione di analisi al gráfo di TensorFlow chiamando una funzione di analisi nella funzione di input di pubblicazione. Puoi trovare le funzioni di analisi elencate nel modulo tf.io. Queste funzioni di analisi di solito restituiscono tensori come risposta e questi tensori sono scelte migliori per i metadati della spiegazione.

Ad esempio, potresti utilizzare tf.parse_example() durante l'esportazione del modello. Prende un messaggio tf.Example serializzato e genera un dizionario di tensori che alimentano le colonne di caratteristiche. Puoi utilizzare il suo output per compilare i metadati della spiegazione. Se alcuni di questi output tf.SparseTensor, che è una tupla denominata composta da 3 tensori, dovrebbe ottenere i nomi degli indici, dei valori e dei tensori dense_shape e riempire e i campi corrispondenti nei metadati.

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

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)

Input di pre-elaborazione

Se il grafico del modello contiene alcune operazioni di pre-elaborazione, potresti 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 inseriscili 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.

Discrepanze nell'output

Nella maggior parte dei casi, gli output nella pubblicazione SignatureDef sono probabilità o logit.

Se il modello attribuisce le probabilità, ma vuoi spiegare il logit Occorre trovare i nomi dei tensori di output appropriati corrispondono ai logit.

Se la pubblicazione di SignatureDef ha output che non sono probabilità o devi fare riferimento all'operazione delle probabilità nel grafico di addestramento. Questo scenario è improbabile per i modelli Keras. In tal caso, puoi utilizzare TensorBoard (o altri strumenti di visualizzazione del grafico) per facilitare la localizzazione i nomi dei tensori di output corretti.

Considerazioni aggiuntive sui gradienti integrati

Le spiegazioni AI forniscono due metodi di attribuzione delle funzionalità: valori di Shapley campionati e gradienti integrati. Il metodo dei gradienti integrati richiede assicurati che gli input siano differenziabili rispetto all'output, in modo da devi tenerlo a mente quando prepari i metadati della spiegazione. Non devi assicurarti che gli input siano differenziabili se utilizzi il modello Metodo di attribuzione delle caratteristiche di Shapley. Scopri di più sulle metodi di attribuzione delle caratteristiche supportato in AI Explanations.

I metadati della spiegazione separano logicamente le caratteristiche di un modello dai suoi input. Quando si utilizzano gradienti integrati con un tensore di input non differenziabile rispetto al tensore di output, è necessario fornire il valore codificato (e differenziabile) di quella funzionalità.

Utilizza il seguente approccio se hai tensori di input non differenziabili o se operazioni non differenziabili nel grafico:

  • Codifica gli input non differenziabili come input differenziabili.
  • Imposta input_tensor_name sul nome dell'input originale non differenziabile tensor e imposta encoded_tensor_name sul nome del file codificato, più differenziabile.

File di metadati di spiegazione con codifica

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

Per utilizzare i dati di entrambi i tensori di input nella richiesta di spiegazione, imposta il valore metadati inputs come segue:

  • Imposta la chiave della 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"
      }
    },
  "framework": "tensorflow"
}

In alternativa, puoi impostare input_tensor_name sul nome di il tensore di input differenziabile codificato e omette l'originale, non differenziabile. Il vantaggio di fornire entrambi i tensori è che le attribuzioni possono essere fatte a singoli valori di codici postali anziché rappresentazione di codifica one-hot. In questo esempio, dovresti escludere il tensore originale (zip_codes:0) e impostare input_tensor_name su zip_codes_embedding:0. Questo approccio non è consigliato perché sarebbe difficile spiegare le attribuzioni delle caratteristiche risultanti.

Codifica

Per attivare la codifica nella richiesta di spiegazioni, specifica le impostazioni di codifica come mostrato nell'esempio precedente.

La funzionalità di codifica aiuta a invertire il processo dai dati codificati ai dati di input per le attribuzioni, eliminando così la necessità di dover elaborare attribuzioni manualmente. Al momento, le spiegazioni basate sull'IA supportano combined_embedding, dove una funzionalità di lunghezza variabile viene combinata in un embedding. Un'operazione di esempio che corrisponde a questo combined_embedding è tf.nn.embedding_lookup_sparse.

Per combined_embedding:

Il tensore di input è codificato in un array 1D. Ad esempio:

  • Ingresso: ["This", "is", "a", "test"]
  • Codificato: [0.1, 0.2, 0.3, 0.4]

Passaggi successivi