En este tutorial, comenzamos configurando un agente de IA compacto pero capaz que se ejecuta sin problemas, aprovechando los transformadores de la cara abrazando. Integramos la generación de diálogo, la respuesta de pregunta, el análisis de sentimientos, los trozos de búsqueda web, los aspecto del clima y una calculadora segura en una sola clase de Python. A medida que avanzamos, instalamos solo las bibliotecas esenciales, cargamos modelos livianos que respetan los límites de memoria de Colab y envuelven cada capacidad dentro de los métodos ordenados y reutilizables. Juntos, exploramos cómo cada componente, desde la detección de intenciones hasta la carga del modelo consciente del dispositivo, se ajusta a un flujo de trabajo coherente, lo que nos permite prototipos de agentes sofisticados y múltiples.
!pip install transformers torch accelerate datasets requests beautifulsoup4
import torch
import json
import requests
from datetime import datetime
from transformers import (
AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification,
AutoModelForQuestionAnswering, pipeline
)
from bs4 import BeautifulSoup
import warnings
warnings.filterwarnings('ignore')Comenzamos instalando las bibliotecas clave de Python, transformadores, antorcha, acelerar, conjuntos de datos, solicitudes y beautifulsoup, por lo que nuestro entorno de Colab tiene todo lo que necesita para la carga de modelos, la inferencia y el raspado web. A continuación, importamos Pytorch, Json Utilities, HTTP y ayudantes de fecha, abrazando clases faciales para la generación, clasificación y QA, así como BeautifulSoup para el análisis HTML, mientras silencian advertencias innecesarias para mantener la producción del cuaderno limpio.
class AdvancedAIAgent:
def __init__(self):
"""Initialize the AI Agent with multiple models and capabilities"""
self.device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"🚀 Initializing AI Agent on {self.device}")
self._load_models()
self.tools = {
"web_search": self.web_search,
"calculator": self.calculator,
"weather": self.get_weather,
"sentiment": self.analyze_sentiment
}
print("✅ AI Agent initialized successfully!")
def _load_models(self):
"""Load all required models"""
print("📥 Loading models...")
self.gen_tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
self.gen_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
self.gen_tokenizer.pad_token = self.gen_tokenizer.eos_token
self.sentiment_pipeline = pipeline(
"sentiment-analysis",
model="cardiffnlp/twitter-roberta-base-sentiment-latest",
device=0 if self.device == "cuda" else -1
)
self.qa_pipeline = pipeline(
"question-answering",
model="distilbert-base-cased-distilled-squad",
device=0 if self.device == "cuda" else -1
)
print("✅ All models loaded!")
def generate_response(self, prompt, max_length=100, temperature=0.7):
"""Generate text response using the language model"""
inputs = self.gen_tokenizer.encode(prompt + self.gen_tokenizer.eos_token,
return_tensors="pt")
with torch.no_grad():
outputs = self.gen_model.generate(
inputs,
max_length=max_length,
temperature=temperature,
do_sample=True,
pad_token_id=self.gen_tokenizer.eos_token_id,
attention_mask=torch.ones_like(inputs)
)
response = self.gen_tokenizer.decode(outputs[0][len(inputs[0]):],
skip_special_tokens=True)
return response.strip()
def analyze_sentiment(self, text):
"""Analyze sentiment of given text"""
result = self.sentiment_pipeline(text)[0]
return {
"sentiment": result['label'],
"confidence": round(result['score'], 4),
"text": text
}
def answer_question(self, question, context):
"""Answer questions based on given context"""
result = self.qa_pipeline(question=question, context=context)
return {
"answer": result['answer'],
"confidence": round(result['score'], 4),
"question": question
}
def web_search(self, query):
"""Simulate web search (replace with actual API if needed)"""
try:
return {
"query": query,
"results": f"Search results for '{query}': Latest information retrieved successfully.",
"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
}
except Exception as e:
return {"error": f"Search failed: {str(e)}"}
def calculator(self, expression):
"""Safe calculator function"""
try:
allowed_chars = set('0123456789+-*/.() ')
if not all(c in allowed_chars for c in expression):
return {"error": "Invalid characters in expression"}
result = eval(expression)
return {
"expression": expression,
"result": result,
"type": type(result).__name__
}
except Exception as e:
return {"error": f"Calculation failed: {str(e)}"}
def get_weather(self, location):
"""Mock weather function (replace with actual weather API)"""
return {
"location": location,
"temperature": "22°C",
"condition": "Partly cloudy",
"humidity": "65%",
"note": "This is mock data. Integrate with a real weather API for actual data."
}
def detect_intent(self, user_input):
"""Simple intent detection based on keywords"""
user_input = user_input.lower()
if any(word in user_input for word in ['calculate', 'math', '+', '-', '*', '/']):
return 'calculator'
elif any(word in user_input for word in ['weather', 'temperature', 'forecast']):
return 'weather'
elif any(word in user_input for word in ['search', 'find', 'look up']):
return 'web_search'
elif any(word in user_input for word in ['sentiment', 'emotion', 'feeling']):
return 'sentiment'
elif '?' in user_input:
return 'question_answering'
else:
return 'chat'
def process_request(self, user_input, context=""):
"""Main method to process user requests"""
print(f"🤖 Processing: {user_input}")
intent = self.detect_intent(user_input)
response = {"intent": intent, "input": user_input}
try:
if intent == 'calculator':
import re
expr = re.findall(r'[0-9+\-*/.() ]+', user_input)
if expr:
result = self.calculator(expr[0].strip())
response.update(result)
else:
response["error"] = "No valid mathematical expression found"
elif intent == 'weather':
words = user_input.split()
location = "your location"
for i, word in enumerate(words):
if word.lower() in ['in', 'at', 'for']:
if i + 1 < len(words):
location = words[i + 1]
break
result = self.get_weather(location)
response.update(result)
elif intent == 'web_search':
query = user_input.replace('search', '').replace('find', '').strip()
result = self.web_search(query)
response.update(result)
elif intent == 'sentiment':
text_to_analyze = user_input.replace('sentiment', '').strip()
if not text_to_analyze:
text_to_analyze = "I'm feeling great today!"
result = self.analyze_sentiment(text_to_analyze)
response.update(result)
elif intent == 'question_answering' and context:
result = self.answer_question(user_input, context)
response.update(result)
else:
generated_response = self.generate_response(user_input)
response["response"] = generated_response
response["type"] = "generated_text"
except Exception as e:
response["error"] = f"Error processing request: {str(e)}"
return responseEncapsulamos todo nuestro conjunto de herramientas dentro de una clase avanzada de gpu en GPU cuando esté disponible, carga el diálogo, el sentimiento y los modelos de control de calidad, y registra herramientas auxiliares para la búsqueda, el clima y la aritmética. Con la detección de intenciones livianas basadas en palabras clave, enrutamos dinámicamente cada mensaje de usuario a la tubería correcta o recurrimos a la generación de forma libre, proporcionando un agente unificado y múltiple impulsado por unos pocos métodos limpios.
if __name__ == "__main__":
agent = AdvancedAIAgent()
print("\n" + "="*50)
print("🎯 DEMO: Advanced AI Agent Capabilities")
print("="*50)
test_cases = [
"Calculate 25 * 4 + 10",
"What's the weather in Tokyo?",
"Search for latest AI developments",
"Analyze sentiment of: I love working with AI!",
"Hello, how are you today?"
]
for test in test_cases:
print(f"\n👤 User: {test}")
result = agent.process_request(test)
print(f"🤖 Agent: {json.dumps(result, indent=2)}")
"""
print("\n🎮 Interactive Mode - Type 'quit' to exit")
while True:
user_input = input("\n👤 You: ")
if user_input.lower() == 'quit':
break
result = agent.process_request(user_input)
print(f"🤖 Agent: {json.dumps(result, indent=2)}")
"""
Concluimos que generamos el avanzado, anunciando una sección de demostración rápida y disparando cinco indicaciones representativas que prueban el cálculo, el clima, la búsqueda, el sentimiento y el chat abierto en un solo barrido. Después de revisar las respuestas de JSON cuidadosamente formateadas, mantenemos un bucle interactivo opcional en espera, listo para la experimentación en vivo cada vez que decidimos no competir con él.
En conclusión, probamos una variedad de indicaciones en el mundo real y observamos cómo maneja la aritmética, obtiene datos meteorológicos simulados, califica el sentimiento y se involucra en una conversación natural, a través de una sola interfaz unificada utilizando modelos faciales de abrazamiento. Este ejercicio demuestra cómo podemos coser múltiples tareas de PNL en un marco extensible que sigue siendo amigable con los recursos de Colab.
Mira el Codos. Todo el crédito por esta investigación va a los investigadores de este proyecto.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.
