ctransformers Download - ctransformers Quellcode Download

Ctransformers

Python -Bindungen für die in C/C ++ implementierten Transformatormodelle unter Verwendung der GGML -Bibliothek.

Siehe auch Chatdocs

Unterstützte Modelle
Installation
Verwendung
- ? Transformatoren
- Langchain
- GPU
- Gptq
Dokumentation
Lizenz

Unterstützte Modelle

Modelle	Modelltyp	CUDA	Metall
GPT-2	`gpt2`
GPT-J, GPT4ALL-J	`gptj`
GPT-Neox, Stablelm	`gpt_neox`
Falke	`falcon`	✅
LAMA, LAMA 2	`llama`	✅	✅
Mpt	`mpt`	✅
StarCoder, Stärke	`gpt_bigcode`	✅
Dolly v2	`dolly-v2`
Reaktion	`replit`

Installation

pip install ctransformers

Verwendung

Es bietet eine einheitliche Schnittstelle für alle Modelle:

 from ctransformers import AutoModelForCausalLM

llm = AutoModelForCausalLM . from_pretrained ( "/path/to/ggml-model.bin" , model_type = "gpt2" )

print ( llm ( "AI is going to" ))

In Google Colab ausführen

Um die Ausgabe zu streamen, setzen Sie stream=True :

 for text in llm ( "AI is going to" , stream = True ):
    print ( text , end = "" , flush = True )

Sie können Modelle direkt aus dem Umarmung des Gesichtszentrums laden:

 llm = AutoModelForCausalLM . from_pretrained ( "marella/gpt-2-ggml" )

Wenn ein Modell -Repo über mehrere Modelldateien ( .bin oder .gguf -Dateien) verfügt, geben Sie eine Modelldatei mit:

 llm = AutoModelForCausalLM . from_pretrained ( "marella/gpt-2-ggml" , model_file = "ggml-model.bin" )

? Transformatoren

Hinweis: Dies ist ein experimentelles Merkmal und kann sich in Zukunft ändern.

Zu benutzen mit? Transformatoren, erstellen Sie Modell und Tokenizer mit:

 from ctransformers import AutoModelForCausalLM , AutoTokenizer

model = AutoModelForCausalLM . from_pretrained ( "marella/gpt-2-ggml" , hf = True )
tokenizer = AutoTokenizer . from_pretrained ( model )

In Google Colab ausführen

Sie können verwenden? Transformers Text Generation Pipeline:

 from transformers import pipeline

pipe = pipeline ( "text-generation" , model = model , tokenizer = tokenizer )
print ( pipe ( "AI is going to" , max_new_tokens = 256 ))

Sie können verwenden? Transformatorengenerierungsparameter:

 pipe ( "AI is going to" , max_new_tokens = 256 , do_sample = True , temperature = 0.8 , repetition_penalty = 1.1 )

Sie können verwenden? Transformers Tokenizer:

 from ctransformers import AutoModelForCausalLM
from transformers import AutoTokenizer

model = AutoModelForCausalLM . from_pretrained ( "marella/gpt-2-ggml" , hf = True )  # Load model from GGML model repo.
tokenizer = AutoTokenizer . from_pretrained ( "gpt2" )  # Load tokenizer from original model repo.

Langchain

Es ist in Langchain integriert. Siehe Langchain Docs.

GPU

Setzen Sie den Parameter gpu_layers , um einige der Modellebenen auf der GPU auszuführen:

 llm = AutoModelForCausalLM . from_pretrained ( "TheBloke/Llama-2-7B-GGML" , gpu_layers = 50 )

In Google Colab ausführen

CUDA

Installieren Sie CUDA -Bibliotheken mit:

pip install ctransformers[cuda]

Rocm

Um die ROCM -Unterstützung zu aktivieren, installieren Sie das ctransformers -Paket mit:

CT_HIPBLAS=1 pip install ctransformers --no-binary ctransformers

Metall

So installieren Sie das ctransformers -Paket mit: So installieren Sie die Metallunterstützung mit:

CT_METAL=1 pip install ctransformers --no-binary ctransformers

Gptq

Hinweis: Dies ist ein experimentelles Merkmal und nur Lama -Modelle werden mit Exllama unterstützt.

Installieren Sie zusätzliche Abhängigkeiten mit:

pip install ctransformers[gptq]

Laden Sie ein GPTQ -Modell mit:

 llm = AutoModelForCausalLM . from_pretrained ( "TheBloke/Llama-2-7B-GPTQ" )

In Google Colab ausführen

Wenn der Modellname oder Pfad nicht das Wort gptq enthält, geben Sie model_type="gptq" an.

