LLMUnidade

Outro código-fonte

Baixar

Crie personagens no Unity com LLMs!

O LLM for Unity permite a integração perfeita de Large Language Models (LLMs) no mecanismo Unity.
Ele permite criar personagens inteligentes com os quais seus jogadores podem interagir para uma experiência envolvente.
O pacote também conta com um sistema Retrieval-Augmented Generation (RAG) que permite realizar pesquisas semânticas em seus dados, que podem ser usadas para aprimorar o conhecimento do personagem. O LLM for Unity foi desenvolvido com base na incrível biblioteca llama.cpp.

_{Visão geral • Como ajudar • Jogos usando LLM para Unity • Configuração • Como usar • RAG • Gerenciamento de modelo LLM • Exemplos • Opções • Licença}

De relance

Plataforma cruzada! Windows, Linux, macOS e Android
? Funciona localmente sem acesso à Internet. Nenhum dado sai do jogo!
⚡ Inferência extremamente rápida em CPU e GPU (Nvidia, AMD, Apple Metal)
? Suporta todos os principais modelos LLM
? Fácil de configurar, ligue com uma única linha de código
? Gratuito para uso para fins pessoais e comerciais

? Testado no Unity: 2021 LTS, 2022 LTS, 2023
? Próximos lançamentos

Como ajudar

Marque o repositório com estrela, deixe-nos um comentário e divulgue o projeto!
Junte-se a nós no Discord e diga oi.
Contribua enviando solicitações de recursos, bugs ou até mesmo seu próprio PR.
este trabalho para permitir recursos ainda mais legais!

Jogos usando LLM para Unity

Veredicto Verbal
Eu, Chatbot: AISYLUM
Almas Sem Nome do Vazio
Assassinato no corredor 4
IA exigente de entrega de comida
Namorada Emocional AI
Caso encerrado

Entre em contato conosco para adicionar seu projeto!

Configurar

Método 1: instalar usando o armazenamento de ativos

Abra a página de ativos do LLM for Unity e clique em Add to My Assets
Abra o Gerenciador de Pacotes no Unity: Window > Package Manager
Selecione a opção Packages: My Assets no menu suspenso
Selecione o pacote LLM for Unity , clique em Download e depois Import

Método 2: instalar usando o repositório GitHub:

Abra o Gerenciador de Pacotes no Unity: Window > Package Manager
Clique no botão + e selecione Add package from git URL
Use o URL do repositório https://github.com/undreamai/LLMUnity.git e clique em Add

Como usar

Primeiro você configurará o LLM para o seu jogo?:

Crie um GameObject vazio.
No GameObject Inspector, clique em Add Component e selecione o script LLM.
Baixe um dos modelos padrão com o botão Download Model (~GBs).
Ou carregue seu próprio modelo .gguf com o botão Load model (consulte gerenciamento de modelo LLM).

Então você pode configurar cada um de seus personagens da seguinte maneira ?‍♀️:

Crie um GameObject vazio para o personagem.
No GameObject Inspector, clique em Add Component e selecione o script LLMCharacter.
Defina a função da sua IA no Prompt . Você pode definir o nome da IA ( AI Name ) e do jogador ( Player Name ).
(Opcional) Selecione o LLM construído acima no campo LLM se você tiver mais de um GameObjects LLM.

Você também pode ajustar o LLM e as configurações de personagem de acordo com sua preferência (consulte Opções).

No seu script você pode usá-lo da seguinte maneira?:

 using LLMUnity ;

public class MyScript {
  public LLMCharacter llmCharacter ;
  
  void HandleReply ( string reply ) {
    // do something with the reply from the model
    Debug . Log ( reply ) ;
  }
  
  void Game ( ) {
    // your game function
    .. .
    string message = " Hello bot! " ;
    _ = llmCharacter . Chat ( message , HandleReply ) ;
    .. .
  }
}

