Actualmente, tres temas de tendencia en la implementación de AI son LLMS, TRAPOy bases de datos. Estos nos permiten crear sistemas adecuados y específicos para nuestro uso. Este sistema impulsado por IA, que combina una saco de datos vectorial y respuestas generadas por IA, tiene aplicaciones en varias industrias. En la atención al cliente, los chatbots de IA recuperan las respuestas de la saco de conocimiento dinámicamente. Los sectores justo y financiero se benefician de la epítome de documentos y la investigación de casos impulsados por la IA. Los asistentes de IA de la vitalidad ayudan a los médicos con investigación médica e interacciones de drogas. Las plataformas de educación electrónico brindan capacitación corporativa personalizada. El periodismo utiliza IA para epítome de parte y comprobación de hechos. El exposición de software aprovecha la IA para la afluencia de codificación y la depuración. La investigación científica se beneficia de las revisiones de letras impulsadas por la IA. Este enfoque progreso la recuperación del conocimiento, automatiza la creación de contenido y personaliza las interacciones del usufructuario en múltiples dominios.
En este tutorial, crearemos un tutor de inglés con AI usando trapo. El sistema integra una saco de datos vectorial (ChromAdB) para juntar y recuperar materiales de educación de idioma inglés relevantes y reproducción de texto con IA (API Groq) para crear lecciones estructuradas y atractivas. El flujo de trabajo incluye extraer texto de PDFS, juntar conocimiento en una saco de datos vectorial, recuperar contenido relevante y originar lecciones detalladas de IA. El objetivo es construir un tutor de inglés interactivo que genera dinámicamente lecciones basadas en temas al tiempo que aprovecha el conocimiento previamente almacenado para una anciano precisión y relevancia contextual.
Paso 1: Instalación de las bibliotecas necesarias
!pip install PyPDF2
!pip install groq
!pip install chromadb
!pip install sentence-transformers
!pip install nltk
!pip install fpdf
!pip install torchPYPDF2 extrae texto de archivos PDF, lo que lo hace útil para manejar información basada en documentos. Groq es una biblioteca que proporciona llegada a la API AI de Groq, que permite capacidades avanzadas de reproducción de texto. ChromAdB es una saco de datos vectorial diseñada para recuperar el texto de forma capaz. Los transformadores de oraciones generan incrustaciones de texto, lo que ayuda a juntar y recuperar la información de forma significativa. NLTK (kit de herramientas de estilo natural) es una biblioteca NLP perfectamente conocida para preprocesamiento de texto, tokenización y examen. FPDF es una biblioteca liviana para crear y manipular documentos PDF, lo que permite que las lecciones generadas se guarden en un formato estructurado. La velón es un ámbito de educación profundo que se usa comúnmente para tareas de educación espontáneo, incluida la reproducción de texto basada en IA.
Paso 2: descarga de datos de tokenización de NLP
import nltk
nltk.download('punkt_tab')El conjunto de datos punkt_tab se descarga utilizando el código antedicho. nltk.download (‘punkt_tab’) obtiene un conjunto de datos requerido para la tokenización de oraciones. La tokenización es dividir el texto en oraciones o palabras, lo cual es crucial para descomponer grandes cuerpos de texto en segmentos manejables para el procesamiento y la recuperación.
Paso 3: Configuración del directorio de datos NLTK
working_directory = os.getcwd()
nltk_data_dir = os.path.join(working_directory, 'nltk_data')
nltk.data.path.append(nltk_data_dir)
nltk.download('punkt_tab', download_dir=nltk_data_dir)Configuraremos un directorio dedicado para los datos NLTK. La función OS.GetCwd () recupera el directorio de trabajo presente, y se crea un nuevo directorio nltk_data internamente de él para juntar capital relacionados con NLP. El comando nltk.data.path.append (nltk_data_dir) garantiza que este directorio almacene los conjuntos de datos NLTK. El conjunto de datos punkt_tab, requerido para la tokenización de oraciones, se descarga y almacena en el directorio especificado.
Paso 4: Importar bibliotecas requeridas
import os
import torch
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.utils import embedding_functions
import numpy as np
import PyPDF2
from fpdf import FPDF
from functools import lru_cache
from groq import Groq
import nltk
from nltk.tokenize import sent_tokenize
import uuid
from dotenv import load_dotenvAquí, importamos todas las bibliotecas necesarias utilizadas en todo el cuaderno. El sistema eficaz se utiliza para las operaciones del sistema de archivos. La velón se importa para manejar tareas relacionadas con el educación profundo. Sentence-Transformers proporciona una forma obvio de originar incrustaciones a partir del texto. ChromAdB y su módulo Ingredding_Functions ayudan a juntar y recuperar el texto relevante. Numpy es una biblioteca matemática utilizada para manejar matrices y cálculos numéricos. PYPDF2 se usa para extraer texto de PDFS. FPDF permite la reproducción de documentos PDF. LRU_CACHE se usa para juntar en gusto las horizontes de la función para la optimización. Groq es un servicio de IA que genera respuestas humanas. NLTK proporciona funcionalidades de NLP, y Sent_Tokenize se importa específicamente para dividir el texto en oraciones. UUID genera IDS únicos, y Load_dotenv Cargue las variables de entorno desde un archivo .env.
Paso 5: Variables de entorno de carga y tecla API
load_dotenv()
api_key = os.getenv('api_key')
os.environ("GROQ_API_KEY") = api_key
#or manually retrieve key from https://console.groq.com/ and add it hereA través del código antedicho, cargaremos variables de entorno desde un archivo .env. La función load_dotenv () lee variables de entorno del archivo .env y las pone a disposición del entorno Python. El API_KEY se recupera usando OS.Getenv (‘API_KEY’), asegurando la trámite de claves API seguras sin codificarla en el script. La secreto se almacena en OS.environ («Groq_api_Key»), lo que lo hace accesible para llamadas API posteriores.
Paso 6: Definición de la clase de saco de datos Vector
class VectorDatabase:
def __init__(self, collection_name="english_teacher_collection"):
self.client = chromadb.PersistentClient(path="./chroma_db")
self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
self.embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
self.collection = self.client.get_or_create_collection(name=collection_name, embedding_function=self.embedding_function)
def add_text(self, text, chunk_size):
sentences = sent_tokenize(text, language="english")
chunks = self._create_chunks(sentences, chunk_size)
ids = (str(uuid.uuid4()) for _ in chunks)
self.collection.add(documents=chunks, ids=ids)
def _create_chunks(self, sentences, chunk_size):
chunks = ()
for i in range(0, len(sentences), chunk_size):
chunk = ' '.join(sentences(i:i+chunk_size))
chunks.append(chunk)
return chunks
def retrieve(self, query, k=3):
results = self.collection.query(query_texts=(query), n_results=k)
return results('documents')(0)Esta clase define una vectordatabase que interactúa con ChromAdB para juntar y recuperar el conocimiento basado en texto. La función __init __ () inicializa la saco de datos, creando un directorio persistente Chroma_DB para el almacenamiento a holgado plazo. El maniquí de SentenceTransformer (All-Minilm-L6-V2) genera incrustaciones de texto, que convierten la información textual en representaciones numéricas que se pueden juntar y inquirir eficientemente. La función add_text () divide el texto de entrada en oraciones y las divide en trozos más pequeños antaño de almacenarlos en la saco de datos Vector. La función _create_chunks () asegura que el texto esté correctamente segmentado, haciendo que la recuperación sea más efectiva. La función Remieve () toma una consulta y devuelve los documentos almacenados más relevantes en función de la similitud.
Paso 7: Implementación de la reproducción de lecciones de IA con Groq
class GroqGenerator:
def __init__(self, model_name="mixtral-8x7b-32768"):
self.model_name = model_name
self.client = Groq()
def generate_lesson(self, topic, retrieved_content):
prompt = f"Create an engaging English lesson about {topic}. Use the following information:n"
prompt += "nn".join(retrieved_content)
prompt += "nnLesson:"
chat_completion = self.client.chat.completions.create(
model=self.model_name,
messages=(
{"role": "system", "content": "You are an AI English teacher designed to create an elaborative and engaging lesson."},
{"role": "user", "content": prompt}
),
max_tokens=1000,
temperature=0.7
)
return chat_completion.choices(0).message.contentEsta clase, GroqGenerator, es responsable de originar lecciones de inglés con IA. Interactúa con el maniquí Groq AI a través de una convocatoria API. La función __init __ () inicializa el alternador utilizando el maniquí mixtral-8x7b-32768, diseñado para IA conversacional. La función Generate_lesson () toma un tema y recuperó el conocimiento como entrada, formatea un mensaje y lo envía a la API Groq para la reproducción de lecciones. El sistema AI devuelve una conferencia estructurada con explicaciones y ejemplos, que luego se pueden juntar o mostrar.
Paso 8: Combinar la recuperación de vectores y la reproducción de IA
class RAGEnglishTeacher:
def __init__(self, vector_db, generator):
self.vector_db = vector_db
self.generator = generator
@lru_cache(maxsize=32)
def teach(self, topic):
relevant_content = self.vector_db.retrieve(topic)
lesson = self.generator.generate_lesson(topic, relevant_content)
return lessonLa clase antedicho, RagenGlishTeacher, integra los componentes VectordAdatabase y GroqGenerator para crear un sistema de reproducción (RAG) de recuperación (RAG). La función Teach () recupera contenido relevante de la saco de datos Vector y lo pasa al GroqGenerator para producir una conferencia estructurada. El interiorista LRU_CACHE (MaxSize = 32) almacena en gusto hasta 32 lecciones generadas previamente para mejorar la eficiencia al evitar los cálculos repetidos.
En conclusión, creamos con éxito un tutor en inglés con AI que combina una saco de datos vectorial (ChromAdB) y el maniquí de IA de Groq para implementar la reproducción de recuperación acuática (RAG). El sistema puede extraer texto de PDFS, juntar el conocimiento relevante de forma estructurada, recuperar información contextual y originar lecciones detalladas dinámicamente. Este tutor proporciona lecciones atractivas, conscientes de contexto y personalizadas mediante la utilización de integridades de oraciones para recuperación capaz y respuestas generadas por IA para el educación estructurado. Este enfoque garantiza que los alumnos reciban lecciones de inglés precisas, informativas y perfectamente organizadas sin requerir la creación de contenido manual. El sistema se puede ampliar aún más integrando módulos de educación adicionales, mejorando la eficiencia de la saco de datos o las respuestas de IA ajustados para que el proceso de tutoría sea más interactivo e inteligente.
Usar el Cuaderno de colab aquí. Adicionalmente, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GResparcir. No olvides unirte a nuestro 70k+ ml de subreddit.
🚨 Conocer Intellagent: Un ámbito de múltiples agentes de código despejado para evaluar un sistema de IA conversacional enredado (Promocionado)
Sana Hassan, una pasante de consultoría en MarktechPost y estudiante de doble límite en IIT Madras, le apasiona aplicar tecnología e IA para acometer los desafíos del mundo verdadero. Con un gran interés en resolver problemas prácticos, aporta una nueva perspectiva a la intersección de la IA y las soluciones de la vida verdadero.