Es kann auch mit Langchain verwendet werden. APIs mit niedriger Ebene werden nicht vollständig unterstützt.

Dokumentation

Konfiguration

Parameter	Typ	Beschreibung	Standard
`top_k`	`int`	Der Top-K-Wert für die Probenahme.	`40`
`top_p`	`float`	Der Top-P-Wert für die Probenahme.	`0.95`
`temperature`	`float`	Die Temperatur für die Probenahme.	`0.8`
`repetition_penalty`	`float`	Die Wiederholungsstrafe für die Probenahme.	`1.1`
`last_n_tokens`	`int`	Die Anzahl der letzten Token für Wiederholungsstrafen.	`64`
`seed`	`int`	Der Saatgutwert für Probenahme -Token.	`-1`
`max_new_tokens`	`int`	Die maximale Anzahl neuer Token zu generieren.	`256`
`stop`	`List[str]`	Eine Liste von Sequenzen, um die Erzeugung zu stoppen, wenn sie angetroffen werden.	`None`
`stream`	`bool`	Ob der generierte Text streamen.	`False`
`reset`	`bool`	Ob Sie den Modellzustand zurücksetzen möchten, bevor Sie Text generieren.	`True`
`batch_size`	`int`	Die Stapelgröße für die Bewertung von Token in einer einzigen Eingabeaufforderung.	`8`
`threads`	`int`	Die Anzahl der Threads, die für die Bewertung von Token verwendet werden sollen.	`-1`
`context_length`	`int`	Die maximale Kontextlänge zu verwenden.	`-1`
`gpu_layers`	`int`	Die Anzahl der auf GPU ausgeführten Schichten.	`0`

Hinweis: Derzeit unterstützen nur Lama-, MPT- und Falcon -Modelle den Parameter context_length .

`KlassenautomodelforcausAllm` `AutoModelForCausalLM`

`classMethod` `AutoModelForCausalLM.from_pretrained`

 from_pretrained (
    model_path_or_repo_id : str ,
    model_type : Optional [ str ] = None ,
    model_file : Optional [ str ] = None ,
    config : Optional [ ctransformers . hub . AutoConfig ] = None ,
    lib : Optional [ str ] = None ,
    local_files_only : bool = False ,
    revision : Optional [ str ] = None ,
    hf : bool = False ,
    ** kwargs
) → LLM

Laden Sie das Sprachmodell aus einer lokalen Datei oder einem Remote -Repo.

Args:

model_path_or_repo_id : Der Pfad zu einer Modelldatei oder einem Verzeichnis oder dem Namen eines Umarmungsgesichts -Hub -Modells.
model_type : Der Modelltyp.
model_file : Der Name der Modelldatei in Repo oder Verzeichnis.
config : AutoConfig -Objekt.
lib : Der Weg zu einer gemeinsamen Bibliothek oder einer von avx2 , avx , basic .
local_files_only : ob man sich nur lokale Dateien ansehen oder nicht (dh nicht versuchen, das Modell herunterzuladen).
revision : Die zu verwendende Modellversion. Es kann ein Zweigname, ein Tag -Name oder eine Commit -ID sein.
hf : Ob Sie ein Modell der umarmenden Gesichtstransformatoren erstellen sollen.

Rückgabe: LLM -Objekt.

`Klasse` `LLM`

`Methode` `LLM.init`

 __init__ (
    model_path : str ,
    model_type : Optional [ str ] = None ,
    config : Optional [ ctransformers . llm . Config ] = None ,
    lib : Optional [ str ] = None
)

Lädt das Sprachmodell aus einer lokalen Datei.

Args:

model_path : Der Pfad zu einer Modelldatei.
model_type : Der Modelltyp.
config : Config .
lib : Der Weg zu einer gemeinsamen Bibliothek oder einer von avx2 , avx , basic .

`Property` llm.bos_token_id

Der Sequenz-Token.

`Property` llm.config

Das Konfigurationsobjekt.

`Eigenschaft` llm.context_length

Die Kontextlänge des Modells.

`Property` llm.embedings

Die Eingangsbettdings.

`Property` llm.eos_token_id

Das Ende der Sachhunde Token.

`Property` LLM.Logits

Die nicht operativen Protokollwahrscheinlichkeiten.

`Property` llm.model_path

Der Pfad zur Modelldatei.

`Property` llm.model_type

Der Modelltyp.

`Property` llm.pad_token_id

Das Polstertoken.

`Property` llm.vocab_size

Die Anzahl der Token im Wortschatz.

`Methode` `LLM.detokenize`

 detokenize ( tokens : Sequence [ int ], decode : bool = True ) → Union [ str , bytes ]

Konvertiert eine Liste von Token in Text.

