Assez vite ! Le projet open source populaire équivalent à ChatGPT est là, internaute : j'ai peur de ne pas pouvoir l'exécuter

​Récemment, le programme de chatbot IA ChatGPT développé par OpenAI a balayé les principales communautés d'IA. L'enthousiasme de chacun pour lui n'a fait que croître et ils continuent d'exploiter son potentiel.

Certains chercheurs ne pouvaient pas rester assis et ont commencé à se demander comment développer un logiciel open source équivalent à ChatGPT. Pour ceux qui ne sont pas encore passés à l'action, voici cette fois un exemple de référence Le projet (PaLM + RLHF) que nous présenterons ci-dessous implémente une telle fonction.

Adresse du projet : https://github.com/lucidrains/PaLM-rlhf-pytorch

Ce projet consiste à implémenter le RLHF (Human Feedback Reinforcement Learning) au-dessus de l'architecture PaLM. Fondamentalement identique à ChatGPT, la différence est que PaLM est utilisé. PaLM est un grand modèle de langage avec 540 milliards de paramètres entraînés sur l'architecture générale d'IA de Google « Pathways ». RLHF est l'introduction par ChatGPT de « données artificiellement étiquetées + apprentissage par renforcement » (RLHF) sur la base de la série de modèles GPT 3.5 pour affiner continuellement le modèle de langage pré-entraîné, dans le but de permettre au grand modèle de langage (LLM) d'apprendre pour comprendre les commandes humaines et apprendre à donner la réponse optimale en fonction d'une invite donnée.

Si vous souhaitez en savoir plus sur RLHF, vous pouvez vous référer à : https://huggingface.co/blog/rlhf

Comme le disent les internautes : « Dans le domaine de l'IA, chaque fois qu'il y a une avancée particulière, les développeurs rapidement Une version open source sera reproduite. "

Cependant, le projet ne contient actuellement que l'architecture et le code de formation, sans poids pré-entraînés. Dans la notice d'utilisation, le document montre également que PaLM doit être formé en premier.

Certains internautes ont également exprimé leur inquiétude à ce sujet, en disant : Ce n'est pas un projet prêt à l'emploi, c'est juste une structure, tout comme une coque, sa formation nécessite des frais généraux coûteux. Non. l'organisation peut ressembler à Google Train PaLM de cette façon.

Certains internautes ont déclaré : "C'est très mauvais de ne pas avoir de poids pré-entraînés. Le responsable doit libérer au moins 50 % des poids clairsemés, et laisser les développeurs entraîner le reste par eux-mêmes est la meilleure option."

Cependant, certains internautes ont dit qu'ils allaient l'essayer :

Voyons comment fonctionne ce projet.

Installation

$ pip install palm-rlhf-pytorch

Utilisation

Entraînez d'abord PaLM, comme n'importe quel autre transformateur autorégressif.

import torch
from palm_rlhf_pytorch import PaLM
palm = PaLM(
num_tokens = 20000,
dim = 512,
depth = 12
).cuda()
seq = torch.randint(0, 20000, (1, 2048)).cuda()
loss = palm(seq, return_loss = True)loss.backward()
# after much training, you can now generate sequences
generated = palm.generate(2048) # (1, 2048)

utilise ensuite des commentaires humains sélectionnés pour entraîner le modèle de récompense. Dans l'article original, il n'était pas possible d'obtenir un modèle de récompense affiné à partir d'un transformateur pré-entraîné sans surajustement. Les auteurs du projet offrent la possibilité d'utiliser LoRA pour un réglage fin.

import torch
from palm_rlhf_pytorch import PaLM, RewardModel
palm = PaLM(
num_tokens = 20000,
dim = 512,
depth = 12,
causal = False
)
reward_model = RewardModel(
palm,
num_binned_output = 5 # say rating from 1 to 5
).cuda()
# mock data
seq = torch.randint(0, 20000, (1, 1024)).cuda()prompt_mask = torch.zeros(1, 1024).bool().cuda() # which part of the sequence is prompt, which part is response
labels = torch.randint(0, 5, (1,)).cuda()
# train
loss = reward_model(seq, prompt_mask = prompt_mask, labels = labels)loss.backward()
# after much training
reward = reward_model(seq, prompt_mask = prompt_mask)

Enfin, transmettez le modèle de transformateur et de récompense à RLHFTrainer.

import torch
from palm_rlhf_pytorch import PaLM, RewardModel, RLHFTrainer
# load your pretrained palm
palm = PaLM(
num_tokens = 20000,
dim = 512,
depth = 12
).cuda()
palm.load('./path/to/pretrained/palm.pt')
# load your pretrained reward model
reward_model = RewardModel(
palm,
num_binned_output = 5
).cuda()
reward_model.load('./path/to/pretrained/reward_model.pt')
# ready your list of prompts for reinforcement learning
prompts = torch.randint(0, 256, (50000, 512)).cuda() # 50k prompts
# pass it all to the trainer and train
trainer = RLHFTrainer(
palm = palm,
reward_model = reward_model,
prompt_token_ids = prompts
)
trainer.train(num_episodes = 50000)
# then, if it succeeded...
# generate say 10 samples and use the reward model to return the best one
answer = trainer.generate(2048, prompt = prompts[0], num_samples = 10) # (<= 2048,)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!