Zobacz na temat generatywnej AI

Uruchom w Google Colab

Wyświetl źródło na GitHubie

Naucz się w Codelabs

Wstęp

Usługi generatywnej AI są stosunkowo nowe, a zachowanie aplikacji może być większe niż w przypadku wcześniejszych form oprogramowania. Dlatego tak ważne jest sondowanie używanych modeli systemów uczących się, badanie przykładów działania modelu i badanie niespodzianek.

Narzędzie do interpretacji informacji o uczniach (LIT, witryna, GitHub) to platforma do debugowania i analizowania modeli systemów uczących się, która pomaga zrozumieć, dlaczego i jak działają one w taki sposób, w jaki się one zachowują.

Z tego ćwiczenia w programie dowiesz się, jak używać LIT, aby jak najlepiej wykorzystać model Gemma Google. Dzięki temu ćwiczeniu w Codelabs dowiesz się, jak wykorzystać znaczenie znaczenia sekwencji, czyli technikę interpretacji, do analizowania różnych metod tworzenia promptów.

Cele szkoleniowe:

1. Omówienie istotności sekwencji i jej zastosowań w analizie modelu.
2. Konfiguruję LIT dla Gemma, aby obliczać dane wyjściowe promptów i istotność sekwencji.
3. Użycie istotności sekwencji w module LM Salience w celu poznania wpływu projektów promptów na dane wyjściowe modelu.
4. Testowanie hipotetycznych ulepszeń promptów w LIT i sprawdzanie ich wpływu.

Uwaga: w tym ćwiczeniu w Codelabs używana jest implementacja KerasNLP środowiska Gemma i TensorFlow v2 na potrzeby backendu. Zdecydowanie zalecamy użycie jądra GPU.

Salience sekwencji i jej zastosowania w analizie modelu

Modele generatywne oparte na tekście na tekst, takie jak Gemma, przyjmują sekwencję wejściową w postaci tokenizowanego tekstu i generują nowe tokeny, które są typowymi następstwami lub uzupełnieniami danych wejściowych. To generowanie następuje po 1 tokenie naraz, dołączając (w pętli) każdy nowo wygenerowany token do danych wejściowych oraz wszystkie poprzednie generacje, aż model osiągnie warunek zatrzymania. Przykładem może być sytuacja, w której model generuje token końca sekwencji (EOS) lub osiąga zdefiniowaną maksymalną długość.

Metody istotności to klasa wyjaśnialnych technik AI (XAI), które pozwalają wskazać, które części danych wejściowych są ważne dla modelu w przypadku różnych części jego danych wyjściowych. LIT obsługuje metody analizy w różnych zadaniach klasyfikacji, które wyjaśniają wpływ sekwencji tokenów wejściowych na prognozowaną etykietę. Rozpoznanie sekwencji sekwencji uogólnia te metody na modele generatywne oparte na tekście na tekst i wyjaśnia wpływ poprzednich tokenów na wygenerowane tokeny.

Do tego celu użyj tutaj metody Grad L2 Norm, która analizuje gradienty modelu i określa wpływ każdego poprzedniego tokena na dane wyjściowe. Ta metoda jest prosta i wydajna. Wykazano jej, że dobrze sprawdza się w klasyfikacji i innych środowiskach. Im większy jest wskaźnik widoczności, tym większy wpływ. Ta metoda jest wykorzystywana w LIT, ponieważ jest dobrze zrozumiała i szeroko stosowana w społeczności badań nad zrozumiałością.

Bardziej zaawansowane metody sprawdzania widoczności oparte na gradientie to Grad ⋅ Dane wejściowe i gradienty zintegrowane. Dostępne są również metody oparte na ablacji, np. LIME i SHAP. Mogą one być bardziej niezawodne, ale znacznie droższe w obliczeniach. W tym artykule znajdziesz szczegółowe porównanie różnych metod pomiaru ważności.

Więcej o metodach wyróżnienia możesz dowiedzieć się z tej interaktywnej prezentacji dla początkujących, która zawiera więcej informacji.

