Bauen Sie Ihr eigenes Code-Generierungstool mit LLM

In der heutigen Zeit, in der künstliche Intelligenz immer zugänglicher wird, fragen sich viele Menschen, wie sie das Potenzial großer Sprachmodelle (LLM) nutzen können, um das Schreiben von Code zu automatisieren. In diesem Artikel stelle ich einen praktischen Leitfaden zum Bau eines eigenen Code-Generierungstools mit LLM vor.

Einführung

Große Sprachmodelle wie Mistral können Code in verschiedenen Programmiersprachen generieren. Sie können zur Erstellung von Tools verwendet werden, die Programmierern in ihrer täglichen Arbeit helfen. In diesem Artikel besprechen wir, wie man ein solches Tool Schritt für Schritt baut.

Modellauswahl

Der erste Schritt besteht darin, ein geeignetes Modell auszuwählen. Sie können eines der verfügbaren Open-Source-Modelle auswählen oder ein API nutzen, das von einem Cloud-Anbieter bereitgestellt wird. In diesem Beispiel verwenden wir das Modell Mistral.

Aufbau des Grundwerkzeugs

1. Installation der erforderlichen Bibliotheken

Um zu beginnen, benötigen wir einige Bibliotheken. In diesem Beispiel verwenden wir die transformers-Bibliothek zum Laden des Modells und torch für Berechnungen.

pip install transformers torch

2. Laden des Modells

Als Nächstes laden Sie das Mistral-Modell.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistral"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

3. Code-Generierung

Jetzt können wir eine Funktion schreiben, die Code basierend auf einer gegebenen Eingabeaufforderung generiert.

def generate_code(prompt):
    inputs = tokenizer(prompt, return_tensors="pt")
    outputs = model.generate(**inputs, max_length=100)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

4. Testen des Tools

Testen wir unser Tool, indem wir einen einfachen Python-Code generieren.

prompt = "Schreiben Sie eine Funktion, die zwei Zahlen addiert."
print(generate_code(prompt))

Erweiterung der Funktionalität

1. Hinzufügen von Kontext

Man kann das Tool erweitern, indem man Kontext hinzufügt, der dem Modell hilft zu verstehen, welchen Code es generieren soll.

def generate_code_with_context(prompt, context):
    full_prompt = f"{context}\n\n{prompt}"
    return generate_code(full_prompt)

2. Verbesserung der Qualität des generierten Codes

Um die Qualität des generierten Codes zu verbessern, kann man einen Mechanismus zur Überprüfung und Korrektur von Fehlern hinzufügen.

def verify_and_fix_code(code):
    verification_prompt = f"Überprüfen Sie diesen Code und korrigieren Sie die Fehler:\n\n{code}"
    return generate_code(verification_prompt)

Bereitstellung des Tools

1. Erstellen einer Benutzeroberfläche

Man kann eine einfache Benutzeroberfläche erstellen, die eine einfache Nutzung des Tools ermöglicht.

def main():
    print("Willkommen im Code-Generierungstool!")
    while True:
        prompt = input("Geben Sie eine Eingabeaufforderung ein (oder 'exit' zum Beenden): ")
        if prompt.lower() == 'exit':
            break
        code = generate_code(prompt)
        print("\nGenerierter Code:")
        print(code)
        print("\n")

if __name__ == "__main__":
    main()

2. Bereitstellung auf einem Server

Um das Tool anderen zugänglich zu machen, kann man es auf einem Server bereitstellen. Man kann die Bibliothek Flask verwenden, um ein einfaches API zu erstellen.

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/generate', methods=['POST'])
def generate():
    data = request.json
    prompt = data.get('prompt', '')
    code = generate_code(prompt)
    return jsonify({'code': code})

if __name__ == '__main__':
    app.run(debug=True)

Zusammenfassung

In diesem Artikel haben wir besprochen, wie man ein eigenes Code-Generierungstool mit großen Sprachmodellen erstellt. Wir haben gezeigt, wie man ein Modell lädt, Code generiert und die Funktionalität des Tools erweitert. Man kann das Tool weiterentwickeln, indem man mehr Funktionen hinzufügt und die Qualität des generierten Codes verbessert.

Beispielcode

Hier ist der vollständige Beispielcode, der als Ausgangspunkt für Ihr eigenes Tool verwendet werden kann.

from transformers import AutoModelForCausalLM, AutoTokenizer
from flask import Flask, request, jsonify

# Laden des Modells
model_name = "mistral"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Code-Generierung
def generate_code(prompt):
    inputs = tokenizer(prompt, return_tensors="pt")
    outputs = model.generate(**inputs, max_length=100)
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# API-Schnittstelle
app = Flask(__name__)

@app.route('/generate', methods=['POST'])
def generate_api():
    data = request.json
    prompt = data.get('prompt', '')
    code = generate_code(prompt)
    return jsonify({'code': code})

if __name__ == '__main__':
    app.run(debug=True)

Schlussfolgerungen

Der Bau eines eigenen Code-Generierungstools mit LLM ist eine faszinierende Aufgabe, die die Arbeit von Programmierern erheblich erleichtern kann. Dank der Verfügbarkeit fortschrittlicher Sprachmodelle wie Mistral kann jeder sein eigenes Tool erstellen, das an individuelle Bedürfnisse angepasst ist.