Você também pode especificar uma função a ser chamada quando a resposta do modelo for concluída.
Isto é útil se a opção Stream estiver habilitada para saída contínua do modelo (comportamento padrão):

  void ReplyCompleted ( ) {
    // do something when the reply from the model is complete
    Debug . Log ( " The AI replied " ) ;
  }
  
  void Game ( ) {
    // your game function
    .. .
    string message = " Hello bot! " ;
    _ = llmCharacter . Chat ( message , HandleReply , ReplyCompleted ) ;
    .. .
  }

Para interromper o chat sem esperar que ele termine você pode usar:

    llmCharacter . CancelRequests ( ) ;

Por fim, no Inspetor do GameObject do seu script, selecione o GameObject LLMCharacter criado acima como propriedade llmCharacter.

Isso é tudo ✨!

Você também pode:

Crie um aplicativo móvel no Android

Para construir um aplicativo Android, você precisa especificar o back-end de script IL2CPP e o ARM64 como arquitetura de destino nas configurações do player.
Essas configurações podem ser acessadas no menu Edit > Project Settings na seção Player > Other Settings .

Também é uma boa ideia ativar a opção Download on Build no LLM GameObject para baixar o modelo na inicialização, a fim de manter o tamanho do aplicativo pequeno.

Salvar/Carregar seu histórico de bate-papo

Para salvar/carregar automaticamente seu histórico de bate-papo, você pode especificar o parâmetro Save do LMCharacter para o nome do arquivo (ou caminho relativo) de sua escolha. O arquivo é salvo na pasta persistenteDataPath do Unity. Isso também salva o estado do LLM, o que significa que o prompt armazenado em cache anteriormente não precisa ser recalculado.

Para salvar manualmente seu histórico de bate-papo, você pode usar:

    llmCharacter . Save ( " filename " ) ;

e para carregar o histórico:

    llmCharacter . Load ( " filename " ) ;

onde filename é o nome do arquivo ou caminho relativo de sua escolha.

Processe o prompt no início do seu aplicativo para um tempo de processamento inicial mais rápido

  void WarmupCompleted ( ) {
    // do something when the warmup is complete
    Debug . Log ( " The AI is nice and ready " ) ;
  }

  void Game ( ) {
    // your game function
    .. .
    _ = llmCharacter . Warmup ( WarmupCompleted ) ;
    .. .
  }

Decida se deseja ou não adicionar a mensagem ao histórico de bate-papo/prompt

O último argumento da função Chat é um booleano que especifica se a mensagem deve ser adicionada ao histórico (padrão: true):

  void Game ( ) {
    // your game function
    .. .
    string message = " Hello bot! " ;
    _ = llmCharacter . Chat ( message , HandleReply , ReplyCompleted , false ) ;
    .. .
  }

Use preenchimento de texto puro

  void Game ( ) {
    // your game function
    .. .
    string message = " The cat is away " ;
    _ = llmCharacter . Complete ( message , HandleReply , ReplyCompleted ) ;
    .. .
  }

Aguarde a resposta antes de prosseguir para as próximas linhas de código

Para isso você pode usar a funcionalidade async / await :

  async void Game ( ) {
    // your game function
    .. .
    string message = " Hello bot! " ;
    string reply = await llmCharacter . Chat ( message , HandleReply , ReplyCompleted ) ;
    Debug . Log ( reply ) ;
    .. .
  }

Adicionar um componente LLM/LLMCharacter programaticamente

(); // set the LLM object that handles the model llmCharacter.llm = llm; // set the character prompt llmCharacter.SetPrompt("A chat between a curious human and an artificial intelligence assistant."); // set the AI and player name llmCharacter.AIName = "AI"; llmCharacter.playerName = "Human"; // optional: set streaming to false to get the complete result in one go // llmCharacter.stream = true; // optional: set a save path // llmCharacter.save = "AICharacter1"; // optional: enable the save cache to avoid recomputation when loading a save file (requires ~100 MB) // llmCharacter.saveCache = true; // optional: set a grammar // await llmCharacter.SetGrammar("json.gbnf"); // re-enable gameObject gameObject.SetActive(true); } }">

 using UnityEngine ;
using LLMUnity ;

public class MyScript : MonoBehaviour
{
    LLM llm ;
    LLMCharacter llmCharacter ;