Importy, środowisko i inny kod konfiguracji

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
bigframes 0.21.0 requires scikit-learn>=1.2.2, but you have scikit-learn 1.0.2 which is incompatible.
google-colab 1.0.0 requires ipython==7.34.0, but you have ipython 8.14.0 which is incompatible.

Możesz je bezpiecznie zignorować.

Instalowanie LIT i Keras NLP

Do wykonania tych ćwiczeń w Codelabs potrzebujesz najnowszej wersji keras (3) keras-nlp (0.8.0) i lit-nlp (1.1) oraz konta Kaggle, aby pobrać model podstawowy.

pip install -q -U lit-nlp
pip uninstall -y umap-learn
pip install -q -U keras-nlp
pip install -q -U keras

Dostęp do Kaggle

Aby zalogować się w Kaggle, możesz zapisać plik danych logowania kaggle.json w ~/.kaggle/kaggle.json lub uruchomić podane niżej polecenie w środowisku Colab. Więcej informacji znajdziesz w dokumentacji pakietu kagglehub.

import kagglehub

kagglehub.login()

Pamiętaj, aby zaakceptować także umowę licencyjną na Gemma.

Konfigurowanie LIT na potrzeby Gemma

Konfigurowanie modeli LIT

import os

os.environ["KERAS_BACKEND"] = "tensorflow"

import keras
import keras_nlp

# Run at half precision.
keras.config.set_floatx("bfloat16")

model_name = 'gemma_instruct_2b_en'
gemma_model = keras_nlp.models.GemmaCausalLM.from_preset(model_name)

Poniższy kod inicjuje otoki LIT w celu obsługi znaczenia w modelu Gemma. Platforma LIT określa je jako modele, ale w tym przypadku są to po prostu różne punkty końcowe dla tego samego bazowego elementu gemma_model wczytanego powyżej. Dzięki temu LIT może obliczać generacje, tokenizację i znaczenie na żądanie.

from lit_nlp.examples.models import instrumented_keras_lms

batch_size = 1
max_sequence_length = 512
init_models = instrumented_keras_lms.initialize_model_group_for_salience
models = init_models(model_name, gemma_model,
                     batch_size=batch_size,
                     max_length=max_sequence_length)

Konfigurowanie zbiorów danych LIT

Gemma to model generatywny „tekst na tekst”, który korzysta z danych wejściowych i generuje tekstowe dane wyjściowe. Modele LIT zakładają, że zbiory danych będą udostępniać te pola do obsługi generowania:

• prompt: dane wejściowe do KerasGenerationModel.
• target: opcjonalna sekwencja docelowa, np. odpowiedź „ground truth” (złota) lub wstępnie wygenerowana odpowiedź z modelu.

LIT zawiera niewielki zbiór sample_prompts z przykładami z kilku różnych źródeł, takich jak:

• [GSM8K][GSM8K]: Rozwiązywanie zadań matematycznych w szkołach podstawowych za pomocą przykładów kilku zdjęć.
• [Gigaword Benchmark][gigaword]: generowanie nagłówków kolekcji krótkich artykułów.
• [Podpowiedzi konstytucyjne][prompt konstytucyjny]: Generowanie nowych pomysłów na wykorzystanie obiektów wraz z wytycznymi/granicami

Możesz też łatwo wczytywać własne dane jako plik .jsonl zawierający rekordy z polami prompt i opcjonalnie target([example][jsonl-example]) lub w dowolnym formacie przy użyciu interfejsu Dataset API firmy LIT.

Uruchom komórkę poniżej, aby wczytać przykładowe prompty.

from lit_nlp.examples.datasets import lm as lm_data

datasets = {
  'sample_prompts': lm_data.PromptExamples(
      lm_data.PromptExamples.SAMPLE_DATA_PATH
  ),
}

Konfigurowanie interfejsu LIT

LIT to interaktywne narzędzie do analizowania modeli, które umożliwia ocenę i badanie zachowań modeli z człowiekiem. Interfejs LIT ułatwia tę interakcję, umożliwiając:

• wizualizować zbiory danych i przetwarzać na bieżąco dane wyjściowe modelu,
• uruchamiać metody pomiaru widoczności, aby zrozumieć działanie tokenów wejściowych, a także
• tworzyć kontrfakty, aby sprawdzać hipotezy.

LIT umożliwia to wszystko w ramach jednego interfejsu, co ułatwia przełączanie się między różnymi narzędziami. Jest to szczególnie przydatne w przypadku takich zadań jak inżynieria promptów, którą skupisz się w dalszej części tego ćwiczenia w programowaniu.

Tego układu interfejsu użytkownika można używać w przypadku każdego innego generatywnego modelu językowego. Jeśli interesują Cię funkcje inne niż wymienione tutaj, pełną listę znajdziesz tutaj.

from lit_nlp.api import layout
modules = layout.LitModuleName

LM_SALIENCE_LAYOUT = layout.LitCanonicalLayout(
    left={
        'Data Table': [modules.DataTableModule],
        'Datapoint Editor': [modules.DatapointEditorModule],
    },
    upper={  # if 'lower' not specified, this fills the right side
        'Salience': [modules.LMSalienceModule],
    },
    layoutSettings=layout.LayoutSettings(leftWidth=40),
    description='Custom layout for language model salience.',
)

Ta komórka inicjuje serwer LIT. Może to potrwać kilka sekund, ponieważ model jest również uruchamiany na przykładowych promptach i zapisywany w pamięci podręcznej.

from lit_nlp import notebook as lit_notebook

lit_widget = lit_notebook.LitWidget(
    models=models,
    datasets=datasets,
    layouts={'default': LM_SALIENCE_LAYOUT},
    default_layout='default',
)

Możesz teraz pokazać interfejs użytkownika:

lit_widget.render(height=800)

<IPython.core.display.Javascript object>

Możesz też otworzyć LIT jako pełną stronę w nowej karcie. Uruchom kod z komórki i kliknij link, który się w niej wyświetla:

lit_widget.render(open_in_new_tab=True)

<IPython.core.display.Javascript object>

Analiza kilku promptów dotyczących Gemmy w LIT

Obecnie prompty to nie tylko nauka, ale też sztuka. LIT może pomóc Ci empirycznie poprawić prompty w przypadku dużych modeli językowych, takich jak Gemma. Poniżej znajdziesz przykład wykorzystania LIT do badania zachowań Gemmy, przewidywania potencjalnych problemów i zwiększania bezpieczeństwa.

Identyfikowanie błędów w złożonych promptach

Dwie najważniejsze techniki promptów w przypadku wysokiej jakości prototypów i aplikacji opartych na LLM to prompty typu „few-shot” (w tym przykłady oczekiwanego zachowania w prompcie) oraz łańcuch myśli (w tym forma wyjaśnienia lub rozumowania przed ostatecznym wynikiem LLM). Stworzenie skutecznego promptu to często jednak wyzwanie.

Przyjrzyjmy się przykładowi, w którym pomagasz komuś ocenić, czy spodoba się mu jedzenie zgodne z jego gustem. Początkowy szablon promptu w łańcuchu myśli może wyglądać tak:

def analyze_menu_item_template(food_likes, food_dislikes, menu_item):
  return f"""Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: {food_likes}
Taste-dislikes: {food_dislikes}
Suggestion: {menu_item}
Analysis:"""

Czy dostrzegasz problemy z tym promptem? LIT pomoże Ci sprawdzić prompt za pomocą modułu LM Salience.

Użyj znaczenia sekwencji do debugowania

W tym module wyróżnione są fragmenty promptu, które model bierze pod uwagę podczas generowania odpowiedzi. Waga jest obliczana na najmniejszym możliwym poziomie (czyli dla każdego tokena wejściowego), ale LIT może agregować wydajność tokenów w bardziej zrozumiałe, większe rozpiętości, takie jak wiersze, zdania lub słowa. Więcej informacji o tym, jak ważny jest cel, i o tym, jak go używać do wykrywania niezamierzonych uprzedzeń, znajdziesz w raporcie Saliency Explorable (w języku angielskim).

