Jak uzyskać dostęp do Lamy3 za pomocą Flaska?

Wprowadzenie

Świat sztucznej inteligencji stał się o wiele bardziej ekscytujący wraz z wydaniem Llama3! Ten potężny model języka open source, stworzony przez Meta, wstrząsa światem. Llama3, dostępna w wersjach 8B i 70B, wstępnie przeszkolonych i dostrojonych do instrukcji, oferuje szeroki zakres zastosowań. W tym przewodniku przyjrzymy się możliwościom Llama3 i sposobom uzyskania dostępu do Llama3 Kolba, koncentrując się na jego potencjale zrewolucjonizowania generatywnej sztucznej inteligencji.

Cele kształcenia

• Poznaj architekturę i metodologie szkoleniowe stojące za Llama3, odkrywając jej innowacyjne dane przedtreningowe i strojenie technik niezbędnych do zrozumienia jego wyjątkowego działania.
• Doświadcz praktycznej implementacji Llama3 poprzez Flask, opanowując sztukę generowania tekstu za pomocą transformatorów, jednocześnie zyskując wgląd w krytyczne aspekty testowania i dostrajania bezpieczeństwa.
• Przeanalizuj imponujące możliwości Llama3, w tym jego zwiększoną dokładność, możliwości adaptacji i solidną skalowalność, rozpoznając jednocześnie jego ograniczenia i potencjalne ryzyko, kluczowe dla odpowiedzialnego użytkowania i rozwoju.
• Zapoznaj się z przykładami ze świata rzeczywistego i przypadkami użycia Llama3, co umożliwi Ci efektywne wykorzystanie jego mocy w różnych zastosowaniach i scenariuszach, uwalniając w ten sposób jego pełny potencjał w dziedzinie generatywnej sztucznej inteligencji.

Ten artykuł został opublikowany jako część Blogathon nauki o danych.

Architektura i szkolenie Lamy3

Lama3 to model języka autoregresyjnego, który wykorzystuje zoptymalizowaną architekturę transformatora. Tak, zwykły transformator, ale z ulepszonym podejściem. Dostrojone wersje wykorzystują nadzorowane dostrajanie (SFT) i uczenie się przez wzmacnianie na podstawie informacji zwrotnej od człowieka (RLHF), aby dostosować się do ludzkich preferencji w zakresie przydatności i bezpieczeństwa. Model został wstępnie przeszkolony na obszernym zbiorze ponad 15 bilionów tokenów danych z publicznie dostępnych źródeł, przy czym terminy końcowe przypadały odpowiednio na marzec 2023 r. dla modelu 8B i grudzień 2023 r. dla modelu 70B. Dane dostrajające obejmują publicznie dostępne zbiory danych instrukcji, a także ponad 10 milionów przykładów z adnotacjami ludzkimi.

Imponujące możliwości Lamy3

Jak już wcześniej zauważyliśmy, Llama3 ma zoptymalizowaną konstrukcję transformatora i jest dostępna w dwóch rozmiarach, o parametrach 8B i 70B, zarówno w wersji wstępnie wytrenowanej, jak i dostrojonej zgodnie z instrukcjami. Tokenizator modelu ma słownictwo tokenów o wartości 128 tys. Do uczenia modeli wykorzystano sekwencje 8,192 tokenów. Llama3 okazała się niezwykle zdolna do:

• Zwiększona dokładność: Llama3 wykazała lepszą wydajność w przypadku różnych zadań przetwarzania języka naturalnego.
• Zdolność adaptacji: Zdolność modelu do dostosowania się do różnorodnych kontekstów i zadań sprawia, że ​​jest to idealny wybór do szerokiego zakresu zastosowań.
• Solidna skalowalność: Skalowalność Llama3 pozwala z łatwością obsługiwać duże ilości danych i złożone zadania.
• Możliwości kodowania: Uznaje się, że możliwości kodowania Llama3 są po prostu niezwykłe i wynoszą ponad 250 tokenów na sekundę. Zamiast złotych procesorów graficznych, wydajność jednostek LPU jest niezrównana, co czyni je najlepszym wyborem do obsługi dużych modeli językowych.

Najbardziej znaczącą zaletą Llama3 jest jego otwarty i darmowy charakter, dzięki czemu jest dostępny dla programistów bez konieczności rozbijania banku.

Warianty i funkcje Lamy3

Jak wspomniano wcześniej, Llama3 oferuje dwa główne warianty, każdy przeznaczony do różnych zastosowań w dwóch rozmiarach 8B i 70B:

• Wstępnie wytrenowane modele: Nadaje się do zadań związanych z generowaniem języka naturalnego. Trochę bardziej ogólnie jeśli chodzi o wydajność.
• Modele dostosowane do instrukcji: Zoptymalizowany pod kątem zastosowań dialogowych, przewyższający wiele modeli czatów typu open source w testach branżowych.

Dane szkoleniowe i testy porównawcze Lamy3