    async void Start ( )
    {
        // disable gameObject so that theAwake is not called immediately
        gameObject . SetActive ( false ) ;

        // Add an LLM object
        llm = gameObject . AddComponent < LLM > ( ) ;
        // set the model using the filename of the model.
        // The model needs to be added to the LLM model manager (see LLM model management) by loading or downloading it.
        // Otherwise the model file can be copied directly inside the StreamingAssets folder.
        llm . SetModel ( " Phi-3-mini-4k-instruct-q4.gguf " ) ;
        // optional: you can also set loras in a similar fashion and set their weights (if needed)
        llm . AddLora ( " my-lora.gguf " ) ;
        llm . SetLoraWeight ( 0.5f ) ;
        // optional: you can set the chat template of the model if it is not correctly identified
        // You can find a list of chat templates in the ChatTemplate.templates.Keys
        llm . SetTemplate ( " phi-3 " ) ;
        // optional: set number of threads
        llm . numThreads = - 1 ;
        // optional: enable GPU by setting the number of model layers to offload to it
        llm . numGPULayers = 10 ;

        // Add an LLMCharacter object
        llmCharacter = gameObject . AddComponent < LLMCharacter > ( ) ;
        // set the LLM object that handles the model
        llmCharacter . llm = llm ;
        // set the character prompt
        llmCharacter . SetPrompt ( " A chat between a curious human and an artificial intelligence assistant. " ) ;
        // set the AI and player name
        llmCharacter . AIName = " AI " ;
        llmCharacter . playerName = " Human " ;
        // optional: set streaming to false to get the complete result in one go
        // llmCharacter.stream = true;
        // optional: set a save path
        // llmCharacter.save = "AICharacter1";
        // optional: enable the save cache to avoid recomputation when loading a save file (requires ~100 MB)
        // llmCharacter.saveCache = true;
        // optional: set a grammar
        // await llmCharacter.SetGrammar("json.gbnf");

        // re-enable gameObject
        gameObject . SetActive ( true ) ;
    }
}

Use um servidor remoto

Você pode usar um servidor remoto para realizar o processamento e implementar caracteres que interajam com ele.

Crie o servidor
Para criar o servidor:

Crie um projeto com um GameObject usando o script LLM conforme descrito acima
Habilite a opção Remote do LLM e opcionalmente configure os parâmetros do servidor: porta, chave API, certificado SSL, chave SSL
Construa e execute para iniciar o servidor

Alternativamente, você pode usar um binário de servidor para facilitar a implantação:

Execute a cena acima no Editor e copie o comando das mensagens de depuração (começando com "Comando do servidor:")
Baixe os binários e DLLs do servidor e extraia-os na mesma pasta
Encontre a arquitetura de seu interesse na pasta acima, por exemplo, para Windows e CUDA, use windows-cuda-cu12.2.0 .
Você também pode verificar a arquitetura que funciona para o seu sistema nas mensagens de depuração (começando com "Usando arquitetura").
Da linha de comando, mude o diretório para a pasta de arquitetura selecionada e inicie o servidor executando o comando copiado acima.

Crie os personagens
Crie um segundo projeto com os personagens do jogo usando o script LLMCharacter conforme descrito acima. Habilite a opção Remote e configure o host com o endereço IP (começando com "http://") e porta do servidor.

Calcular embeddings usando um LLM

A função Embeddings pode ser usada para obter os emdeddings de uma frase:

    List < float > embeddings = await llmCharacter . Embeddings ( " hi, how are you? " ) ;

Uma documentação detalhada sobre o nível de função pode ser encontrada aqui:

Pesquisa semântica com sistema Retrieval-Augmented Generation (RAG)

LLM for Unity implementa uma funcionalidade de pesquisa de similaridade super-rápida com um sistema Retrieval-Augmented Generation (RAG).
É baseado na funcionalidade LLM e na pesquisa de vizinhos mais próximos (ANN) da biblioteca usearch.
A pesquisa semântica funciona da seguinte maneira.