Zacznijmy od podania dla promptu nowych przykładowych danych wejściowych zmiennych szablonu promptu:

food_likes = """Cheese"""
food_dislikes = """Can't eat eggs"""
menu_item = """Quiche Lorraine"""

prompt = analyze_menu_item_template(food_likes, food_dislikes, menu_item)
print(prompt)

fewshot_mistake_example = {'prompt': prompt}  # you'll use this below

Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis:

Jeśli interfejs LIT jest otwarty w komórce powyżej lub na osobnej karcie, możesz dodać ten komunikat za pomocą edytora punktów danych LIT:

Innym sposobem jest ponowne wyrenderowanie widżetu bezpośrednio z prośbą o zainteresowanie:

lit_widget.render(data=[fewshot_mistake_example])

<IPython.core.display.Javascript object>

Zwróć uwagę na zaskakujące zakończenie modelu:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: A savoury tart with cheese and eggs
Recommendation: You might not like it, but it's worth trying.

Dlaczego model sugeruje, że możesz jeść coś, czego według Ciebie nie można jeść?

Wyróżnienie w sekwencji może pomóc w uwidocznieniu głównego problemu, który występuje na naszych przykładach w kilku ujęciach. W pierwszym przykładzie rozumowanie łańcucha myśli w sekcji analizy it has cooked onions in it, which you don't like nie jest zgodne z ostateczną rekomendacją You have to try it.

W module LM Salience wybierz „Zdania”, a potem wybierz wiersz rekomendacji. Interfejs powinien teraz wyglądać tak:

Teraz poprawmy pole „Rekomendacja” w pierwszym przykładzie na Avoid i spróbujmy jeszcze raz. W LIT ten przykład jest wstępnie wczytany w przykładowych promptach, możesz więc użyć tej małej funkcji:

def get_fewshot_example(source: str) -> str:
  for example in datasets['sample_prompts'].examples:
    if example['source'] == source:
      return example['prompt']
  raise ValueError(f'Source "{source}" not found in the dataset.')

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-fixed')}])

<IPython.core.display.Javascript object>

Ukończenie modelu wygląda teraz tak:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish contains eggs and cheese, which you don't like.
Recommendation: Avoid.

Warto się tego nauczyć: wczesne prototypowanie pomaga ujawnić zagrożenia, o których moglibyśmy nie pamiętać z wyprzedzeniem, a podatność na błędy modeli językowych oznacza, że trzeba je aktywnie projektować pod kątem błędów. Więcej szczegółów na ten temat można znaleźć w naszym przewodniku na temat projektowania z wykorzystaniem AI od osób i sztucznej inteligencji (w języku angielskim).

Poprawiona prośba o kilka ujęć jest lepsza, ale nadal nie jest poprawna – wskazuje użytkownikowi, aby unikał jajek, ale uzasadnienie jest niepoprawne. Według niego użytkownik nie lubi jajek, podczas gdy w rzeczywistości użytkownik stwierdził, że nie może jeść jajek. W tej sekcji dowiesz się, co możesz poprawić.

Przetestuj hipotezy, aby ulepszyć działanie modelu

LIT umożliwia testowanie zmian w promptach w tym samym interfejsie. W tej instancji przetestujesz dodawanie konstytucji, aby poprawić jego działanie. Konstytucje odwołują się do promptów projektowych z zasadami, które pomagają kształtować model. Najnowsze metody umożliwiają nawet interaktywne wychodzenie z zasad konstytucyjnych.

Wykorzystajmy tę propozycję, aby ulepszyć tę prośbę. Na początku promptu dodaj sekcję z zasadami generowania treści, która zaczyna się tak:

Analyze a menu item in a restaurant.

* The analysis should be brief and to the point.
* The analysis and recommendation should both be clear about the suitability for someone with a specified dietary restriction.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: Avoid.

...

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-constitution')}])

<IPython.core.display.Javascript object>

