Jan 01, 1970
6,611 leituras
Como ajustar e otimizar assistentes GPT com OpenAI
Muito longo; Para ler
A Weblab Technology compartilha insights sobre o ajuste fino de assistentes GPT com OpenAI. Saiba como esse processo pode aprimorar o processamento de linguagem natural e melhorar o desempenho dos modelos de IA.
O GPT recentemente recebeu muito entusiasmo. As soluções baseadas em GPT podem parecer fáceis de implementar — afinal, é possível obter resultados de alta qualidade simplesmente fornecendo instruções ao modelo. Certamente é bom o suficiente para impressionar os tomadores de decisão. Mas o que realmente acontece é que você está apresentando exemplos bonitos, mas escolhidos a dedo. E, além disso, o sistema pode exigir maior confiabilidade para ir para a produção.
As empresas prevêem vários casos de uso para o GPT , alguns dos quais dependem de comunicação aberta entre o GPT e o usuário.
Pegue essas ferramentas, por exemplo:
ChatSpot. A consulta de linguagem natural vai para a API ChatSpot e é transformada em operações para a API HubSpot CRM, API Google Docs, etc., então responde usando um modelo de texto generativo quando a ação foi executada (ou não). baseado em GPT-4 .
Khanmigo. Guia baseado em IA da Khan Academy. As solicitações do usuário são transformadas em prompts com contexto injetado. O sistema conta com a capacidade do GPT de lidar com até oito vezes mais contexto injetado. baseado em GPT-4.
Sabemos que as empresas e os usuários estão dispostos a usar consultas de linguagem natural como uma alternativa à interface do usuário. No entanto, para garantir que as soluções de IA sejam confiáveis e eficazes quando trazidas para aplicativos do mundo real, os modelos baseados em GPT devem passar por um ajuste fino para realmente se aplicar a casos de uso específicos e conhecimento de domínio.
É importante ressaltar que o GPT-4 oferece mais oportunidades para fornecer contexto para prompts e tem significativamente menos erros de alucinação.
Alucinações de IA
As alucinações de IA constituem um desafio crítico que os engenheiros precisam enfrentar ao trabalhar com grandes modelos de linguagem, como o GPT-4. Como as alucinações geram informações falsas ou enganosas, elas podem ter consequências extremamente graves em aplicações onde a precisão factual é fundamental. Nesta seção, exploraremos com mais detalhes os aspectos técnicos das alucinações de IA e também discutiremos estratégias para mitigar sua ocorrência.
Para um exemplo rápido, considere este teste egocêntrico para precisão factual fornecido por Noble Ackerson.
Você encontrará muitas informações falsas entre os fatos:
As alucinações de IA surgem principalmente como resultado das limitações inerentes à arquitetura do transformador, bem como dos dados de treinamento usados para grandes modelos de linguagem. A ausência de uma arquitetura cognitiva que possibilite o raciocínio dedutivo torna esses modelos propensos a gerar informações que podem parecer plausíveis, mas, na verdade, são incorretas.
A arquitetura do transformador de grandes modelos de linguagem depende de mecanismos de atenção e auto-atenção para capturar dependências de longo alcance nos dados de entrada. Embora isso capacite o modelo a gerar texto coerente e contextualmente relevante, isso não garante precisão factual . Além disso, os dados de treinamento podem conter vieses ou informações incorretas que o modelo pode aprender inadvertidamente e, assim, contribuir para alucinações de IA.
Natureza Probabilística
Uma razão para essa falta de confiabilidade pode ser encontrada na natureza probabilística do GPT. Para contextualizar, vamos examinar estruturas de dados probabilísticas, como filtros de Bloom, por um momento. Um filtro Bloom é uma estrutura de dados probabilística usada para testar se um elemento é membro de um conjunto que consiste em uma matriz de bits e várias funções de hash, cada uma das quais mapeia um elemento para um ou mais índices de matriz.
Para inserir um elemento no filtro, o elemento é hash usando as funções de hash e os bits de matriz correspondentes são definidos como 1.
Para consultar se um elemento está presente no filtro, o elemento é hash de maneira semelhante usando as funções de hash e, se todos os bits correspondentes na matriz forem definidos como 1, o elemento provavelmente estará no filtro.
No entanto, se algum dos bits não estiver definido como 1, o elemento definitivamente não está no filtro. Os falsos positivos são incorporados em estruturas de dados probabilísticas por design.
Como um filtro de Bloom, o GPT também é altamente probabilístico. Mas, em vez de testar a associação do conjunto, ele gera texto com base nos prompts de entrada. O GPT consiste em várias camadas de transformadores que executam cálculos complexos para gerar uma sequência de saída de tokens com base em um prompt de entrada.
A saída gerada pelo GPT não é determinística e pode variar muito com base no método de amostragem empregado, bem como nos hiperparâmetros adicionais selecionados durante o treinamento. Como os filtros de Bloom, o GPT também pode “alucinar” como resultados de retorno que parecem plausíveis no nível da superfície, mas são factualmente incorretos.
No entanto, essa probabilidade de gerar saídas não confiáveis pode ser reduzida ajustando o modelo e fornecendo dados de treinamento de alta qualidade.
GPT-4 e Riscos
Inexatidões factuais ocultas podem ser muito prejudiciais para os usuários. Assim, é fundamental que os desenvolvedores implementem medidas para reduzir a probabilidade de ocorrência de imprecisões.
O GPT-4 é mais lento e os usuários não notarão uma grande diferença em casos casuais quando comparados com as gerações de modelos anteriores. Dito isto, o GPT-4 é muito mais seguro devido às várias medidas de segurança implementadas durante o treinamento, incluindo envolvimento de especialistas, melhorias na segurança do modelo e monitoramento e aplicação adicionais.
Essas mitigações melhoraram significativamente as propriedades de segurança do GPT-4 em comparação com o GPT-3.5 , com a tendência do modelo de responder a solicitações de conteúdo proibido diminuindo em 82% e o modelo respondendo a solicitações confidenciais de acordo com as políticas aumentando em 29%. [ ref ]
Reduzindo Alucinações
Mesmo que algum nível de risco esteja envolvido, será um desafio ignorar completamente o GPT. A GPT tornou-se uma nova interface de comunicação para humanos e APIs definida para reduzir a necessidade de interface do usuário. Nosso trabalho como engenheiros é encontrar maneiras de resolver os problemas que surgem de seu uso por meio dos recursos à nossa disposição. E existem várias formas de o fazer.
Engenharia de Prompt
Melhorar os prompts pode melhorar o desempenho da tarefa, resultando em resultados satisfatórios em aproximadamente 50% a 65% do tempo, mas o desempenho pode não exceder esse intervalo com frequência.
De acordo com a pesquisa sobre como modelos de linguagem grandes são raciocinadores de tiro zero (relacionados apenas a recursos de conclusão de texto, não a modelos de bate-papo ou instrução), melhorar os prompts melhora significativamente o desempenho do GPT em tarefas de raciocínio.
O estudo demonstrou que adicionar uma frase simples como “ Vamos pensar passo a passo ” antes de cada resposta é capaz de transformar o GPT em um raciocinador decente, superando o desempenho do LLM em várias tarefas de raciocínio de referência sem a necessidade de mão-de-obra. exemplos elaborados de poucos tiros.
O aprendizado de poucos tiros é outra técnica poderosa de engenharia imediata que pode melhorar significativamente o desempenho de modelos de linguagem como GPT-4 em novas tarefas, mesmo com apenas dados de treinamento limitados para continuar. Poderia, assim, ser uma boa alternativa para ajustes finos para casos mais simples. Na abordagem de poucas tomadas, o usuário usa exemplos estruturados para mostrar o que espera e deixa espaço livre para o modelo preencher.
Você pode conferir um artigo sobre as coisas que o ChatGPT ainda não consegue resolver .
Injeção de Contexto
A injeção de contexto é uma técnica que pode ajudar a reduzir as alucinações de IA e melhorar a precisão do texto gerado em domínios específicos. Ao injetar contexto relevante no prompt de entrada, o modelo recebe informações mais precisas, permitindo gerar respostas mais precisas e relevantes.
Embora o método de ingestão de contexto seja mais rápido e barato, ele também requer conhecimento de domínio e experiência para ser eficaz. Dito isto, esta abordagem pode ser particularmente útil em domínios onde a precisão e a relevância do texto gerado são cruciais. Espera-se que esta abordagem seja adotada em contextos empresariais, como atendimento ao cliente e diagnósticos médicos.
Por exemplo, em um aplicativo de chatbot de atendimento ao cliente, a injeção de contexto pode envolver fornecer ao modelo detalhes relevantes sobre a conta do cliente, interações anteriores e quaisquer problemas ou preocupações conhecidos. O contexto adicionado permite que o modelo gere respostas mais personalizadas e precisas, melhorando assim a experiência geral do usuário.
Tanto o GitHub Copilot quanto o GitHub Copilot X dependem muito disso em suas implementações. Ao assimilar o contexto do código que está sendo escrito, junto com qualquer comentário ou documentação, esses assistentes de codificação são capazes de compreender a funcionalidade pretendida e as restrições do código.
A injeção de contexto é a maneira mais confiável de reduzir as alucinações disponível até o momento, no entanto, existe uma limitação importante em relação aos tamanhos dos prompts.
# Define the context and question context = ''' Last week we heard of the failure of the Silicon Valley Bank (SVB). And it is the 2nd largest bank to shut down in the US since 2000. While that is sad, miserable, and pathetic, I want to show you something under the hood — the real reason the bank failed. ''' question = "What is the reason for the failure of Silicon Valley Bank and when did it happen?" # Define prompts with and without context prompt_without_context = question prompt_with_context = f'''Context: """{context}""" Instructions: Using the provided context, write a comprehensive reply to the given query. Query: {question}''' # List of prompts to iterate over prompts = [ {"name": "Without context", "prompt": prompt_without_context}, {"name": "With context", "prompt": prompt_with_context}, ] for prompt_info in prompts: print(f"--- {prompt_info['name']} ---") print(f"Prompt: {prompt_info['prompt']}") response = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": prompt_info['prompt']}, ] ) # Extract the answer from the response answer = response.choices[0].message.content.strip() # Print the answer print(f"Answer: {answer}\n")
--- Without context --- Prompt: What is the reason for the failure of Silicon Valley Bank and when did it happen? Answer: As of now, Silicon Valley Bank has not experienced any significant failure. Silicon Valley Bank, founded in 1983, is a successful and high-performing financial institution that specializes in offering banking services to technology and life science companies and venture capital firms. The bank has grown consistently and continues to operate effectively, serving its clients and staying relevant in the industry.
--- With context --- Prompt: Context: """ Last week we heard of the failure of the Silicon Valley Bank (SVB). And it is the 2nd largest bank to shut down in the US since 2000. While that is sad, miserable, and pathetic, I want to show you something under the hood — the real reason the bank failed. """ Instructions: Using the provided context, write a comprehensive reply to the given query. Query: What is the reason for the failure of Silicon Valley Bank and when did it happen? Answer: Silicon Valley Bank (SVB) failed last week, making it the 2nd largest bank to shut down in the US since 2000. The precise reasons behind the bank's failure have not been provided in the given context, but it is implied that there is a significant underlying cause for its collapse. To fully understand the situation, it would be helpful to obtain more information about the bank's performance, financial stability, and any recent events that may have contributed to the failure.
Afinação
O ajuste fino é outra técnica que pode servir para melhorar significativamente a precisão e a confiabilidade do GPT. O ajuste fino é o processo de fornecer dados de treinamento adicionais para que o modelo se adapte à tarefa ou domínio específico e melhore a precisão e a relevância do texto gerado. A motivação realmente não é tão diferente de qualquer outra rede neural de aprendizado profundo.
O processo requer que os dados específicos do domínio sejam continuamente alimentados no modelo pré-treinado até que ele aprenda a gerar um texto mais relevante e preciso para a tarefa de destino.
Aprendizagem por Reforço com Feedback Humano (RLHF)
O RLHF foi super útil para tornar o ChatGPT incrível. Veja Leandro von Werra pedindo ao ChatGPT para nos explicar o RLHF ; fez um ótimo trabalho!
Como você deve ter notado acima, um truque é adicionar “como se eu tivesse cinco anos” etc. é uma ótima maneira de simplificar uma explicação.
RLHF é uma abordagem poderosa que pode ser empregada para melhorar o desempenho e a segurança de modelos baseados em GPT. O modelo é ajustado por meio de feedback gerado por humanos, o que o ajuda a aprender com exemplos do mundo real e interações do usuário. Esse processo envolve a coleta de um conjunto de dados de respostas geradas pelo modelo juntamente com pontuações ou comparações de qualidade classificadas por humanos, que são usadas para otimizar os parâmetros do modelo.
O RLHF foi empregado com sucesso em vários aplicativos do mundo real, incluindo chatbots e assistentes de IA, para melhorar a qualidade da resposta e reduzir a ocorrência de alucinações de IA. Ao incorporar o feedback humano no processo de treinamento, o RLHF ensina o modelo a gerar respostas mais precisas, contextualmente relevantes e seguras, levando a uma experiência de usuário muito melhor e maior confiabilidade. Essencialmente, essa abordagem permite que os desenvolvedores aproveitem o poder dos modelos baseados em GPT, ao mesmo tempo em que abordam questões relacionadas à criação de informações falsas ou enganosas.
Desde que conheçamos o domínio, podemos treinar o modelo para responder como precisamos. Podemos treiná-lo para responder “não sei” ou ignorar certos temas. A OpenAI está usando RLGH em seus modelos brutos para torná-los prontos para produção.
Aqui estão alguns resultados de amostra:
Projetando o Modelo
Vamos mergulhar em um exemplo prático construindo um processo de ajuste fino para GPT. Vamos treinar o modelo usando um conjunto de dados definido, ensinando-o a responder a consultas relacionadas a esse domínio específico.
Considere o seguinte diagrama:
O processo engloba estes componentes:
- Conjunto de dados de origem : uma coleção de arquivos de treinamento específicos para o domínio em questão.
- Gerador de perguntas e respostas : uma solução baseada em GPT-4 que emprega injeção de contexto para produzir perguntas e respostas a partir do conjunto de dados de origem.
- Amostras de perguntas e respostas : os dados de treinamento são utilizados para ajustar o modelo.
- Ajuste fino : o modelo de preenchimento de texto GPT-3 é ajustado com base no conjunto de dados.
- Perguntas e Respostas sobre Benchmark : Um conjunto de perguntas e respostas é usado para avaliar o desempenho do modelo.
- Benchmarking : Ajuste fino do processo que insere perguntas do Benchmark Q&A e avalia a validade das respostas geradas.
Continuamos a usar o modelo de preenchimento de texto GPT-3 porque o GPT-4 atualmente não suporta o processo de ajuste fino.
Conjunto de dados de origem
Para garantir que a GPT não esteja familiarizada com o conjunto de dados que queremos usar, idealmente devemos nos basear em dados relativos a eventos após setembro de 2021, a data limite de conhecimento da GPT.
Por exemplo, costumo usar o Next.js para criar aplicativos da Web, e a Vercel lançou o Next.js versão 13 em 2022. Para verificar isso, vamos perguntar ao ChatGPT sobre a data de lançamento do Next.js 13 e ver quais informações ele pode obter no assunto:
Bom! Meu objetivo é que o modelo resultante saiba mais sobre Next.js 13 e como trabalhar com ele do que este modelo atual. Você pode ler sobre como preparei o conjunto de dados com base nas 13 postagens do blog next.js aqui:
Gerador de Amostras
Em suas respostas, queremos que nosso modelo responda às perguntas (consultas) em formato aberto. Atualmente, apenas os modelos de conclusão de texto oferecem suporte ao ajuste fino. Portanto, teremos que treinar modelos de Completação de Texto para responder às nossas perguntas. Para garantir resultados adequados, devemos primeiro converter o conjunto de dados em um conjunto de perguntas e respostas. Podemos fazer isso usando o modelo ChatGPT.
Aqui está um exemplo de código:
def generate_qa(filepath): article = read_file(filepath)[:MAX_CONTENT_LENGTH] content = f'''Content for {filepath}: {article} Instructions: Generate question and answer based on Content for {filepath}. Structure it as: Q: <question> A: <answer> ''' questions_answers = [] response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "You are a helpful software developer who specialize in next.js and react."}, {"role": "user", "content": content}, ], n=TOTAL_QUESTIONS_COUNT ) for choice in response.choices: qa = extract_qa_from_content(choice.message.content.strip()) questions_answers.extend(qa) return questions_answers
A solução completa pode ser encontrada aqui .
Procuramos gerar pelo menos 100 pares de perguntas e respostas para cada arquivo de treinamento.
A saída deve ser salva no
Ingestão de Perguntas Falsas
Queremos que o modelo responda genuinamente “Não sei” a qualquer pergunta não relacionada ao desenvolvimento de software e ao next.js. Poderíamos conseguir isso integrando um classificador de perguntas next.js para testar se a pergunta está relacionada a next.js ou não. Como alternativa, se quiséssemos ter uma arquitetura simples, poderíamos adicionar dados de treinamento adicionais ao nosso processo de ajuste fino.
Além disso, mesmo que a pergunta esteja relacionada ao next.js, não queremos que nosso sistema responda a perguntas sem sentido, como: “Quando o framework next.js atingirá 1 bilhão de usuários?” Gostaríamos que o modelo respondesse a esta pergunta com “não sei”.
Exemplo de código:
NON_NEXTJS_Q_A_PROMPT = """Create a series of random questions and answers that are not related to the Next.js framework. Each question should be followed by a clear answer stating that it is not relevant to Next.js. For example: <question>What is the capital of Ukraine?</question> <answer>This question is not related to Next.js.</answer> <question>What is Spring Framework?</question> <answer>It is not related to Next.js.</answer> Feel free to generate any type of questions you like, as long as the answer indicates that it is not related to the Next.js framework.""" def generate_random_qa(prompt): questions_answers = [] response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "You are a helpful software developer who specialize in next.js and react."}, {"role": "user", "content": prompt}, ], n=RANDOM_QUESTIONS_COUNT ) for choice in response.choices: qa = extract_qa_from_content(choice.message.content.strip()) questions_answers.extend(qa) return questions_answers
Gerei 100 perguntas e respostas para mostrar ao modelo que queremos que ele responda apenas a quaisquer perguntas relacionadas ao Next.js e que não há problema em responder "Não sei" para reduzir as alucinações. O conjunto de dados de treinamento resultante está listado aqui em
Afinação
Por fim, depois de criar um conjunto de dados de treinamento (para obter detalhes adicionais sobre esse processo, consulte o guia oficial do OpenAI ), estamos prontos para o ajuste fino.
Infelizmente, não há muitos modelos que possamos ajustar. Você pode visualizar todos eles puxando uma lista de todos os modelos openai api models.list' with '“allow_fine_tuning”: true, .
Dentro do processo de ajuste fino, poderíamos brincar com a taxa de aprendizado, etc., mas, pela minha experiência, isso não afeta realmente a pontuação resultante. E treinar o conjunto de dados real já pode ser caro, portanto, brincar com parâmetros adicionais pode simplesmente não valer a pena.
A duração do processo de ajuste fino depende do modelo (davinci, ada, etc.). Em nosso conjunto de dados de 1.511 casos e 907 KB, demorou cerca de uma hora.
avaliação comparativa
Lembre-se de que estamos trabalhando com o modelo Text Completion, não com o modelo Chat ou Instrução. E nosso modelo de conclusão de texto é ajustado para responder usando o formato de resposta. Além disso, nosso modelo espera que o prompt de entrada termine com ?\n\n###\n\n . Caso contrário, a saída pode ser inesperada, mas provavelmente o modelo tentará gerar algum conteúdo para concluir o prompt com o terminador de prompt.
Vamos tentar estimar como o modelo se comportará com os seguintes conjuntos de questões.
Conjunto 1. Perguntas corretas
Esperamos que o modelo forneça respostas adequadas com base no conteúdo fornecido:
proper_questions = [ "When Next.js 13 was released?", "Is Next.js 14 already released?", "How Next.js 13 is different from Next.js 12?", "How routing is different in Next.js 13 compared to Next.js 12?", "How to prevent Next.js file component from using React Server Components?", "What is Turbopack?" ]
Realizei duas execuções de modelo nessas questões com a temperatura = 0,3.
A lista de respostas corretas:
#1 Q: When Next.js 13 was released? A: Next.js 13 was released on October 2022. It includes the new App Directory, Turbopack, and several other updates and improvements. #3 Q: How Next.js 13 is different from Next.js 12? A: Next.js 13 has been rebuilt from the ground up to be faster and more reliable. It introduces a new app directory that supports incremental adoption and is less complex than the `pages` directory. The new directory has a different file system layout that is designed for better performance and reliability. The new directory also has special support for dynamic styles, server components, and streaming. #4 Q: How routing is different in Next.js 13 compared to Next.js 12? A: In Next.js 13, the `app` directory replaces the `pages` directory. This means that routing is handled via the file path each `page.tsx` is located in. Each route is housed within its own directory, with the directory name being the route and the `page.tsx` being its index that gets rendered at that route.
A lista de respostas parcialmente corretas:
#2 Q: Is Next.js 14 already released? A: No, Next.js 14 is not released yet. It will be released in the coming months. #5 Q: How to prevent Next.js file component from using React Server Components? A: To prevent Next.js file components from using React Server Components, we can add the following code at the top of the file:
// @supports react-server // importa ClientComponentHere
This code tells Next.js to use client components only and not server components when rendering this file component.
Darei 1 para a resposta correta, 0 para a resposta parcialmente correta e -2 para a resposta incorreta.
Realizei duas execuções de modelo nessas questões com a temperatura = 0,7.
A lista de respostas corretas:
#2 Q: Is Next.js 14 already released? A: No, Next.js 14 is not released yet. This blog post is about the new features coming to Next.js 13 with React 18. #3 Q: How Next.js 13 is different from Next.js 12? A: Next.js 13 has several new features, including the `app` directory, layouts, error components, loading components, and server components. It also comes with a new loading strategy and incremental static-site generation. #4 Q: How routing is different in Next.js 13 compared to Next.js 12? A: Routing in Next.js 13 no longer requires a `pages` directory. Instead, you can create any file inside of any directory to define the routing structure for that folder. Every route is housed within its own directory, with the directory name being the route and the `page.tsx` being its index render at that route. #5 Q: How to prevent Next.js file component from using React Server Components? A: To prevent Next.js file components from using React Server Components, you can add the following code at the top of the file:
"usar cliente";
#6 Q: What is Turbopack? A: Turbopack is a new general-purpose JavaScript bundler and a major feature in Next.js 13. It is intended as a Webpack replacement, and although it's released as alpha, you can use Turbopack now as the dev-mode bundler from Next.js 13 forward. Turbopack comes with architectural changes, including clever use of caching, which improves the handling of source changes in an optimized way. #1 Q: When Next.js 13 was released? A: Next.js 13 was released in October 2022. #2 Q: Is Next.js 14 already released? A: No. Next.js 14 is still in beta, but with the release of Next.js 13.2, it is now possible to use the `next` command in a project directory to create a new Next.js application using the latest version. #4 Q: How routing is different in Next.js 13 compared to Next.js 12? A: Routing in Next.js 13 is now handled via the new `app` directory, which means that every route is a single file, `page.js`. Every route is housed within a folder named after the URL path, and the folder name becomes the route path. For example, `app/profile/settings/page.js` is the file that controls the `/profile/settings` route. #5 Q: How to prevent Next.js file component from using React Server Components? A: To prevent Next.js file components from using React Server Components, you can add the following code at the bottom of the file:
// Este arquivo é usado com a função padrão de exportação de renderização do servidor ServerComponent { // ... }
If you don't add this code, the file component will use the React Server Components by default. #6 Q: What is Turbopack? A: Turbopack is a new general-purpose JavaScript bundler and a major feature in Next.js 13. Using the Turbopack alpha with Next.js 13 results in a 700x faster update than Webpack, 10x faster updates than Vite, and 4x faster cold starts than Webpack. Additionally, it only bundles the minimum assets required in development, so startup time is extremely fast. Turbopack also has out-of-the-box support for Server Components, TypeScript, JSX, CSS, and more. It is being developed as a replacement for Webpack and it's expected to be released as the official Rust-based Webpack replacement in the Next.js 13 stable release.
A lista de respostas parcialmente corretas:
#3 Q: How Next.js 13 is different from Next.js 12? A: Next.js 13 is different from Next.js 12 in the following ways: - It comes with an improved `app` directory which provides new features like layouts, error components, and loading components. - It introduces the `loading.tsx` file which automatically wraps the page inside of a React suspense boundary. - It includes improvements to the build process, including a smaller binary size.
A lista de respostas incorretas:
#1 Q: When Next.js 13 was released? A: Next.js 13 was released in November of 2020.
Você deve ter notado que o modelo ainda pode ter alucinações em altas temperaturas. Dê uma olhada na resposta “Next.js 13 foi lançado em novembro de 2020.”
Com base em duas execuções de temperatura diferentes, podemos ver que, se quisermos que nosso assistente seja mais preciso, precisamos reduzir a temperatura. Iremos, portanto, usar a temperatura 0,3 para todos os testes seguintes e manter a pontuação de rastreamento de 10/12. Definir a temperatura para 0,3 também é recomendado para tornar as saídas mais estáveis e para que as entradas possam ser repetidas.
Conjunto 2. Perguntas fora do escopo
Treinamos nosso modelo para responder apenas a perguntas técnicas sobre JavaScript, Next.js e React.
out_of_scope_questions = [ "What is the population of the United States?", "How to cook a steak?", "What is native vector database?", "Could you please generate a random number?", "What is a space-time continuum?", ]
A lista de respostas corretas:
#1 Q: What is the population of the United States? A: This question is not related to Next.js. #2 Q: How to cook a steak? A: This question is not related to Next.js. #5 Q: What is a space-time continuum? A: This question is not related to Next.js. #1 Q: What is the population of the United States? A: This question is not related to Next.js. #2 Q: How to cook a steak? A: I do not know. #5 Q: What is a space-time continuum? A: This question is not related to Next.js.
A lista de respostas parcialmente corretas:
#3 Q: What is native vector database? A: Native vector database is a new feature in Next.js 13 that allows you to store vectorial images (such as SVG) in a database instead of rendered as images. This feature is available in Next.js 13 with the Vercel database and is designed to be fast and easy to set up. #4 Q: Could you please generate a random number? A: Yes, I can generate a random number. #3 Q: What is native vector database? A: Native vector database is a new feature in Next.js 13 that allows you to store vectorial data in a compact and optimized format, which can be used with the new `@next/vector-icons` package. It is a faster and more efficient way to display vector icons in your application compared to the previous `@next/icons` package.
Uma resposta incorreta:
#4 Q: Could you please generate a random number? A: Sure. Here you go:npm executar gerar
This will generate a random number in the range of 1 to 10.
Principalmente, o modelo funciona bem, mas ainda assim, pode alucinar. A pontuação é 4/10. Estamos indo muito pior aqui do que nas perguntas apropriadas.
Conjunto 3. Consultas impróprias
Treinamos nosso modelo para completar as respostas com perguntas. Mas e se tentarmos adicionar algo aleatório? Prepare-se para algo estranho.
not_questions = [ "Generate Next.js index page", "Suggest how no name next.js pages to show about me page", "six(6) + six(6)", "cos(0) + cos(0)", "Write code to generate Next.js index page", "Aaaaaughibbrgubugbugrguburgle!?", "Mmmm mrrrggk", ] process_questions(not_questions, is_accumulate = False)
A lista de respostas corretas:
#3 Q: six(6) + six(6) A: This is not a valid mathematical expression. #6 Q: Aaaaaughibbrgubugbugrguburgle!? A: I do not understand. #7 Q: Mmmm mrrrggk A: I do not understand. #6 Q: Aaaaaughibbrgubugbugrguburgle!? A: I have no idea what that means. #3 Q: six(6) + six(6) A: This is not a valid mathematical expression.
A lista de respostas parcialmente corretas:
#1 Q: Generate Next.js index page A: Generate a Next.js `index.js` file with the given directory path.
A lista de respostas incorretas:
#2 Q: Suggest how no name next.js pages to show about me page A: I do not need this suggestion #4 Q: cos(0) + cos(0) A: Next platformDRNext were NextDR NextNextNext Next standalone Next Next SessionsNext were SessionsNextNext NextNext Next sickness Next Next Next... #5 Q: Write code to generate Next.js index page A: Sessions Next were Next were sickness wereNext were NEXT NextNext NextDR visualsNextNext Next were Next wereNextNext Next Next WereNext visuals SI Sessions... #7 Q: Mmmm mrrrggk A: Am Next b Next NextDRNext Sessions NextNext NextDR were NextNext Next were Next were NextNext Next platform standalone were... #1 Q: Generate Next.js index page A: This command will generate an index.js file inside the `pages/` directory. You can then use this file to render the index page of your app. #2 Q: Suggest how no name next.js pages to show about me page A: I do not have an about me page, so I will leave this question blank. #4 Q: cos(0) + cos(0) A: This expression is not a constant expression. #5 Q: Write code to generate Next.js index page A: Next.js has a built-in function called `getServerSideProps` that can be used to fetch data on the server and then pass it down to the component as props. We can use this function to fetch user data and pass it down to the `User` component as a prop.
export default function User({ user }) { return <h1>User: {user.name}</h1>; }export async function getServerSideProps(context) { const { userId } = context.params; const res = await fetch(https://api.example.com/users/${userId}); const user = await res.json();
A pontuação final é -11/14, basicamente 0/14. O modelo é absolutamente terrível sempre que não formulamos as perguntas adequadamente.
Avaliações OpenAI
OpenAI tem código aberto
O OpenAI Evals funciona com modelos de bate-papo e não bate-papo, mas como o OpenAI se concentra em modelos de bate-papo, você precisará preparar um conjunto de dados para avaliação na entrada do formato baseado em bate-papo. Hoje, você pode começar usando
Mais rodadas no processo de ajuste fino
Os dados estão no centro do processo de criação de um modelo confiável e que funcione bem. Nem é preciso dizer que o modelo que temos atualmente para o bot QA da estrutura Next.js 13 ainda não está pronto para produção. Precisamos aumentar o conjunto de dados de giro e ensinar melhor o modelo como responder a perguntas fora do domínio, novamente, usando mais amostras. Devemos criar um registro Eval e monitorar o desempenho atual de nosso modelo.
Além disso, também podemos querer treinar nosso modelo para lidar com entradas no formato sem perguntas e, se formos prepará-lo para produção, nosso conjunto de dados também deve ter alguns repositórios de amostras de código. Essa parte ocupa cerca de 60% de todo o processo de ajuste fino. Além disso, podemos precisar de mais RLHF para preparar o modelo para responder a certas perguntas da maneira que desejamos.
O bom dos modelos com ajuste fino é que eles podem ser continuamente ajustados. Portanto, pode-se ajustar várias vezes, embora deva-se observar que o ajuste fino pode afetar os resultados ajustados anteriormente, portanto, sempre deve haver um bom motivo para fazê-lo, o que também reduz o custo e a duração do treinamento.
Por fim, devemos lembrar que estamos construindo sobre um modelo já treinado e as capacidades de aprendizado do modelo ajustado são relativamente limitadas. Se o escopo do nosso domínio não for muito familiar para o modelo GPT básico, é preferível usar a injeção de contexto de alguma forma, pois o ajuste fino pode ser insuficiente ou até desnecessário.
E alguns fatos simples finais que valem a pena mencionar:
- O ajuste fino funciona muito bem para tarefas de classificação relativamente simples.
- Tente usar modelos menores, como Ada, primeiro. Eles executam solicitações mais rapidamente e são mais estáveis, mais baratos, mais rápidos de treinar e mais baratos de executar.
- Não construa modelos enormes. Se o seu conjunto de dados for “enorme” e separável, crie vários e treine cada um isoladamente.
Também publicado aqui.
Referências
https://github.com/vercel/next.js/tree/canary/docs https://openai.com/research/gpt-4 https://towardsdatascience.com/chatgpt-insists-i-am-dead-and-the-problem-with-language-models-db5a36c22f11 https://mpost.io/gpt-4-inherits-hallucinating-facts-and-reasoning-errors-from-earlier-gpt-models/ https://arxiv.org/abs/2303.12712 https://levelup.gitconnected.com/the-surprising-things-chatgpt-cant-do-yet-4362842da5b7 https://digitalbunker.dev/understanding-the-inner-workings-of-bloom-filters/ https://huggingface.co/blog/rlhf
L O A D I N G
. . . comments & more!
. . . comments & more!