Construindo os dados Você fornece entradas de texto (uma frase, parágrafo, documento) para adicionar aos dados.
Cada entrada é dividida em partes (opcional) e codificada em embeddings com um LLM.

Procurando Você pode então procurar uma entrada de texto de consulta.
A entrada é novamente codificada e as entradas de texto ou partes de dados mais semelhantes são recuperadas.

Para usar a pesquisa semântica:

crie um GameObject para o LLM conforme descrito acima. Baixe um dos modelos RAG fornecidos ou carregue o seu próprio (boas opções podem ser encontradas na tabela de classificação do MTEB).
crie um GameObject vazio. No GameObject Inspector, clique em Add Component e selecione o script RAG .
No menu suspenso Tipo de pesquisa do RAG, selecione seu método de pesquisa preferido. SimpleSearch é uma pesquisa simples de força bruta, enquanto DBSearch é um método rápido de RNA que deve ser preferido na maioria dos casos.
No menu suspenso Chunking Type do RAG você pode selecionar um método para dividir as entradas em pedaços. Isso é útil para ter um significado mais consistente em cada parte dos dados. São fornecidos métodos de divisão de acordo com tokens, palavras e frases.

Alternativamente, você pode criar o RAG a partir do código (onde llm é seu LLM):

  RAG rag = gameObject . AddComponent < RAG > ( ) ;
  rag . Init ( SearchMethods . DBSearch , ChunkingMethods . SentenceSplitter , llm ) ;

No seu script você pode usá-lo da seguinte maneira?:

 using LLMUnity ;

public class MyScript : MonoBehaviour
{
  RAG rag ;

  async void Game ( ) {
    .. .
    string [ ] inputs = new string [ ] {
      " Hi! I'm a search system. " ,
      " the weather is nice. I like it. " ,
      " I'm a RAG system "
    } ;
    // add the inputs to the RAG
    foreach ( string input in inputs ) await rag . Add ( input ) ;
    // get the 2 most similar inputs and their distance (dissimilarity) to the search query
    ( string [ ] results , float [ ] distances ) = await rag . Search ( " hello! " , 2 ) ;
    // to get the most similar text parts (chnuks) you can enable the returnChunks option
    rag . ReturnChunks ( true ) ;
    ( results , distances ) = await rag . Search ( " hello! " , 2 ) ;
    .. .
  }
}

Você pode salvar o estado RAG (armazenado na pasta Assets/StreamingAssets ):

rag . Save ( " rag.zip " ) ;

e carregue-o do disco:

 await rag . Load ( " rag.zip " ) ;

Você pode usar o RAG para alimentar dados relevantes ao LLM com base em uma mensagem do usuário:

  string message = " How is the weather? " ;
  ( string [ ] similarPhrases , float [ ] distances ) = await rag . Search ( message , 3 ) ;

  string prompt = " Answer the user query based on the provided data. n n " ;
  prompt += $" User query: { message } n n " ;
  prompt += $" Data: n " ;
  foreach ( string similarPhrase in similarPhrases ) prompt += $" n - { similarPhrase } " ;

  _ = llmCharacter . Chat ( prompt , HandleReply , ReplyCompleted ) ;

A amostra RAG inclui um exemplo de implementação de RAG, bem como um exemplo de integração RAG-LLM.

Isso é tudo ✨!

Gerenciamento de modelo LLM

O LLM for Unity usa um gerenciador de modelos que permite carregar ou baixar LLMs e enviá-los diretamente no seu jogo.
O gerenciador de modelo pode ser encontrado como parte do LLM GameObject:

Você pode baixar modelos com o botão Download model .
LLM for Unity inclui diferentes modelos de última geração integrados para diferentes tamanhos de modelo, quantizados com o método Q4_K_M.
Modelos alternativos podem ser baixados do HuggingFace no formato .gguf.
Você pode baixar um modelo localmente e carregá-lo com o botão Load model ou copiar o URL no campo Download model > Custom URL para baixá-lo diretamente.
Se um modelo HuggingFace não fornecer um arquivo gguf, ele poderá ser convertido para gguf com este conversor online.

