Hướng dẫn Groq LPU Inference Engine

Nếu bạn từng bực bội vì phải chờ ChatGPT phản hồi, bạn sẽ hào hứng khi biết về Groq Language Processing Unit (LPU) Inference Engine.

Với Groq, bạn có thể nhanh chóng nhận được phản hồi cho truy vấn của mình, rút ngắn thời gian chờ từ 40 giây xuống chỉ còn 2 giây.

Trong hướng dẫn này, chúng ta sẽ:

1. Tìm hiểu về Groq LPU Inference Engine.
2. So sánh tính năng và cấu trúc API của OpenAI và Groq. 
3. Học cách dùng Groq trực tuyến và cục bộ.
4. Tích hợp Groq API vào VSCode.
5. Học cách dùng Groq Python API.
6. Xây dựng ứng dụng AI nhận biết ngữ cảnh với Groq API và LlamaIndex.

Nếu bạn mới làm quen với các mô hình ngôn ngữ lớn (LLM), chúng tôi khuyến nghị theo học lộ trình kỹ năng Developing Large Language Models để nắm các kiến thức cơ bản về fine-tune LLM và tự xây dựng mô hình từ đầu.

Groq LPU Inference Engine là gì?

LPU (language processing unit) Inference Engine của Groq là một hệ thống xử lý mới, đảm nhiệm các tác vụ tính toán chuyên sâu có thành phần tuần tự, đặc biệt là khi tạo phản hồi cho các mô hình ngôn ngữ lớn. Công nghệ đột phá này thay đổi cách chúng ta xử lý và tạo văn bản, mang lại hiệu năng và độ chính xác vượt trội.

So với bộ xử lý trung tâm (CPU) và bộ xử lý đồ họa (GPU) truyền thống, LPU có năng lực tính toán lớn hơn. Điều này có nghĩa thời gian dự đoán một từ giảm đáng kể, giúp tạo chuỗi văn bản nhanh hơn nhiều. Hơn nữa, LPU cũng giải quyết nút thắt cổ chai về bộ nhớ, một hạn chế phổ biến của GPU khi làm việc với LLM. 

Groq thiết kế LPU để giải quyết các thách thức như mật độ tính toán, băng thông bộ nhớ, độ trễ thấp và thông lượng cao. Nó mang lại mức hiệu năng vượt qua GPU và TPU (tensor processing unit). Ví dụ, LPU có thể tạo hơn 310 token mỗi giây cho mỗi người dùng trên Llama-3 70B.

Bạn có thể tìm hiểu thêm về kiến trúc LPU bằng cách đọc bài báo nghiên cứu chính thức Groq ISCA 2022 Paper.

OpenAI và Groq API

Hiện tại, chúng ta chỉ có thể truy cập các LLM của Groq thông qua groq.com, Groq Cloud API, Groq Playground và các nền tảng bên thứ ba như Poe. 

Trong phần này, chúng ta sẽ tìm hiểu các tính năng và mô hình mà OpenAI và Groq Cloud cung cấp. Ngoài ra, chúng ta sẽ kiểm tra tốc độ gọi API bằng CURL và so sánh thiết kế API.

OpenAI

OpenAI API cung cấp dải tính năng và mô hình rất rộng. Bao gồm:

1. Các mô hình embedding.
2. Truy cập mô hình tạo văn bản như GPT-4o và GPT-4 Turbo.
3. Trình thông dịch mã và tìm kiếm tệp.
4. Khả năng fine-tune mô hình trên bộ dữ liệu tuỳ chỉnh.
5. Truy cập mô hình tạo ảnh.
6. Mô hình âm thanh cho chuyển lời nói thành văn bản, dịch và chuyển văn bản thành giọng nói.
7. Mô hình thị giác để hiểu hình ảnh.
8. Gọi hàm (function calling).

OpenAI API nhanh và ngày càng rẻ hơn theo thời gian.

Chúng ta có thể truy cập mô hình mới nhất của OpenAI bằng cách gõ lệnh sau trong terminal. API yêu cầu khóa API của OpenAI, tên mô hình và messages chứa system prompt và truy vấn của người dùng. 

curl -X POST https://api.openai.com/v1/chat/completions \ 
  -H "Content-Type: application/json" \ 
  -H "Authorization: Bearer $OPENAI_API_KEY" \ 
  -d '{ 
    "model": "gpt-4o", 
    "messages": [ 
      {        "role": "system", 
        "content": "You are a helpful assistant." 
      }, 
      { 
        "role": "user", 
        "content": "How do I get better at programming?" 
      } 
    ] 
  }'Được hỗ trợ bởi