Llama3 została wstępnie przeszkolona na obszernym zbiorze ponad 15 bilionów tokenów publicznie dostępnych danych, z datą graniczną przypadającą na marzec 2023 r. dla modelu 8B i grudzień 2023 r. dla modelu 70B. Dane dostrajające obejmują publicznie dostępne zbiory danych instrukcji i ponad 10 milionów przykładów z adnotacjami ludzkimi (dobrze słyszałeś!). Model osiągnął imponujące wyniki w standardowych automatycznych testach porównawczych, w tym MMLU, AGIEval English, CommonSenseQA i innych.

Przypadki użycia i przykłady Lamy3

Lamy można używać jak innych Rodzina lamy modeli, co również bardzo ułatwiło korzystanie z niego. Zasadniczo musimy zainstalować transformator i przyspieszyć. W tej sekcji zobaczymy skrypt opakowania. Możesz znaleźć całe fragmenty kodu i notatnik do działania z GPU tutaj. Dodałem notatnik, aplikację kolbową i skrypt trybu interaktywnego, aby przetestować zachowanie modelu. Oto przykład użycia Llama3 z potokiem:

Jak uzyskać dostęp do Lamy3 za pomocą Flaska?

Przeanalizujmy teraz kroki, aby uzyskać dostęp do Llama3 za pomocą Flask.

Krok 1: Skonfiguruj środowisko Python

Utwórz środowisko wirtualne (opcjonalne, ale zalecane):

$ python -m venv env
$ source env/bin/activate   # On Windows use `.envScriptsactivate`

Zainstaluj niezbędne pakiety:

Instalujemy transformator i przyspieszamy, ale ponieważ Llama3 jest nowa, kontynuujemy instalację bezpośrednio z Git Hub.

(env) $ pip install -q git+https://github.com/huggingface/transformers.git
(env) $ pip install -q flask transformers torch accelerate # datasets peft bitsandbytes

Krok 2: Przygotuj główny plik aplikacji

Utwórz nowy plik Pythona o nazwie main.py. Wewnątrz niego wklej następujący kod.

from flask import Flask, request, jsonify
import transformers
import torch

app = Flask(__name__)

# Initialize the model and pipeline outside of the function to avoid unnecessary reloading
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
pipeline = transformers.pipeline(
    "text-generation",
    model=model_id,
    model_kwargs={"torch_dtype": torch.bfloat16},
    device_map="auto",
)


@app.route('/generate', methods=['POST'])
def generate():
    data = request.get_json()
    user_message = data.get('message')

    if not user_message:
        return jsonify({'error': 'No message provided.'}), 400

    # Create system message
    messages = [{"role": "system", "content": "You are a pirate chatbot who always responds in pirate speak!"}]

    # Add user message
    messages.append({"role": "user", "content": user_message})

    prompt = pipeline.tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )

    terminators = [
        pipeline.tokenizer.eos_token_id,
        pipeline.tokenizer.convert_tokens_to_ids("<|eot_id|>")
    ]

    outputs = pipeline(
        prompt,
        max_new_tokens=256,
        eos_token_id=terminators,
        do_sample=True,
        temperature=0.6,
        top_p=0.9,
    )

    generated_text = outputs[0]['generated_text'][len(prompt):].strip()
    response = {
        'message': generated_text
    }

    return jsonify(response), 200


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

Powyższy kod inicjuje serwer WWW Flask z pojedynczą trasą, /Generować, odpowiedzialny za odbieranie i przetwarzanie wiadomości użytkowników oraz zwracanie odpowiedzi generowanych przez sztuczną inteligencję.

Krok 3: Uruchom aplikację Flask

Uruchom aplikację Flask, wykonując następujące polecenie:

(env) $ export FLASK_APP=main.py
(env) $ flask run --port=5000

Teraz powinieneś mieć uruchomioną aplikację Flask http://localhost:5000. Możesz przetestować API za pomocą narzędzi takich jak Postman lub CURL, a nawet napisać prostą stronę frontendową HTML.

Tryb interaktywny przy użyciu transformatorów AutoModelForCausalLM

Aby interaktywnie wysyłać zapytania do modelu w Notatniku Jupyter, wklej to do komórki i uruchom:

import requests
import sys
sys.path.insert(0,'..')
import torch

from transformers import AutoTokenizer, AutoModelForCausalLM

MODEL_NAME ='meta-llama/Meta-Llama-3-8B-Instruct'

class InteractivePirateChatbot:
    def __init__(self):
        self._tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, padding_side='left')
        self._tokenizer.pad_token = self._tokenizer.eos_token
        self._model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.bfloat16, device_map="auto", offload_buffers=True)
        
    def _prepare_inputs(self, messages):
        try:
            inputs = self._tokenizer([message['content'] for message in messages], padding='longest', truncation=True, max_length=512, return_tensors='pt')
            input_ids = inputs.input_ids.to(self._model.device)
            attention_mask = inputs.attention_mask.to(self._model.device)
            return {'input_ids': input_ids, 'attention_mask': attention_mask}
        except Exception as e:
            print(f"Error preparing inputs: {e}")
            return None

    def ask(self, question):
        try:
            messages = [
                {"role": "system", "content": "You are a pirate chatbot who always responds in pirate speak!"},
                {"role": "user", "content": question}
            ]

            prepared_data = self._prepare_inputs(messages)
            if prepared_data is None:
                print("Error preparing inputs. Skipping...")
                return

            output = self._model.generate(**prepared_data, max_length=512, num_beams=5, early_stopping=True)

            answer = self._tokenizer.decode(output[0], skip_special_tokens=True)
            print("Pirate:", answer)
        except Exception as e:
            print(f"Error generating response: {e}")