O modelo de chat usado para construir os prompts é determinado automaticamente a partir do modelo (se existir uma entrada relevante) ou do nome do modelo.
Se identificado incorretamente, você pode selecionar outro modelo no menu suspenso de modelos de chat.

Os modelos adicionados no gerenciador de modelos são copiados para o jogo durante o processo de construção.
Você pode omitir a construção de um modelo desmarcando a caixa de seleção "Construir".
Para remover o modelo (mas não excluí-lo do disco), você pode clicar no botão bin.
O caminho e URL (se baixado) de cada modelo adicionado é exibido na visualização expandida do acesso do gerenciador de modelos com o botão >> :

Você pode criar compilações mais leves selecionando a opção Download on Build .
Usando esta opção, os modelos serão baixados na primeira vez que o jogo for iniciado, em vez de copiados na compilação.
Se você carregou um modelo localmente você precisa definir sua URL através da visualização expandida, caso contrário ele será copiado no build.

❕ Antes de usar qualquer modelo verifique sua licença ❕

Exemplos

A pasta Samples~ contém vários exemplos de interação?:

SimpleInteraction: demonstra uma interação simples com um personagem de IA
MultipleCharacters: demonstra uma interação simples usando vários personagens de IA
RAG: amostra RAG. Inclui um exemplo usando o RAG para alimentar informações para um LLM
ChatBot: Demonstra a interação entre um jogador e uma IA com uma UI semelhante a um aplicativo de mensagens (veja a imagem abaixo)
KnowledgeBaseGame: Jogo de detetive simples usando uma base de conhecimento para fornecer informações ao LLM baseado em google/mysteryofthreebots
AndroidDemo: exemplo de aplicativo Android com tela inicial com progresso de download do modelo

Para instalar uma amostra:

Abra o Gerenciador de Pacotes: Window > Package Manager
Selecione o LLM for Unity . Na guia Samples , clique em Import ao lado da amostra que deseja instalar.

Os exemplos podem ser executados com a cena Scene.unity que eles contêm em sua pasta.
Na cena, selecione o GameObject LLM e clique no botão Download Model para baixar um modelo padrão ou Load model para carregar seu próprio modelo (consulte gerenciamento de modelo LLM).
Salve a cena, corra e aproveite!

Opções

Configurações de LLM

Show/Hide Advanced Options Alterne para mostrar/ocultar opções avançadas abaixo
Log Level selecione o nível de detalhamento das mensagens de log
Use extras selecione para instalar e permitir o uso de recursos extras (atenção flash e quants de QI)

Configurações de configuração

Seleção Remote para fornecer acesso remoto ao LLM
Porta Port para executar o servidor LLM (se Remote estiver definido)
Num Threads número de threads a serem usados (padrão: -1 = todos)
Num GPU Layers número de camadas do modelo a serem descarregadas para a GPU. Se definido como 0, a GPU não será usada. Use um número grande, ou seja,> 30 para utilizar a GPU tanto quanto possível. Observe que valores mais altos de tamanho de contexto usarão mais VRAM. Se a GPU do usuário não for suportada, o LLM retornará à CPU
Debug select para registrar a saída do modelo no Unity Editor
Opções avançadas
- Parallel Prompts número de prompts/slots que podem acontecer em paralelo (padrão: -1 = número de objetos LLMCharacter). Observe que o tamanho do contexto é dividido entre os slots.
  Se quiser reter o máximo de contexto para o LLM e não precisar de todos os caracteres presentes ao mesmo tempo, você poderá definir esse número e especificar o slot para cada objeto LLMCharacter.
por exemplo, definir Parallel Prompts como 1 e slot 0 para todos os objetos LLMCharacter usará o contexto completo, mas todo o prompt precisará ser computado (sem cache) sempre que um objeto LLMCharacter for usado para bate-papo.
- Dont Destroy On Load selecione para não destruir o LLM GameObject ao carregar uma nova cena

Configurações de segurança do servidor

