Der folgende Artikel hilft Ihnen dabei: Erstellen Sie Ihr eigenes ChatGPT: Ein Leitfaden zur Feinabstimmung von LLMs mit LoRA
Während sich die KI weiterentwickelt, werden Chatbots in ihrer Fähigkeit, auf Eingaben in natürlicher Sprache zu reagieren, immer ausgefeilter und menschenähnlicher. Eines der beeindruckendsten Modelle in diesem Bereich ist chatGPT von OpenAI, das neue Maßstäbe für das Sprachverständnis und die Sprachgenerierung gesetzt hat. Aber was wäre, wenn Sie Ihren eigenen Chatbot hätten, der Ihre Fragen beantworten, Informationen bereitstellen und sogar Witze machen könnte, genau wie chatGPT? Dank der jüngsten Fortschritte bei den Feinabstimmungstechniken ist es nun möglich, durch die Feinabstimmung eines vorab trainierten Modells Ihren eigenen hochwertigen Chatbot zu erstellen. In diesem Artikel werfen wir einen Blick darauf, wie Sie mithilfe einer Feinabstimmungstechnik namens LoRA (Low Rank Adaptation) und dem vorab trainierten Modell flan-T5 XXL Ihren eigenen Chatbot erstellen.
Was ist LoRA?
LoRA ist eine Feinabstimmungstechnik, die eine neue Möglichkeit bietet, die Leistung vorab trainierter Sprachmodelle bei bestimmten Aufgaben zu verbessern. Im Gegensatz zu herkömmlichen Feinabstimmungsmethoden, die das gesamte Modell anhand neuer Daten trainieren, friert LoRA die vorab trainierten Modellgewichte ein und fügt trainierbare Rangzerlegungsmatrizen in jede Ebene der Transformer-Architektur ein. Dadurch wird die Anzahl der trainierbaren Parameter erheblich reduziert, was zu einer schnelleren Feinabstimmung und einer geringeren Überanpassung führen kann. Dem LoRA-Papier zufolge kann LoRA im Vergleich zur Feinabstimmung von GPT-3 175B mit Adam die Anzahl der trainierbaren Parameter um den Faktor 10.000 und den GPU-Speicherbedarf um den Faktor 3 reduzieren. Dies macht es zu einer effizienten und effektiven Methode um vorab trainierte große Modelle für bestimmte Aufgaben zu optimieren.
Veranschaulichung, wie LoRA funktioniert
Was ist Flan-T5 XXL?
Flan-T5 ist ein vorab trainiertes Sprachmodell auf dem neuesten Stand der Technik, das mithilfe der Technik der Instruktionsfeinabstimmung verfeinert wurde. Es hat sich gezeigt, dass diese Technik die Modellleistung und die Verallgemeinerung auf unbekannte Aufgaben verbessert, indem sie das Modell anhand einer Sammlung von Datensätzen, die als Anweisungen formuliert sind, feinabstimmt. XXL steht für die Modellgröße, dieses Modell ist die größte Version von FLAN-T5 mit 11B Parametern.
Datensatz
Für den Zweck dieses Experiments verwenden wir zwei Datensätze:
https://huggingface.co/datasets/Hello-SimpleAI/HC3
Und
https://huggingface.co/datasets/MohamedRashad/ChatGPT-prompts
Bitte beachten Sie, dass diese Datensätze Ausgaben von chatGPT enthalten, die gegen die Nutzungsbedingungen von chatGPT verstoßen. Daher werde ich das endgültig trainierte Modell nicht veröffentlichen und dieser Beitrag als pädagogisches Experiment dienen.
Schritte zur Feinabstimmung von Flan-T5 XXL mit LoRA
- Zuerst müssen Sie die Abhängigkeiten installieren. Wir werden Transformatoren, Datensätze, Beschleunigung, DeepSpeed und Peft verwenden.
- Als nächstes verbinden wir die beiden Datensätze;
Pandas als PD importieren json importieren f1 = open(‘data/all.jsonl’) f2 = open(‘data/train.jsonl’) Zeilen1 = f1.readlines() Zeilen2 = f2.readlines() Fragen, Antworten = [], []
für Zeile in Zeilen1: row = json.loads(line) für Antwort in Zeile[“human_answers”]: questions.append(“Human: “+row[“question”]) antworten.append(“Assistant: “+answer) für Antwort in Zeile[“chatgpt_answers”]: questions.append(“Human: “+row[“question”]) antworten.append(“Assistant: “+answer) für Zeile in Zeilen2: row = json.loads(line) History = row[“chosen”]
split = History.split(“Assistant:”) Frage = History.replace(“Assistant:”+Split[-1],””) answer = “Assistent:”+split[-1]
Fragen.append(Frage) Antworten.append(Antwort) df = pd.DataFrame() df[“question”] = Fragen df[“answer”] = antwortet df.to_csv(“data/train.csv”, index=False)
-
Sie sollten Ihre Beschleunigung so konfigurieren, dass sie mit DeepSpeed funktioniert. Dazu müssen Sie nur „accelerate config“ auf Ihrer Konsole eingeben. Es ist interessant, DeepSpeed Stage 3 Offload zu verwenden, um Ressourcen zu sparen;
-
Als nächstes rufen wir unser Trainingsskript mit „accelerate launch train_lora.py“ auf.
Betriebssystem importieren, Torch aus Accelerator importieren, Accelerator aus Torch.utils.data importieren, DataLoader aus Transformers importieren, AutoModelForSeq2SeqLM, AutoTokenizer, default_data_collator, get_linear_schedule_with_warmup, DataCollatorForSeq2Seq aus Datensätzen importieren, Load_dataset aus Peft importieren, LoraConfig, TaskType, get_peft_model, get_peft_model_state_dict aus peft.utils.other importieren sdp_auto_wrap_policy from tqdm import tqdm def main(): accelerator = Accelerator() model_name_or_path = “google/flan-t5-xxl” batch_size = 2 max_length = 512 lr = 1e-4 num_epochs = 1 train_data = “./data/train.csv” test_data = “./data/val.csv” peft_config = LoraConfig( task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1 ) checkpoint_name = “chaT5_lora.pt” model = AutoModelForSeq2SeqLM.from_pretrained( model_name_or_path) model = get_peft_model(model, peft_config) accelerator.print(model.print_trainable_parameters()) dataset = load_dataset( ‘csv’, data_files={ “train”: train_data, “validation”: test_data, }, cache_dir=”./ Cache”) tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) def preprocess_function(examples): inputs = [doc for doc in examples[“question”]]model_inputs = tokenizer( inputs, max_length=max_length, padding=True, truncation=True) mit tokenizer.as_target_tokenizer(): labels = tokenizer( Beispiele[“answer”]max_length=max_length, padding=True, truncation=True) model_inputs[“labels”] = Etiketten[“input_ids”]
Geben Sie model_inputs mit accelerator.main_process_first() zurück: processing_datasets = dataset.map( preprocess_function,batched=True,num_proc=16,remove_columns=dataset[“train”].column_names, load_from_cache_file=False, desc=”Tokenizer für Datensatz ausführen”, ) train_dataset = processing_datasets[“train”]
eval_dataset = verarbeitete_Datensätze[“validation”]
data_collator = DataCollatorForSeq2Seq( tokenizer, model=model) train_dataloader = DataLoader( train_dataset, shuffle=True, collate_fn=data_collator, batch_size=batch_size, pin_memory=True) eval_dataloader = DataLoader( eval_dataset, collate_fn=data_collator, batch_size=batch_size, pin_ Speicher=Wahr) Optimizer = Torch.optim.AdamW(model.parameters(), lr=lr) lr_scheduler = get_linear_schedule_with_warmup( Optimizer=Optimizer, num_warmup_steps=0, num_training_steps=(len(train_dataloader) * num_epochs), ) if getattr(accelerator.state, ” FSDP_PLUGIN “, keine) ist nicht keine: Accelerator.state.fsdp_plugin.auto_wrap_policy = fsdp_auto_wrap_policy (Modell) Modell, Train_dataloader, Eval_dataloader, optimierer, lr_Scheduler, Acceler. _Scheduler) Accelerator.print (Modell ) accelerator.state.deepspeed_plugin.zero_stage == 3 für Epoche in Bereich (num_epochs): model.train() total_loss = 0 für Schritt, Batch in enumerate(tqdm(train_dataloader)): Ausgänge = Modell(**batch) Verlust = Outputs.loss total_loss += loss.detach().float() accelerator.backward(loss)optimierer.step() lr_scheduler.step()optimierer.zero_grad() if step%1000 == 0: print(“loss: ” ,loss.detach().float()) accelerator.wait_for_everyone() if accelerator.is_main_process: accelerator.save( get_peft_model_state_dict(model, state_dict=accelerator.get_state_dict(model)), checkpoint_name ) model.eval() eval_loss = 0 eval_preds = []
für Schritt, Batch in enumerate(tqdm(eval_dataloader)): mit Torch.no_grad(): Outputs = Model(**Batch) Loss = Outputs.loss eval_loss += Loss.detach().float() Preds = Accelerator.gather_for_metrics (torch.argmax(outputs.logits, -1)).detach().cpu().numpy() eval_preds.extend(tokenizer.batch_decode(preds, skip_special_tokens=True)) eval_epoch_loss = eval_loss / len(train_dataloader) eval_ppl = Torch.exp(eval_epoch_loss) train_epoch_loss = total_loss / len(eval_dataloader) train_ppl = Torch.exp(train_epoch_loss) accelerator.print(f”{epoch=}: {train_ppl=} {train_epoch_loss=} {eval_ppl=} {eval_epoch_loss=}” ) accelerator.wait_for_everyone() accelerator.save( get_peft_model_state_dict(model, state_dict=accelerator.get_state_dict(model)), checkpoint_name ) accelerator.wait_for_everyone() if __name__ == “__main__”: main()
Durch den Einsatz von LoRA und DeepSpeed konnten wir eine beeindruckende Optimierung beim Training großer Sprachmodelle (LLMs) mit nur 65 GB VRAM erreichen. Dies ist besonders bemerkenswert, da allein die Gewichte der Modelle, gespeichert im fp32-Format, etwa 40 GB beanspruchen.
Ergebnisse
Nach der Feinabstimmung des Flan-T5 XXL-Modells mit der LoRA-Technik konnten wir unseren eigenen Chatbot erstellen. Die Qualität des vom Chatbot generierten Textes war gut, aber nicht so gut wie die von OpenAIs ChatGPT. Uns ist aufgefallen, dass der Chatbot Fehler machte und sich manchmal wiederholte. Dies kann auf die unterschiedlichen Parameter zwischen den beiden Modellen zurückgeführt werden – während ChatGPT über 175 Milliarden Parameter verfügt, hat Flan-T5 nur 11 Milliarden. Darüber hinaus könnte der zur Feinabstimmung verwendete Trainingsdatensatz verbessert werden, um die Qualität des generierten Textes weiter zu verbessern. Trotz dieser Einschränkungen zeigten die Ergebnisse dennoch, dass die Feinabstimmung des Flan-T5-XXL-Modells mit LoRA eine vielversprechende Technik für die Erstellung eines Chatbots ist.
Beispiel für ein Gespräch mit dem verfeinerten Modell. Beispiel für ein Gespräch mit dem verfeinerten Modell
Abschluss
Durch den Einsatz vorab trainierter Modelle und Feinabstimmungstechniken wie LoRA ist es nun möglich, hochwertige Chatbots zu erstellen, die Fragen beantworten, Informationen bereitstellen und Gespräche führen können. Indem Sie die in diesem Artikel beschriebenen Schritte befolgen, können Sie das Flan-T5-XXL-Modell verfeinern, um Ihren eigenen Chatbot zu erstellen, der natürliche Sprache verstehen und generieren kann.
Nächste Schritte
Der Schlüssel zur Erzeugung qualitativ hochwertiger Texte mit ChatGPT liegt nicht nur in den Trainingsdaten. In Zukunft plane ich, tiefer in die Technik von RLHF einzutauchen und zu untersuchen, wie sie beim Training großer Sprachmodelle (LLMs) eingesetzt werden kann.