generator = InteractivePirateChatbot()
while True:
    question = input("User: ")
    generator.ask(question)

Powyższy kod pozwoli Ci na szybką interakcję i sprawdzenie jak działa model. Znajdź cały kod tutaj.

User: "Who are you?"

Pirate: "Arrrr, me hearty! Me name be Captain Chat, the scurviest pirate chatbot to ever sail the Seven Seas! I be here to swab yer decks with me clever responses and me trusty parrot, Polly, perched on me shoulder. So hoist the colors, me matey, and let's set sail fer a swashbucklin' good time!"

Ponieważ widzieliśmy, jak działa ten model, przyjrzyjmy się kilku przewodnikom dotyczącym bezpieczeństwa i odpowiedzialności.

Odpowiedzialność i bezpieczeństwo

Meta podjęła szereg kroków, aby zapewnić odpowiedzialny rozwój sztucznej inteligencji, w tym wdrożenie najlepszych praktyk w zakresie bezpieczeństwa, udostępnienie zasobów takich jak zabezpieczenia Meta Llama Guard 2 i Code Shield oraz aktualizację Przewodnika odpowiedzialnego użytkowania. Zachęcamy programistów do dostrajania i wdrażania tych zabezpieczeń zgodnie ze swoimi potrzebami, rozważając korzyści płynące z dostosowania i przydatności dla ich konkretnego przypadku użycia i odbiorców. Wszystkie te linki są dostępne w repozytorium Hugginface dla Llama3.

Względy etyczne i ograniczenia

Chociaż Llama3 jest potężnym narzędziem, należy pamiętać o jego ograniczeniach i potencjalnym ryzyku. Model może generować niedokładne, stronnicze lub niewłaściwe odpowiedzi na podpowiedzi użytkownika. Dlatego programiści powinni przeprowadzić testy bezpieczeństwa i strojenie dostosowane do ich konkretnych zastosowań modelu. Meta zaleca włączenie rozwiązań Purple Llama do przepływów pracy, w szczególności Llama Guard, który zapewnia model podstawowy do filtrowania podpowiedzi wejściowych i wyjściowych w celu nałożenia bezpieczeństwa na poziomie systemu na bezpieczeństwo na poziomie modelu.

Wnioski

Meta przekształciła krajobraz sztucznej inteligencji poprzez wprowadzenie Llama3, potężnego modelu języka open source stworzonego przez Meta. Dzięki dostępności w wersjach 8B i 70B, wstępnie przeszkolonych i dostrojonych do instrukcji, Llama3 oferuje wiele możliwości innowacji. W tym przewodniku szczegółowo omówiono możliwości Llama3 i sposoby uzyskiwania dostępu do Llama3 za pomocą Flask, podkreślając jej potencjał w zakresie ponownego zdefiniowania generatywnej sztucznej inteligencji.

Na wynos

• Meta opracowała Llama3, potężny model języka open source, dostępny zarówno w wersjach 8B, jak i 70B, wstępnie przeszkolonych i dostrojonych do instrukcji.
• Llama3 wykazała imponujące możliwości, w tym zwiększoną dokładność, możliwości adaptacji i solidną skalowalność.
• Model ma charakter open source i jest całkowicie bezpłatny, dzięki czemu jest dostępny dla programistów i niskobudżetowych badaczy.
• Użytkownicy mogą używać Llama3 z transformatorami, wykorzystując abstrakcję potokową lub klasy Auto z funkcją generate().
• Llama3 i Flask umożliwiają programistom odkrywanie nowych horyzontów w zakresie generatywnej sztucznej inteligencji, wspierając innowacyjne rozwiązania, takie jak chatboty i generowanie treści, przesuwając granice interakcji człowiek-maszyna.

Często Zadawane Pytania

Linki

Media pokazane w tym artykule nie są własnością Analytics Vidhya i są wykorzystywane według uznania Autora.

• Dystrybucja treści i PR oparta na SEO. Uzyskaj wzmocnienie już dziś.
• PlatoData.Network Pionowe generatywne AI. Wzmocnij się. Dostęp tutaj.
• PlatoAiStream. Inteligencja Web3. Wiedza wzmocniona. Dostęp tutaj.
• PlatonESG. Węgiel Czysta technologia, Energia, Środowisko, Słoneczny, Gospodarowanie odpadami. Dostęp tutaj.
• Platon Zdrowie. Inteligencja w zakresie biotechnologii i badań klinicznych. Dostęp tutaj.
• Źródło: https://www.analyticsvidhya.com/blog/2024/04/how-to-access-llama3-with-flask/