Dzięki tej aktualizacji można uruchomić przykład jeszcze raz i odnotować zupełnie inne wyniki:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish containts eggs, which you can't eat.
Recommendation: Not suitable for you.

Można następnie ponownie przeanalizować znaczenie promptu, aby lepiej zrozumieć, dlaczego zachodzi zmiana:

Zwróć uwagę, że rekomendacja jest znacznie bezpieczniejsza. Dodatkowo na oznaczenie „Nieodpowiednie dla Ciebie” wpływa zasada jasnego określenia, czy aplikacja jest odpowiednia zgodnie z wymaganiami żywieniowymi, a także analiza (tzw. łańcuch myśli). Dzięki temu masz większą pewność, że dane wyjściowe działają z właściwego powodu.

Uwzględnij w sondzie i eksploracji modeli zespoły inne niż techniczne

Zrozumiałość ma polegać na wysiłkach zespołowych, które obejmuje doświadczenie w zakresie XAI, zasad, przepisów i nie tylko.

Interakcje z modelami na wczesnym etapie opracowywania wymagały znacznej wiedzy technicznej, co utrudniało niektórym współpracownikom dostęp do nich i ich analizę. W przeszłości nie istniały narzędzia umożliwiające tym zespołom udział w wczesnych fazach prototypowania.

LIT daje nadzieję, że ten model może się zmienić. Jak widać na tym ćwiczeniu w Codelabs, wizualna medium i interaktywne możliwości LIT w zakresie analizy znaczenia i analizowania przykładów mogą ułatwić różnym zainteresowanym stronom dzielenie się swoimi ustaleniami i ich przekazywanie. Dzięki temu możesz zatrudnić więcej osób w zespole do eksploracji, sondowania i debugowania modeli. Poznanie tych metod technicznych może pomóc w lepszym zrozumieniu sposobu działania modeli. Poza tym bardziej zróżnicowana wiedza we wczesnej fazie testowania modeli również może pomóc w wykrywaniu niepożądanych wyników, które można poprawić.

Podsumowanie

Podsumowując:

• Interfejs LIT zawiera interfejs do interaktywnego wykonywania modelu, co pozwala użytkownikom bezpośrednio generować dane wyjściowe i testować scenariusze „co się stanie, jeśli”. Jest to szczególnie przydatne do testowania różnych odmian promptu.
• Moduł LM Salience przedstawia wizualną reprezentację wyróżnienia i zapewnia sterowaną szczegółowość danych, dzięki czemu można przekazywać informacje o konstrukcjach skoncentrowanych na człowieku (np. zdaniach i słowach) zamiast o konstrukcjach skoncentrowanych na modelu (np. tokenach).

Jeśli w ocenach modelu znajdziesz problematyczne przykłady, umieść je w LIT w celu debugowania. Zacznij od przeanalizowania największej możliwej jednostki treści, która logicznie wiąże się z zadaniem modelowania, skorzystaj z wizualizacji, aby sprawdzić, w którym miejscu model prawidłowo lub nieprawidłowo rozpoznaje treść promptu, a potem przejdź do mniejszych jednostek treści, aby dokładniej opisać zaobserwowane nieprawidłowe zachowanie, aby znaleźć możliwe poprawki.

I wreszcie: Lit jest stale doskonalony. Więcej informacji o naszych funkcjach i sugestie możesz podzielić się tutaj.

Dodatek: jak LIT oblicza Salience sekwencji

LIT oblicza znaczenie sekwencji w procesie wieloetapowym.

1. Po podaniu ciągu wejściowego (komunikatu oraz generowania modelu lub „złotej” sekwencji docelowej) tokenizuj go na potrzeby danych wejściowych modelu.
2. Oblicz sekwencję „celową”, przewijając tokeny wejściowe o jedną pozycję w lewo.
3. Wyodrębnij wektory dystrybucyjne na potrzeby obliczenia utraty tokenów między sekwencjami generowania a sekwencjami „docelowymi”.
4. Zasłoń stratę, aby wyodrębnić tokeny, które chcesz objaśnić.
5. Aby obliczyć gradienty reprezentacji danych wejściowych z uwzględnieniem utraty maskowanej, użyj funkcji tf.GradientTape.gradient().
6. Przetwórz gradienty, aby uzyskać jeden wynik dla każdego tokena wejściowego. Na przykład, biorąc normę L2 gradientu w każdej pozycji.

