imodelsX Download - imodelsX Source Code Download

Scikit-Learn Friendly Library, um Textmodelle/Daten vorherzusagen, vorherzusagen und zu steuern.
Auch eine Reihe von Versorgungsunternehmen zum Einstieg mit Textdaten.

Demo -Notizbücher

Erklärbare Modellierung/Lenkung

Modell	Referenz	Ausgabe	Beschreibung
Baumprompt	,?,?,,	Erläuterung + Lenkung	Erzeugt einen Baum von Aufgaben zu einen LLM ( offiziell ) steuern
iprompt	,?,?,	Erläuterung + Lenkung	Erzeugt eine Aufforderung, die Erklärt Muster in Daten ( offiziell )
Autoprompt	ㅤㅤ,?,?	Erläuterung + Lenkung	Finden Sie eine natürliche Eingabeaufforderung Verwenden von Eingangsgradstoffen
D3	,?,?,	Erläuterung	Erklären Sie den Unterschied zwischen zwei Verteilungen
SASC	ㅤㅤ,?,?	Erläuterung	Erklären Sie ein Black-Box-Textmodul Verwenden eines LLM ( offiziell )
Aug-linear	,?,?,	Lineares Modell	Mit einem LLM ein besseres lineares Modell einstellen Ausbettung ( offiziell ) extrahieren
Aug-Tree	,?,?,	Entscheidungsbaum	Passen Sie einen besseren Entscheidungsbaum mit einem LLM an Merkmale erweitern ( offiziell )
Qaemb	,?,?,	Erklärbar Einbettung	Erzeugen interpretierbaren Einbettungen Indem Sie LLMs Fragen stellen ( offiziell )
Kan	,?,?,	Klein Netzwerk	Fit 2-Layer Kolmogorov-Arnold-Netzwerk

Demo -Notizbücher doc? Referenzcode? Forschungspapier
⌛ Wir planen, andere interpretierbare Algorithmen wie RLPROMPT, CBMS und NBDT zu unterstützen. Wenn Sie einen Algorithmus beibringen möchten, können Sie eine PR eröffnen?

Allgemeine Versorgungsunternehmen

Modell	Referenz
LLM Wrapper	Rufen Sie einfach verschiedene LLMs an
Dataset -Wrapper	Laden Sie minimal verarbeitete Harmgingface -Datensätze herunter
Tasche Ngrams	Erfahren Sie ein lineares Modell von Ngrams
Lineare Finetune	Finetune eine einzelne lineare Schicht über LLM -Einbettungen

QuickStart

Installation : pip install imodelsx (oder für mehr Steuerung, Klon und Installation von Quelle)

Demos : Siehe Demo -Notizbücher

Natürliche Erklärungen

Baumprompt

 from imodelsx import TreePromptClassifier
import datasets
import numpy as np
from sklearn . tree import plot_tree
import matplotlib . pyplot as plt

# set up data
rng = np . random . default_rng ( seed = 42 )
dset_train = datasets . load_dataset ( 'rotten_tomatoes' )[ 'train' ]
dset_train = dset_train . select ( rng . choice (
    len ( dset_train ), size = 100 , replace = False ))
dset_val = datasets . load_dataset ( 'rotten_tomatoes' )[ 'validation' ]
dset_val = dset_val . select ( rng . choice (
    len ( dset_val ), size = 100 , replace = False ))

# set up arguments
prompts = [
    "This movie is" ,
    " Positive or Negative? The movie was" ,
    " The sentiment of the movie was" ,
    " The plot of the movie was really" ,
    " The acting in the movie was" ,
]
verbalizer = { 0 : " Negative." , 1 : " Positive." }
checkpoint = "gpt2"

# fit model
m = TreePromptClassifier (
    checkpoint = checkpoint ,
    prompts = prompts ,
    verbalizer = verbalizer ,
    cache_prompt_features_dir = None ,  # 'cache_prompt_features_dir/gp2',
)
m . fit ( dset_train [ "text" ], dset_train [ "label" ])


# compute accuracy
preds = m . predict ( dset_val [ 'text' ])
print ( ' n Tree-Prompt acc (val) ->' ,
      np . mean ( preds == dset_val [ 'label' ]))  # -> 0.7

# compare to accuracy for individual prompts
for i , prompt in enumerate ( prompts ):
    print ( i , prompt , '->' , m . prompt_accs_ [ i ])  # -> 0.65, 0.5, 0.5, 0.56, 0.51

# visualize decision tree
plot_tree (
    m . clf_ ,
    fontsize = 10 ,
    feature_names = m . feature_names_ ,
    class_names = list ( verbalizer . values ()),
    filled = True ,
)
plt . show ()

iprompt

 from imodelsx import explain_dataset_iprompt , get_add_two_numbers_dataset

# get a simple dataset of adding two numbers
input_strings , output_strings = get_add_two_numbers_dataset ( num_examples = 100 )
for i in range ( 5 ):
    print ( repr ( input_strings [ i ]), repr ( output_strings [ i ]))

# explain the relationship between the inputs and outputs
# with a natural-language prompt string
prompts , metadata = explain_dataset_iprompt (
    input_strings = input_strings ,
    output_strings = output_strings ,
    checkpoint = 'EleutherAI/gpt-j-6B' , # which language model to use
    num_learned_tokens = 3 , # how long of a prompt to learn
    n_shots = 3 , # shots per example
    n_epochs = 15 , # how many epochs to search
    verbose = 0 , # how much to print
    llm_float16 = True , # whether to load the model in float_16
)
- - - - - - - -
prompts is a list of found natural - language prompt strings

