Téléchargement ctransformers - Téléchargement du code source ctransformers

Ctransformateurs

Liens Python pour les modèles de transformateur implémentés en C / C ++ à l'aide de la bibliothèque GGML.

Voir aussi les chatdocs

Modèles pris en charge
Installation
Usage
- ? Transformateurs
- Lubriole
- GPU
- GPTQ
Documentation
Licence

Modèles pris en charge

Modèles	Type de modèle	Cuda	Métal
Gpt-2	`gpt2`
GPT-J, GPT4ALL-J	`gptj`
Gpt-neox, stablelm	`gpt_neox`
Faucon	`falcon`	✅
Lama, lama 2	`llama`	✅	✅
Mpte	`mpt`	✅
Lecoder étoilé, Starchat	`gpt_bigcode`	✅
Dolly V2	`dolly-v2`
Repérer	`replit`

Installation

pip install ctransformers

Usage

Il fournit une interface unifiée pour tous les modèles:

 from ctransformers import AutoModelForCausalLM

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

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

Exécuter dans Google Colab

Pour diffuser la sortie, set stream=True :

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

Vous pouvez charger directement des modèles à partir de Hugging Face Hub:

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

Si un modèle de modèle a plusieurs fichiers de modèle (fichiers .bin ou .gguf ), spécifiez un fichier de modèle à l'aide:

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

? Transformateurs

Remarque: il s'agit d'une fonctionnalité expérimentale et peut changer à l'avenir.

Pour l'utiliser avec? Transformers, créez un modèle et un tokenzer en utilisant:

 from ctransformers import AutoModelForCausalLM , AutoTokenizer

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

Exécuter dans Google Colab

Vous pouvez utiliser? 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 ))

Vous pouvez utiliser? Paramètres de génération de transformateurs:

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

Vous pouvez utiliser? Tokenisers Transformers:

 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.

Lubriole

Il est intégré à Langchain. Voir Langchain Docs.

GPU

Pour exécuter certaines des calques de modèle sur GPU, définissez le paramètre gpu_layers :

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

Exécuter dans Google Colab

Cuda

Installez les bibliothèques CUDA en utilisant:

pip install ctransformers[cuda]

Rocm

Pour activer la prise en charge de ROCM, installez le package ctransformers en utilisant:

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

Métal

Pour activer la prise en charge des métaux, installez le package ctransformers en utilisant:

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

GPTQ

Remarque: Il s'agit d'une fonctionnalité expérimentale et seuls les modèles LLAMA sont pris en charge à l'aide d'Exllama.

Installez des dépendances supplémentaires en utilisant:

pip install ctransformers[gptq]

Chargez un modèle GPTQ en utilisant:

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

Exécuter dans Google Colab

Si le nom du modèle ou le chemin ne contient pas le mot gptq , spécifiez model_type="gptq" .

Il peut également être utilisé avec Langchain. Les API de bas niveau ne sont pas entièrement prises en charge.

Documentation

Configurer

Paramètre	Taper	Description	Défaut
`top_k`	`int`	La valeur supérieure-K à utiliser pour l'échantillonnage.	`40`
`top_p`	`float`	La valeur TOP-P à utiliser pour l'échantillonnage.	`0.95`
`temperature`	`float`	La température à utiliser pour l'échantillonnage.	`0.8`
`repetition_penalty`	`float`	La pénalité de répétition à utiliser pour l'échantillonnage.	`1.1`
`last_n_tokens`	`int`	Le nombre de derniers jetons à utiliser pour la pénalité de répétition.	`64`
`seed`	`int`	La valeur des semences à utiliser pour les jetons d'échantillonnage.	`-1`
`max_new_tokens`	`int`	Le nombre maximum de nouveaux jetons à générer.	`256`
`stop`	`List[str]`	Une liste de séquences à arrêter la génération lorsqu'elle est rencontrée.	`None`
`stream`	`bool`	S'il faut diffuser le texte généré.	`False`
`reset`	`bool`	S'il faut réinitialiser l'état du modèle avant de générer du texte.	`True`
`batch_size`	`int`	La taille du lot à utiliser pour évaluer les jetons dans une seule invite.	`8`
`threads`	`int`	Le nombre de threads à utiliser pour évaluer les jetons.	`-1`
`context_length`	`int`	La longueur de contexte maximale à utiliser.	`-1`
`gpu_layers`	`int`	Le nombre de couches à exécuter sur GPU.	`0`