API key Chave de API a ser usada para permitir acesso a solicitações de objetos LLMCharacter (se Remote estiver definido)
Opções avançadas
- Load SSL certificate permite carregar um certificado SSL para criptografia ponta a ponta de solicitações (se Remote estiver configurado). Requer chave SSL também.
- Load SSL key permite carregar uma chave SSL para criptografia ponta a ponta de solicitações (se Remote estiver definido). Requer certificado SSL também.
- SSL certificate path o certificado SSL usado para criptografia ponta a ponta de solicitações (se Remote estiver definido).
- SSL key path a chave SSL usada para criptografia ponta a ponta de solicitações (se Remote estiver definido).

? Configurações do modelo

Download model clique para baixar um dos modelos padrão
Load model clique para carregar seu próprio modelo no formato .gguf
Download on Start permite baixar os modelos LLM na primeira vez que o jogo é iniciado. Alternativamente, os modelos LLM serão copiados diretamente no build
Tamanho do Context Size Tamanho do contexto do prompt (0 = tamanho do contexto do modelo)
Este é o número de tokens que o modelo pode usar como entrada ao gerar respostas. Valores mais altos usam mais RAM ou VRAM (se estiver usando GPU).
Opções avançadas
- Download lora clique para baixar um modelo LoRA no formato .gguf
- Load lora clique para carregar um modelo LoRA no formato .gguf
- Batch Size tamanho do lote para processamento imediato (padrão: 512)
- Model o caminho do modelo que está sendo usado (em relação à pasta Assets/StreamingAssets)
- Chat Template o modelo de bate-papo usado para o LLM
- Lora o caminho dos LoRAs que estão sendo usados (relativo à pasta Assets/StreamingAssets)
- Lora Weights os pesos dos LoRAs usados
- Flash Attention clique para usar atenção flash no modelo (se Use extras estiver habilitado)

?️ Configurações de bate-papo

Opções avançadas
Base Prompt um prompt base comum para usar em todos os objetos LLMCharacter usando o LLM

Configurações de personagem LMC

Show/Hide Advanced Options Alterne para mostrar/ocultar opções avançadas abaixo
Log Level selecione o nível de detalhamento das mensagens de log
Use extras selecione para instalar e permitir o uso de recursos extras (atenção flash e quants de QI)

Configurações de configuração

