Budowanie własnego narzędzia do generowania kodu z użyciem LLM

W dzisiejszych czasach, kiedy sztuczna inteligencja staje się coraz bardziej dostępna, wiele osób zastanawia się, jak wykorzystać potencjał dużych modeli językowych (LLM) do automatyzacji pisania kodu. W tym artykule przedstawię praktyczny przewodnik po budowie własnego narzędzia do generowania kodu z użyciem LLM.

Wprowadzenie

Duże modele językowe, takie jak Mistral, są w stanie generować kod w różnych językach programowania. Można je wykorzystać do tworzenia narzędzi, które pomogą programistom w codziennej pracy. W tym artykule omówimy, jak zbudować takie narzędzie krok po kroku.

Wybór modelu

Pierwszym krokiem jest wybór odpowiedniego modelu. Można wybrać jeden z dostępnych modeli open-source lub skorzystać z API dostarczanego przez dostawcę chmury. W tym przykładzie użyjemy modelu Mistral.

Budowa podstawowego narzędzia

1. Instalacja wymaganych bibliotek

Aby rozpocząć, potrzebujemy kilku bibliotek. W tym przykładzie użyjemy transformers biblioteki do ładowania modelu i torch do obliczeń.

pip install transformers torch

2. Ładowanie modelu

Następnie załadowanie modelu Mistral.

from transformers import AutoModelForCausalLM, AutoTokenizer

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

3. Generowanie kodu

Teraz możemy napisać funkcję, która będzie generować kod na podstawie podanego promptu.

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. Testowanie narzędzia

Przetestujmy nasze narzędzie, generując prosty kod Python.

prompt = "Napisz funkcję, która dodaje dwie liczby."
print(generate_code(prompt))

Rozszerzanie funkcjonalności

1. Dodawanie kontekstu

Można rozszerzyć nasze narzędzie, dodając kontekst, który pomoże modelowi zrozumieć, jaki kod ma generować.

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

2. Poprawa jakości generowanego kodu

Aby poprawić jakość generowanego kodu, można dodać mechanizm weryfikacji i poprawiania błędów.

def verify_and_fix_code(code):
    verification_prompt = f"Sprawdź ten kod i popraw błędy:\n\n{code}"
    return generate_code(verification_prompt)

Wdrażanie narzędzia

1. Tworzenie interfejsu użytkownika

Można stworzyć prosty interfejs użytkownika, który pozwoli na łatwe korzystanie z narzędzia.

def main():
    print("Witaj w narzędziu do generowania kodu!")
    while True:
        prompt = input("Podaj prompt (lub 'exit' aby zakończyć): ")
        if prompt.lower() == 'exit':
            break
        code = generate_code(prompt)
        print("\nWygenerowany kod:")
        print(code)
        print("\n")

if __name__ == "__main__":
    main()

2. Wdrażanie na serwerze

Aby udostępnić narzędzie innym, można je wdrażyć na serwerze. Można użyć biblioteki Flask do tworzenia prostego API.

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)

Podsumowanie

W tym artykule omówiliśmy, jak zbudować własne narzędzie do generowania kodu z użyciem dużych modeli językowych. Pokazaliśmy, jak ładować model, generować kod i rozszerzać funkcjonalność narzędzia. Można dalej rozwijać to narzędzie, dodając więcej funkcji i poprawiając jakość generowanego kodu.

Przykładowy kod

Oto pełny przykładowy kod, który można użyć jako punkt wyjścia dla własnego narzędzia.

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

# Ładowanie modelu
model_name = "mistral"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# Generowanie kodu
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)

# Interfejs API
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)

Wnioski

Budowanie własnego narzędzia do generowania kodu z użyciem LLM to fascynujące zadanie, które może znacznie ułatwić pracę programistów. Dzięki dostępności zaawansowanych modeli językowych, takich jak Mistral, każdy może stworzyć swoje własne narzędzie, dostosowane do indywidualnych potrzeb.