Yêu cầu này mất 13 giây để hoàn tất. 

Để tìm hiểu thêm về API và tính năng của OpenAI, hãy xem Hướng dẫn cho người mới bắt đầu về OpenAI API: Thực hành và Best Practices.

Groq

Groq là cái tên mới trong ngành AI và hiện cung cấp số lượng tính năng và mô hình còn hạn chế. Bao gồm:

1. Các mô hình tạo văn bản như LLaMA3 70b, Gemma 7b và Mixtral 8x7b.
2. Phiên âm và dịch bằng mô hình Whisper Large V3 (chưa mở cho công chúng).
3. Tương thích với API của OpenAI.
4. Gọi hàm (function calling).

Groq Cloud API cho thời gian phản hồi nhanh hơn so với OpenAI API. Để kiểm chứng, chúng ta sẽ dùng lệnh CURL trong terminal và gửi cùng một message đến Groq API.

Groq API tương tự OpenAI API, chỉ khác về URL.

curl -X POST "https://api.groq.com/openai/v1/chat/completions" \ 
    -H "Authorization: Bearer $GROQ_API_KEY" \ 
    -H "Content-Type: application/json" \ 
    -d '{"messages": [ 
     { 
       "role": "system", 
       "content": "You are a helpful assistant." 
     }, 
     {        "role": "user", 
       "content": "How do I get better at programming?" 
     } 
   ], 
   "model": "llama3-70b-8192"}'Được hỗ trợ bởi

Nó mất hai giây để phản hồi, so với OpenAI API thì nhanh hơn 6,5 lần. 

Với Groq, bạn có được khả năng tạo phản hồi theo thời gian thực, điều này rất quan trọng với một số ứng dụng.

Sử dụng Groq Cloud

Groq Cloud đi kèm playground AI nơi bạn có thể thử tất cả mô hình và API để xây dựng sản phẩm và ứng dụng AI. 

Để truy cập Groq Cloud, trước tiên bạn phải tạo tài khoản bằng cách truy cập liên kết này.

Sau đó, nhấp tab playground ở bảng bên trái, chọn mô hình llama3-70b-8192 và bắt đầu viết prompt cho phần USER. 

Mất 2,94 giây để tạo toàn bộ phản hồi với tốc độ 305 token mỗi giây. Đây là hiệu năng đỉnh mà chúng ta khó có được từ ChatGPT. 

Giờ hãy chọn mô hình nhỏ mitral-8x7b-32768 và viết prompt tiếp theo.

Các mô hình nhỏ thậm chí còn nhanh hơn với tốc độ 577 token mỗi giây.

Bạn có thể đọc hướng dẫn Phân loại LLM: Cách chọn LLM tốt nhất cho ứng dụng của bạn để tìm hiểu các tùy chọn LLM hiện có và các yếu tố cần cân nhắc khi lựa chọn.

Sử dụng Groq cục bộ

Để truy cập các LLM của Groq cục bộ, chúng ta phải tạo khóa API bằng cách vào tab API Keys và nhấp nút Create API Key. 

Jan AI cho phép chúng ta dùng LLM cục bộ—cả mô hình mã nguồn mở và độc quyền. Nó hỗ trợ các nhà cung cấp mô hình như OpenAI, Anthropic, Cohere, MistralAI và Groq.

Chúng ta sẽ tải và cài đặt Jan AI bằng cách truy cập trang web chính thức. Sau đó có thể khởi chạy ứng dụng.

Vào phần cài đặt, chọn tab Groq Inference Engine và dán khóa API mà chúng ta vừa tạo. 

Thoát menu cài đặt, vào Thread và chọn mô hình Groq Llama 3 70b.

Viết một câu hỏi hoặc prompt để tạo phản hồi theo thời gian thực:

Gói miễn phí của Groq Cloud có một số giới hạn tốc độ. Ví dụ, gói llama3-70b-8192 cho phép 30 yêu cầu mỗi phút, 14.400 yêu cầu mỗi ngày và 6.000 token mỗi phút. Dù các giới hạn này khá rộng rãi, nếu bạn định xây dựng một ứng dụng AI hoàn chỉnh sử dụng Groq API, bạn có thể cân nhắc nâng cấp lên gói On Demand hoặc Enterprise.

Bạn có thể đọc hướng dẫn về chạy LLM cục bộ để khám phá bảy cách đơn giản vận hành ứng dụng AI trên máy của bạn.

Tích hợp Groq với VSCode

Ngoài việc dùng Groq API trong ứng dụng chatbot, chúng ta cũng có thể tích hợp vào VSCode bằng tiện ích CodeGPT. Nó sẽ trở thành trợ lý viết mã AI siêu nhanh của chúng ta. 

