phenomenal ai

? IA phénoménal

L'IA phénoménale est un package dactylographié pour construire un générateur d'invite conversationnel basé sur le tour pour les modèles de grands langues. Ce package fournit les éléments constitutifs de la simulation des interactions conversationnelles entre plusieurs entités, appelées acteurs. Les acteurs peuvent partager des informations, s'engager dans le dialogue et ajuster dynamiquement le cours de la conversation en fonction des règles prédéfinies.

? Caractéristiques

• Abstraction de haut niveau : l'IA phénoménale fournit un niveau élevé d'abstraction pour les modèles de conversation basés sur l'IA. Cela vous permet de vous concentrer sur la logique de conversation et non sur le modèle sous-jacent.
• ? Plusieurs acteurs : ce package prend en charge l'interaction entre plusieurs acteurs, permettant des scénarios conversationnels complexes. Chaque acteur peut avoir sa propre personnalité et préférences.
• Histoire de la conversation : Chaque conversation a une histoire qui suit le cours du dialogue au fil du temps. L'historique est utilisé pour générer des réponses aux nouvelles lignes de dialogue.
• ? Contexte partagé : les acteurs d'une conversation partagent un contexte qui leur permet de stocker et de récupérer des informations pertinentes pour la discussion en cours. Le contexte peut être utilisé pour stocker des informations telles que le sujet de la conversation, l'emplacement, l'heure de la journée, etc.
• Planification : Le package fournit un mécanisme pour décider de l'ordre des virages entre les acteurs à l'aide de planificateurs. Le package est livré avec un planificateur par défaut qui calendait les programmes à la ronde.
• ? Management de tour de conversation : contrôle le flux de virage de la conversation et fournit une méthode pour injecter de nouveaux messages dans la conversation. Le package fournit également une méthode pour interroger la conversation avec une question et obtenir une réponse.
• Gestion de la fenêtre de contexte : Le package fournit un mécanisme pour gérer la fenêtre de contexte. La fenêtre de contexte est le nombre de jetons à démasquer dans l'histoire lors de la génération d'une réponse. Cela vous permet de contrôler la taille rapide et la quantité de contexte fournie au modèle.
• ? Léger : le package n'a qu'une seule dépendance externe ( mustache ), ce qui le rend léger et facile à utiliser.
• ? Extensible : l'emballage est conçu pour être extensible. Vous pouvez fournir votre propre fonction de génération de texte, planificateur, etc.

? Commencer

Vous pouvez installer le package via npm :

npm install @wecandobetter/phenomenal-ai

Ou via le fil:

yarn add @wecandobetter/phenomenal-ai

Exemples d'utilisation

La classe Conversation résume tous les acteurs et gère l'histoire, le contexte et la planification des virages des acteurs. La classe Actor représente un acteur dans la conversation.

L'exemple suivant montre comment utiliser la classe Conversation pour simuler une conversation entre deux acteurs.

 import { Actor , Conversation } from "@wecandobetter/phenomenal-ai" ;
import { generateText } from "./text-generation" ; // provide your own text generation function

// Define your actors
const actors = [
  new Actor ( "John" ) ,
  new Actor ( "Emma" ) ,
] ;

// Initialize a conversation
const conversation = new Conversation ( "Morning Talk" , { actors } ) ;

// Add a context entry
conversation . context . set ( "topic" , "Current topic of conversation" , "AI Ethics" ) ;

// Make a query:

