თქვენი ჩატბოტი არ კითხულობს სიტყვებს - ის ითვლის ჟეტონებს

ტოკენიზაცია არის კარიბჭე, რომლის მეშვეობითაც ნედლეული ტექსტი გარდაიქმნება ფორმატში, რომელსაც გამოსაყენებელია დიდი ენობრივი მოდელები (LLM), როგორიცაა GPT. ის მოქმედებს, როგორც ხიდი ადამიანის მიერ წაკითხულ შინაარსსა და რიცხობრივ მონაცემებს შორის, რომლებსაც მოდელები ამუშავებენ. სანამ მოდელი შეძლებს თანმიმდევრული ტექსტის გაგებას ან გენერირებას, მან უნდა დაშალოს შეყვანა უფრო მცირე ერთეულებად, რომელსაც ეწოდება ტოკენები .

GPT არქიტექტურებში ტოკენიზაცია ფუნდამენტურია მოდელის მუშაობისა და შესაძლებლობებისთვის, რაც გავლენას ახდენს ეფექტურობაზე, კონტექსტური ფანჯრის გამოყენებაზე და გამომავალი ხარისხზე. ტოკენიზაცია არის ტექსტის დაშლის პროცესი უფრო მცირე ერთეულებად, სახელწოდებით ჟეტონები, რომლებიც შეიძლება წარმოადგენდეს სიტყვებს, ქვესიტყვებს, სიმბოლოებს ან თუნდაც სპეციალურ სიმბოლოებს. ეს ნიშნები არის ძირითადი სამშენებლო ბლოკები, რომლებსაც მოდელი ამუშავებს. ტექსტის ტოკენიზაციის გზა პირდაპირ გავლენას ახდენს იმაზე, თუ რამდენად ეფექტურად შეუძლია მოდელს მონაცემების მართვა, რამდენად ჯდება ინფორმაცია მის კონტექსტურ ფანჯარაში და მის მიერ გამომუშავებული პასუხების ხარისხზე.

კონტექსტური ფანჯარა არის ტოკენების მაქსიმალური რაოდენობა, რომელსაც მოდელს შეუძლია დაამუშაოს ერთ ოპერაციაში, როგორც შეყვანის, ასევე გენერირებული გამომავალის ჩათვლით. მაგალითად, მოდელი 32000 ტოკენიანი კონტექსტური ფანჯრით უნდა მოერგოს ყველაფერს - თქვენს შეყვანილ ტექსტს, სისტემის ინსტრუქციებს და მოდელის პასუხს - ამ ლიმიტის ფარგლებში. ეფექტური ტოკენიზაცია ამცირებს ტოკენების რაოდენობას, რომლებიც საჭიროა მოცემული ტექსტის წარმოსადგენად, რაც საშუალებას გაძლევთ შეიტანოთ მეტი კონტენტი ან მიიღოთ უფრო გრძელი, მდიდარი შედეგები ლიმიტის გადაჭარბების გარეშე. მეორეს მხრივ, ცუდი ტოკენიზაციამ შეიძლება ზედმეტად გაზარდოს ტოკენების რაოდენობა, კარგავს ღირებულ ადგილს კონტექსტურ ფანჯარაში და ზღუდავს მოდელის გამოყენებადობას უფრო გრძელი ამოცანებისთვის.

ტექსტის ტოკენიზაციის შემდეგ, თითოეული ჟეტონი გარდაიქმნება ციფრულ ჩადგმად - მათემატიკური წარმოდგენა მაღალგანზომილებიან სივრცეში (ხშირად ასობით ან ათასობით განზომილებით). ეს ჩანერგვა ასახავს ნიშნის მნიშვნელობას და კავშირებს მთელი ლექსიკის კონტექსტში. მაგალითად, მსგავსი სიტყვების ნიშნები, როგორიცაა "run" და "running" უფრო ახლოს იქნება განთავსებული ამ სივრცეში, ვიდრე დაუკავშირებელი ნიშნები, როგორიცაა "run" და "table". ეს ჩაშენებები საშუალებას აძლევს მოდელს გაიგოს ნიშნების თანმიმდევრობა და იწინასწარმეტყველოს ყველაზე სავარაუდო შემდეგი ნიშანი ტექსტის გენერირების დროს. ეს პროცესი არის ის, რაც GPT-ს საშუალებას აძლევს შექმნას თანმიმდევრული, კონტექსტური შესაბამისი შედეგები, იქნება ეს შეკითხვაზე პასუხის გაცემა, წინადადების დასრულება თუ კრეატიული შინაარსის გენერირება.

