Cette implémentation de LogicGuide vous est présentée par Agora, nous sommes consacrés à l'avancement de l'humanité avec une recherche significative sur l'IA open source
Rejoignez notre discorde pour contribuer à ce projet ou plus de 40 autres projets
Le lien papier est là
LogicGuide est un complément innovant qui peut être branché sur n'importe quel modèle pour augmenter ses capacités de raisonnement logique de 40%. LogicGuide est conçu pour permettre à votre modèle d'exploiter la puissance des algorithmes et fonctions de raisonnement logique avancé, ce qui lui permet de générer des réponses plus précises, sensées et significatives. C'est aussi simple que Plug and Play!
Tout d'abord, clonez ce référentiel:
git clone https://github.com/kyegomez/LOGICGUIDE.git
cd LOGICGUIDE
Ensuite, installez les dépendances nécessaires:
pip install -r requirements.txt
Vous trouverez ci-dessous le guide d'utilisation de LogicGuide:
from logicguide import MemoryGuide , QuoteGuide , AlgebraGuide , LogicGuide ,
model_id = "tiiuae/falcon-40b"
device = "cuda:0" # Change to "cpu" if you don't have a CUDA-compatible GPU.
# Memory Guide
memory_guide = MemoryGuide ()
logic_guide = LogicGuide ( model_id = model_id , guide_function = memory_guide , device = device )
text = "[[set:name=OpenAI]] What is your name?"
print ( logic_guide . generate ( text )) # Output: "My name is OpenAI."
text = "[[get:name=]] What is your name?"
print ( logic_guide . generate ( text )) # Output: "My name is OpenAI."
# Quote Guide (for this example, we're using Project Gutenberg's "The Adventures of Sherlock Holmes")
quote_guide = QuoteGuide ( source = "https://www.gutenberg.org/files/1661/1661-h/1661-h.htm" )
logic_guide = LogicGuide ( model_id = model_id , guide_function = quote_guide , device = device )
text = "[[quote:]] What is a quote from Sherlock Holmes?"
print ( logic_guide . generate ( text )) # Output: A quote from "The Adventures of Sherlock Holmes" (random quote from the source)
# Algebra Guide
algebra_guide = AlgebraGuide ()
logic_guide = LogicGuide ( model_id = model_id , guide_function = algebra_guide , device = device )
text = "[[eq]] x^2 + 3x + 2 = 0"
print ( logic_guide . generate ( text )) # Output: "x^2 + 3x + 2 = 0" (and stores the equation for later)
text = "[[solve:x=]] What is the value of x?"
print ( logic_guide . generate ( text )) # Output: "The value of x is ..." (the solutions of the equation)
Nous aimons votre contribution! Nous voulons contribuer à LogicGuide aussi facile et transparent que possible. Veuillez consulter notre guide de contribution pour plus d'informations.
Établir des méta-fonctions de contexte formalisé qui augmentent la réponse LLM de base
Établir une suite de tests de référence à partir des articles
Établir plus de fonctions de guidage
LogicGuide est publié sous la licence MIT. Voir le fichier de licence pour plus de détails.
Remarque: LogicGuide a été créé et est maintenu par Kye Gomez.
Il s'agit d'une classe de guide de base qui ne modifie pas l'entrée.
Méthodes
__call__(self, history)
: Lorsque l'instance de classe est appelée comme une fonction, il renvoie simplement l' history
de la chaîne d'entrée inchangé. Cette classe de guidage est conçue pour interagir avec les opérations liées au chiffre dans la chaîne d'entrée.
Méthodes
__init__(self)
: Dans la méthode d'initialisation, un objet d'expression régulière est créé qui correspond à un ou plusieurs chiffres.__call__(self, history)
: Si l' history
de la chaîne d'entrée correspond à l'expression régulière (c'est-à-dire, c'est une séquence de chiffres), la méthode renvoie l'objet d'expression régulière. Sinon, il n'en renvoie aucun. Il s'agit d'une classe pour créer des fonctions de guidage basées sur un outil fourni.
Méthodes
__init__(self, tool)
: La méthode d'initialisation accepte un objet tool
qui est stocké pour une utilisation ultérieure.__call__(self, model_output)
: Lorsque l'instance est appelée en fonction avec model_output
comme argument, il applique la méthode tool_check
de l'objet tool
à model_output
. Cette fonction est utilisée pour vérifier la parité d'une chaîne binaire.
binary_string
: cette fonction prend une chaîne binaire comme argument.1
Si la chaîne binaire a un nombre uniforme de 1 (appartenant à la langue de parité), et 0
si ce n'est pas le cas. Ces classes sont conçues pour fournir une vérification logique et une vérification des faits sur le texte d'entrée respectivement.
Méthodes
check(self, text)
: ces méthodes acceptent un text
de chaîne en entrée et retourne true. Dans une implémentation complète, ces méthodes utiliseraient des systèmes logiques complexes, une analyse sémantique, des systèmes d'inférence logique et des systèmes de vérification des faits pour vérifier la cohérence logique et la précision factuelle du texte. Cette classe agit en tant que gestionnaire de mémoire, stockant et récupérant des valeurs en fonction de certains déclencheurs de la chaîne d'entrée.
Méthodes
__init__(self)
: Dans la méthode d'initialisation, un dictionnaire vide est créé pour agir comme magasin de mémoire.__call__(self, history)
: Cette méthode modifie l' history
de la chaîne d'entrée basée sur l'ensemble de mémoire / les déclencheurs. Cette classe récupère les citations d'une URL source et permet le remplacement d'un déclencheur de devis dans le texte d'entrée avec un devis de la source.
Méthodes
__init__(self, source)
: La méthode d'initialisation accepte une URL source et stocke une liste de citations obtenues à partir de la source.get_quotes_from_source(self)
: Cette méthode récupère tous les paragraphes de la page Web source et les renvoie sous forme de liste.__call__(self, history)
: Cette méthode remplace un déclencheur de devis dans l' history
de la chaîne d'entrée par un devis de la source. Cette classe interagit avec les équations algébriques dans la chaîne d'entrée.
Méthodes
__init__(self)
: La méthode d'initialisation crée un dictionnaire vide pour stocker des paires de symboles variables.__call__(self, history)
: Cette méthode interagit avec l' history
des chaînes d'entrée en fonction de l'équation et des déclencheurs de résolution. Cette classe agit comme le principal guide de logique qui utilise la bibliothèque de transformateurs FACE HUGGING pour générer des réponses en fonction d'une fonction de guide.
Méthodes
__init__(self, model_id, guide_function=None, device="cuda:0")
: la méthode d'initialisation définit le modèle et le tokenizer des transformateurs basés sur model_id
et définit la fonction de guide sur guide_function
ou un Fonction par défaut si guide_function
n'est pas.
default_guide_function(self, S)
S
cette méthode renvoie la chaîne d'entrée in inchangée.get_bnb_config(self)
: Cette méthode renvoie un objet BitsAndBytesConfig
pour la quantification du modèle.guide(self, S)
: Cette méthode applique la fonction de guide à la chaîne d'entrée S
.get_blocks(self, s)
: Cette méthode renvoie une liste de tous les blocs de guidage dans la chaîne d'entrée s
.generate(self, text, max_new_tokens=20)
: cette méthode génère une réponse basée sur le text
de chaîne d'entrée, en utilisant le modèle Transformers et en appliquant la fonction de guide si nécessaire. L'utilisation de l'exemple montre comment utiliser la classe LogicGuide
avec un modèle Transformers spécifique. Il génère une réponse à l'entrée "Quelle est votre théorie de tout?" en utilisant le comportement par défaut du modèle, car aucune fonction de guide n'est fournie.