Remarque: Actuellement, seuls les modèles LLAMA, MPT et FALCON prennent en charge le paramètre context_length .

`classe` `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

Charge le modèle de langue à partir d'un fichier local ou d'un dépôt distant.

Args:

model_path_or_repo_id : le chemin d'accès à un fichier ou un répertoire de modèle ou le nom d'un repo de modèle Hub Hub Embring Face.
model_type : le type de modèle.
model_file : le nom du fichier modèle dans Repo ou répertoire.
config : objet AutoConfig .
lib : Le chemin vers une bibliothèque partagée ou l'un des avx2 , avx , basic .
local_files_only : que ce soit uniquement à regarder les fichiers locaux (c'est-à-dire n'essayez pas de télécharger le modèle).
revision : la version du modèle spécifique à utiliser. Il peut s'agir d'un nom de branche, d'un nom de balise ou d'un ID de validation.
hf : Que ce soit pour créer un modèle de transformateurs à face étreint.

Renvoie: objet LLM .

`classe` `LLM`

`Méthode` `LLM.init`

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

Charge le modèle de langue à partir d'un fichier local.

Args:

model_path : le chemin du chemin vers un fichier de modèle.
model_type : le type de modèle.
config : Config Object.
lib : Le chemin vers une bibliothèque partagée ou l'un des avx2 , avx , basic .

`propriété` llm.bos_token_id

Le jeton de début de séquence.

`propriété` llm.config

L'objet config.

`propriété` llm.context_length

La longueur de contexte du modèle.

`propriété` llm.embeddings

Les incorporations d'entrée.

`propriété` llm.eos_token_id

Le jeton de fin de séquence.

`propriété` llm.logits

Les probabilités logarithmiques non normalisées.

`propriété` llm.model_path

Le chemin d'accès au fichier du modèle.

`propriété` llm.model_type

Le type de modèle.

`propriété` llm.pad_token_id

Le jeton de rembourrage.

`propriété` llm.vocab_size

Le nombre de jetons dans le vocabulaire.

`Méthode` `LLM.detokenize`

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

Convertit une liste de jetons en texte.

Args:

tokens : la liste des jetons.
decode : s'il faut décoder le texte en tant que chaîne UTF-8.

Renvoie: le texte combiné de tous les jetons.

`method` `LLM.embed`

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

Computes embeddings for a text or list of tokens.

Note: Currently only LLaMA and Falcon models support embeddings.

Args:

input : The input text or list of tokens to get embeddings for.
batch_size : The batch size to use for evaluating tokens in a single prompt. Default: 8
threads : The number of threads to use for evaluating tokens. Par défaut: -1

Renvoie: les incorporations d'entrée.

`Méthode` `LLM.eval`

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

Évalue une liste de jetons.

Args:

tokens : la liste des jetons à évaluer.
batch_size : la taille du lot à utiliser pour évaluer les jetons dans une seule invite. Par défaut: 8
threads : le nombre de threads à utiliser pour évaluer les jetons. Par défaut: -1

`Méthode` `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 ]

Génère de nouveaux jetons à partir d'une liste de jetons.

Args:

tokens : la liste des jetons pour générer des jetons à partir de.
top_k : la valeur supérieure-k à utiliser pour l'échantillonnage. Par défaut: 40
top_p : la valeur top-p à utiliser pour l'échantillonnage. Par défaut: 0.95
temperature : la température à utiliser pour l'échantillonnage. Par défaut: 0.8
repetition_penalty : The repetition penalty to use for sampling. Par défaut: 1.1
last_n_tokens : le nombre de jetons dernier à utiliser pour la pénalité de répétition. Par défaut: 64
seed : La valeur des semences à utiliser pour les jetons d'échantillonnage. Par défaut: -1
batch_size : la taille du lot à utiliser pour évaluer les jetons dans une seule invite. Par défaut: 8
threads : le nombre de threads à utiliser pour évaluer les jetons. Par défaut: -1
reset : s'il faut réinitialiser l'état du modèle avant de générer du texte. Par défaut: True

Renvoie: les jetons générés.

`Méthode` `LLM.is_eos_token`

 is_eos_token ( token : int ) → bool

Vérifie si un jeton est un jeton de fin de séquence.

Args:

token : le jeton à vérifier.

Renvoie: True si le jeton est un jeton de fin de séquence autrement False .

`Méthode` `LLM.prepare_inputs_for_generation`

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

Supprime les jetons d'entrée qui sont évalués dans le passé et met à jour le contexte LLM.