არსებითად, ტოკენიზაცია არ არის მხოლოდ წინასწარი დამუშავების საფეხური - ის არის GPT მოდელების ეფექტური ფუნქციონირებისა და მაღალი ხარისხის შედეგების მიწოდების მნიშვნელოვანი საშუალება.

როგორ მუშაობს ტოკენიზაცია

ტოკენიზაცია არ არის ერთიანი პროცესი; ის განსხვავდება წინასწარ განსაზღვრული წესების ან ალგორითმების მიხედვით, რომლებიც შექმნილია ტექსტის მართვად ერთეულებად დაყოფისთვის, რომელსაც ეწოდება ტოკენები.

აქ უფრო ღრმად გამოიყურება, თუ როგორ მუშაობს:

გაყოფა

ეს გულისხმობს ტექსტის დაყოფას უფრო მცირე ერთეულებად, როგორიცაა სიტყვები, ქვესიტყვები ან სიმბოლოები. თანამედროვე LLM-ები ხშირად ეყრდნობიან ქვესიტყვის ტოკენიზაციას , რადგან ის გთავაზობთ ბალანსს ეფექტურობასა და სიმტკიცეს შორის. ეს ბალანსი წარმოიქმნება იმის გამო, რომ ქვესიტყვების ტოკენიზაციას შეუძლია გაუმკლავდეს იშვიათ ან უცნობ სიტყვებს მათი დაყოფით უფრო მცირე, უფრო გავრცელებულ კომპონენტებად, ხოლო ხშირი სიტყვების დაშიფვრით, როგორც ცალკეული ნიშნები.

მაგალითი :
განვიხილოთ სიტყვა unhappiness . ქვესიტყვის ტოკენიზაციის გამოყენებით, ის შეიძლება დაიშალოს:

• un , happi ness .

ეს მიდგომა უზრუნველყოფს:

• ეფექტურობა : საერთო კომპონენტები, როგორიცაა un და ness ხელახლა გამოიყენება სხვადასხვა სიტყვებში, რაც ამცირებს ლექსიკის ზომას.
• გამძლეობა : იშვიათი სიტყვები, როგორიცაა unhappiness მაინც შეიძლება დამუშავდეს მათი ცნობილ ქვეკომპონენტებად დაყოფით, ლექსიკის უსუსური საკითხების თავიდან აცილებით.

პრაქტიკული თვალსაზრისით, ეს საშუალებას აძლევს მოდელებს უკეთ განზოგადონ სხვადასხვა ტექსტის შეყვანა, ლექსიკის ზედმეტად გაფუჭების გარეშე.

კოდირება

კოდირება ანიჭებს უნიკალურ მთელ რიცხვს თითოეულ ჟეტონს წინასწარ განსაზღვრული ლექსიკის საფუძველზე - ყველა შესაძლო ნიშნის კრებულს, რომელსაც მოდელი აღიარებს. GPT და მსგავსი მოდელების კონტექსტში, ლექსიკა იქმნება ტრენინგის დროს და წარმოადგენს ქვესიტყვების (ან სიმბოლოების) ერთობლიობას, რომელსაც მოდელი იყენებს ტექსტის გასაგებად და გენერირებისთვის.

მაგალითად, GPT-ში:

• სიტყვა hello შეიძლება იყოს ერთი ნიშანი მთელი რიცხვით, როგორიცაა 1356 .
• იშვიათი ტერმინი, როგორიცაა micropaleontology შეიძლება დაიყოს ქვესიტყვების ნიშნებად, როგორიცაა micro , paleo და ntology , თითოეულს აქვს თავისი მთელი რიცხვი.

ChatGPT-სთვის ეს ნიშნავს, რომ როდესაც მომხმარებელი აწვდის ტექსტს, ტოკენიზატორი ასახავს შეყვანის სტრიქონს მთელი რიცხვების თანმიმდევრობაში, მოდელის ლექსიკის საფუძველზე. შემდეგ ეს თანმიმდევრობა მუშავდება ნერვული ქსელის მიერ. ლექსიკის ზომა გავლენას ახდენს მოდელის მეხსიერების გამოყენებასა და გამოთვლით ეფექტურობაზე, რაც არღვევს ბალანსს ენის რთული კონსტრუქციების მართვასა და სისტემის ეფექტურობის შენარჩუნებას შორის.

