# Introducción
Los potentes modelos de lenguaje como GPT3.5-turbo y GPT4 han revolucionado el desarrollo de aplicaciones, lo que ha resultado en un aumento de las aplicaciones específicas de dominio. Aplicaciones destacadas como PandaGPT y GiftWarp ejemplifican las capacidades de estos modelos. Lo que distingue a estas aplicaciones es su excepcional manejo de datos. PandaGPT, por ejemplo, recupera información de cientos de documentos PDF de manera fluida. Esto posiciona a PandaGPT para tener éxito en el competitivo mercado de aplicaciones.
Para garantizar la longevidad, los emprendedores deben priorizar la escalabilidad del procesamiento de datos. A medida que las aplicaciones ganan popularidad, el manejo eficiente de datos se vuelve crucial. Una infraestructura sólida y sistemas escalables son esenciales para gestionar cargas de datos cada vez mayores. Al abordar los cuellos de botella y planificar una expansión fluida, los emprendedores posicionan sus aplicaciones para el crecimiento y la satisfacción del usuario.
Adoptar un enfoque basado en datos ofrece oportunidades sin precedentes. Con modelos de lenguaje como GPT3.5-turbo y GPT4, los desarrolladores desbloquean el potencial de innovaciones revolucionarias y experiencias de usuario excepcionales. Al aprovechar el poder de estos modelos, el desarrollo de aplicaciones alcanza nuevas alturas. El futuro radica en soluciones basadas en datos y en el aprovechamiento de modelos de lenguaje avanzados para experiencias transformadoras.
# Planificación de la escalabilidad desde el principio
Con la ayuda de la API de OpenAI, podemos crear fácilmente un chatbot de servicio al cliente utilizando GPT y una pequeña cantidad de datos de productos. Al utilizar GPT para analizar las indicaciones, podemos buscar de manera eficiente elementos en una lista dada y obtener resultados impresionantes. Aquí tienes un ejemplo:
import os
import openai
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv()) # leer archivo .env local
openai.api_key = os.environ['OPENAI_API_KEY']
delimiter = "####"
system_message = f"""
Follow these steps to answer the customer queries.
The customer query will be delimited with four hashtags,
i.e. {delimiter}.
Step 1:{delimiter} First decide whether the user is
asking a question about a specific product or products.
Product cateogry doesn't count.
Step 2:{delimiter} If the user is asking about
specific products, identify whether
the products are in the following list.
All available products:
1. Product: TechPro Ultrabook
Category: Computers and Laptops
Brand: TechPro
Model Number: TP-UB100
Warranty: 1 year
Rating: 4.5
Features: 13.3-inch display, 8GB RAM, 256GB SSD, Intel Core i5 processor
Description: A sleek and lightweight ultrabook for everyday use.
Price: $799.99
2. Product: BlueWave Gaming Laptop
Category: Computers and Laptops
Brand: BlueWave
Model Number: BW-GL200
Warranty: 2 years
Rating: 4.7
Features: 15.6-inch display, 16GB RAM, 512GB SSD, NVIDIA GeForce RTX 3060
Description: A high-performance gaming laptop for an immersive experience.
Price: $1199.99
3. Product: PowerLite Convertible
Category: Computers and Laptops
Brand: PowerLite
Model Number: PL-CV300
Warranty: 1 year
Rating: 4.3
Features: 14-inch touchscreen, 8GB RAM, 256GB SSD, 360-degree hinge
Description: A versatile convertible laptop with a responsive touchscreen.
Price: $699.99
......
Step 3:{delimiter} If the message contains products
in the list above, list any assumptions that the
user is making in their
message e.g. that Laptop X is bigger than
Laptop Y, or that Laptop Z has a 2 year warranty.
Step 4:{delimiter}: If the user made any assumptions,
figure out whether the assumption is true based on your
product information.
Step 5:{delimiter}: First, politely correct the
customer's incorrect assumptions if applicable.
Only mention or reference products in the list of
5 available products, as these are the only 5
products that the store sells.
Answer the customer in a friendly tone.
Use the following format:
Step 1:{delimiter} <step 1 reasoning>
Step 2:{delimiter} <step 2 reasoning>
Step 3:{delimiter} <step 3 reasoning>
Step 4:{delimiter} <step 4 reasoning>
Response to user:{delimiter} <response to customer>
Make sure to include {delimiter} to separate every step.
"""
user_message = f"""
how much is the BlueWave Chromebook more expensive
than the TechPro Desktop"""
messages = [
{'role':'system',
'content': system_message},
{'role':'user',
'content': f"{delimiter}{user_message}{delimiter}"},
]
response = get_completion_from_messages(messages)
print(response)
Si una startup tiene como objetivo desarrollar un chatbot de servicio al cliente que incorpore multimodalidad y utilice un conjunto de datos más grande, es necesario utilizar una base de datos vectorial para satisfacer sus necesidades. Implementar una base de datos vectorial en esta etapa es crucial para un almacenamiento y recuperación efectivos de datos.
Para lograr este objetivo, podemos aprovechar una base de datos vectorial diseñada específicamente para manejar datos de alta dimensionalidad, incluida información multimodal. Con una base de datos vectorial, podemos almacenar e indexar vectores que representan diferentes aspectos de los datos de servicio al cliente, como texto, imágenes o incluso audio.
Por ejemplo, cuando un cliente envía una consulta al chatbot, el sistema puede utilizar técnicas de procesamiento del lenguaje natural para convertir el texto en una representación vectorial. Esta representación vectorial se puede utilizar luego para buscar en la base de datos vectorial las respuestas relevantes. Además, si el chatbot es capaz de manejar imágenes o entradas de audio, esas entradas también se pueden convertir en representaciones vectoriales y almacenarse en la base de datos.
La base de datos vectorial indexa eficientemente los vectores, lo que permite una recuperación rápida de información relevante. Al utilizar algoritmos de búsqueda avanzados como la búsqueda del vecino más cercano, el chatbot puede identificar las respuestas más apropiadas en función de las métricas de similitud entre la consulta del usuario y los vectores almacenados en la base de datos.
A medida que el conjunto de datos se expande, la base de datos vectorial garantiza la escalabilidad y el almacenamiento eficiente de datos multimodales. Simplifica el proceso de actualización y adición al conjunto de datos, lo que permite que el chatbot mejore continuamente su rendimiento y proporcione respuestas precisas y relevantes a las consultas de los clientes.
# Equilibrando la escalabilidad con la eficiencia de costos
Las startups también deben considerar la eficiencia de costos al lograr la escalabilidad. Estructurar y preprocesar los datos para extraer características y atributos relevantes puede ayudar a reducir los requisitos de almacenamiento y procesamiento, minimizando los costos. Aprovechar herramientas y marcos existentes que ofrecen capacidades multimodales también puede ahorrar tiempo y recursos valiosos. Estos recursos suelen venir con estructuras de datos y algoritmos optimizados, lo que elimina la necesidad de construir todo desde cero.
Cuando se trata de elegir una base de datos, las startups deben considerar MyScale como una solución rentable. MyScale es una base de datos vectorial densa y eficiente en costos que ofrece un alto rendimiento a un costo menor en comparación con otras opciones. Al implementar estrategias como la estructuración y el preprocesamiento de datos, aprovechar herramientas y marcos existentes y considerar soluciones rentables como MyScale, las startups pueden encontrar un equilibrio entre la escalabilidad y la eficiencia de costos. Estos enfoques optimizan el rendimiento al aprovechar al máximo los recursos disponibles, lo que permite a las startups crecer y tener éxito de manera rentable.
# Estudios de caso y mejores prácticas
Aquí, proporcionaremos una breve introducción sobre cómo utilizar MyScale para escalar rápidamente un chatbot de servicio al cliente multimodal. Para este propósito, hemos utilizado un conjunto de datos simplificado derivado de Taobao Live (opens new window).
# Instalación de los requisitos previos
transformers: Ejecución del modelo CLIPtqdm: Barra de progreso visualmente atractiva para humanosclickhouse-connect: Cliente de base de datos MyScale
python3 -m pip install transformers tqdm clickhouse-connect streamlit pandas lmdb torch
# Accediendo a los datos
Primero, examinemos la estructura de los conjuntos de datos, hemos dividido los datos en dos tablas.
| id | product_url | label |
|---|---|---|
| 102946 | url_to_store_the image | Men's Long Sleeve Shirt |
El conjunto de datos consta de tres columnas: ID del producto, imagen del producto y etiqueta. La primera columna sirve como identificador único para cada imagen de producto. La segunda columna contiene la URL que lleva a la imagen. La tercera columna es la etiqueta del producto. Aquí tienes un ejemplo de la columna product_url mencionada anteriormente:
| id | product_text | label |
|---|---|---|
| 102946 | POOF C(1's)I MOCK NECK POCKET TEE | Men's Long Sleeve Shirt |
# Creación de una tabla de base de datos MyScale
# Trabajando con la base de datos
Necesitas una conexión a un backend de base de datos para crear una tabla en MyScale. Puedes consultar la guía detallada para el cliente de Python en esta página (opens new window).
Si estás familiarizado con SQL (Structured Query Language), te resultará mucho más fácil trabajar con MyScale. MyScale combina la consulta estructurada con la búsqueda vectorial, lo que significa que crear una base de datos vectorial es casi lo mismo que crear bases de datos convencionales. Y así es como creamos dos tablas vectoriales en SQL:
CREATE TABLE IF NOT EXISTS TaoBaoData_image(
id String,
vector Array(Float32),
CONSTRAINT vec_len CHECK length(vector) = 512
) ENGINE = MergeTree ORDER BY id;
CREATE TABLE IF NOT EXISTS TaoBaoData_text(
id String,
vector Array(Float32),
CONSTRAINT vec_len CHECK length(vector) = 512
) ENGINE = MergeTree ORDER BY id;
# Extracción de características y llenado de la base de datos
CLIP (opens new window) es un método popular que relaciona datos de diferentes formas (adoptamos el término académico "modalidad") en un espacio unificado, lo que permite una recuperación intermodal de alto rendimiento. Este modelo puede codificar tanto imágenes como texto. Aquí tienes un ejemplo:
import torch
import clip
from PIL import Image
# Cargar el modelo CLIP
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)
# Cargar y preprocesar la imagen
ruta_imagen = "path_to_your_image.jpg"
image = Image.open(image_path).convert("RGB")
image_input = preprocess(image).unsqueeze(0).to(device)
# Codificar la imagen
with torch.no_grad():
image_features = model.encode_image(image_input)
# Codificar el texto
texto = "Your text here""
text_input = clip.tokenize([text]).to(device)
with torch.no_grad():
text_features = model.encode_text(text_input)
# Imprimir las características de la imagen y el texto
print("Image features shape:", image_features.shape)
print("Text features shape:", text_features.shape)
# Cargar datos en MyScale
Una vez que los datos se han procesado en vectores, procedemos a cargar los datos en MyScale.
# cargar datos de los conjuntos de datos
client.insert("TaoBaoData_image",
data_image.to_records(index=False).tolist(),
column_names=data_image.columns.tolist())
client.insert("TaoBaoData_text",
data_text.to_records(index=False).tolist(),
column_names=data_text.columns.tolist())
# crear índice vectorial con coseno
client.command("""
ALTER TABLE TaoBaoData_image
ADD VECTOR INDEX image_feature_index feature
TYPE MSTG
('metric_type=Cosine')
""")
client.command("""
ALTER TABLE TaoBaoData_text
ADD VECTOR INDEX text_feature_index feature
TYPE MSTG
('metric_type=Cosine')
""")
# Búsqueda con MyScale
Cuando un usuario ingresa una pregunta, convertimos su pregunta en un vector y realizamos una búsqueda en la base de datos. Este proceso de búsqueda nos ayuda a obtener las mejores K imágenes de productos y sus descripciones de productos correspondientes. Luego pasamos estas descripciones de productos al modelo GPT, que refina aún más las recomendaciones y proporciona introducciones de productos más detalladas. Además, en el resultado final de la conversación, también incluimos la visualización de imágenes de productos al usuario.
Codificar la pregunta:
question = 'Do you have any black dress for women?'
emb_query = retriever.encode(question).tolist()
Buscar en el conjunto de datos TaoBaoData_text, devolver la información de los 2 mejores productos:
top_k = 2
results = client.query(f"""
SELECT id, product_text, distance(vector, {emb_query}) as dist
FROM TaoBaoData_text
ORDER BY dist LIMIT {top_k}
""")
summaries = {'id': [], 'product_text': []}
for res in results.named_results():
summaries['product_text'].append(res["product_text"])
summaries['id'].append(res["id"])
Ahora tenemos una dist como la siguiente:
{'id':['065906','104588'],
'product_text': ['Plus Size Womens Autumn New Arrival Elegant Temperament 2019 Concealing Belly Fashionable Mid-length Lace Dress.'
'2019 Summer New Arrival High-end Asymmetrical Shoulder Strap Chic Slimming Daily V-neck Dress for Women, Trendy.']}
Después de eso, podemos pasar esta lista nuevamente a GPT4 a través de la API de OpenAI como se mencionó al principio, aquí tienes un ejemplo:
system_message = f"""
Based on the user's question, we have retrieved two items with the
following information. provide recommendations for these two items based on
the product text.
{summaries}
If the user requests to see the style, please return the corresponding
product IDs.
"""
Cuando tenemos el ID del producto, podemos buscar en el conjunto de datos TaoBaoData_image para obtener las imágenes de la siguiente manera:
results = client.query(f"""
SELECT id, product_url,
FROM TaoBaoData_image
WHERE id IN {summaries['id']}
""")
| 65906 | 104588 |
|---|---|
 |  |
Ahora podemos devolver este resultado al usuario para ayudarlo a tomar decisiones e interactuar más.
Un pipeline similar también se puede utilizar para la recuperación de imágenes, por ejemplo, si un usuario desea encontrar ropa similar a la que se muestra en una imagen, podemos utilizar incrustaciones de imágenes para la recuperación.
# Conclusión
MyScale puede manejar eficientemente datos multimodales, proporcionando a las startups una solución rentable. Al integrar diferentes modalidades y optimizar el uso de recursos, MyScale mejora las capacidades de servicio al cliente sin costos significativos. Este enfoque permite a las startups asignar recursos de manera eficiente, centrándose en aspectos críticos de su negocio. La escalabilidad y la eficiencia de costos son vitales para el éxito de las startups, garantizando un crecimiento sostenible y maximizando el retorno de la inversión. Las fortalezas de MyScale en el procesamiento de datos multimodales permiten a las startups escalar mientras mantienen la eficiencia de costos. Adoptar MyScale potencia a las startups para administrar los recursos de manera inteligente y prosperar en el mercado competitivo.