Dodatek: zautomatyzowane przetwarzanie Salience

Wyniki znaczenia można obliczyć bezpośrednio w Pythonie, wykonując te same czynności co narzędzie LIT działa wewnętrznie. Zrobisz to w 3 krokach:

1. Przygotuj przykład i uruchom tokenizator modelu.
2. Przygotuj maskę, która wybiera (przewidywane) tokeny do wyjaśnienia,
3. Wywołaj opakowanie wyróżniania.

Podaj przykład danych wejściowych dla LIT

example = {
    'prompt': 'Keras is a',
    'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'
}
example

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'}

Uwaga na temat wywoływania konwencji: zarówno tokenizator, jak i kodowanie znaczenia korzystają z interfejsu Model API platformy LIT, gdzie funkcja .predict() pobiera listę przykładów (dyktów) i zwraca generator odpowiedzi (dyktów). Jest to znacznie bardziej elastyczne podczas pracy z większymi zbiorami danych lub wolniejszymi modelami, ale jeśli chcesz, aby prognozy dotyczyły tylko jednego przykładu, musisz dodać go w ten sposób: list(model.predict([example])[0]

Pobierz tokeny, aby wybrać cele wyjaśnień

tokenizer = models[f"_{model_name}_tokenizer"].predict
tokens = list(tokenizer([example]))[0]['tokens']
tokens

array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
       '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
       '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
       '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
       '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')

Aby obliczyć istotność, musisz utworzyć maskę docelową określającą, które (przewidywane) tokeny mają być wyjaśnione. Maska docelowa będzie tablicą o tej samej długości co tokeny, z 1 na pozycjach w przypadku tokenów, które chcesz wyjaśnić. Użyjmy ▁training i ▁evaluating jako naszego celu:

Przygotuj maskę docelową

import numpy as np

target_start = list(tokens).index("▁training")
target_end = list(tokens).index("▁evaluating")

# Prepare our mask
target_mask = np.zeros(len(tokens), dtype=np.float32)
target_mask[target_start:target_end+1] = 1
target_mask

# Add to our LIT input
example_for_salience = example | {'target_mask': target_mask}
example_for_salience

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**',
 'target_mask': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
       dtype=float32)}

Wywołaj model istotności

compute_salience = models[f"_{model_name}_salience"].predict
salience = list(compute_salience([example_for_salience]))
salience[0]

{'grad_l2': array([45.75, 36.75, 61, 5.40625, 4.09375, 5.625, 6.46875, 7.3125, 3.375,
        5.03125, 3.23438, 4.5625, 2.375, 3.40625, 2.75, 1.97656, 3.95312,
        3.42188, 14.125, 4.53125, 11.375, 12.625, 18.5, 4.5625, 6.5, 0, 0,
        0, 0, 0, 0, 0], dtype=bfloat16),
 'grad_dot_input': array([-4.03125, 3.04688, -7.03125, -0.800781, 0.769531, -0.679688,
        -0.304688, 2.04688, 0.275391, -1.25781, -0.376953, -0.0664062,
        -0.0405273, -0.357422, 0.355469, -0.145508, -0.333984, 0.0181885,
        -5.0625, 0.235352, -0.470703, 2.25, 3.90625, -0.199219, 0.929688,
        0, 0, 0, 0, 0, 0, 0], dtype=bfloat16),
 'tokens': array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
        '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
        '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
        '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
        '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')}

I to wszystko. Wyniki w polach grad_l2 i grad_dot_input są wyrównane do tokens i takie same jak w interfejsie LIT.

Kilka ostatnich wyników to 0: ponieważ nasz model jest modelem językowym z zapisem od lewej do prawej, tokeny po prawej stronie zakresu docelowego nie mają żadnego wpływu na prognozę.