დეკოდირება

გაშიფვრა არის საპირისპირო პროცესი: ტოკენის მთელი რიცხვების თანმიმდევრობის გადაქცევა ადამიანის მიერ წასაკითხად ტექსტად. ქვესიტყვების ტოკენიზაციისთვის, ეს გულისხმობს ქვესიტყვების ხელახლა შეკრებას სრულ სიტყვებად, სადაც ეს შესაძლებელია.

როგორ მუშაობს :

1. მოდელი წარმოქმნის მთელი რიცხვების (ტოკენების) თანმიმდევრობას გამოსვლისას.
2. დეკოდერი ეძებს თითოეულ მთელ რიცხვს ლექსიკაში და იღებს მის შესაბამის ქვესიტყვას ან სიმბოლოს.
3. ქვესიტყვები ერთმანეთთან შერწყმულია სიტყვების შესაქმნელად, წესების გამოყენებით თანმიმდევრულობის უზრუნველსაყოფად (მაგ., ქვესიტყვების ირგვლივ არასაჭირო სივრცეების ამოღება).

მაგალითი :
დავუშვათ, რომ მოდელი აგენერირებს ტოკენებს un , happi და ness . დეკოდირება აღადგენს ამას unhappiness ქვესიტყვების შეერთებით. სივრცეების სწორად დამუშავება უზრუნველყოფს, რომ un არ განიხილება როგორც ცალკე სიტყვა.

ეს სისტემა საშუალებას აძლევს ქვესიტყვებზე დაფუძნებულ მოდელებს ეფექტურად წარმოქმნან ტექსტი იშვიათი ან რთული ტერმინების სწორად წარმოდგენის უნარის შენარჩუნებით.

რატომ უნდა ვიზრუნო როგორც დეველოპერმა?

მიუხედავად იმისა, რომ ChatGPT API ავტომატურად ამუშავებს ტოკენიზაციას, დეველოპერები უშუალოდ იყენებენ tiktoken რათა მიიღონ უფრო ზუსტი კონტროლი მათ აპლიკაციებზე. ის საშუალებას გაძლევთ წინასწარ შეამოწმოთ და მართოთ ტოკენის ლიმიტები , რაც უზრუნველყოფს, რომ შეყვანილი ტექსტი და პასუხები შეესაბამება მოდელის შეზღუდვებს. ეს განსაკუთრებით მნიშვნელოვანია ხანგრძლივ საუბრებთან ან დოკუმენტებთან მუშაობისას შეცდომების თავიდან ასაცილებლად. გარდა ამისა, დეველოპერებს შეუძლიათ ტოკენის გამოყენების ოპტიმიზაცია , რათა შეამცირონ API ხარჯები შეყვანის შემცირებით ან შეჯამებით.