D3 (beschriebene Verteilung

 from imodelsx import explain_dataset_d3
hypotheses , hypothesis_scores = explain_dataset_d3 (
    pos = positive_samples , # List[str] of positive examples
    neg = negative_samples , # another List[str]
    num_steps = 100 ,
    num_folds = 2 ,
    batch_size = 64 ,
)

SASC

Hier erklären wir eher ein Modul als einen Datensatz

 from imodelsx import explain_module_sasc
# a toy module that responds to the length of a string
mod = lambda str_list : np . array ([ len ( s ) for s in str_list ])

# a toy dataset where the longest strings are animals
text_str_list = [ "red" , "blue" , "x" , "1" , "2" , "hippopotamus" , "elephant" , "rhinoceros" ]
explanation_dict = explain_module_sasc (
    text_str_list ,
    mod ,
    ngrams = 1 ,
)

Aug-Imodelle

Verwenden Sie diese nur wie ein Scikit-Learn-Modell. Während des Trainings passen sie über LLMs bessere Funktionen, aber zur Testzeit sind sie extrem schnell und vollständig transparent.

 from imodelsx import AugLinearClassifier , AugTreeClassifier , AugLinearRegressor , AugTreeRegressor
import datasets
import numpy as np

# set up data
dset = datasets . load_dataset ( 'rotten_tomatoes' )[ 'train' ]
dset = dset . select ( np . random . choice ( len ( dset ), size = 300 , replace = False ))
dset_val = datasets . load_dataset ( 'rotten_tomatoes' )[ 'validation' ]
dset_val = dset_val . select ( np . random . choice ( len ( dset_val ), size = 300 , replace = False ))

# fit model
m = AugLinearClassifier (
    checkpoint = 'textattack/distilbert-base-uncased-rotten-tomatoes' ,
    ngrams = 2 , # use bigrams
)
m . fit ( dset [ 'text' ], dset [ 'label' ])

# predict
preds = m . predict ( dset_val [ 'text' ])
print ( 'acc_val' , np . mean ( preds == dset_val [ 'label' ]))

# interpret
print ( 'Total ngram coefficients: ' , len ( m . coefs_dict_ ))
print ( 'Most positive ngrams' )
for k , v in sorted ( m . coefs_dict_ . items (), key = lambda item : item [ 1 ], reverse = True )[: 8 ]:
    print ( ' t ' , k , round ( v , 2 ))
print ( 'Most negative ngrams' )
for k , v in sorted ( m . coefs_dict_ . items (), key = lambda item : item [ 1 ])[: 8 ]:
    print ( ' t ' , k , round ( v , 2 ))

Kan

 import imodelsx
from sklearn . datasets import make_classification , make_regression
from sklearn . metrics import accuracy_score
import numpy as np

X , y = make_classification ( n_samples = 5000 , n_features = 5 , n_informative = 3 )
model = imodelsx . KANClassifier ( hidden_layer_size = 64 , device = 'cpu' ,
                               regularize_activation = 1.0 , regularize_entropy = 1.0 )
model . fit ( X , y )
y_pred = model . predict ( X )
print ( 'Test acc' , accuracy_score ( y , y_pred ))

# now try regression
X , y = make_regression ( n_samples = 5000 , n_features = 5 , n_informative = 3 )
model = imodelsx . kan . KANRegressor ( hidden_layer_size = 64 , device = 'cpu' ,
                                  regularize_activation = 1.0 , regularize_entropy = 1.0 )
model . fit ( X , y )
y_pred = model . predict ( X )
print ( 'Test correlation' , np . corrcoef ( y , y_pred . flatten ())[ 0 , 1 ])

Allgemeine Versorgungsunternehmen

Einfache Baselines

Leicht zu passende Basislinien, die der sklearn-API folgen.

 from imodelsx import LinearFinetuneClassifier , LinearNgramClassifier
# fit a simple one-layer finetune on top of LLM embeddings
m = LinearFinetuneClassifier (
    checkpoint = 'distilbert-base-uncased' ,
)
m . fit ( dset [ 'text' ], dset [ 'label' ])
preds = m . predict ( dset_val [ 'text' ])
acc = ( preds == dset_val [ 'label' ]). mean ()
print ( 'validation acc' , acc )

LLM Wrapper

Einfache API zum Aufrufen verschiedener Sprachmodelle mit Caching (viel leichter als Langchain).

 import imodelsx . llm
# supports any huggingface checkpoint or openai checkpoint (including chat models)
llm = imodelsx . llm . get_llm (
    checkpoint = "gpt2-xl" ,  # text-davinci-003, gpt-3.5-turbo, ...
    CACHE_DIR = ".cache" ,
)
out = llm ( "May the Force be" )
llm ( "May the Force be" ) # when computing the same string again, uses the cache

Datenverpackung

API zum Laden von Umarmungsface -Datensätzen mit grundlegender Vorverarbeitung.

 import imodelsx . data
dset , dataset_key_text = imodelsx . data . load_huggingface_dataset ( 'ag_news' )
# Ensures that dset has a split named 'train' and 'validation',
# and that the input data is contained for each split in a column given by {dataset_key_text}