Args:

tokens : Die Liste der Token.
decode : Ob Sie den Text als UTF-8-Zeichenfolge dekodieren sollen.

Rückgabe: Der kombinierte Text aller Token.

`Method` `LLM.embed`

 embed (
    input : Union [ str , Sequence [ int ]],
    batch_size : Optional [ int ] = None ,
    threads : Optional [ int ] = None
) → List [ float ]

Berechnet Einbettung für einen Text oder eine Liste von Token.

Hinweis: Derzeit unterstützen nur Lama- und Falcon -Modelle Einbettung.

Args:

input : Der Eingabetxt oder die Liste der Token, um Einbettung zu erhalten.
batch_size : Die Stapelgröße für die Bewertung von Token in einer einzigen Eingabeaufforderung. Standard: 8
threads : Die Anzahl der Threads, die für die Bewertung von Token verwendet werden sollen. Standard: -1

Rückgabe: Die Eingangsbettungen.

`Methode` `LLM.eval`

 eval (
    tokens : Sequence [ int ],
    batch_size : Optional [ int ] = None ,
    threads : Optional [ int ] = None
) → None

Bewertet eine Liste von Token.

Args:

tokens : Die Liste der Tokens zu bewerten.
batch_size : Die Stapelgröße für die Bewertung von Token in einer einzigen Eingabeaufforderung. Standard: 8
threads : Die Anzahl der Threads, die für die Bewertung von Token verwendet werden sollen. Standard: -1

`Methode` `LLM.generate`

 generate (
    tokens : Sequence [ int ],
    top_k : Optional [ int ] = None ,
    top_p : Optional [ float ] = None ,
    temperature : Optional [ float ] = None ,
    repetition_penalty : Optional [ float ] = None ,
    last_n_tokens : Optional [ int ] = None ,
    seed : Optional [ int ] = None ,
    batch_size : Optional [ int ] = None ,
    threads : Optional [ int ] = None ,
    reset : Optional [ bool ] = None
) → Generator [ int , NoneType , NoneType ]

Generiert neue Token aus einer Liste von Token.

Args:

tokens : Die Liste der Token, um Token zu generieren.
top_k : Der Top-K-Wert für die Probenahme. Standard: 40
top_p : Der Top-P-Wert für die Probenahme. Standard: 0.95
temperature : Die für die Probenahme zu verwendende Temperatur. Standard: 0.8
repetition_penalty : Die Wiederholungsstrafe für die Probenahme. Standard: 1.1
last_n_tokens : Die Anzahl der letzten Token, die für die Wiederholungsstrafe verwendet werden sollen. Standard: 64
seed : Der Samenwert für Probenahme -Token. Standard: -1
batch_size : Die Stapelgröße für die Bewertung von Token in einer einzigen Eingabeaufforderung. Standard: 8
threads : Die Anzahl der Threads, die für die Bewertung von Token verwendet werden sollen. Standard: -1
reset : Ob Sie den Modellzustand vor dem Generieren von Text zurücksetzen sollen. Standard: True

Rückgabe: Die erzeugten Token.

`Method` `LLM.is_eos_token`

 is_eos_token ( token : int ) → bool

Überprüft, ob ein Token ein Token am Ende der Sachhunde ist.

Args:

token : Das Token zum Überprüfen.

Rückgabe: True , wenn das Token ein Sequenz-Token ist, sonst False .

`Method` `LLM.prepare_inputs_for_generation`

 prepare_inputs_for_generation (
    tokens : Sequence [ int ],
    reset : Optional [ bool ] = None
) → Sequence [ int ]

Entfernt Eingangs -Token, die in der Vergangenheit ausgewertet werden, und aktualisiert den LLM -Kontext.

Args:

tokens : Die Liste der Eingabestypen.
reset : Ob Sie den Modellzustand vor dem Generieren von Text zurücksetzen sollen. Standard: True

Rückgabe: Die Liste der Tokens zu bewerten.

`Methode` `LLM.reset`

 reset () → None

Veraltet seit 0.2.27.

`Methode` `LLM.sample`

 sample (
    top_k : Optional [ int ] = None ,
    top_p : Optional [ float ] = None ,
    temperature : Optional [ float ] = None ,
    repetition_penalty : Optional [ float ] = None ,
    last_n_tokens : Optional [ int ] = None ,
    seed : Optional [ int ] = None
) → int

Proben ein Token aus dem Modell.

Args:

top_k : Der Top-K-Wert für die Probenahme. Standard: 40
top_p : Der Top-P-Wert für die Probenahme. Standard: 0.95
temperature : Die für die Probenahme zu verwendende Temperatur. Standard: 0.8
repetition_penalty : Die Wiederholungsstrafe für die Probenahme. Standard: 1.1
last_n_tokens : Die Anzahl der letzten Token, die für die Wiederholungsstrafe verwendet werden sollen. Standard: 64
seed : Der Samenwert für Probenahme -Token. Standard: -1

Rückkehr: Das abgetastete Token.

`Method` `LLM.tokenize`

 tokenize ( text : str , add_bos_token : Optional [ bool ] = None ) → List [ int ]

Konvertiert einen Text in die Liste der Token.

Args:

text : Der Text zum Tokenize.
add_bos_token : ob das add-sequence-token hinzugefügt wird.

Rückgabe: Die Liste der Token.

`Methode` `LLM.call`

 __call__ (
    prompt : str ,
    max_new_tokens : Optional [ int ] = None ,
    top_k : Optional [ int ] = None ,
    top_p : Optional [ float ] = None ,
    temperature : Optional [ float ] = None ,
    repetition_penalty : Optional [ float ] = None ,
    last_n_tokens : Optional [ int ] = None ,
    seed : Optional [ int ] = None ,
    batch_size : Optional [ int ] = None ,
    threads : Optional [ int ] = None ,
    stop : Optional [ Sequence [ str ]] = None ,
    stream : Optional [ bool ] = None ,
    reset : Optional [ bool ] = None
) → Union [ str , Generator [ str , NoneType , NoneType ]]

Erzeugt Text von einer Eingabeaufforderung.

Args:

prompt : Die Eingabeaufforderung, Text aus zu generieren.
max_new_tokens : Die maximale Anzahl neuer Token zu generieren. Standard: 256
top_k : Der Top-K-Wert für die Probenahme. Standard: 40
top_p : Der Top-P-Wert für die Probenahme. Standard: 0.95
temperature : Die für die Probenahme zu verwendende Temperatur. Standard: 0.8
repetition_penalty : Die Wiederholungsstrafe für die Probenahme. Standard: 1.1
last_n_tokens : Die Anzahl der letzten Token, die für die Wiederholungsstrafe verwendet werden sollen. Standard: 64
seed : Der Samenwert für Probenahme -Token. Standard: -1
batch_size : Die Stapelgröße für die Bewertung von Token in einer einzigen Eingabeaufforderung. Standard: 8
threads : Die Anzahl der Threads, die für die Bewertung von Token verwendet werden sollen. Standard: -1
stop : Eine Liste von Sequenzen, um die Erzeugung zu stoppen, wenn sie angetroffen werden. Standard: None
stream : Ob der generierte Text streamen. Standard: False
reset : Ob Sie den Modellzustand vor dem Generieren von Text zurücksetzen sollen. Standard: True

Rückgabe: Der generierte Text.

Lizenz

MIT

Expandieren

ctransformers

Ctransformers

Unterstützte Modelle

Installation

Verwendung

? Transformatoren

Langchain

GPU

CUDA

Rocm

Metall

Gptq

Dokumentation

Konfiguration

KlassenautomodelforcausAllm AutoModelForCausalLM

classMethod AutoModelForCausalLM.from_pretrained

Klasse LLM

Methode LLM.__init__

Property llm.bos_token_id

Property llm.config

Eigenschaft llm.context_length

Property llm.embedings

Property llm.eos_token_id

Property LLM.Logits

Property llm.model_path

Property llm.model_type

Property llm.pad_token_id

Property llm.vocab_size

Methode LLM.detokenize

Method LLM.embed

Methode LLM.eval

Methode LLM.generate

Method LLM.is_eos_token

Method LLM.prepare_inputs_for_generation

Methode LLM.reset

Methode LLM.sample

Method LLM.tokenize

Methode LLM.__call__

Lizenz

`KlassenautomodelforcausAllm` `AutoModelForCausalLM`

`classMethod` `AutoModelForCausalLM.from_pretrained`

`Klasse` `LLM`

`Methode` `LLM.init`

`Property` llm.bos_token_id

`Property` llm.config

`Eigenschaft` llm.context_length

`Property` llm.embedings

`Property` llm.eos_token_id

`Property` LLM.Logits

`Property` llm.model_path

`Property` llm.model_type

`Property` llm.pad_token_id

`Property` llm.vocab_size

`Methode` `LLM.detokenize`

`Method` `LLM.embed`

`Methode` `LLM.eval`

`Methode` `LLM.generate`

`Method` `LLM.is_eos_token`

`Method` `LLM.prepare_inputs_for_generation`

`Methode` `LLM.reset`

`Methode` `LLM.sample`

`Method` `LLM.tokenize`

`Methode` `LLM.call`