tiktoken ასევე ეხმარება ტოკენიზაციის საკითხების გამართვაში , რაც უზრუნველყოფს ტექსტის ტოკენიზაციისა და გაშიფვრის გამჭვირვალობას. ხანგრძლივი შეყვანისთვის , tiktoken შეუძლია დაყოს ტექსტი პატარა ნაწილებად, რაც შესაძლებელს გახდის დიდი დოკუმენტების ნაწილებად დამუშავებას. და ბოლოს, მოწინავე გამოყენების შემთხვევებისთვის, როგორიცაა ჩაშენება ან ტოკენის დონის მანიპულაციები, tiktoken უზრუნველყოფს ზუსტ კონტროლს, თუ როგორ წარმოიქმნება და დამუშავდება ტოკენები.

 import openai import tiktoken openai.api_key = "your-api-key" # Initialize tokenizer for GPT-4 encoding = tiktoken.get_encoding("cl100k_base") # Function to count tokens def count_tokens(text): return len(encoding.encode(text)) # Example input user_input = "Explain the theory of relativity in detail with examples." conversation_history = [ {"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "What is the theory of relativity?"} ] # Combine inputs for token counting conversation_text = "".join([msg["content"] for msg in conversation_history]) + user_input # Pre-check input token limit (Use Case 1) token_limit = 4096 if count_tokens(conversation_text) > token_limit: print("Trimming conversation to fit within token limit.") conversation_history = conversation_history[1:] # Trim oldest message # Optimize input by summarizing if too long (Use Case 2) def summarize_if_needed(text, max_tokens=500): if count_tokens(text) > max_tokens: print("Input too long, summarizing...") response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": "Summarize the following text."}, {"role": "user", "content": text} ], max_tokens=200 ) return response.choices[0].message["content"] return text long_text = "A very long text input that exceeds the desired token limit ... (more text)" optimized_text = summarize_if_needed(long_text, max_tokens=500) # Debug tokenization (Use Case 3) tokens = encoding.encode("OpenAI's ChatGPT is amazing!") print("Tokenized:", tokens) for token in tokens: print(f"Token ID: {token}, Token: '{encoding.decode([token])}'") # Handle long documents by splitting into chunks (Use Case 4) def split_into_chunks(text, chunk_size): tokens = encoding.encode(text) for i in range(0, len(tokens), chunk_size): yield encoding.decode(tokens[i:i + chunk_size]) document = "A very long document... (more text)" chunks = list(split_into_chunks(document, chunk_size=1000)) # Process each chunk separately responses = [] for chunk in chunks: response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[{"role": "user", "content": chunk}], max_tokens=300 ) responses.append(response.choices[0].message["content"]) full_response = " ".join(responses) # Advanced token manipulation (Use Case 5) custom_text = "Analyze the sentiment of this text." tokens = encoding.encode(custom_text) response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[{"role": "user", "content": encoding.decode(tokens)}], max_tokens=100 ) print("Final Response:", response.choices[0].message["content"])

ხაზგასმა კოდში:

1. ჟეტონების ლიმიტების წინასწარი შემოწმება უზრუნველყოფს შეყვანის მორგებას მოდელის შეზღუდვებში, თავიდან აიცილებს შეკვეცას ან შეცდომებს.
2. შეყვანის შეჯამება ამცირებს ჟეტონის გამოყენებას გრძელ ტექსტთან მუშაობისას.
3. გამართვის ტოკენიზაცია უზრუნველყოფს გამჭვირვალობას, თუ როგორ ხდება ტოკენების კოდირება და გაშიფვრა.
4. გრძელი დოკუმენტების მართვადი ნაწილებად დაყოფა დიდ შეყვანას ეფექტურად ამუშავებს.
5. ტოკენის გაფართოებული მანიპულირება აჩვენებს ზუსტ კონტროლს ტოკენიზებულ შეყვანებზე.

ეს მიდგომა უზრუნველყოფს როგორც ოპტიმალურ შესრულებას, ასევე ხარჯების ეფექტურობას ChatGPT API-ზე მუშაობისას.

3. tiktoken შესწავლა : GPT's Tokenizer

OpenAI-ს tiktoken ბიბლიოთეკა შექმნილია იმისთვის, რომ ეფექტურად მოახდინოს ტოკენიზაცია და გაიგოს GPT მოდელების შეზღუდვები. მოდით გამოვიკვლიოთ როგორ მუშაობს:

გამოყენების მაგალითი

აი პითონის მაგალითი იმისა, თუ როგორ უნდა მოხდეს ტექსტის ტოკენიზაცია tiktoken გამოყენებით. მე მინდა გამოვიყენო https://colab.research.google.com/ ჩემი პითონის ნოუთბუქების გასაშვებად.

 import tiktoken # Choose a model-specific tokenizer encoding = tiktoken.get_encoding("o200k_base") # Input text text = "Tokenization is crucial for GPT models." # Tokenize text tokens = encoding.encode(text) print("Tokens:", tokens) # Decode back to text decoded_text = encoding.decode(tokens) print("Decoded Text:", decoded_text)

გამომავალი

 Tokens: [4421, 2860, 382, 19008, 395, 174803, 7015, 13] Decoded Text: Tokenization is crucial for GPT models.

4. დეველოპერის ბერკეტები ტოკენიზაციისთვის ChatGPT API-ებში

ChatGPT API-ების გამოყენებისას, ტოკენიზაციის გაგება ხელს უწყობს ოპტიმიზაციას:

