Una guía paso a paso para alimentar su aplicación con LLMS

Si Genai es solo exagerado o ruido externo. También pensé que esto era exagerado, y podía sentarme a este hasta que el polvo se limpió. Oh, chico, me equivocé. Genai tiene aplicaciones del mundo real. También genera ingresos para las empresas, por lo que esperamos que las empresas inviertan mucho en la investigación. Cada vez que una tecnología interrumpe algo, el proceso generalmente se mueve a través de las siguientes fases: negación, ira y aceptación. Lo mismo sucedió cuando se introdujeron las computadoras. Si trabajamos en el campo de software o hardware, es posible que necesitemos usar Genai en algún momento.

En este artículo, cubro cómo alimentar su aplicación con modelos de idiomas grandes (LLMS) y discuta los desafíos que enfrenté al configurar LLM. Comencemos.

1. Comience definiendo su caso de uso claramente

Antes de saltar a LLM, debemos hacernos algunas preguntas

a. ¿Qué problema resolverá mi LLM?
b. ¿Puede mi aplicación hacer sin LLM?
do. ¿Tengo suficientes recursos y calcular energía para desarrollar e implementar esta aplicación?

Reduzca su caso de uso y documente. En mi caso, estaba trabajando en una plataforma de datos como servicio. Tuvimos toneladas de información sobre wikis, holgueros, canales de equipo, etc. Queríamos que un chatbot leyera esta información y responda preguntas en nuestro nombre. El chatbot respondería las preguntas y solicitudes de los clientes en nuestro nombre, y si los clientes aún estuvieran infelices, serían enrutados a un ingeniero.

2. Elige tu modelo

Tiene dos opciones: entrenar su modelo desde cero o usar un modelo previamente capacitado y construir sobre él. Este último funcionaría en la mayoría de los casos a menos que tenga un caso de uso particular. Capacitar a su modelo desde cero requerirá una potencia informática masiva, esfuerzos significativos de ingeniería y costos, entre otras cosas. Ahora, la siguiente pregunta es, ¿qué modelo previamente capacitado debería elegir? Puede seleccionar un modelo basado en su caso de uso. El modelo de parámetros 1B tiene conocimientos básicos y coincidencia de patrones. Los casos de uso pueden ser reseñas de restaurantes. El modelo de parámetros 10B tiene un excelente conocimiento y puede seguir instrucciones como un chatbot de orden de alimentos. Un modelo de parámetros 100B+ tiene un rico conocimiento mundial y un razonamiento complejo. Esto se puede usar como un compañero de lluvia de ideas. Hay muchos modelos disponibles, como Llama y Chatgpt. Una vez que tenga un modelo en su lugar, puede expandirse en el modelo.

3. Mejore el modelo según sus datos

Una vez que tenga un modelo en su lugar, puede expandirse en el modelo. El modelo LLM está capacitado en datos generalmente disponibles. Queremos entrenarlo en nuestros datos. Nuestro modelo necesita más contexto para proporcionar respuestas. Supongamos que queremos construir un chatbot de restaurante que responda las preguntas del cliente. El modelo no conoce información particular de su restaurante. Entonces, queremos proporcionar al modelo algunos contexto. Hay muchas maneras en que podemos lograr esto. Vamos a sumergirnos en algunos de ellos.

Ingeniería rápida

La ingeniería rápida implica aumentar el mensaje de entrada con más contexto durante el tiempo de inferencia. Usted proporciona contexto en su cita de entrada misma. Este es el más fácil de hacer y no tiene mejoras. Pero esto viene con sus desventajas. No puede dar un gran contexto dentro del aviso. Hay un límite para el mensaje de contexto. Además, no puede esperar que el usuario siempre proporcione un contexto completo. El contexto podría ser extenso. Esta es una solución rápida y fácil, pero tiene varios limitaciones. Aquí hay una muestra de ingeniería rápida.

“Clasifica esta revisión
Amo la película
Sentimiento: positivo