Để truy cập mô hình Groq trong VSCode, chúng ta cần cài đặt tiện ích CodeGPT từ marketplace.

Sau khi cài đặt, chúng ta sẽ thiết lập khóa API Groq bằng cách nhấp biểu tượng chat CodeGPT ở bảng bên trái và chọn nhà cung cấp cùng mô hình. Chúng ta chọn Groq làm nhà cung cấp và llama3-70b-8192 làm mô hình.

Sau đó, chúng ta có thể viết prompt trong hộp chat và tạo mã. Chỉ mất vài giây để tạo đoạn mã phù hợp và xây dựng hệ thống email.

Sau đó, chúng ta có thể ghi chú tài liệu cho mã, refactor, và tạo unit test bằng các lệnh tích hợp sẵn. 

Bạn có thể tìm hiểu về VSCode qua hướng dẫn thiết lập VSCode cho Python.

Hướng dẫn từng bước sử dụng Groq Python API

Trong phần này, chúng ta sẽ học những điều cơ bản về Groq Python API và các tính năng chính như streaming và async chat completion. 

Trong hướng dẫn này, chúng tôi sử dụng DataLab của DataCamp. DataLab là Jupyter Notebook trên AI Cloud với rất nhiều tính năng để viết mã, phân tích dữ liệu và chia sẻ insight.

Thiết lập

Trước hết, chúng ta cần thiết lập khóa API Groq trong DataLab bằng cách nhấp nút Environment ở bảng bên trái và thêm biến môi trường bằng cách nhấp nút dấu cộng +.

Chúng ta có thể đặt tên biến và dán khóa API Groq như minh hoạ dưới đây.

Sau đó, chúng ta có thể kích hoạt biến môi trường bằng cách nhấp vào ba chấm bên cạnh biến môi trường Groq và chọn Connect.

Cuối cùng, chúng ta sẽ cài đặt gói Groq Python bằng lệnh pip. 

%pip install groq -qĐược hỗ trợ bởi

Hoàn thành và trò chuyện cơ bản

Nếu bạn đã dùng OpenAI Python API, bạn có thể thấy cấu trúc mã tương tự. Để chạy chat completion:

1. Tạo client Groq bằng cách cung cấp khóa API.
2. Tạo phản hồi đơn giản bằng hàm chat completion. 
3. Hàm chat completion yêu cầu tên mô hình và message. 
4. Chuyển đầu ra sang Markdown.

import os
from groq import Groq
from IPython.display import display, Markdown

client = Groq(    
   api_key=os.environ.get("GROQ_API_KEY"),
)

chat_completion = client.chat.completions.create(    
   messages=[        
       {"role": "system", "content": "You are a professional Data Scientist."},        
       {"role": "user", "content": "Can you explain how the neural networks work?"},    
   ],    
   model="llama3-70b-8192",)

Markdown(chat_completion.choices[0].message.content)Được hỗ trợ bởi

Kết quả là chúng ta có một phần giải thích được định dạng hoàn hảo về mạng nơ-ron là gì.

Streaming chat completion

Streaming trong LLM đề cập đến việc xử lý và tạo văn bản từng token một, cho phép sử dụng bộ nhớ hiệu quả và cải thiện tốc độ cảm nhận của ứng dụng AI.

Trong các ví dụ này, chúng ta bật streaming và tuỳ chỉnh mô hình bằng cách thay đổi các siêu tham số như temperature, max_tokens và top_p.

chat_streaming = client.chat.completions.create( 
    messages=[ 
       {"role": "system", "content": "You are a monk from Thailand."}, 
       {"role": "user", "content": "Can you explain the meaning of life?"}, 
    ], 
    model="llama3-70b-8192", 
    temperature=0.3, 
    max_tokens=360, 
    top_p=1, 
    stop=None, 
    stream=True,
)

for chunk in chat_streaming: 
    print(chunk.choices[0].delta.content, end="")Được hỗ trợ bởi

Kết quả là chúng ta bắt đầu nhận phản hồi ngay khi chạy đoạn mã này. 

Async chat completion

API bất đồng bộ (asynchronous) cho phép xử lý đồng thời nhiều yêu cầu mà không bị chặn, giúp hệ thống xử lý và phản hồi từng yêu cầu độc lập. Cách tiếp cận này hiệu quả và có khả năng mở rộng tốt hơn, vì có thể xử lý khối lượng yêu cầu lớn hơn và cung cấp thời gian phản hồi nhanh hơn.

Để bật gọi API async, chúng ta phải thay đổi cấu trúc mã. Cụ thể:

1. Tạo client Groq async với khóa API. 
2. Định nghĩa hàm async main.
3. Viết hàm chat completion với từ khóa await.
4. Chạy hàm main với từ khóa await.

Lưu ý: Mã dưới đây chạy được trên Jupyter Notebook, nhưng nếu bạn chạy trong tệp Python, có thể cần đổi dòng cuối thành asyncio.run(main()).

import asyncio
from groq import AsyncGroq

client = AsyncGroq(

    api_key=os.environ.get("GROQ_API_KEY"),

)

async def main(): 

   chat_completion = await client.chat.completions.create( 
       messages=[            {"role": "system", "content": "You are a psychiatrist helping young minds"}, 
                  {                "role": "user",                "content": "I panicked during the test, even though I knew everything on the test paper.",            }, 
                ], 
                model="llama3-70b-8192", 
                temperature=0.3, 
                max_tokens=360, 
                top_p=1, 
                stop=None, 
                stream=False, 
       ) 

       print(chat_completion.choices[0].message.content)

await main()  # for Python file use asyncio.run(main())Được hỗ trợ bởi

Streaming cho Async chat completion

Chúng ta cũng có thể stream API async bằng cách bật tham số stream trong hàm chat completion và thay đổi cách in kết quả. Chúng ta sẽ in từng mảnh (chunk) bằng vòng lặp for với lệnh async.

import asyncio

from groq import AsyncGroq


client = AsyncGroq()

async def main(): 

    chat_streaming = await client.chat.completions.create( 
        messages=[ 
           {"role": "system", "content": "You are a psychiatrist helping young minds"}, 
           {                "role": "user",                "content": "I panicked during the test, even though I knew everything on the test paper.",            }, 
        ], 
        model="llama3-70b-8192", 
        temperature=0.3, 
        max_tokens=360, 
        top_p=1, 
        stop=None, 
        stream=True, 
     ) 
     async for chunk in chat_streaming: 
            print(chunk.choices[0].delta.content, end="")

await main()  # for Python file use asyncio.run(main())Được hỗ trợ bởi

Nếu bạn gặp khó khăn khi chạy mã, vui lòng tham khảo notebook DataLab này: Groq Cloud API.

Xây dựng ứng dụng AI với Groq API và LlamaIndex

Trong hướng dẫn này, chúng ta sẽ tiến thêm một bước và học cách xây dựng ứng dụng AI bằng Groq API và LlamaIndex, một framework cho LLM. Chúng ta sẽ xây dựng ứng dụng tải văn bản từ tệp PDF, chuyển thành embedding và lưu vào vector store. Sau đó, chúng ta chuyển vector store thành retriever để xây dựng chat engine RAG có lịch sử. 

Nói ngắn gọn, chúng ta đang xây dựng ứng dụng ChatPDF nhận biết ngữ cảnh để giúp bạn hiểu tài liệu nhanh hơn nhiều.

Để học cách nạp, quản lý và truy xuất dữ liệu riêng tư hoặc theo miền bằng ngôn ngữ tự nhiên, hãy xem hướng dẫn này: LlamaIndex: Khung dữ liệu cho các mô hình ngôn ngữ lớn (LLM).

Cài đặt các gói Python

Đầu tiên, chúng ta sẽ cài tất cả gói Python cần thiết bằng pip. Chúng ta dùng magic %%capture để ẩn log.

%%capture
%pip install llama-index
%pip install llama-index-llms-groq
%pip install llama-index-embeddings-huggingfaceĐược hỗ trợ bởi

Thiết lập LLM bằng Groq

Chúng ta sẽ tạo client Groq LLM bằng hàm của llama_index. Client LLM yêu cầu tên mô hình và khóa API.

from llama_index.llms.groq import Groq
import os

llm = 
Groq(model="llama3-70b-8192",api_key=os.environ.get("GROQ_API_KEY"))Được hỗ trợ bởi

Thiết lập mô hình embedding

Tiếp theo, chúng ta sẽ tải và nạp mô hình embedding của Hugging Face bằng LlamaIndex embeddings API. 

Trong trường hợp này, chúng ta nạp mô hình embedding phổ biến nhất trên Hugging Face có tên mxbai-embed-large-v1.

from llama_index.embeddings.huggingface import HuggingFaceEmbedding

embed_model = 
HuggingFaceEmbedding(model_name="mixedbread-ai/mxbai-embed-large-v1")Được hỗ trợ bởi

Cấu hình thiết lập toàn cục

LlamaIndex cho phép đặt cấu hình toàn cục, loại bỏ nhu cầu truyền đối tượng LLM hoặc embedding ở mọi nơi.

