Kaip sukurti pokalbių sąsają naudojant „Gradio & Vultr Cloud“ GPU – „SitePoint“.

Šis straipsnis buvo sukurtas bendradarbiaujant su Vultr. Dėkojame, kad remiate partnerius, kurie leidžia sukurti „SitePoint“.

„Gradio“ yra „Python“ biblioteka, kuri supaprastina mašininio mokymosi modelių diegimo ir dalijimosi procesą, suteikdama patogią sąsają, kuriai reikia minimalaus kodo. Jį galite naudoti kurdami tinkinamas sąsajas ir patogiai jomis bendrinti naudodami viešą nuorodą kitiems vartotojams.

Šiame vadove sukursite žiniatinklio sąsają, kurioje galėsite bendrauti su Mistral 7B didelės kalbos modeliu per įvesties lauką ir matyti modelio išvestis, rodomus realiuoju laiku sąsajoje.

Būtinos sąlygos

Prieš tau pradedant:

Sukurkite Gradio pokalbių sąsają

Įdiegtame egzemplioriuje turite įdiegti kai kuriuos paketus, kad sukurtumėte Gradio programą. Tačiau jums nereikia įdiegti tokių paketų kaip NVIDIA CUDA Toolkit, cuDNN ir PyTorch, nes jie yra iš anksto įdiegti Vultr GPU Stack atvejų.

1. Atnaujinkite Jinja paketą:

   $ pip install --upgrade jinja2
   

2. Įdiekite reikiamas priklausomybes:

   $ pip install transformers gradio
   

3. Sukurkite naują failą pavadinimu chatbot.py naudojant nano:

   $ sudo nano chatbot.py
   

   Atlikite kitus šio failo užpildymo veiksmus.

4. Importuokite reikiamus modulius:

   import gradio as gr
   import torch
   from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
   from threading import Thread
   

   Aukščiau pateiktas kodo fragmentas importuoja visus reikalingus modulius į vardų sritį, kad būtų galima nustatyti Mistral 7B didelės kalbos modelį ir paleisti Gradio pokalbių sąsają.

5. Inicijuoti modelį ir tokenizatorių:

   
   
   
   
   model_repo = "mistralai/Mistral-7B-v0.1"
   
   
   model = AutoModelForCausalLM.from_pretrained(model_repo, torch_dtype=torch.float16)
   tokenizer = AutoTokenizer.from_pretrained(model_repo)
   
   
   model = model.to('cuda:0')
   

   Aukščiau pateiktas kodo fragmentas inicijuoja modelį, prieigos raktą ir įgalina CUDA apdorojimą.

6. Apibrėžkite stabdymo kriterijus:

   class StopOnTokens(StoppingCriteria):
       def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
           stop_ids = [29, 0]
           for stop_id in stop_ids:
               if input_ids[0][-1] == stop_id:
                   return True
           return False
   

   Aukščiau pateikti kodo fragmentai paveldi naują klasę pavadinimu StopOnTokens nuo StoppingCriteria klasė.

7. Apibrėžkite predict() funkcija:

   def predict(message, history):
       stop = StopOnTokens()
   
       history_transformer_format = history + [[message, ""]]
       messages = "".join(["".join(["\n<human>:" + item[0], "\n<bot>:" + item[1]]) for item in history_transformer_format])
   

   Aukščiau pateiktas kodo fragmentas apibrėžia kintamuosius StopOnToken() objektą ir saugoti pokalbio istoriją. Jis formatuoja istoriją, susiejant kiekvieną pranešimą su atsakymu ir pateikdamas žymas, kad būtų galima nustatyti, ar jis yra nuo žmogaus, ar nuo roboto.

   Kodo fragmentas kitame žingsnyje turi būti įklijuotas viduje predict() funkcija taip pat.

8. Inicijuoti teksto interaktyviojo srauto programą:

   model_inputs = tokenizer([messages], return_tensors="pt").to("cuda")
       streamer = TextIteratorStreamer(tokenizer, timeout=10., skip_prompt=True, skip_special_tokens=True)
   
       generate_kwargs = dict(
           model_inputs,
           streamer=streamer,
           max_new_tokens=200,
           do_sample=True,
           top_p=0.95,
           top_k=1000,
           temperature=0.4,
           num_beams=1,
           stopping_criteria=StoppingCriteriaList([stop])
       )
   
       t = Thread(target=model.generate, kwargs=generate_kwargs)
       t.start()
   
       partial_message  = ""
       for new_token in streamer:
           if new_token != '<':
               partial_message += new_token
               yield partial_message
   

   The streamer užklausa naujų žetonų iš modelio ir gauna juos po vieną, užtikrinant nuolatinį teksto išvedimo srautą.

   Galite reguliuoti modelio parametrus, pvz max_new_tokens, top_p, top_kir temperature manipuliuoti modelio atsaku. Norėdami sužinoti daugiau apie šiuos parametrus, galite peržiūrėti Kaip naudoti TII Falcon Large Language modelį Vultr Cloud GPU.

9. Paleiskite Gradio pokalbių sąsają failo pabaigoje:

   gr.ChatInterface(predict).launch(server_name='0.0.0.0')
   

10. Išeikite iš teksto rengyklės naudodami CTRL + X norėdami išsaugoti failą ir paspauskite Y kad būtų galima perrašyti failus.
11. Leisti įeinančius ryšius prievade 7860:

    $ sudo ufw allow 7860
    

    „Gradio“ naudoja prievadą 7860 pagal nutylėjimą.

12. Iš naujo įkelkite ugniasienę:

    $ sudo ufw reload
    

13. Vykdykite programą:

    $ python3 chatbot.py
    

    Pirmą kartą paleidus programą, gali prireikti papildomo laiko, kol bus atsisiunčiami Mistral 7B didelės kalbos modelio kontroliniai taškai ir įkeliami į GPU. Ši procedūra gali trukti nuo 5 minučių iki 10 minučių, atsižvelgiant į jūsų aparatinę įrangą, interneto ryšį ir pan.

    Kai jis bus paleistas, galėsite pasiekti Gradio pokalbių sąsają naudodami žiniatinklio naršyklę, eidami į:

    http://SERVER_IP_ADRESS:7860/
    

    Numatoma produkcija parodyta žemiau.

    

Padarykite daugiau naudodami „Gradio“.

Išvada

Šiame vadove naudojote „Gradio“, kad sukurtumėte pokalbių sąsają ir nustatytumėte „Mistral AI“ sukurtą „Mistral 7B“ modelį naudodami Vultr GPU Stack.

Tai yra Vultr remiamas straipsnis. Vultr yra didžiausia pasaulyje privati ​​debesų kompiuterijos platforma. Kūrėjų pamėgta „Vultr“ aptarnavo daugiau nei 1,5 mln. klientų 185 šalyse, naudodama lanksčius, keičiamo dydžio, pasaulinius „Cloud Compute“, „Cloud GPU“, „Bare Metal“ ir „Cloud Storage“ sprendimus. Išmokti daugiau apie Vultr.