Clasificar esta revisión
Odiaba la película.
Sentimiento: negativo

Clasificar la película
El final fue emocionante “

Aprendizaje reforzado con comentarios humanos (RLHF)

RLHF es uno de los métodos más utilizados para integrar LLM en una aplicación. Proporciona algunos datos contextuales para que el modelo aprenda. Aquí está el flujo que sigue: el modelo toma una acción del espacio de acción y observa el cambio de estado en el entorno como resultado de esa acción. El modelo de recompensa generó una clasificación de recompensa basada en la salida. El modelo actualiza su peso en consecuencia para maximizar la recompensa y aprende iterativamente. Por ejemplo, en LLM, la acción es la siguiente palabra que genera el LLM, y el espacio de acción es el diccionario de todas las palabras y vocabulario posibles. El entorno es el contexto de texto; El estado es el texto actual en la ventana de contexto.

La explicación anterior es más como una explicación del libro de texto. Echemos un vistazo a un ejemplo de la vida real. Desea que su chatbot responda preguntas sobre sus documentos wiki. Ahora, elige un modelo previamente capacitado como ChatGPT. Sus wikis serán sus datos de contexto. Puedes aprovechar el langchain Biblioteca para realizar trapo. Puede aquí hay un código de muestra en Python

from langchain.document_loaders import WikipediaLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA

import os

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "your-openai-key-here"

# Step 1: Load Wikipedia documents
query = "Alan Turing"
wiki_loader = WikipediaLoader(query=query, load_max_docs=3)
wiki_docs = wiki_loader.load()

# Step 2: Split the text into manageable chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
split_docs = splitter.split_documents(wiki_docs)

# Step 3: Embed the chunks into vectors
embeddings = OpenAIEmbeddings()
vector_store = FAISS.from_documents(split_docs, embeddings)

# Step 4: Create a retriever
retriever = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 3})

# Step 5: Create a RetrievalQA chain
llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",  # You can also try "map_reduce" or "refine"
    retriever=retriever,
    return_source_documents=True,
)

# Step 6: Ask a question
question = "What did Alan Turing contribute to computer science?"
response = qa_chain(question)

# Print the answer
print("Answer:", response["result"])
print("\n--- Sources ---")
for doc in response["source_documents"]:
    print(doc.metadata)

4. Evalúa tu modelo

Ahora, has agregado trapo a tu modelo. ¿Cómo verifica si su modelo se está comportando correctamente? Este no es un código en el que proporcione algunos parámetros de entrada y reciba una salida fija, con la que puede probar. Dado que esta es una comunicación basada en el lenguaje, puede haber múltiples correctos respuestas. Pero lo que puede saber con certeza es si la respuesta es incorrecta. Hay muchas métricas con las que puede probar su modelo.

Evaluar manualmente

Puede evaluar continuamente su modelo manualmente. Por ejemplo, habíamos integrado un chatbot Slack que se mejoró con Rag usando nuestros wikis y Jira. Una vez que agregamos el chatbot al canal Slack, inicialmente sombreamos sus respuestas. Los clientes no pudieron ver las respuestas. Una vez que ganamos confianza, hicimos el chatbot visible públicamente para los clientes. Evaluamos su respuesta manualmente. Pero este es un enfoque rápido y vago. No puede ganar confianza de tales pruebas manuales. Entonces, la solución es probar con algún punto de referencia, como Rouge.

Evaluar con la puntuación Rouge.

Las métricas de Rouge se utilizan para el resumen de texto. Las métricas de Rouge comparan el resumen generado con resúmenes de referencia utilizando diferentes métricas de Rouge. Las métricas de Rouge evalúan el modelo utilizando puntajes de recuperación, precisión y F1. Las métricas de Rouge vienen en varios tipos, y la mala finalización aún puede dar como resultado una buena puntuación; Por lo tanto, nos referimos a diferentes métricas de Rouge. Para algún contexto, un unigram es una sola palabra; Un bigram es dos palabras; y un n-gram es n palabras.