Args:

tokens : la liste des jetons d'entrée.
reset : s'il faut réinitialiser l'état du modèle avant de générer du texte. Par défaut: True

Renvoie: la liste des jetons à évaluer.

`Méthode` `LLM.reset`

 reset () → None

Déprécié depuis 0,2.27.

`Méthode` `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

Échantillons un jeton du modèle.

Args:

top_k : la valeur supérieure-k à utiliser pour l'échantillonnage. Par défaut: 40
top_p : la valeur top-p à utiliser pour l'échantillonnage. Par défaut: 0.95
temperature : la température à utiliser pour l'échantillonnage. Par défaut: 0.8
repetition_penalty : The repetition penalty to use for sampling. Par défaut: 1.1
last_n_tokens : le nombre de jetons dernier à utiliser pour la pénalité de répétition. Par défaut: 64
seed : La valeur des semences à utiliser pour les jetons d'échantillonnage. Par défaut: -1

Renvoie: le jeton échantillonné.

`Méthode` `LLM.tokenize`

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

Convertit un texte en liste de jetons.

Args:

text : le texte à tokenize.
add_bos_token : s'il faut ajouter le jeton de début de séquence.

Renvoie: la liste des jetons.

`Méthode` `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 ]]

Génère du texte à partir d'une invite.

Args:

prompt : l'invite pour générer du texte à partir de.
max_new_tokens : Le nombre maximum de nouveaux jetons à générer. Par défaut: 256
top_k : la valeur supérieure-k à utiliser pour l'échantillonnage. Par défaut: 40
top_p : la valeur top-p à utiliser pour l'échantillonnage. Par défaut: 0.95
temperature : la température à utiliser pour l'échantillonnage. Par défaut: 0.8
repetition_penalty : la pénalité de répétition à utiliser pour l'échantillonnage. Par défaut: 1.1
last_n_tokens : le nombre de jetons dernier à utiliser pour la pénalité de répétition. Par défaut: 64
seed : La valeur des semences à utiliser pour les jetons d'échantillonnage. Par défaut: -1
batch_size : la taille du lot à utiliser pour évaluer les jetons dans une seule invite. Par défaut: 8
threads : le nombre de threads à utiliser pour évaluer les jetons. Par défaut: -1
stop : une liste de séquences pour arrêter la génération lorsqu'elle est rencontrée. Par défaut: None
stream : s'il faut diffuser le texte généré. Par défaut: False
reset : s'il faut réinitialiser l'état du modèle avant de générer du texte. Par défaut: True

Renvoie: le texte généré.

Licence

Mit

Développer

ctransformers

Ctransformateurs

Modèles pris en charge

Installation

Usage

? Transformateurs

Lubriole

GPU

Cuda

Rocm

Métal

GPTQ

Documentation

Configurer

classe AutoModelForCausalLM

ClassMethod AutoModelForCausalLM.from_pretrained

classe LLM

Méthode LLM.__init__

propriété llm.bos_token_id

propriété llm.config

propriété llm.context_length

propriété llm.embeddings

propriété llm.eos_token_id

propriété llm.logits

propriété llm.model_path

propriété llm.model_type

propriété llm.pad_token_id

propriété llm.vocab_size

Méthode LLM.detokenize

method LLM.embed

Méthode LLM.eval

Méthode LLM.generate

Méthode LLM.is_eos_token

Méthode LLM.prepare_inputs_for_generation

Méthode LLM.reset

Méthode LLM.sample

Méthode LLM.tokenize

Méthode LLM.__call__

Licence

`classe` `AutoModelForCausalLM`

`ClassMethod` `AutoModelForCausalLM.from_pretrained`

`classe` `LLM`

`Méthode` `LLM.init`

`propriété` llm.bos_token_id

`propriété` llm.config

`propriété` llm.context_length

`propriété` llm.embeddings

`propriété` llm.eos_token_id

`propriété` llm.logits

`propriété` llm.model_path

`propriété` llm.model_type

`propriété` llm.pad_token_id

`propriété` llm.vocab_size

`Méthode` `LLM.detokenize`

`method` `LLM.embed`

`Méthode` `LLM.eval`

`Méthode` `LLM.generate`

`Méthode` `LLM.is_eos_token`

`Méthode` `LLM.prepare_inputs_for_generation`

`Méthode` `LLM.reset`

`Méthode` `LLM.sample`

`Méthode` `LLM.tokenize`

`Méthode` `LLM.call`