from llama_index.core import Settings

Settings.llm = llm
Settings.embed_model = embed_modelĐược hỗ trợ bởi

Tải dữ liệu

Về dữ liệu, chúng ta sử dụng bài viết 14 công cụ thiết yếu cho Kỹ sư Dữ liệu năm 2024 và chuyển thành PDF bằng lệnh in.

Dùng hàm SimpleDirectoryReader, bạn có thể tải nhiều loại tài liệu từ thư mục. Chỉ cần cung cấp đường dẫn thư mục và các phần mở rộng tệp cần thiết. 

from llama_index.core import SimpleDirectoryReader

de_tools_blog = SimpleDirectoryReader("./",required_exts=[".pdf", ".docx"]).load_data()Được hỗ trợ bởi

Vector search

VectorStoreIndex cung cấp cách nhanh nhất để tạo vector store bằng cách nạp tài liệu và xây dựng index. Index có thể dùng cho query engine, retriever và pipeline truy vấn.

Trong trường hợp này, chúng ta tạo index bằng cách đưa tài liệu vào vector store, hệ thống sẽ chuyển văn bản thành embedding rồi lưu vào vector store. 

Sau đó, chúng ta chuyển index thành query engine để thực hiện RAG (retrieval augmented generation) cơ bản, kết hợp truy xuất và mô hình AI để tạo câu trả lời có ngữ cảnh.

from llama_index.core import VectorStoreIndex

index = VectorStoreIndex.from_documents(de_tools_blog)
query_engine = index.as_query_engine(similarity_top_k=3)

response = query_engine.query("How many tools are there?")
print(response)Được hỗ trợ bởi

RAG chat engine có lịch sử

Giờ chúng ta sẽ tạo RAG chat engine có lịch sử. Việc thêm lịch sử sẽ cho phép chat engine ghi nhớ cả tin nhắn của người dùng và phản hồi đã tạo, từ đó cung cấp câu trả lời theo ngữ cảnh.

Để xây dựng ứng dụng này, chúng ta cần tạo ChatMemoryBuffer 3.900 token và cung cấp nó cho chat engine cùng với retriever và đối tượng LLM.

Khi bạn đặt câu hỏi, chat engine sẽ dùng tài liệu PDF và các tin nhắn trước đó làm ngữ cảnh và phản hồi phù hợp.

from llama_index.core.memory import ChatMemoryBuffer
from llama_index.core.chat_engine import CondensePlusContextChatEngine

memory = ChatMemoryBuffer.from_defaults(token_limit=3900)

chat_engine = CondensePlusContextChatEngine.from_defaults(    
   index.as_retriever(),    
   memory=memory,    
   llm=llm
)

response = chat_engine.chat(    
   "What tools are suitable for data processing?"
)
print(str(response))Được hỗ trợ bởi

Chúng ta đã hỏi các câu chung chung, và hệ thống đã tìm trong tài liệu về các công cụ xử lý dữ liệu rồi cung cấp danh sách. Tất cả công cụ đều được nêu trong bài blog.

Hãy hỏi một câu tiếp theo để kiểm tra phần ghi nhớ của chat engine.

response = chat_engine.chat(
    "Can you create a diagram of a data pipeline using these tools?"
)
print(str(response))Được hỗ trợ bởi

Chat engine đã ghi nhớ cuộc trò chuyện trước đó và phản hồi tương ứng. 

Toàn bộ mã chúng ta dùng có ở notebook DataLab này: Groq Cloud API — DataLab.

Kết luận

Groq LPU inference engine là một bước ngoặt trong AI. Trong khi các ông lớn như OpenAI và Google tập trung phát triển LLM chất lượng cao, Groq giúp các mô hình này nhanh hơn. Dù còn mới mẻ trong lĩnh vực AI, Groq đang tạo ra những làn sóng đáng kể trong cộng đồng.

Trong bài viết này, chúng ta đã tìm hiểu về Groq LPU inference engine, khám phá Groq Cloud, và tích hợp Groq API vào VSCode và ứng dụng Jan AI. Ngoài ra, chúng ta đã đi sâu vào gói Groq Python với các ví dụ mã và học cách xây dựng ứng dụng AI nhận biết ngữ cảnh có thể học từ lịch sử trò chuyện và tài liệu PDF.

Bước tiếp theo trong hành trình học tập của bạn có thể là fine-tune LLM trên bộ dữ liệu tuỳ chỉnh. Bạn có thể học cách thực hiện qua hướng dẫn này: Fine-tuning Google Gemma: Nâng cao LLM với hướng dẫn tuỳ chỉnh.