1. შეყვანის ეფექტურობა :
   • შეინახეთ მონაცემები ლაკონური. ყოველი ჟეტონი ხარჯავს დამუშავების სიმძლავრეს და გავლენას ახდენს ტოკენის ლიმიტზე (მაგ., 8k GPT-3.5, 32k GPT-4-ისთვის).
   • ხელახლა გამოიყენეთ კონტექსტი ეფექტურად მხოლოდ არსებითი ინფორმაციის შენარჩუნებით.
2. მოდელის შერჩევა :
   • GPT-ის სხვადასხვა მოდელს აქვს ტოკენიზაციის განსხვავებული ქცევა. უფრო დიდი კონტექსტური ფანჯრების მქონე მოდელები უფრო ფართო შეყვანის საშუალებას იძლევა, მაგრამ უფრო დიდ ხარჯებს იწვევენ.
3. სწრაფი სტრუქტურირება :
   • ექსპერიმენტი გაფორმებით და ფრაზებით, რათა მინიმუმამდე დაიყვანოთ არასაჭირო ნიშნები. სიტყვიერების შემცირებამ შეიძლება გაზარდოს სიმბოლური ბიუჯეტი მნიშვნელობის დაკარგვის გარეშე.
4. დახვეწილი რეგულირება და ტოკენის მანიპულირება :
   • გამოიყენეთ ტოკენის დონის ოპერაციები, როგორიცაა padding და truncation, რათა უზრუნველყოთ ერთიანი შეყვანები აპლიკაციებში.

5. ნიმუშის დანერგვა პითონში

აქ არის პრაქტიკული მაგალითი ტოკენის გამოყენების გამოსათვლელად ChatGPT API-ს მოთხოვნისას:

 import tiktoken import openai def calculate_tokens(api_input, model="gpt-3.5-turbo"): encoding = tiktoken.encoding_for_model(model) tokens = encoding.encode(api_input) return len(tokens) # Example API call with token usage calculation api_input = "Explain the significance of tokenization in LLMs." model = "gpt-4" token_count = calculate_tokens(api_input, model) print(f"Token count for input: {token_count}") response = openai.ChatCompletion.create( model=model, messages=[{"role": "user", "content": api_input}] ) print("API Response:", response['choices'][0]['message']['content'])

ეს კოდი ეხმარება ტოკენის გამოყენების მონიტორინგს, რაც გადამწყვეტია ღირებულებისა და შესრულების ოპტიმიზაციისთვის.

6. Takeaways

ტოკენიზაციის გაგება აუცილებელია ინჟინრებისთვის, რომლებიც ქმნიან AI აპლიკაციებს, რადგან ის პირდაპირ გავლენას ახდენს ტექსტური მონაცემების დამუშავებაზე ენის მოდელების მიერ. ტოკენიზაცია გულისხმობს ნედლეული ტექსტის დაშლას უფრო მცირე, მნიშვნელოვან ერთეულებად, როგორიცაა სიტყვები, ქვესიტყვები ან სიმბოლოები, რომლებიც ამ მოდელების ძირითადი შენატანია. ეს პროცესი დეველოპერებს საშუალებას აძლევს ზუსტად მართონ შეყვანის ზომები, ოპტიმიზაცია მოახდინონ ღირებულების ტოკენის არასაჭირო გამოყენების შემცირებით და გააუმჯობესონ მოდელის შესრულება ტექსტის სეგმენტაციის უზრუნველსაყოფად, რომ შეინარჩუნოს კონტექსტური მნიშვნელობა. უფრო მეტიც, ტოკენიზაციის უშუალოდ კლიენტის მხარის კოდში ჩართვას შეუძლია ოპერაციების გამარტივება მონაცემთა გადაცემის ზედნადებისა და შეყოვნების შემცირებით, რაც უზრუნველყოფს უფრო ეფექტური ქეშირებას და უფრო სწრაფ წინასწარ დამუშავებას. ტოკენიზაციის დაუფლებით, ინჟინრებს შეუძლიათ შექმნან ხელოვნური ინტელექტის სისტემები, რომლებიც არის ძლიერი და ეკონომიური, რაც საბოლოოდ აძლიერებს მათი აპლიკაციების რეაგირებას და მასშტაბურობას.