ROUGE-1 RECORT = Unigram Matches/Unigram en referencia
Rouge-1 Precision = unigram coincidencias/unigram en salida generada
Rouge-1 f1 = 2 * (recordar * precisión / (recuperación + precisión))
ROUGE-2 RECINTO = BigRam Matches/BigRam Reference
Rouge-2 Precision = BigRam Matches / BigRam en salida generada
Rouge-2 f1 = 2 * (recordar * precisión / (recuperación + precisión))
ROUGE-L RECORT = Subsecuencia común más larga/unigram en referencia
Rouge-L Precision = subsecuencia común más larga/unigram en la producción
Rouge-L F1 = 2 * (RECORT * Precision / (RetRark + Precision))

Por ejemplo,

Referencia: “Hace frío afuera”.
Salida generada: “Hace mucho frío afuera”.

ROUGE-1 RECORTO = 4/4 = 1.0
Rouge-1 Precision = 4/5 = 0.8
Rouge-1 F1 = 2 * 0.8/1.8 = 0.89
RUGE-2 RECUERTO = 2/3 = 0.67
Rouge-2 Precision = 2/4 = 0.5
Rouge-2 F1 = 2 * 0.335/1.17 = 0.57
ROUGE-L RECORT = 2/4 = 0.5
Rouge-L Precision = 2/5 = 0.4
Rouge-L F1 = 2 * 0.335/1.17 = 0.44

Reducir la molestia con el punto de referencia externo

La puntuación Rouge se utiliza para comprender cómo funciona la evaluación del modelo. Existen otros puntos de referencia, como la puntuación Bleu. Sin embargo, no podemos construir prácticamente el conjunto de datos para evaluar nuestro modelo. Podemos aprovechar las bibliotecas externas para comparar nuestros modelos. Los más utilizados son el Punto de referencia de pegamento y Punto de referencia de superpeglue.

5. Optimizar e implementar su modelo

Es posible que este paso no sea crucial, pero reducir los costos informáticos y obtener resultados más rápidos siempre es bueno. Una vez que su modelo esté listo, puede optimizarlo para mejorar el rendimiento y reducir los requisitos de memoria. Tocaremos algunos conceptos que requieren más esfuerzos de ingeniería, conocimiento, tiempo y costos. Estos conceptos lo ayudarán a familiarizarse con algunas técnicas.

Cuantización de los pesos

Los modelos tienen parámetros, variables internas dentro de un modelo que se aprenden de los datos durante el entrenamiento y cuyos valores determinan cómo el modelo hace predicciones. 1 Parámetro generalmente requiere 24 bytes de memoria del procesador. Entonces, si elige 1B, los parámetros requerirán 24 GB de memoria del procesador. La cuantización convierte los pesos del modelo de números de punto flotante de mayor precisión a números de punto flotante de menor precisión para un almacenamiento eficiente. Cambiar la precisión de almacenamiento puede afectar significativamente el número de bytes necesarios para almacenar un solo valor del peso. La siguiente tabla ilustra diferentes precisiones para almacenar pesos.

Poda

La poda implica eliminar pesos en un modelo que son menos importantes y que tengan poco impacto, como pesos iguales o cercanos a cero. Algunas técnicas de poda son
a. Ventrimiento completo de modelos
b. Peft como Lora
do. Post-entrenamiento.

Conclusión

Para concluir, puede elegir un modelo previamente capacitado, como ChatGPT o Flan-T5, y construir sobre él. Construir su modelo previamente capacitado requiere experiencia, recursos, tiempo y presupuesto. Puede ajustarlo en lo que respecta a su caso de uso si es necesario. Luego, puede usar su LLM para alimentar aplicaciones y adaptarlas al caso de uso de su aplicación utilizando técnicas como RAG. Puede evaluar su modelo en algunos puntos de referencia para ver si se comporta correctamente. Luego puede implementar su modelo.