const response = await conversation . query ( {
  speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
  answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
  query : "What is the topic of conversation?" , // the query to be answered
  generateText , // provide your own text generation function
  store : true , // store the response in the history
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;

// Moderate the conversation by injecting a new message:

conversation . inject ( "Let's get back to the topic of conversation." , {
  speaker : "Moderator" , // the speaker of the message (defaults to `System`)
  ephemeral : true , // this message will not be stored in the history
} ) ;

// Make one turn:

const turn = await conversation . turn ( {
  actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
  generateText , // provide your own text generation function
} ) ;

console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;

// or use an async generator:

const ac = new AbortController ( ) ;

const loop = conversation . loop ( {
  signal : ac . signal , // provide an AbortSignal to stop the loop
  generateText , // provide your own text generation function
  scheduler : conversation . scheduler , // provide your own scheduler
} ) ;

for await ( const turn of loop ) {
  console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;
} 

Référence de l'API

Les principales classes de ce package sont Conversation , ConversationHistory et Actor .

Conversation

La classe Conversation représente une conversation en cours entre plusieurs acteurs.

Propriétés

• id : identifiant unique pour la conversation.
• name : Nom de la conversation.
• actors : Tableau d' Actor participant à la conversation.
• history : l'histoire de la conversation.
• context : contexte partagé entre tous les acteurs de la conversation.

Méthodes

Ce sont les méthodes disponibles sur la classe Conversation .

new Conversation(name: string, { actors: Actor[], generateText?: GenerateText, scheduler?: Scheduler, messages?: Message[], windowss?: { history?: number } })

Initialise une nouvelle instance de la classe Conversation .

 const conversation = new Conversation ( "Morning Talk" , {
  actors : [
    new Actor ( "John" ) ,
    new Actor ( "Emma" ) ,
  ] ,
  generateText : generateText , // provide your own text generation function
  scheduler : RoundRobinScheduler , // provide your own scheduler
  messages : [ ] , // bootstrap the conversation with messages
  windows : { // configure the conversation window
    max : 1024 , // the maximum number of tokens to unmask in the history
  } ,
} ) ; 

conversation.inject(text: string, { speaker = "System" embeddings?: number[][], ephemeral?: true })

Injecte un nouveau message dans la conversation. Renvoie le message injecté.

 const message = conversation . inject (
  "Let's get back to the topic of conversation." ,
  {
    speaker : "Moderator" ,
    ephemeral : true , // if true, the message will not be stored in the history after the next turn
  } ,
) ; 

conversation.query({ speaker: Actor, answerer: Actor, query: string, generateText?: GenerateText, store = false })

Renvoie une promesse qui se résout à une réponse de virage.

 const response = await conversation . query ( {
  speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
  answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
  query : "What is the topic of conversation?" , // the query to be answered
  generateText , // provide your own text generation function
  store : true , // store the response in the history
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; 

conversation.turn({ actor: Actor, generateText?: GenerateText })

Renvoie une promesse qui se résout à une réponse de virage.

 const response = await conversation . turn ( {
  actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
  generateText , // provide your own text generation function
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; 

conversation.loop({ signal: AbortSignal; generateText?: GenerateText })

Un générateur asynchrone qui donne le haut-parleur, le texte et éventuellement les incorporations de chaque virage dans la conversation.

 const ac = new AbortController ( ) ;

// start the loop, which will yield the responses
const loop = conversation . loop ( {
  signal : ac . signal , // provide an AbortSignal to stop the loop
  generateText , // provide your own text generation function
} ) ;

for await ( const response of loop ) {
  console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;
} 

conversation.toJSON()

Renvoie une représentation JSON de la conversation.

 const json = conversation . toJSON ( ) ;

Thistory de conversation

La classe ConversationHistory représente l'histoire d'une conversation.

Propriétés

• messages : tableau de messages dans la conversation.

Méthodes

Ce sont les méthodes disponibles sur la classe ConversationHistory .

new ConversationHistory(messages?: Message[])

Initialise une nouvelle instance de la classe ConversationHistory .

 const history = new ConversationHistory ( [
  { speaker : "John" , text : "Hello, Emma!" } ,
  { speaker : "Emma" , text : "Hi, John!" } ,
] ) ; 

history.push(message: PartialBy<Message, "feedback">)

Pousse un nouveau message à l'histoire.

 history . push ( { actor : "John" , text : "Hello, Emma!" } ) ; 

history.getMessagesFor(actor: string)

Renvoie une carte des index et des messages pour l'acteur donné.

 const messages = history . getMessagesFor ( "John" ) ; 

history.getStats()

Renvoie des statistiques sur l'histoire. Les statistiques sont regroupées par l'acteur.

 const stats = history . getStats ( ) ;

console . log ( stats ) ;

// {
//   "Bob": {
//     count: 2, // total number of messages
//     textCount: 22, // total number of characters
//     percentage: 0.5, // percentage of messages in the conversation
//     textPercentage: 0.5, // percentage of characters in the conversation
//   },
// } 

history.cleanEphemeral()

Supprime les messages éphémères de l'histoire.

 history . cleanEphemeral ( ) ; 

history.up(message: Message)

Ajoutez des commentaires positifs au message donné.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . up ( message ) ; 

history.down(message: Message)

Ajoutez des commentaires négatifs au message donné.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . down ( message ) ; 

history.first(): Message

Renvoie le premier message de l'histoire.

history.last(): Message

Renvoie le dernier message de l'histoire.

history.toJSON()

Renvoie une représentation JSON de l'histoire.

history.clear()

Efface l'histoire.

Acteur

La classe Actor représente une entité qui participe à une conversation.

Propriétés

• id : identifiant unique pour l'acteur.
• name : Nom de l'acteur.
• template : modèle pour les invites de l'acteur.
• context : contexte partagé entre tous les acteurs de la conversation.
• persona : Persona de l'acteur.
• knowledge : Connaissance de l'acteur.
• memory : mémoire de l'acteur.

Méthodes

Ce sont les méthodes disponibles sur la classe Actor .

new Actor(name: string, { template?: string, persona?: Persona, knowledge?: Knowledge, memory?: Memory })

Initialise une nouvelle instance de la classe Actor . Si aucun modèle n'est fourni, le modèle par défaut sera utilisé.

 const actor = new Actor ( "John" , {
  template : "Hello, my name is {{name}}." ,
) ; 

actor.render(conversation: Conversation)

Rend le modèle de l'acteur dans une invite. L'invite est un message qui peut être utilisé par le modèle de grande langue que vous avez choisi pour générer une réponse.

 const prompt = actor . render ( conversation ) ; 

actor.toJSON()

Renvoie une représentation JSON de l'acteur.

❤️ Contribution

Les demandes de traction sont les bienvenues. Pour les changements majeurs, veuillez d'abord ouvrir un problème pour discuter de ce que vous souhaitez changer. N'hésitez pas à vérifier la page des problèmes.

Licence

Ce projet est autorisé sous la licence du MIT. N'hésitez pas à l'utiliser pour vos propres projets.

Notes

Codage heureux! ?

Si vous rencontrez des problèmes ou si vous avez des suggestions d'améliorations, n'hésitez pas à ouvrir un problème ou une demande de traction.

Donnez un ️ si vous aimez ce projet!

Codé avec ❤️ par nous pouvons faire mieux.