Com tantos LLMs sendo lançados, muitas empresas estão se concentrando em aumentar as velocidades de inferência de modelos de linguagem grandes com hardware especializado e otimizações para poder dimensionar os recursos de inferência desses modelos. Uma dessas empresas que está fazendo grandes avanços nesse espaço é a Groq.
Nesta postagem do blog, exploraremos o Groq e como integrar os recursos rápidos de inferência LLM do Groq com o Couchbase Vector Search para criar aplicativos RAG rápidos e eficientes. Também compararemos o desempenho de diferentes soluções LLM, como OpenAI e Gemini, e como elas se comparam às velocidades de inferência do Groq.
O que é o Groq?
A Groq, Inc. é uma empresa americana de tecnologia especializada em inteligência artificial, particularmente conhecida por seu desenvolvimento da Unidade de Processamento de Linguagem (LPU), um circuito integrado de aplicativo específico (ASIC) projetado para acelerar as tarefas de inferência de IA. Ele foi projetado especificamente para aprimorar Modelos de linguagem grandes (LLMs) com recursos de inferência de latência ultrabaixa. As APIs do Groq Cloud permitem que os desenvolvedores integrem LLMs de última geração, como o Llama3 e o Mixtral 8x7B, em seus aplicativos.
O que isso significa para os desenvolvedores? Significa que as APIs do Groq podem ser perfeitamente integradas a aplicativos que exigem processamento de IA em tempo real com necessidades de inferência rápida.
Como começar a usar as APIs do Groq
Para aproveitar o poder das APIs do Groq, a primeira etapa é gerar uma chave de API. Esse é um processo simples que começa com a inscrição no console do Groq Cloud.
Depois de se inscrever, navegue até a página Chaves de API seção. Aqui, você terá a opção de criar uma nova chave de API.
A chave de API permitirá que você integre modelos de linguagem grandes e de última geração, como Llama3 e Mixtral em seus aplicativos. Em seguida, integraremos o modelo de bate-papo do Groq com LangChain em nosso aplicativo.
Usando o Groq como LLM
Você pode aproveitar a API do Groq como um dos provedores de LLM no LangChain:
|
1 2 3 4 5 6 |
from langchain_groq import ChatGroq llm = ChatGroq( temperature=0.3, model_name="mixtral-8x7b-32768", ) |
Quando você instanciar o ChatGroq você pode passar a temperatura e o nome do modelo. Você pode dar uma olhada no objeto modelos atualmente suportados no Groq.
Criação de aplicativo RAG com Couchbase e Groq
O objetivo é criar um aplicativo de bate-papo que permita aos usuários fazer upload de PDFs e conversar com eles. Usaremos o Couchbase Python SDK e o Streamlit para facilitar o upload de PDFs para o Couchbase VectorStore. Além disso, exploraremos como usar o RAG para responder a perguntas baseadas em contexto a partir de PDFs, tudo isso com a tecnologia Groq.
Você pode seguir as etapas mencionadas em este tutorial sobre como configurar um aplicativo Streamlit RAG alimentado pelo Couchbase Vector Search. Neste tutorial, usamos o Gemini como LLM. Substituiremos a implementação do Gemini pelo Groq.
Comparação do desempenho do Groq
Neste blog, também comparamos o desempenho de diferentes provedores de LLM. Para isso, criamos um menu suspenso para que o usuário possa selecionar o provedor de LLM que deseja usar para o aplicativo RAG. Neste exemplo, estamos usando Gemini, OpenAI, Ollama e Groq como os diferentes provedores de LLM. Há um grande lista de provedores de LLM suportados pelo LangChain.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
st.sidebar.subheader("Select LLM") llm_choice = st.sidebar.selectbox( "Select LLM", [ "OpenAI", "Groq", "Gemini", "Ollama" ] ) if llm_choice == "Gemini": check_environment_variable("GOOGLE_API_KEY") llm = GoogleGenerativeAI( temperature=0.3, model="models/gemini-1.5-pro", ) llm_without_rag = GoogleGenerativeAI( temperature=0, model="models/gemini-1.5-pro", ) elif llm_choice == "Groq": check_environment_variable("GROQ_API_KEY") llm = ChatGroq( temperature=0.3, model_name="mixtral-8x7b-32768", ) llm_without_rag = ChatGroq( temperature=0, model_name="mixtral-8x7b-32768", ) elif llm_choice == "OpenAI": check_environment_variable("OPENAI_API_KEY") llm = ChatOpenAI( temperature=0.3, model="gpt-3.5-turbo", ) llm_without_rag = ChatOpenAI( temperature=0, model="gpt-3.5-turbo", ) elif llm_choice == "Ollama": llm = Ollama( temperature=0.3, model = ollama_model, base_url = ollama_url ) llm_without_rag = Ollama( temperature=0, model = ollama_model, base_url = ollama_url ) |
Para destacar a velocidade de inferência rápida do Groq, criamos uma maneira de calcular o tempo de inferência para a resposta LLM. Isso mede e registra o tempo gasto para cada geração de resposta. Os resultados são exibidos em uma tabela na barra lateral, mostrando o modelo usado e o tempo gasto para cada consulta, comparando diferentes provedores de LLM, como OpenAI, Ollama, Gemini e Groq; por meio dessas comparações, verificou-se que o LLM da Groq forneceu consistentemente os tempos de inferência mais rápidos. Essa referência de desempenho permite que os usuários vejam a eficiência de vários modelos em tempo real.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
if question := st.chat_input("Ask a question based on the PDF"): # Start timing start_time = time.time() # Display user message in chat message container st.chat_message("user").markdown(question) # Add user message to chat history st.session_state.messages.append( {"role": "user", "content": question, "avatar": "👤"} ) # Add placeholder for streaming the response with st.chat_message("assistant", avatar=couchbase_logo): message_placeholder = st.empty() # stream the response from the RAG rag_response = "" for chunk in chain.stream(question): rag_response += chunk message_placeholder.markdown(rag_response + "▌") message_placeholder.markdown(rag_response) st.session_state.messages.append( { "role": "assistant", "content": rag_response, "avatar": couchbase_logo, } ) # stream the response from the pure LLM with st.chat_message("ai", avatar="🤖"): message_placeholder_pure_llm = st.empty() pure_llm_response = "" for chunk in chain_without_rag.stream(question): pure_llm_response += chunk message_placeholder_pure_llm.markdown(pure_llm_response + "▌") message_placeholder_pure_llm.markdown(pure_llm_response) st.session_state.messages.append( { "role": "assistant", "content": pure_llm_response, "avatar": "🤖", } ) # End timing and calculate duration end_time = time.time() duration = end_time - start_time # Display the time taken st.write(f"Time taken to generate complete output: {duration:.2f} seconds") st.session_state.query_results.append({ "model": llm_choice, "time": duration }) st.sidebar.subheader("Query Results") table_header = "| Model | Time (s) |\n| --- | --- |\n" # create table rows table_rows = "" for idx, result in enumerate(st.session_state.query_results, 1): table_rows += f"| {result['model']} | {result['time']:.2f} |\n" table = table_header + table_rows st.sidebar.markdown(table, unsafe_allow_html=True) if st.sidebar.button("Clear Results"): st.session_state.query_results = [] st.experimental_rerun() |
Como você pode ver nos resultados, a velocidade de inferência do Groq é a mais rápida em comparação com os outros provedores de LLM.
Conclusão
A LangChain é uma excelente estrutura de código aberto que oferece muitas opções possíveis para armazenamentos de vetores e LLM de sua escolha para criar aplicativos com tecnologia de IA. O Groq está na vanguarda por ser um dos mecanismos de inferência LLM mais rápidos e combina bem com aplicativos alimentados por IA que precisam de inferência rápida e em tempo real. Assim, com o poder de inferência rápida do Groq e do Couchbase Vector Search, você pode criar aplicativos RAG prontos para produção e dimensionáveis.
-
- Comece a usar o Capella hoje mesmo, de graça
- Saiba mais sobre pesquisa vetorial