Remote quer o LLM usado seja remoto ou local
LLM o LLM GameObject (se Remote não estiver definido)
Hort ip do servidor LLM (se Remote estiver configurado)
Porta Port do servidor LLM (se Remote estiver definido)
Num Retries número de novas tentativas de solicitação HTTP do servidor LLM (se Remote estiver definido)
API key Chave de API do servidor LLM (se Remote estiver definido)
Save salvar nome do arquivo ou caminho relativo
Se definido, o histórico de bate-papo e o estado do LLM (se o cache de salvamento estiver ativado) serão salvos automaticamente no arquivo especificado.
O histórico do chat é salvo com um sufixo json e o estado LLM com um sufixo de cache.
Ambos os arquivos são salvos na [pasta persistentDataPath do Unity](https://docs.unity3d.com/ScriptReference/Application-persistentDataPath.html).
Save Cache selecione para salvar o estado LLM junto com o histórico de bate-papo. O estado LLM é normalmente em torno de 100 MB+.
Debug Prompt selecione para registrar os prompts construídos no Unity Editor

?️ Configurações de bate-papo

Player Name o nome do jogador
AI Name o nome da IA
Descrição Prompt da função de IA

? Configurações do modelo

Selecione Stream para receber a resposta do modelo conforme ela é produzida (recomendado!).
Se não for selecionado, a resposta completa do modelo será recebida de uma só vez
Num Predict número máximo de tokens a serem previstos (padrão: 256, -1 = infinito, -2 = até o contexto ser preenchido)
Esta é a quantidade máxima de tokens que o modelo irá prever ao máximo. Quando N tokens forem alcançados, o modelo irá parar de gerar. Isso significa que palavras/frases podem não ser concluídas se o valor for muito baixo.
Opções avançadas
- Load grammar clique para carregar uma gramática no formato .gbnf
- Grammar o caminho da gramática que está sendo usada (em relação à pasta Assets/StreamingAssets)
- Cache Prompt salva o prompt em andamento do chat (padrão: true)
  Salva o prompt enquanto ele está sendo criado pelo chat para evitar o reprocessamento do prompt inteiro todas as vezes
- Slot slot do servidor a ser usado para computação. O valor pode ser definido de 0 a Parallel Prompts -1 (padrão: -1 = novo slot para cada caractere)
- Seed sementes para reprodutibilidade. Para resultados aleatórios sempre use -1
- Temperature Temperatura LLM, valores mais baixos fornecem respostas mais determinísticas (padrão: 0,2)
  A configuração de temperatura ajusta o quão aleatórias são as respostas geradas. Aumentá-lo torna as escolhas geradas mais variadas e imprevisíveis. Recusá-lo torna as respostas geradas mais previsíveis e focadas nas opções mais prováveis.
- Amostragem Top K top-k (padrão: 40, 0 = desativado)
  O valor k superior controla os k tokens mais prováveis em cada etapa de geração. Esse valor pode ajudar a ajustar a saída e fazer com que ela siga padrões ou restrições específicas.
- Amostragem Top P top-p (padrão: 0,9, 1,0 = desativado)
  O valor p superior controla a probabilidade cumulativa dos tokens gerados. O modelo irá gerar tokens até que este limite (p) seja atingido. Ao reduzir este valor, você pode reduzir a produção e incentivar/desencorajar produções mais diversas.
- Probabilidade mínima Min P para um token ser usado (padrão: 0,05)
  A probabilidade é definida em relação à probabilidade do token mais provável.
- Repeat Penalty controla a repetição de sequências de token no texto gerado (padrão: 1.1)
  A penalidade é aplicada a tokens repetidos.
- Presence Penalty Penalidade de presença de token repetida (padrão: 0,0, 0,0 = desativado)
  Valores positivos penalizam novos tokens com base no fato de eles terem aparecido no texto até o momento, aumentando a probabilidade do modelo falar sobre novos tópicos.
- Frequency Penalty Penalidade de frequência de token repetida (padrão: 0,0, 0,0 = desativado)
  Valores positivos penalizam novos tokens com base na frequência existente no texto até o momento, diminuindo a probabilidade do modelo repetir a mesma linha literalmente.
- Tfs_z : habilita amostragem livre de cauda com parâmetro z (padrão: 1,0, 1,0 = desabilitado).
- Typical P : habilita amostragem típica local com parâmetro p (padrão: 1,0, 1,0 = desabilitado).
- Repeat Last N : últimos N tokens a serem considerados para penalizar a repetição (padrão: 64, 0 = desabilitado, -1 = tamanho ctx).
- Penalize Nl : penaliza tokens de nova linha ao aplicar a penalidade de repetição (padrão: verdadeiro).
- Penalty Prompt : prompt para fins de avaliação de penalidade. Pode ser null , uma string ou uma matriz de números representando tokens (padrão: null = use original prompt ).
- Mirostat : habilita a amostragem do Mirostat, controlando a perplexidade durante a geração do texto (padrão: 0, 0 = desabilitado, 1 = Mirostat, 2 = Mirostat 2.0).
- Mirostat Tau : defina a entropia alvo do Mirostat, parâmetro tau (padrão: 5.0).
- Mirostat Eta : define a taxa de aprendizagem do Mirostat, parâmetro eta (padrão: 0,1).
- N Probs : se for maior que 0, a resposta também contém as probabilidades dos N principais tokens para cada token gerado (padrão: 0)
- Ignore Eos : permite ignorar tokens de fim de fluxo e continuar gerando (padrão: falso).

Licença

A licença do LLM para Unity é MIT (LICENSE.md) e usa software de terceiros com licenças MIT e Apache. Alguns modelos incluídos no ativo definem seus próprios termos de licença. Revise-os antes de usar cada modelo. Licenças de terceiros podem ser encontradas em (Third Party Notices.md).

Expandir

Informações adicionais