AWS Sagemaker es la suite de Machine Learning de AWS. Con la llegada de la IA, AWS ha añadido inteligentemente capacidades LLM a Sagemaker.

Sagemaker admite una amplia gama de LLM, incluidos Dolly, Falcon, Llama2 y Mistral-7B. Sin embargo, aún no admite Claude, al que se debe acceder a través de AWS Bedrock.

Para los profesionales de Analytics, averiguar cómo acceder a LLM y otros modelos de Machine Learning desde almacenes de datos como Snowflake y conectar trabajos de extremo a extremo con marcos de modelado de datos como dbt es imprescindible para activar la IA generativa en la capa de Analytics. En este artículo, te mostraremos cómo.

Una canalización de datos básica

Una canalización de datos básica para el ajuste fino de LLM implicaría mover datos a Snowflake o S3, transformarlos utilizando dbt o Coalesce y ejecutar pruebas de calidad de datos. Esto se representa a continuación:

Estos conjuntos de datos limpios se pueden utilizar para ajustar los LLM.

Utilizar Snowflake como fuente de datos para entrenar modelos ML con Amazon SageMaker
Aquí me baso en gran medida en el blog de arquitectura de soluciones de AWS. En este ejemplo, utilizaremos un modelo ML normal como ejemplo y podremos ver cómo se compara con un trabajo de ajuste fino de LLM.

La arquitectura general se muestra a continuación:

Paso 1: configurar el AWS SageMaker Notebook

El SageMaker Notebook es un repositorio python controlado por git que es el código que tiene tanto la lógica de obtención de datos como la de entrenamiento. A continuación se muestra un ejemplo del código a utilizar:

import pandas as pd
import snowflake.connector

def data_pull(ctx: snowflake.connector.SnowflakeConnection, table: str, hosts: int) -> pd.DataFrame:

    # Query Snowflake table for number of table records
    sql_cnt = f"select count(*) from {table};"
    df_cnt = pd.read_sql(sql_cnt, ctx)

    # Retrieve the total number of table records from dataframe
    for index, row in df_cnt.iterrows():
        num_of_records = row.astype(int)
        list_num_of_rec = num_of_records.tolist()
    tot_num_records = list_num_of_rec[0]

    record_percent = str(round(100/hosts))
    print(f"going to download a random {record_percent}% sample of the data")
    # Query Snowflake HOUSING table
    sql = f"select * from {table} sample ({record_percent});"
    print(f"sql={sql}")

    # Get the dataset into Pandas
    df = pd.read_sql(sql, ctx)
    print(f"read data into a dataframe of shape {df.shape}")
    # Prepare the data for ML
    df.dropna(inplace=True)

    print(f"final shape of dataframe to be used for training {df.shape}")
    return df

Aquí definimos un método data_pull que se conecta a Snowflake y obtiene los datos como un marco de datos. Se trata de una muestra aleatoria de los datos, ya que es lo que debe aprovecharse para el ajuste fino o la formación de modelos en general.

Paso 2: configuración de credenciales y preparación de datos

Hay algunos pasos adicionales en el código que se puede encontrar en el repositorio de código Github de AWS Sagemaker. Estos incluirían:

• Obtención de los secretos de Snowflake desde AWS Secrets Manager
• Definición de los pasos de preparación de datos después de que los datos se hayan obtenido de Snowflake
• Determinar cosas como Hyperparameters

Paso 3: configurar el paso AWS SageMaker Fit

El paso final, que es de nuestro interés, es el comando donde el cuaderno entrena el modelo:

import boto3
import sagemaker
from sagemaker import image_uris
from sagemaker import get_execution_role
from sagemaker.inputs import TrainingInput
from sagemaker.xgboost.estimator import XGBoost

role = get_execution_role()
sm_session = sagemaker.Session()
bucket = None #optionally specify your bucket here, eg: 'mybucket-us-east-1'; Otherwise, SageMaker will use 
              #the default acct bucket to upload model artifacts
if bucket is None and sm_session is not None:
    bucket = sm_session.default_bucket()
print(f"bucket={bucket}, role={role}")
prefix = "sagemaker/sagemaker-snowflake-example"
output_path = "s3://{}/{}/{}/output".format(bucket, prefix, "housing-dist-xgb")
custom_img_name = "xgboost-ddp-training-custom"
custom_img_tag = "latest"
account_id = boto3.client('sts').get_caller_identity().get('Account')

# collect default subnet IDs to deploy Sagemaker training job into
ec2_session = boto3.Session(region_name=region)
ec2_resource = ec2_session.resource("ec2")
subnet_ids = []
for vpc in ec2_resource.vpcs.all():
    # here you can choose which subnet based on the id
    if vpc.is_default == True:
        for subnet in vpc.subnets.all():
            if subnet.default_for_az == True:
                subnet_ids.append(subnet.id)

# Retrieve XGBoost custom container from ECR registry path  
xgb_image_uri = image_uris.retrieve('xgboost', region, version='1.5-1')
print(f"\nusing XGBoost image: {xgb_image_uri}")

# Create Sagemaker Estimator
xgb_script_mode_estimator = sagemaker.estimator.Estimator(
    image_uri = xgb_image_uri,
    role=role,
    instance_count=instance_count,
    instance_type=instance_type,
    output_path="s3://{}/{}/output".format(bucket, prefix),
    sagemaker_session=sm_session,
    entry_point="train.py",
    source_dir="./src",
    hyperparameters=hyperparams,
    environment=env,
    subnets = subnet_ids,
)
# Estimator fitting
xgb_script_mode_estimator.fit()

Esta es la parte jugosa de Sagemaker – aprovechando un modelo para el entrenamiento (en este caso XGBoost) que está en una imagen de contenedor y pasando esto como un parámetro al estimador sagemaker, simplemente necesitas proporcionar los parámetros relevantes (para el entrenamiento del modelo y la infraestructura) y llamar al método «fit()» para producir un modelo.

El resultado es que el modelo entrenado estará disponible en el bucket de S3 elegido.

Cómo ejecutar un trabajo de AWS Sagemaker de forma programada

Un caso de uso común una vez que los modelos están funcionando bien es ejecutar trabajos de entrenamiento en un horario.

Los modelos decaen: si llegan nuevos datos en el transcurso de la semana que significan que un modelo de hace una semana ya no es un buen predictor, será necesario entrenar e implementar un nuevo modelo para garantizar que los modelos en producción no decaigan también, lo que llevaría a resultados empresariales subóptimos.

Afortunadamente, al anidar todo el código anterior en un único archivo python, esto es esencialmente un trabajo de entrenamiento de Sagemaker, que puede ser llamado en cualquier momento usando este endpoint.

Esto se puede hacer en Python, lo que naturalmente significa que debe estar utilizando una herramienta de orquestación basada en Python como Airflow, o un servicio gestionado con una integración Sagemaker como Orchestra.

A continuación se muestra una ilustración de la nueva canalización de datos que conecta AWS Sagemaker con la canalización de datos existente:

¿Qué ocurre con los LLM?

Los LLMs no están disponibles bajo el endpoint antes mencionado, sin embargo un trabajo de ajuste fino sigue la misma estructura arquitectónica.

En lugar de llamar al trabajo SageMaker Training, usted llamaría al endpoint CreateAutoMLJob.

Conclusión

En este artículo, hemos cubierto cómo conectar Amazon Sagemaker a Snowflake que es un almacén de datos popular. Con la IA Generativa prometiendo democratizar los LLM para todas las organizaciones, la pregunta ya no es si, cuándo, sino cómo.

Un enfoque consiste en utilizar los datos que poseen los equipos de análisis como base para afinar los LLM. Esto sería muy útil para casos de uso como el análisis de correo electrónico, la documentación interna o el escaneo de código.

Demostramos cómo estos datos pueden importarse desde Snowflake directamente a un contenedor en AWS y utilizarse para entrenar un modelo de aprendizaje automático o ajustar un LLM. Esto puede ocurrir periódicamente mediante el acceso a AWS Sagemaker a través de la API, que sería gestionado por una herramienta de orquestación.

Esto supone una gran oportunidad para los analistas e ingenieros de datos. En lugar de limitarse a proporcionar datos como un producto, estos equipos tienen ahora todo lo que necesitan para implementar modelos de ML y LLM. Siempre que las organizaciones estén preparadas para ello, es un momento apasionante para trabajar en el sector de los datos.

Sobre mi

Soy Hugo Lu – Empecé mi carrera trabajando en fusiones y adquisiciones en Londres antes de pasar a JUUL y caer en la ingeniería de datos. Tras un breve paso por el mundo de las finanzas, dirigí la función de datos en Codat, una fintech con sede en Londres. Ahora soy CEO en Orchestra, que es una herramienta de canalización de liberación de datos que ayuda a los equipos de datos a liberar datos en producción de forma fiable y eficiente .

Consulta también mi Substack y mi blog interno

¿Quieres ver cómo Orchestra está cambiando el juego mediante la entrega de ahorro de costes y visibilidad sin precedentes? Prueba ahora nuestra capa gratuita.

The post Cómo conectar modelos ML en AWS Sagemaker a Snowflake y dbt first appeared on Planeta Chatbot.

Introducción

Las plataformas de negociación algorítmica han evolucionado considerablemente en la última década. Sin embargo, con la creciente demanda de velocidad y fiabilidad, los desarrolladores se encuentran a menudo revisando los fundamentos de sus sistemas para asegurarse de que aprovechan las mejores herramientas y lenguajes disponibles. NextTrade, un proyecto que se sometió a una importante remodelación en Rust, es un modelo ejemplar de cómo las plataformas de negociación modernas pueden lograr un rendimiento y una fiabilidad superiores. En este artículo, te adentrarás en la trayectoria de NextTrade, sus componentes básicos y cómo puedes aprovechar tus capacidades para tus estrategias de negociación.

¿Por qué Rust para el comercio algorítmico?

Rust es un lenguaje de programación de sistemas que garantiza la seguridad de la memoria sin un recolector de basura, lo que lo convierte en la opción ideal para aplicaciones de rendimiento crítico como el trading algorítmico. He aquí por qué Rust cambia las reglas del juego para las plataformas de negociación:

1. Rendimiento: El rendimiento de Rust es comparable al de C y C++, lo que es crucial para el comercio de alta frecuencia.
2. Seguridad: Rust elimina errores comunes causados por errores de gestión de memoria, mejorando la fiabilidad de los algoritmos de negociación.
3. Concurrencia: El modelo de propiedad de Rust facilita una programación concurrente segura y eficiente, esencial para manejar múltiples operaciones de trading simultáneamente.

Configuración de NextTrade

Para empezar con NextTrade, necesitas clonar el repositorio y configurar tu entorno de desarrollo.

git clone https://github.com/austin-starks/NextTrade.git
cd NextTrade
cargo build

Asegúrate de que tienes Rust instalado. Si no, puedes instalarlo usando rustup.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Configuración

NextTrade requiere configuración para conectarte a tu cuenta de brokerage y proveedores de datos de mercado. Esto se hace a través de un archivo de configuración, típicamente en config.toml.

[broker]
api_key = "your_api_key"
secret_key = "your_secret_key"
base_url = "https://api.broker.com"

[market_data]
provider = "provider_name"
api_key = "your_market_data_api_key"

Componentes principales

La arquitectura de NextTrade consta de varios componentes clave:

1. Gestor de datos de mercado: Obtiene y procesa datos de mercado.
2. Gestor de órdenes: Gestiona la creación, el envío y el seguimiento de órdenes.
3. Motor de estrategias: Ejecuta estrategias de negociación basadas en datos de mercado.

Gestor de datos de mercado

El gestor de datos de mercado es responsable de recuperar y procesar datos en tiempo real. He aquí una versión simplificada de la implementación:

use reqwest::Client;
use serde::Deserialize;

#[derive(Deserialize)]
struct MarketData {
    symbol: String,
    price: f64,
}

async fn fetch_market_data(client: &Client, api_key: &str, symbol: &str) -> Result<MarketData, reqwest::Error> {
    let url = format!("https://api.marketdata.com/v1/quote?symbol={}&api_key={}", symbol, api_key);
    let resp = client.get(&url).send().await?.json::<MarketData>().await?;
    Ok(resp)
}

#[tokio::main]
async fn main() {
    let client = Client::new();
    let api_key = "your_market_data_api_key";
    match fetch_market_data(&client, api_key, "AAPL").await {
        Ok(data) => println!("Symbol: {}, Price: {}", data.symbol, data.price),
        Err(e) => eprintln!("Error fetching market data: {}", e),
    }
}

Gestor de pedidos

El Gestor de pedidos gestiona la creación, envío y seguimiento de cada una de las órdenes. Interactúa con la API de intermediación para ejecutar las operaciones.

use reqwest::Client;
use serde::Serialize;

#[derive(Serialize)]
struct Order {
    symbol: String,
    qty: u32,
    side: String,
    order_type: String,
    time_in_force: String,
}

async fn place_order(client: &Client, api_key: &str, order: &Order) -> Result<(), reqwest::Error> {
    let url = format!("https://api.broker.com/v1/orders?api_key={}", api_key);
    let resp = client.post(&url).json(&order).send().await?;
    if resp.status().is_success() {
        println!("Order placed successfully");
    } else {
        eprintln!("Error placing order: {:?}", resp.text().await?);
    }
    Ok(())
}

#[tokio::main]
async fn main() {
    let client = Client::new();
    let api_key = "your_api_key";
    let order = Order {
        symbol: "AAPL".to_string(),
        qty: 10,
        side: "buy".to_string(),
        order_type: "market".to_string(),
        time_in_force: "gtc".to_string(),
    };
    match place_order(&client, api_key, &order).await {
        Ok(()) => println!("Order executed"),
        Err(e) => eprintln!("Error: {}", e),
    }
}

Motor de estrategia

El motor de estrategia evalúa las señales de negociación y decide cuándo comprar o vender. He aquí un ejemplo de una estrategia simple de cruce de medias móviles.

fn calculate_sma(prices: &[f64], period: usize) -> Vec<f64> {
    prices.windows(period).map(|window| window.iter().sum::<f64>() / period as f64).collect()
}

fn main() {
    let prices = vec![100.0, 102.0, 101.0, 105.0, 107.0, 106.0, 108.0, 110.0];
    let short_sma = calculate_sma(&prices, 3);
    let long_sma = calculate_sma(&prices, 5);

    for (short, long) in short_sma.iter().zip(long_sma.iter()) {
        if short > long {
            println!("Buy signal: short SMA {} > long SMA {}", short, long);
        } else {
            println!("Sell signal: short SMA {} <= long SMA {}", short, long);
        }
    }
}

Aplicación de estrategias de negociación avanzadas

Estrategia de reversión a la media

La reversión a la media es una estrategia basada en la idea de que los precios de los activos tienden a volver a su media histórica a lo largo del tiempo. A continuación te mostramos cómo puede implementar una estrategia simple de reversión a la media en NextTrade:

fn calculate_mean(prices: &[f64]) -> f64 {
    prices.iter().sum::<f64>() / prices.len() as f64
}

fn mean_reversion_strategy(prices: &[f64], threshold: f64) -> Option<&'static str> {
    let mean = calculate_mean(prices);
    let current_price = *prices.last().unwrap();

    if current_price > mean + threshold {
        Some("sell")
    } else if current_price < mean - threshold {
        Some("buy")
    } else {
        None
    }
}

fn main() {
    let prices = vec![100.0, 102.0, 101.0, 105.0, 107.0, 106.0, 108.0, 110.0];
    let threshold = 2.0;

    match mean_reversion_strategy(&prices, threshold) {
        Some("buy") => println!("Buy signal: current price is below mean by threshold"),
        Some("sell") => println!("Sell signal: current price is above mean by threshold"),
        None => println!("No trade signal"),
        _ => unreachable!(),
    }
}

Integración del machine learning

La integración de modelos de machine learning en tus estrategias de negociación puede proporcionar capacidad de predicción y adaptabilidad. He aquí un ejemplo simplificado que utiliza un clasificador de árbol de decisión de la caja de máquinas oxidadas:

use rusty_machine::learning::decision_tree::DecisionTree;
use rusty_machine::learning::SupModel;
use rusty_machine::linalg::Matrix;

fn train_model() -> DecisionTree {
    let data = Matrix::new(4, 2, vec![1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0]);
    let targets = Matrix::new(4, 1, vec![1.0, 0.0, 1.0, 0.0]);
    
    let mut model = DecisionTree::new();
    model.train(&data, &targets).unwrap();
    model
}

fn predict(model: &DecisionTree, data: Matrix<f64>) -> f64 {
    model.predict(&data).unwrap()[0]
}

fn main() {
    let model = train_model();
    let data = Matrix::new(1, 2, vec![1.0, 1.0]);
    let prediction = predict(&model, data);
    
    if prediction == 1.0 {
        println!("Buy signal based on model prediction");
    } else {
        println!("Sell signal based on model prediction");
    }
}

Procesamiento de datos en tiempo real

Para seguir siendo competitivo en el ámbito del comercio, es esencial procesar los datos en tiempo real de forma eficiente. Las capacidades asíncronas de Rust combinadas con tokio pueden ayudarte a conseguirlo.

use tokio::time::{self, Duration};
use std::collections::VecDeque;

async fn process_market_data() {
    let mut interval = time::interval(Duration::from_secs(1));
    let mut prices: VecDeque<f64> = VecDeque::new();

    loop {
        interval.tick().await;
        let price = fetch_latest_price().await;
        prices.push_back(price);
        if prices.len() > 100 {
            prices.pop_front();
        }
        println!("Latest price: {}", price);
    }
}

async fn fetch_latest_price() -> f64 {
    // Simulate fetching latest price
    105.0
}

#[tokio::main]
async fn main() {
    process_market_data().await;
}

Marco de backtesting

Un marco de backtesting robusto es crucial para evaluar el rendimiento de sus estrategias de trading. El módulo de backtesting de NextTrade te permite contrastar tus estrategias con datos históricos.

use chrono::prelude::*;
use std::fs::File;
use std::io::{BufRead, BufReader};

fn load_historical_data(file_path: &str) -> Vec<(DateTime<Utc>, f64)> {
    let file = File::open(file_path).unwrap();
    let reader = BufReader::new(file);
    
    reader.lines().map(|line| {
        let line = line.unwrap();
        let parts: Vec<&str> = line.split(',').collect();
        let date = Utc.datetime_from_str(parts[0], "%Y-%m-%d %H:%M:%S").unwrap();
        let price: f64 = parts[1].parse().unwrap();
        (date, price)
    }).collect()
}

fn backtest_strategy(prices: &[(DateTime<Utc>, f64)]) {
    for (date, price) in prices {
        println!("Date: {}, Price: {}", date, price);
        // Implement your strategy logic here
    }
}

fn main() {
    let historical_data = load_historical_data("historical_data.csv");
    backtest_strategy(&historical_data);
}

Bot de negociación automatizado

Desplegar un bot de trading automatizado implica configurar un sistema que pueda funcionar continuamente y ejecutar operaciones basadas en las señales de tu estrategia.

use tokio::task;

async fn trading_bot() {
    loop {
        let market_data = fetch_market_data().await;
        let signal = generate_trading_signal(&market_data);
        
        if let Some(order) = signal_to_order(signal) {
            place_order(order).await;
        }

        tokio::time::sleep(Duration::from_secs(60)).await;
    }
}

#[tokio::main]
async fn main() {
    let bot = trading_bot();
    task::spawn(bot).await.unwrap();
}

Buenas prácticas para la implantación en producción

• Pruebas y simulación: Realiza siempre pruebas retrospectivas de tus estrategias con datos históricos y simúlalas en un entorno de negociación en papel antes de desplegarlas con dinero real.
• Gestión de errores: Implementa una gestión de errores robusta para gestionar errores de API, problemas de red y otras condiciones inesperadas.
• Gestión de la concurrencia: Utiliza las características de concurrencia de Rust para manejar múltiples tareas de manera eficiente sin carreras de datos o bloqueos.
• Monitorización y alertas: Implementa la monitorización para realizar un seguimiento del rendimiento y la salud de tu bot, y configura alertas para cualquier anomalía.
• Medidas de seguridad: Utiliza métodos seguros para gestionar las claves API y la información confidencial, y asegúrate de que tu sistema es robusto frente a ataques y fallos.
• Escalabilidad: Diseña tu sistema para manejar cargas crecientes, con la capacidad de escalar a medida que crece tu volumen de operaciones.

Conclusión

NextTrade, con su sólida arquitectura y la utilización de Rust, establece un nuevo estándar para las plataformas de negociación algorítmica. Al aprovechar sus funciones avanzadas y seguir las mejores prácticas, los operadores pueden desarrollar, probar y desplegar sofisticadas estrategias de negociación con confianza. A medida que la tecnología siga evolucionando, plataformas como NextTrade desempeñarán un papel fundamental en la configuración del futuro de la negociación algorítmica, ofreciendo a los operadores las herramientas que necesitan para tener éxito en los dinámicos mercados financieros.

Al integrar el machine learning, el procesamiento de datos en tiempo real y un sólido marco de backtesting, NextTrade permite a los operadores mantenerse a la vanguardia. Tanto si es un operador principiante como un profesional experimentado, las estrategias y prácticas descritas en este artículo le ayudarán a aprovechar todo el potencial de NextTrade en sus operaciones.

The post Dominar el trading algorítmico con NextTrade first appeared on Planeta Chatbot.

actions.py

import getpass
from . import constants as c
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC

def login(driver, email=None, password=None, cookie = None, timeout=30):
    try:   
        driver.get("https://www.linkedin.com/login")
        element = WebDriverWait(driver, 10).until(EC.presence_of_element_located(("id", "username")))
    
        email_elem = driver.find_element("id","username")
        email_elem.send_keys(email)
    
        password_elem = driver.find_element("id","password")
        password_elem.send_keys(password)
        password_elem.submit()
       
        element = WebDriverWait(driver, timeout).until(EC.presence_of_element_located(("class name", "global-nav__content"))
        
    except Exception as e:
        print(f"Failed to log in: {e}")

Utilizamos la función driver.get() para obtener la página web de inicio de sesión de LinkedIn. Usamos la función WebDriverWait() para buscar un elemento específico en la página web. Utilizamos esta función para esperar a que la página web se cargue completamente. Una vez cargada la página, utilizamos driver.find_element() para obtener el id de nombre de usuario y el id de contraseña. Una vez que obtenemos esos elementos usamos la función send_keys() para colocar nuestros valores en la caja de texto. Para el elemento password, usamos la función submit() para iniciar sesión. A continuación, utilizamos WebDriverWait() de nuevo, esta vez comprobando la existencia de la barra de navegación global que se ve en la parte superior. Si obtenemos eso, significa que estamos dentro.

entity.py

import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException
from .objects import Experience, Education, Scraper, Interest, Accomplishment, Contact
import os
from linkedin_scraper import selectors

class Entity(Scraper):

    __TOP_CARD = "top-card-background-hero-image"
    __WAIT_FOR_ELEMENT_TIMEOUT = 5

    def __init__(
        self,
        linkedin_url=None,
        driver=None,
        get=True,
        close_on_complete=True,
    ):
        self.driver = driver

Creamos una clase llamada Entidad y tenemos dos constantes en ella que se utilizarán más adelante. El constructor inicializa con un linkedin_url, driver, get y close_on_complete. A continuación, establecemos el controlador de acuerdo con lo que se pasó cuando se llamó al constructor.

def scrape(self, close_on_complete=True):    
    driver = self.driver

    try:
        # Wait for the page to load
        WebDriverWait(driver, self.__WAIT_FOR_ELEMENT_TIMEOUT).until(
            EC.presence_of_element_located(
                (
                    "tag name", "body"
                )
            )
        )
        self.focus()
        self.wait(5)
        
        # Scroll to the bottom of the page to load all dynamic content
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        self.wait(3)  # wait for additional content to load
        
        # Get all the text on the page
        page_text = driver.find_element("tag name", "body").text
        
        print("Scraped Text:")
        print(page_text)
        
        return page_text
        
    except Exception as e:
        print(f"Failed to scrape the page: {e}")
        page_text = ""

    finally:
        if close_on_complete:
            driver.quit()

    return page_text

La función scrape() va a comprobar la existencia del cuerpo en la página. A continuación, utilizarás la función driver.execute_script() para desplazarte hasta el final de la página y cargarlo todo. Después de eso, extraerás todo el texto de la página web utilizando driver.find_element(«tag name», «body»).text y luego imprimiremos y devolveremos el texto raspado.

linkedin_scraper.py

from linkedin_scraper import Person, actions
from openai import OpenAI 
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def scrape_linkedin(linkedin_url, email, password):
    # Set up Chrome options
    chrome_options = Options()
    chrome_options.add_argument("--headless")  # Run in headless mode
    chrome_options.add_argument("--disable-gpu")  # Disable GPU acceleration
    chrome_options.add_argument("--no-sandbox")  # Bypass OS security model
    chrome_options.add_argument("--disable-dev-shm-usage")  # Overcome limited resource problems
    chrome_options.add_argument("start-maximized")  # Start maximized
    chrome_options.add_argument("enable-automation")  # Enable automation controls
    chrome_options.add_argument("--disable-infobars")  # Disable infobars
    chrome_options.add_argument("--disable-extensions")  # Disable extensions
    chrome_options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36")
    
    # Initialize the Chrome driver with the options
    service = Service('/usr/bin/chromedriver')  # Update with the correct path to your chromedriver
    driver = webdriver.Chrome(service=service, options=chrome_options)
    client = OpenAI(api_key="OPENAI_API_KEY")
    if email and password:
        try:    
                
            # Log in to LinkedIn
            actions.login(driver, email, password)
                        
            # Wait for the LinkedIn homepage to load or for login to complete
            WebDriverWait(driver, 20).until(
                EC.presence_of_element_located((By.CSS_SELECTOR, ".global-nav__me-photo"))
            )
            
            # Navigate to the profile page
            driver.get(linkedin_url)
            
            # Wait for the profile page to load
            WebDriverWait(driver, 20).until(
                EC.presence_of_element_located((By.CSS_SELECTOR, ".pv-top-card__photo-wrapper.ml0"))
            )
            
            # Create an Entity object for the LinkedIn profile
            entity = Entity(linkedin_url=linkedin_url, driver=driver, scrape=False)
            
            # Scrape the LinkedIn profile data
            linkedin_data = entity.scrape(close_on_complete=True)  # Close browser after scraping
            
            prompt = """Extract and summarize the LinkedIn profile data into the following format:
                linkedin_data = {
                    "name": person.name,
                    "linkedin_url": person.linkedin_url,
                    "about": person.about,
                    "experiences": [str(exp) for exp in person.experiences],
                    "educations": [str(edu) for edu in person.educations],
                    "interests": [str(interest) for interest in person.interests],
                    "accomplishments": [str(accomplishment) for accomplishment in person.accomplishments],
                    "company": person.company,
                    "job_title": person.job_title
                }
            
            """
        
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                temperature=0.1,
                messages=[
                    {"role": "system", "content": f'{prompt}'},
                    {"role": "user", "content": f'parse the following data: {linkedin_data}'}
                ]
            )

            print(response.choices[0].message.content)
            return response.choices[0].message.content
            
        except Exception as e:
            print(f"Failed to scrape {linkedin_url}: {e}")
            linkedin_data = {}
        
        finally:
            driver.quit()
    else:
        return {}

En nuestra función principal scrape_linkedin() primero estamos creando algunas configuraciones necesarias. Estos son chrome_options, services, driver y el cliente OpenAI. A continuación, ejecutamos la función login() con el controlador, el correo electrónico y la contraseña. A continuación, utilizamos el WebDriverWait() para comprobar si estamos en la página de inicio. Comprobamos la foto de perfil en la barra de navegación. Luego usamos la función driver.get() para ir al perfil que queremos scrapear.

Una vez que estemos en esa página, comprobaremos la foto de perfil utilizando WebDriverWait() de nuevo. Si la obtenemos, pasaremos a inicializar nuestro objeto Entidad y luego ejecutaremos la función scrape() para obtener todo el texto de la página web. Una vez que tenemos esos datos, podemos enviarlos a OpenAI utilizando la API de Chat Completions y hacer que extraiga los datos necesarios de ese gran trozo de texto. A continuación, podemos imprimir y devolver los datos.

Toda esta solución se inspiró en el siguiente repositorio de Github: Échale un vistazo.

The post Crea un scraper de LinkedIn con Selenium y GPT 4o-Mini de OpenAI first appeared on Planeta Chatbot.

El desarrollo de agentes de inteligencia artificial que puedan, entre otras cosas, pensar, planificar y decidir con una destreza similar a la humana es un área destacada de investigación y debate en la actualidad. Por el momento, los LLM han tomado la delantera como base fundamental de estos agentes. Al perseguir capacidades cada vez más complejas, independientemente de los LLM que se utilicen, inevitablemente nos encontramos con los mismos tipos de preguntas una y otra vez, entre ellas:

1. ¿Dispone el modelo de los conocimientos necesarios para realizar una tarea con precisión y eficacia?
2. Si dispone de los conocimientos adecuados, ¿cómo podemos activarlos de forma fiable?
3. ¿Es capaz el modelo de imitar comportamientos cognitivos complejos como el razonamiento, la planificación y la toma de decisiones con un nivel de competencia aceptable?

Este artículo explora estas cuestiones a través de un miniexperimento que he llevado a cabo recientemente y que aprovecha el último benchmark MMLU-Pro. Los hallazgos conducen a algunas ideas interesantes sobre la flexibilidad cognitiva y cómo podríamos aplicar este concepto de la ciencia cognitiva a nuestro agente de IA y a nuestros esfuerzos de ingeniería prompt.

Blackgroud

MMLU-Pro: un desafío de elección múltiple

El recientemente publicado benchmark MMLU-Pro (Massive Multitask Language Understanding) pone a prueba los límites de capacidad de los modelos de IA presentando un conjunto de tareas más robusto y desafiante en comparación con su predecesor, MMLU [1]. El objetivo era crear una evaluación exhaustiva que cubriera una amplia gama de temas, exigiendo a los modelos que poseyeran una amplia base de conocimientos y demostraran la capacidad de aplicarlos en contextos variados. Para ello, MMLU-Pro pone a prueba los modelos con preguntas tipo test muy complejas, orientadas al razonamiento y repartidas en 14 dominios de conocimiento diferentes.

Todos estamos familiarizados con los exámenes tipo test por nuestra propia trayectoria académica. Las estrategias que utilizamos en este tipo de pruebas suelen consistir en una combinación de razonamiento, resolución de problemas, memoria, eliminación, inferencia y conjetura. Nuestra capacidad para alternar sin problemas entre estas estrategias se basa en la flexibilidad cognitiva, que empleamos para adaptar nuestro enfoque a las exigencias de cada pregunta concreta.

La flexibilidad cognitiva abarca capacidades mentales como cambiar de un concepto a otro y pensar en varios conceptos a la vez. Nos permite adaptar nuestro pensamiento a cada situación. ¿Es este concepto potencialmente útil para nuestro agente de IA y para nuestros esfuerzos de ingeniería? Antes de analizarlo, examinemos un ejemplo de pregunta de MMLU-Pro en la categoría «negocios»:

Pregunta 205: Si los beneficios anuales por acción tienen una media de 8,6 $ y una desviación típica de 3,4 $, ¿cuál es la probabilidad de que un BPA observado sea inferior a 5,5 $?

Respuestas: A: 0,3571, B: 0,0625, C: 0,2345, D: 0,5000, E: 0,4112, F: 0,1814, G: 0,3035, H: 0,0923, I: 0.2756, J: 0.1587

Aunque categóricamente etiquetada como «negocios», esta pregunta requiere conocimientos de estadística. Tenemos que normalizar el valor y calcular cuántas desviaciones estándar se aleja de la media para obtener una estimación de la probabilidad. Esto se hace calculando la puntuación Z de la siguiente manera:

Dónde:

X es el valor en cuestión (5,50 $ en este caso).
μ es la media (dada como 8,6 $).
σ es la desviación típica (dada como 3,4 $).

Si sustituimos esos valores en la fórmula obtenemos -0,09118. A continuación, consultamos la tabla de distribución normal estándar y descubrimos que la probabilidad de que Z sea inferior a -0,9118 es de aproximadamente el 18,14%, que corresponde a la respuesta «F» de nuestras opciones.

Creo que se puede afirmar con seguridad que se trata de un problema no trivial que debe resolver un LLM. La respuesta correcta no se puede memorizar y hay que calcularla. ¿Tendría un LLM los conocimientos y la flexibilidad cognitiva necesarios para resolver este tipo de problema? ¿Qué estrategias de ingeniería prompt podríamos emplear?

Ingeniería prompt al rescate

Al abordar el problema anterior con un LLM, podríamos plantearnos: ¿tiene nuestro modelo elegido los conocimientos de estadística necesarios? Suponiendo que los tenga, ¿cómo podemos activar de forma fiable los conocimientos sobre distribuciones normales estándar? Y, por último, ¿puede el modelo imitar los pasos del razonamiento matemático para llegar a la respuesta correcta?

La conocida estrategia de ingeniería de prompts de la «cadena de pensamiento» (CoT) parece encajar a la perfección. Esta estrategia se basa en incitar al modelo a generar pasos de razonamiento intermedios antes de llegar a la respuesta final. Existen dos enfoques básicos.

• Cadena de pensamiento (CoT): Consiste en dar unos cuantos ejemplos del proceso de razonamiento para guiar el modelo [2].

• Cadena de Pensamiento Cero (CoT Cero): Consiste en pedir al modelo que genere pasos de razonamiento sin ejemplos previos, a menudo utilizando frases como «Pensemos paso a paso» [3].

Existen muchas otras estrategias, que generalmente se basan en una combinación de activación de características previa a la generación, es decir, centrada en la activación de conocimientos en la solicitud inicial, y activación de características intrageneración, es decir, centrada en la activación dinámica de conocimientos por parte del LLM a medida que genera su salida token a token.

Miniexperimento

Diseño del experimento

Para diseñar el miniexperimento, utilicé ChatGPT-4o y tomé muestras aleatorias de 10 preguntas de cada uno de los 14 dominios de conocimiento del conjunto de datos MMLU-Pro. El experimento pretendía evaluar dos aspectos principales:

1. Eficacia de las distintas técnicas de ingeniería de prompt: Específicamente, el impacto del uso de diferentes técnicas para activar el conocimiento necesario y el comportamiento deseado en el modelo. Las técnicas se seleccionaron para que se ajustaran a distintos grados de flexibilidad cognitiva y todas se basaron en el disparo cero.
2. El impacto de limitar deliberadamente el razonamiento y la flexibilidad cognitiva: En concreto, cómo afecta a la precisión el hecho de limitar la capacidad del modelo para razonar abiertamente (y, en consecuencia, limitar gravemente la flexibilidad cognitiva).

Las diferentes técnicas de pregunta probadas se basaban en las siguientes plantillas:

• Pregunta directa – {Pregunta}. Seleccione la respuesta correcta entre las siguientes opciones:{Respuestas}. Responda con la letra y la respuesta seleccionadas.

• TdC – {Pregunta}. Pensemos paso a paso y seleccionemos la respuesta correcta de entre las siguientes opciones de respuesta: {Respuestas}. Responda con la letra y la respuesta seleccionadas.

• Activación del Dominio del Conocimiento – {Pregunta}. Pensemos en los conocimientos y conceptos necesarios y seleccionemos la respuesta correcta de entre las siguientes opciones de respuesta:
• {Respuestas}. Responda con la letra y la respuesta seleccionadas.

• Andamios contextuales – {Pregunta}. Mis expectativas son que responda correctamente a la pregunta. Crea un contexto operativo para ti mismo que maximice el cumplimiento de mis expectativas y selecciona la respuesta correcta de entre las siguientes opciones de respuesta: {Respuestas}. Responda con la letra y la respuesta seleccionadas. [4]

El enfoque de Pregunta Directa sirvió como línea de base, permitiendo probablemente el mayor grado de flexibilidad cognitiva del modelo. Es probable que CoT genere la menor flexibilidad cognitiva, ya que el modelo debe proceder paso a paso. La Activación del Dominio del Conocimiento y los Andamios Contextuales se sitúan entre la Pregunta Directa y el CoT.

El razonamiento deliberadamente restrictivo se consiguió tomando la última línea de las plantillas de preguntas anteriores, es decir, «Responde con la letra y la respuesta seleccionadas» y especificando en su lugar «Responde sólo con la letra y la respuesta seleccionadas y nada más».

Si te interesa el código que utilicé para realizar el experimento y los resultados, puedes encontrarlos en este repositorio de GitHub enlazado aquí.

Resultados

A continuación se presentan los resultados de las distintas técnicas de pronóstico y sus variantes con restricciones de razonamiento:

Todas las preguntas de razonamiento sin restricciones obtuvieron resultados comparables, aunque el enfoque de pregunta directa fue ligeramente mejor que los demás. Esto fue una sorpresa, ya que el artículo de MMLU-Pro [1] señala un rendimiento significativamente inferior en la pregunta directa y un fuerte aumento del rendimiento con CoT de pocos disparos. No me detendré aquí en la discrepancia, ya que el propósito del miniexperimento no era replicar su configuración.

Lo más importante para este miniexperimento es que, cuando se restringió deliberadamente el razonamiento, todas las técnicas mostraron un descenso comparable en la precisión, pasando de una media del 66% al 51%. Este resultado coincide con lo que esperábamos. La observación más pertinente es que ninguna de las técnicas consiguió mejorar la activación del conocimiento previo a la generación más allá de lo que ocurriría con la pregunta directa, en la que la activación de características previas a la generación se produce principalmente al exponer el modelo al texto de las opciones de pregunta y respuesta.

La conclusión general de estos resultados de alto nivel sugiere que una combinación óptima para una pronta eficacia de la ingeniería puede muy bien implicar:

1. Permitir que el modelo ejerza cierto grado de flexibilidad cognitiva, como se ejemplifica mejor en el enfoque de Pregunta Directa.
2. Permitir que el modelo razone abiertamente, de forma que las trazas de razonamiento formen parte activa de la generación.

La dimensión del coste computacional

Aunque no se discute a menudo, la eficiencia de los tokens es cada vez más importante a medida que los LLM se abren camino en diversos casos de uso de la industria. El siguiente gráfico muestra la precisión de cada técnica de consulta sin restricciones frente a la media de tokens generados en la respuesta.

Aunque el diferencial de precisión no es el objetivo principal, la eficiencia del enfoque de Pregunta Directa, que genera una media de 180 tokens por respuesta, es notable en comparación con CoT, que produjo aproximadamente 339 tokens por respuesta (es decir, un 88% más). Dado que la precisión es comparable, cabe suponer que CoT es, por término medio, menos eficaz que las demás estrategias en lo que se refiere a la activación del conocimiento intrageneracional, lo que produce resultados excesivamente verborreicos. Pero, ¿a qué se debe este exceso de verbosidad? Para intentar responder a esta pregunta, resultó útil examinar las preguntas de razonamiento sin restricciones y el número de veces que el modelo optó por responder sólo con la respuesta y sin ningún rastro de razonamiento, aunque no se le hubiera indicado explícitamente que lo hiciera. Los resultados fueron los siguientes

Lo que resultó aún más interesante fue la precisión cuando el modelo optó por responder directamente sin ningún rastro de razonamiento, lo que se muestra en la tabla siguiente:

La precisión osciló entre el 64% y el 70% sin que se generara ningún rastro de razonamiento. Incluso con las preguntas de MMLU-Pro, diseñadas a propósito para requerir razonamiento y resolución de problemas, el modelo parece demostrar algo parecido a la selección de diferentes estrategias en función de la pregunta concreta, cuando no está excesivamente condicionado por la pregunta.

Implicaciones prácticas

Lo que se desprende de estos resultados es que las estrategias sencillas pueden ser tan eficaces como las excesivamente estructuradas. Aunque el objetivo de CoT es simular el razonamiento induciendo activaciones de rasgos específicos orientados al razonamiento, puede que no siempre sea necesario u óptimo, especialmente si la generación excesiva de fichas es un problema. En su lugar, un enfoque potencialmente más adecuado puede ser permitir que el modelo ejerza su flexibilidad cognitiva.

Conclusiones: Preparando el camino para la flexibilidad cognitiva en los agentes de IA

Los resultados de este miniexperimento ofrecen una visión convincente de la importancia de la flexibilidad cognitiva en los LLM y los Agentes de IA. En la cognición humana, la flexibilidad cognitiva se refiere a la capacidad de adaptar el pensamiento y el comportamiento en respuesta a tareas o demandas cambiantes. Implica pasar de un concepto a otro, mantener varios conceptos simultáneamente y cambiar la atención según sea necesario. En el contexto de los LLM, puede entenderse como la capacidad del modelo para ajustar dinámicamente sus activaciones internas en respuesta a estímulos textuales.

Si se sigue prestando atención al desarrollo de tecnologías y técnicas en este ámbito, se podría mejorar significativamente la capacidad de los agentes de IA en una serie de tareas complejas. Por ejemplo, la exploración de esta idea junto con otras ideas como las expuestas por Anthropic en su reciente artículo «Scaling Monosemanticity: Extracting Interpretable Features from Claude 3 Sonnet», podría dar lugar a técnicas que desbloqueen la capacidad de observar y adaptar dinámicamente el nivel de flexibilidad cognitiva empleado en función de la complejidad y el dominio de la tarea.

A medida que ampliemos los límites de la IA, la flexibilidad cognitiva será probablemente clave para crear modelos que no sólo funcionen con fiabilidad, sino que también comprendan y se adapten a las complejidades del mundo real.

Gracias por leerme y sígueme para conocer los resultados de futuras exploraciones relacionadas con este trabajo. Si quieres hablar de ello, no dudes en ponerte en contacto conmigo en LinkedIn.
Salvo que se indique lo contrario, todas las imágenes de este artículo son del autor.

The post Ingeniería Prompt para la flexibilidad cognitiva – LLM first appeared on Planeta Chatbot.

En esta continuación de nuestra serie Agentic RAG, nos sumergiremos en el uso de las capacidades de razonamiento multipaso que exploramos anteriormente, pero esta vez a través de una colección diversa de documentos.

Ésta es la parte emocionante: Imagina un agente inteligente capaz de examinar un tesoro de información. Tú formulas una pregunta y este agente te dirige sin problemas al documento más relevante para obtener la respuesta. Agentic RAG lo hace realidad.

Desvelaremos los secretos de este enfoque. Veremos cómo crear una red de «information vaults» específicas para cada documento y cómo capacitar a un agente para navegar por ellas. Por último, seremos testigos de cómo este potente sistema aprovecha los procedimientos tradicionales de RAG para desenterrar las respuestas que busca, independientemente del documento que contenga la clave.

Comencemos con la implementación de una canalización RAG de Agentic para chatear con múltiples documentos.

Configurar el entorno

El primer paso que daremos es configurar nuestro entorno de desarrollo y prepararlo para codificar. Usaremos el mismo entorno que configuramos en el primer artículo. Simplemente crearé un nuevo archivo ipynb para esta lección en particular.

Nuevo archivo de descarga

También vamos a utilizar un nuevo archivo que se puede descargar desde aquí, este archivo en mi caso se llama longlora_efficient_fine_tuning.pdf

Utils.py actualizado

También tendremos que actualizar el archivo utils.py para alojar una nueva función: create_docs_tool . Esta nueva función nos permitirá crear motores de consulta para un resumen y motores de consulta vectoriales.

from llama_index.core.query_engine.router_query_engine import RouterQueryEngine
from llama_index.core.selectors import LLMSingleSelector
from llama_index.core.tools import QueryEngineTool
from llama_index.core import SummaryIndex, VectorStoreIndex
from llama_index.core import Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core import SimpleDirectoryReader

from typing import Tuple


async def create_router_query_engine(
    document_fp: str,
    verbose: bool = True,
) -> RouterQueryEngine:
    # load lora_paper.pdf documents
    documents = SimpleDirectoryReader(input_files=[document_fp]).load_data()

    # chunk_size of 1024 is a good default value
    splitter = SentenceSplitter(chunk_size=1024)
    # Create nodes from documents
    nodes = splitter.get_nodes_from_documents(documents)

    # LLM model
    Settings.llm = OpenAI(model="gpt-3.5-turbo")
    # embedding model
    Settings.embed_model = OpenAIEmbedding(model="text-embedding-ada-002")

    # summary index
    summary_index = SummaryIndex(nodes)
    # vector store index
    vector_index = VectorStoreIndex(nodes)

    # summary query engine
    summary_query_engine = summary_index.as_query_engine(
        response_mode="tree_summarize",
        use_async=True,
    )

    # vector query engine
    vector_query_engine = vector_index.as_query_engine()

    summary_tool = QueryEngineTool.from_defaults(
        query_engine=summary_query_engine,
        description=(
            "Useful for summarization questions related to the Lora paper."
        ),
    )

    vector_tool = QueryEngineTool.from_defaults(
        query_engine=vector_query_engine,
        description=(
            "Useful for retrieving specific context from the the Lora paper."
        ),
    )

    query_engine = RouterQueryEngine(
        selector=LLMSingleSelector.from_defaults(),
        query_engine_tools=[
            summary_tool,
            vector_tool,
        ],
        verbose=verbose
    )

    return query_engine


async def create_doc_tools(
    document_fp: str,
    doc_name: str,
    verbose: bool = True,
) -> Tuple[QueryEngineTool, QueryEngineTool]:
    # load lora_paper.pdf documents
    documents = SimpleDirectoryReader(input_files=[document_fp]).load_data()

    # chunk_size of 1024 is a good default value
    splitter = SentenceSplitter(chunk_size=1024)
    # Create nodes from documents
    nodes = splitter.get_nodes_from_documents(documents)

    # LLM model
    Settings.llm = OpenAI(model="gpt-3.5-turbo")
    # embedding model
    Settings.embed_model = OpenAIEmbedding(model="text-embedding-ada-002")

    # summary index
    summary_index = SummaryIndex(nodes)
    # vector store index
    vector_index = VectorStoreIndex(nodes)

    # summary query engine
    summary_query_engine = summary_index.as_query_engine(
        response_mode="tree_summarize",
        use_async=True,
    )

    # vector query engine
    vector_query_engine = vector_index.as_query_engine()

    summary_tool = QueryEngineTool.from_defaults(
        name=f"{doc_name}_summary_query_engine_tool",
        query_engine=summary_query_engine,
        description=(
            f"Useful for summarization questions related to the {doc_name}."
        ),
    )

    vector_tool = QueryEngineTool.from_defaults(
        name=f"{doc_name}_vector_query_engine_tool",
        query_engine=vector_query_engine,
        description=(
            f"Useful for retrieving specific context from the the {doc_name}."
        ),
    )

    return vector_tool, summary_tool

Creación de vectores y la herramienta de resumen

Vamos a utilizar la función que acabamos de crear para generar vectores y herramientas de resumen para cada uno de los documentos que hemos configurado.

import dotenv
%load_ext dotenv
%dotenv

import nest_asyncio
nest_asyncio.apply()

papers = [
    "./datasets/lora_paper.pdf",
    "./datasets/longlora_efficient_fine_tuning.pdf"
]

from utils import create_doc_tools
from pathlib import Path


paper_to_tools_dict = {}
for paper in papers:
    print(f"Creating {paper} paper tool.")
    path = Path(paper)
    vector_tool, summary_tool = await create_doc_tools(doc_name=path.stem, document_fp=path)
    paper_to_tools_dict[path.stem] = [vector_tool, summary_tool]

paper_to_tools_dict

initial_tools = [t for paper in papers for t in paper_to_tools_dict[Path(paper).stem]]
print(str(initial_tools))

len(initial_tools)

En el diagrama anterior, hemos realizado del paso 1 al paso 5. Hemos creado un resumen y un índice vectorial, asegurándonos de que tenemos 4 herramientas en total, que es también la longitud de la lista de herramientas.

Creando el Agente Trabajador

El trabajador agente es el Orquestador responsable de asignar tareas al trabajador agente. Este es el paso número 6 en el diagrama anterior.

from llama_index.llms.openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo")

from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.core.agent import AgentRunner

agent_worker = FunctionCallingAgentWorker.from_tools(
    initial_tools, 
    llm=llm, 
    verbose=True
)
agent = AgentRunner(agent_worker)

response = agent.query(
    "Explain to me what is Lora and why it's being used."
    "Explain to me what is LongLoRA and why it's being used."
    "Compare and contract LongLoRA and Lora."
)
print(str(response))

Canalización RAG Agentic Multi-Documento más avanzada

Hasta ahora hemos podido utilizar dos documentos y todo funciona correctamente. Esto lleva a un problema con más documentos que se añaden. Imagina que tuviéramos 20 documentos que serían 40 herramientas diferentes, eso es un poco salvaje:

1. Desbordamiento de la ventana de contexto: Al añadir más documentos a la ventana de contexto se añaden más herramientas, lo que puede provocar un desbordamiento de la ventana de contexto. La forma más sencilla de solucionar este problema es añadir una especie de RAG a la sección de herramientas, de forma que primero realicemos algún tipo de recuperación de las herramientas para ver qué herramienta(s) es(son) la(s) más adecuada(s) para la tarea en cuestión y, a continuación, alimentar el LLM sólo con los resultados de esa herramienta. No queremos pasar demasiadas herramientas a la ventana de contexto, es mejor recuperar primero las herramientas más relevantes y luego pasarlas al LLM.
2. Aumento de los costes: Meter muchas herramientas en la ventana de contexto significa más uso de tokens por tu parte. No sé hasta dónde llega tu bolsillo, pero es mejor que me envíes ese dinero a mí.
3. LLM puede confundirse: La investigación ha demostrado que en la mayoría de los casos, los LLM recuerdan principalmente las cosas al principio de la ventana de contexto y las del final, el concurso en el medio puede ser olvidado por el LLM. Esto significa que a pesar de las grandes ventanas de contexto que los LLMs tienen hoy en día como Gemini con su 1 millón de tokens, todavía puede sufrir de esto.

La solución a esto es realizar una recuperación de las herramientas para obtener las más relevantes y pasar estas herramientas relevantes al bucle de razonamiento del agente. Al menos esto es lo que Llama-index ha hecho en segundo plano. Proporcionan una recuperación de herramientas que ayuda en esta tarea.

Implementación de RAG multidocumento con recuperación de herramientas

Para implementar esto, te aconsejo que descargues más documentos. En mi caso, sólo utilizaré los documentos existentes con los que hemos estado trabajando hasta ahora. Si lo deseas, puedes utilizar este código para descargar más documentos.

urls = [
    "https://arxiv.org/pdf/2106.09685"
]

papers = [
    "lora_paper.pdf",
]

# poetry add wget

import wget

for url, paper in zip(urls, papers):
    !wget "{url}" -O "{paper}"

Asegúrate de ejecutar el comando para instalar wget

$ poetry add wget

Pero en aras de la simplicidad y para ahorrar tiempo a todo el mundo, me ceñiré a los documentos que ya hemos estado utilizando:

papers = [
    "./datasets/lora_paper.pdf",
    "./datasets/longlora_efficient_fine_tuning.pdf"
]

from utils import create_doc_tools
from pathlib import Path


paper_to_tools_dict = {}

for paper in papers:
    print(f"Creating {paper} paper tool.")
    path = Path(paper)
    vector_tool, summary_tool = await create_doc_tools(doc_name=path.stem, document_fp=path)
    paper_to_tools_dict[path.stem] = [vector_tool, summary_tool]

tools_list = [t for paper in papers for t in paper_to_tools_dict[Path(paper).stem]]
print(str(tools_list))

Crea el ObjectIndex que utilizaremos para recuperar las herramientas más adecuadas:

from llama_index.core import VectorStoreIndex
from llama_index.core.objects import ObjectIndex

obj_index = ObjectIndex.from_objects(
    tools_list,
    index_cls=VectorStoreIndex,
)

obj_retriever = obj_index.as_retriever(similarity_top_k=3)

retrieved_tools = obj_retriever.retrieve(
    "Write me a summary of the LoRA paper."
    "Write me a summary of the LongLoRA paper."
    "Compare and contract LongLoRA and Lora."
)
print(str(retrieved_tools))

From these set of questions, we can view the tools that have been selected through retrieval:

for tool in retrieved_tools:
    print(tool.metadata.name)

Creación del agente

Necesitaremos crear el agente runner y el agente worker:

from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.core.agent import AgentRunner

agent_worker = FunctionCallingAgentWorker.from_tools(
    tool_retriever=obj_retriever,
    llm=llm, 
    system_prompt=""" \
You are an AI agent programmed to respond to questions based on a 
specified collection of documents. Always utilize the tools available 
to generate answers, ensuring that responses are based directly on the 
provided materials rather than on any pre-existing knowledge. All your responses should be formatted in markdown text
""",
    verbose=True
)
agent = AgentRunner(agent_worker)

We can then go ahead and call the agent:

response = agent.query(
    "Write me a summary of the LoRA paper."
    "Write me a summary of the LongLoRA paper."
    "Compare and contract LongLoRA and Lora."
)
print(str(response))

Conclusión

Enhorabuena por haber llegado hasta aquí. En este artículo hemos visto cómo trabajar con un bucle de razonamiento multipaso sobre múltiples documentos en un sistema RAG agéntico. No sólo hemos visto la implementación de alto nivel, sino también el funcionamiento de bajo nivel del bucle de razonamiento multipaso.

Esperamos que este artículo te proporcione una clara comprensión de la capacidad de razonamiento multipaso sobre múltiples documentos.

Otras plataformas en las que puedes ponerte en contacto conmigo:

1. YouTube
2. Twitter
3. LinkedIn
4. Discord

The post Agentic RAG With Llama-index | Capacidad de razonamiento multipaso sobre múltiples documentos #04 first appeared on Planeta Chatbot.

También pueden convertirse en materiales de referencia para la clase después de la sesión.
Así que aquí está la primera parte de la clase (1 de 4), que es todo acerca de llamar a las API de AI proveedor a través de las API REST y bibliotecas.

• Descargo de responsabilidad: esto se supone que es material introductorio por lo que hay un montón de cosas que he dejado fuera. Esto no es ni pretende ser exhaustivo.

Empecemos con un calentamiento. Con esto me refiero a llamar a algunas APIs. Llamar a APIs para hacer IA es la forma más común y sencilla de acceder a las capacidades de la IA. Mucha gente desprecia esto y lo considera «no lo suficientemente IA». Pero eso es una tontería: el valor del sistema es ofrecer capacidades a los usuarios, no cuánta IA se utiliza.

Actualmente existen muchos proveedores con API, como OpenAI (GPT), Google (Gemini), Anthropic (Claude), Mistral (Mistral), Cohere (Command), etc. Además de estos hay proveedores de plataformas que proporcionan varias capacidades como Replicate, Anyscale, Modal, Banana, etc.
En este artículo, vamos a empezar simplemente con la llamada a las REST API.

REST API

Que yo sepa, todos los proveedores tienen una REST API. Llamarlos es muy simple, sólo tenemos que utilizar curl con un punto final de la URL de la API, y pasarle la clave de la API, y la carga JSON.

Aquí hay un ejemplo de llamada a la API de OpenAI para completar chats.

$ curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ]
  }'

Necesitas una clave API válida, que puede obtener de cada proveedor. La mayoría de las veces basta con registrarse para obtener una cuenta y crear una clave de API. Una vez que tengas la clave API, puedes introducirla directamente o establecerla como variable de entorno:

$ export OPENAI_API_KEY=<your API key>

Cuando llames a la API, deberías devolver algo como esto:

{
  "id": "chatcmpl-9RWBzicE7v7A1ZRLWUMX3a6zwooWd",
  "object": "chat.completion",
  "created": 1716345631,
  "model": "gpt-4o-2024-05-13",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The sky appears blue due to a phenomenon called Rayleigh scattering. Here’s a more detailed explanation:\n\n1. **Sunlight Composition**: Sunlight, or white light, is composed of a spectrum of colors, each with different wavelengths. The visible spectrum ranges from shorter wavelengths (blue and violet) to longer wavelengths (red and orange).\n\n2. **Interaction with the Atmosphere**: When sunlight enters Earth's atmosphere, it encounters molecules and small particles. The shorter wavelengths of light (blue and violet) are scattered more effectively by these particles than the longer wavelengths (red, orange, and yellow). \n\n3. **Human Perception**: While violet light is scattered even more than blue light, our eyes are more sensitive to blue light and there is less violet light in sunlight to begin with. Moreover, some of the violet light is absorbed by the upper atmosphere. As a result, we see the sky as blue.\n\n4. **Resulting Blue Sky**: The scattered blue light is what predominantly reaches our eyes from various directions, making the sky look blue when viewed from the ground during the day.\n\nThis scattering effect is more pronounced when the sun is lower in the sky, which is why we see reddish colors at sunrise and sunset. In these cases, the light has to pass through more of the atmosphere, scattering out even more blue and green light, and leaving the reds and oranges to dominate the sky's appearance."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 23,
    "completion_tokens": 286,
    "total_tokens": 309
  },
  "system_fingerprint": "fp_729ea513f7"
}

Tal vez OpenAI fue el primero que ideó este tipo de API, o tal vez porque es el más popular, muchos otros proveedores utilizan también un formato similar en sus REST API. Por ejemplo, esta es la de Anthropic.

$ curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-3-opus-20240229",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Why is the sky blue?"}
    ]
}'

Como puedes ver, la clave API se pasa a través de una cabecera diferente pero la carga útil es casi exactamente la misma aunque hay ligeras diferencias debido a cómo funciona el modelo. Por ejemplo, no puedes pasar el contenido del rol del sistema como parte de los mensajes en Anthropic.

Este es otro ejemplo, de Mistral.

$ curl https://api.mistral.ai/v1/chat/completions \
     --header 'Content-Type: application/json' \
     --header 'Accept: application/json' \
     --header "Authorization: Bearer $MISTRAL_API_KEY" \
     --data '{
    "model": "mistral-large-latest",
    "messages": [
     {
        "role": "user",
        "content": "Why is the sky blue?"
      }
    ]
  }'

Dicho esto, Google utiliza un enfoque ligeramente diferente de la API, y pasa la clave de la API como parte de la consulta de la URL, y el modelo está incrustado como parte de la URL. La carga útil también es diferente, pero la idea es prácticamente la misma.

$ curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=$API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{ "contents":[
    { "parts":[{"text": "Why is the sky blue?"}]}
  ]
}'

Las REST API son realmente útiles y prácticamente universales. Si estás programando en un lenguaje que no está soportado directamente por el proveedor, puedes utilizar una librería cliente HTTP y llamar directamente a la API REST. Todos los lenguajes de programación razonables tienen una biblioteca cliente HTTP, ya sea en sus bibliotecas estándar o en las de terceros, así que ya está.

Sin embargo, la mayoría de los proveedores también ofrecen soporte para Python como mínimo, principalmente porque la mayoría de las cosas de IA se programan con Python.

Python

Por ejemplo, así es como se puede llamar a OpenAI utilizando su biblioteca Python.

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="gpt-4o",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Why is the sky blue?"}
  ]
)

print(completion.choices[0].message.content)

Es así de sencillo. Puedes configurar parámetros y opciones al crear el cliente, pero eso es todo. Habrás notado que ya no necesitamos especificar la clave de la API. Eso es porque si has configurado la clave de la API como una variable de entorno, la biblioteca Python la recogerá allí.

Lo mismo ocurre con Anthropic.

import anthropic

message = anthropic.Anthropic().messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Why is the sky blue?"}
    ]
)

print(message.content)

Además de con Mistral.

from mistralai.client import MistralClient
from mistralai.models.chat_completion import ChatMessage

client = MistralClient()

chat_response = client.chat(
    model="mistral-large-latest",
    messages=[
        ChatMessage(role="user", content="Why is the sky blue?")
    ],
)

print(chat_response.choices[0].message.content)

La biblioteca Python de Google también es muy fácil de usar, aunque es ligeramente diferente del resto.

import google.generativeai as genai

model = genai.GenerativeModel('gemini-1.5-flash-latest')
chat = model.start_chat(history=[])
response = chat.send_message("Why is the sky blue?")

print(response.text)

Como puedes ver, Python está muy bien soportado. El otro lenguaje bien soportado es Javascript.

Javascript

Aunque Python es el lenguaje mejor soportado, debido a su enorme popularidad, Javascript/Typescript también suele serlo. Echemos un vistazo a cómo acceder a las APIs de OpenAI usando Javascript con node.js.

import OpenAI from "openai";

const openai = new OpenAI();

const completion = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: "Why is the sky blue?" }
  ],    
});

console.log(completion.choices[0]);

Como antes en las librerías Python, ya no necesitamos especificar la clave API. Eso es porque si has configurado la clave API como una variable de entorno la librería Javascript la recogerá ahí.

Esta es la salida del resultado JSON (sólo el completion.choices[0]).

{
  index: 0,
  message: {
    role: 'assistant',
    content: "The sky appears blue because of a phenomenon called Rayleigh scattering. This scattering occurs when sunlight enters Earth's atmosphere and interacts with the molecules and small particles in the air.\n" +
      '\n' +
      "Here's a step-by-step breakdown of why the sky looks blue:\n" +
      '\n' +
      '1. **Sunlight Composition**: Sunlight, or white light, is made up of multiple colors, each with different wavelengths. The colors range from violet and blue (shorter wavelengths) to red and orange (longer wavelengths).\n' +
      '\n' +
      '2. **Scattering**: As sunlight passes through the atmosphere, it collides with gas molecules and small particles. The shorter wavelengths of light (blue and violet) are scattered in all directions by these molecules and particles much more than the longer wavelengths (red and orange).\n' +
      '\n' +
      '3. **Human Perception**: Even though violet light is scattered even more than blue light, our eyes are more sensitive to blue light and less sensitive to violet light. Additionally, some of the violet light is absorbed by the upper atmosphere. Therefore, the sky predominantly appears blue to us.\n' +
      '\n' +
      '4. **Viewing Angle**: When you look up at the sky, you are seeing this scattered blue light coming from all parts of the sky, giving it its characteristic color.\n' +
      '\n' +
      "In summary, the sky is blue because the shorter blue wavelengths of sunlight are scattered more widely in all directions by the molecules in Earth's atmosphere, and our eyes are better equipped to see blue light."
  },
  logprobs: null,
  finish_reason: 'stop'
}

Del mismo modo, así es como se puede llamar a la API antrópica utilizando Javascript con node.js.

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

const completion = await anthropic.messages.create({
  model: "claude-3-haiku-20240307",
  max_tokens: 1024,
  messages: [
    {"role": "user", "content": "Why is the sky blue?"}
  ]
});

console.log(completion);

No voy a seguir con los otros proveedores, pero más o menos te haces una idea. Si prefieres trabajar con las librerías soportadas oficialmente, Python y Javascript son el camino a seguir. Además de la API REST, Python y Javascript, la mayoría de los proveedores no tienen soporte oficial para otros lenguajes, aunque Google tiene una gama mucho más amplia de lenguajes soportados.

Sin embargo, esto no significa que no haya bibliotecas para otros lenguajes.

Bibliotecas de terceros

Existen multitud de librerías de terceros. Si echas un vistazo a la documentación de OpenAI, verás que hay librerías de terceros para casi todos los lenguajes populares. Por ejemplo, el paquete go-openai permite llamar a las bibliotecas de OpenAI en Go.

package main

import (
 "context"
 "fmt"
 "os"

 openai "github.com/sashabaranov/go-openai"
)

func main() {
 client := openai.NewClient(os.Getenv("OPENAI_API_KEY"))
 resp, err := client.CreateChatCompletion(
  context.Background(),
  openai.ChatCompletionRequest{
   Model: openai.GPT4o,
   Messages: []openai.ChatCompletionMessage{
    {
     Role:    openai.ChatMessageRoleUser,
     Content: "Why is the sky blue?",
    },
   },
  },
 )

 if err != nil {
  fmt.Printf("ChatCompletion error: %v\n", err)
  return
 }

 fmt.Println(resp.Choices[0].Message.Content)
}

Aquí tienes una librería OpenAI de terceros para Swift, llamada SwiftOpenAI. Para usarla, añádela como dependencia del paquete en tu proyecto XCode. Este es un ejemplo de una función para llamar a las APIs de OpenAI.

    func sendMessage() async {
        let input = userInput.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !input.isEmpty else { return }
        
        let message = Message(content: input, isUser: true)
        messages.append(message)
        userInput = ""
        
        let openAI = SwiftOpenAI(apiKey: Config.openAIKey)
        let msgs: [MessageChatGPT] = [
            MessageChatGPT(text: "You are a helpful assistant.", role: .system),
            MessageChatGPT(text: input, role: .user)
        ]
        
        let optionalParameters = ChatCompletionsOptionalParameters(
            temperature: 0.7,
            stream: true,
            maxTokens: 1024
        )
        
        do {
            let stream = try await openAI.createChatCompletionsStream(
                model: .gpt4o(.base),
                messages: msgs,
                optionalParameters: optionalParameters
            )
            
            let resp = Message(content: "", isUser: false)
            messages.append(resp)
            
            for try await response in stream {
                let content = response.choices[0].delta?.content ?? ""
                if let lastMessage = messages.last, !lastMessage.isUser {
                    let updatedContent = lastMessage.content + content
                    messages[messages.count - 1] = Message(content: updatedContent, isUser: false)
                }
            }
        } catch {
            print("Error: \(error)")
            if let lastMessage = messages.last, !lastMessage.isUser {
                messages[messages.count - 1] = Message(content: "Cannot get response from OpenAI: \(error)", isUser: false)
            }
        }
    }

Todas estas librerías de terceros son buenas pero en su mayoría sólo soportan 1 proveedor. Si quieres acceder a múltiples proveedores normalmente necesitas usar varias librerías a la vez, o también puedes probar frameworks LLM.

LLM Frameworks

Los frameworks de LLM son un tipo de marco de desarrollo que nos permite escribir aplicaciones basadas en LLM. Estos frameworks proveen soporte y estructura, y usualmente una forma determinada de escribir aplicaciones basadas en LLM.

Hay un gran número de frameworks LLM, y algunos de ellos son muy populares, más que las librerías con soporte oficial o de terceros. Esto se debe a que estos frameworks proporcionan a los desarrolladores un montón de capacidades. Nos permiten conectarnos a múltiples proveedores LLM al mismo tiempo, tiene conectores a múltiples fuentes de datos e incluso implementar agentes sobre los LLM básicos.

Hay un gran número de frameworks incluyendo Langchain, LlamaIndex, Haystack, etc. pero en este artículo sólo hablaré de Langchain y LlamaIndex, ya que actualmente son los dos frameworks más populares para construir aplicaciones basadas en LLM.

Langchain

El framework más popular es probablemente Langchain, que fue publicado por primera vez en octubre de 2022. Ha evolucionado rápidamente desde entonces para cubrir casi todo en el mundo LLM, culminando en cerca de 400 versiones hasta la fecha. En un momento dado, las versiones eran casi diarias, ¡e incluso a veces dos al día!

Durante el último año Langchain ha pasado de ser una librería Python relativamente simple a un ecosistema de capacidades que van desde la librería central a un servidor de despliegue y un conjunto de herramientas de observabilidad.

Aquí está lo básico de cómo utilizar Langchain para conectarse a OpenAI y llamar a su API de chat.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model_name="gpt-4o")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{input}")
])
output_parser = StrOutputParser()

chain = prompt | llm | output_parser
results = chain.invoke({"input": "why is the sky blue?"})

print(results)

El código no parece muy diferente a simple vista, pero te habrás dado cuenta de que hemos encadenado el prompt del chat, LLM y el parser de salida para producir los resultados. Este es un ejemplo de una de las características más poderosas de Langchain y la que le dio a Langchain su nombre – la cadena.

Una cadena es una secuencia de llamadas enlazadas entre sí. Las cadenas se crean usando el Lenguaje de Expresión Langchain (LCEL) y la cadena más básica es la que se muestra arriba:

chain = prompt | llm | output_parser

Para ejecutar la cadena, simplemente llamamos a uno de los pocos métodos de la cadena (en el caso del código anterior, usamos invoke) con la entrada apropiada, y obtendremos la salida.

Las cadenas son potentes y configurables. Veamos cómo queremos realizar una sencilla generación aumentada de recuperación (RAG) pasando el contexto junto con la pregunta al LLM.

Utilizaremos un documento de texto, en este caso, los procedimientos parlamentarios en Singapur sobre el Comité de Suministros para el Ministerio de Comunicaciones e Información (MCI) en enero de 2024. Saqué el texto del sitio y lo guardé como un archivo de texto llamado hansard.txt.

from langchain_community.vectorstores import DocArrayInMemorySearch
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableParallel, RunnablePassthrough
from langchain_openai import OpenAIEmbeddings
from langchain_openai import ChatOpenAI

def extract(file_path):
    with open(file_path, 'r') as file:
        return [line.strip() for line in file if line.strip()]


model = ChatOpenAI(model="gpt-4o")
vectorstore = DocArrayInMemorySearch.from_texts(
    texts=extract('data/hansard.txt'),
    embedding=OpenAIEmbeddings(),
)
retriever = vectorstore.as_retriever()
template = """Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)
output_parser = StrOutputParser()
setup_and_retrieval = RunnableParallel(
    {"context": retriever, "question": RunnablePassthrough()}
)
chain = setup_and_retrieval | prompt | model | output_parser

results = chain.invoke("How has Smart Nation improved citizen's lives?")
print(results)

En el código anterior, primero creamos un almacén de vectores en memoria a partir de cada línea del documento hansard.txt, utilizando incrustaciones de OpenAI. A partir del almacén de vectores, creamos un recuperador, que nos permite obtener las líneas apropiadas como entrada para el prompt.

Ahora, dada una entrada del usuario, la pasamos al recuperador para obtener las líneas del almacén de vectores. La misma entrada del usuario también se pasa al prompt. Estos 2 son ejecutados al mismo tiempo por RunnableParallel, y la salida es enviada al prompt como la pregunta y el contexto.

El resto es más o menos lo mismo, pero aquí está la salida.

% python langchain_test_rag.py
The Smart Nation initiative has improved citizens' lives in Singapore by increasing satisfaction with government services, which rose from 73% to 83% between 2014 and 2023. Additionally, 84% of Singaporeans feel that digital technologies have made their lives easier. The initiative aims to enhance everyday convenience and quality of life, empower people to live more meaningful and fulfilled lives, and ensure that no one is left behind.

Como puedes ver, las cadenas son un mecanismo muy potente. Este mecanismo de encadenamiento no es exclusivo de Langchain. El framework Haystack, que también es un framework LLM bastante popular por sí mismo, lo llama pipeline, mientras que otros frameworks como LLMFlows lo llaman flow.

LlamaIndex

Otro framework LLM popular es LlamaIndex. LlamaIndex comenzó en noviembre de 2022 como un framework llamado GPTIndex . La premisa de LlamaIndex es conectar LLMs a sus datos. Puedes notar que tanto LlamaIndex como Langchain empezaron más o menos al mismo tiempo. De hecho, ambos creadores de Langchain (Harrison Chase) y LlamaIndex (Jerry Liu) eran compañeros en Robust Intelligence, una empresa de seguridad de IA.

Echemos un vistazo rápido a cómo utilizar LlamaIndex para completar chats.

from llama_index.core import Settings
from llama_index.core.llms import ChatMessage
from llama_index.llms.openai import OpenAI

Settings.llm = OpenAI(model="gpt-4o")
messages = [
    ChatMessage(
        role="system", content="You are a helpful assistant."
    ),
    ChatMessage(role="user", content="Why is the sky blue?"),
]
resp = OpenAI().chat(messages)
print(resp)

Como se puede ver, esto no es muy diferente de Langchain o cualquier API, pero la ventaja LlamaIndex tiene es su enfoque en la conexión con los datos. Como era de esperar, el código para hacer un RAG sencillo es bastante simple.

from llama_index.core import Settings, VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI

Settings.llm = OpenAI(model="gpt-4o")

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("How has Smart Nation improved citizen's lives?")
print(response)

En primer lugar, tomamos los archivos del directorio de datos (que no es más que nuestro archivo hansard.txt) y los almacenamos en un almacén vectorial. Después usamos ese almacén vectorial como motor de consulta y le enviamos una consulta, y usará los datos de nuestro documento para formar su respuesta.

Langchain y LlamaIndex son dos potentes frameworks tras el rápido ritmo de evolución. Cada uno de ellos tiene sus propias fortalezas y en este momento, el uso de cualquiera de ellos depende principalmente de la preferencia personal.

Resumen

Esta es la primera parte de la clase que impartiré sobre programación con IA. En el próximo artículo, profundizaré en los LLM locales, es decir, los LLM que puedes implementar en tus propias máquinas, incluso en tu propio portátil.

The post Programación con IA – Llamando a APIs first appeared on Planeta Chatbot.

El potencial económico de la IA generativa

La IA generativa está preparada para revolucionar la productividad mundial, añadiendo potencialmente entre 2,6 y 4,4 billones de dólares anuales a la economía en diversos sectores, una suma comparable a todo el PIB del Reino Unido en 2021. Esta estimación, que podría duplicarse si la IA generativa se integra más ampliamente en el software existente, sugiere un impacto transformador que podría aumentar las contribuciones globales de la IA entre un 15 y un 40 por ciento. Sectores clave como las operaciones de atención al cliente, el marketing, la ingeniería de software y la I+D serán los más beneficiados, ya que se espera que la IA generativa automatice una parte significativa de las actividades laborales, liberando potencialmente entre un 60 y un 70% del tiempo que los empleados dedican actualmente a tareas rutinarias.

Se prevé que sectores como la banca, la alta tecnología y las ciencias de la vida experimenten un aumento sustancial de los ingresos gracias a la adopción de la IA generativa, que podría alcanzar los cientos de miles de millones anuales. A pesar de sus promesas, aprovechar todo el potencial de la IA generativa exigirá una gestión cuidadosa de las transiciones de la mano de obra, la inversión en nuevas competencias y la resolución de los retos éticos y operativos inherentes a su despliegue.

En particular, el valor potencial del uso de la IA generativa para varias funciones que ocupaban un lugar destacado en nuestro anterior dimensionamiento de los casos de uso de la IA, incluidas las funciones de fabricación y cadena de suministro, es ahora mucho menor. Esto se explica en gran medida por la naturaleza de los casos de uso de la IA generativa, que excluyen la mayoría de las aplicaciones numéricas y de optimización que eran los principales impulsores del valor de las aplicaciones anteriores de la IA. (Fuente – McKinsey – Junio 2023)

La evolución de la IA generativa

La IA Generativa está revolucionando las industrias mediante la automatización de tareas complejas, la mejora de los procesos creativos y el análisis perspicaz de los datos. Capaces de generar texto, imágenes e incluso código, modelos como GPT-4 y DALL-E están permitiendo a las empresas conseguir más con menos esfuerzo. Esta tecnología aprovecha grandes conjuntos de datos y algoritmos avanzados para producir resultados de alta calidad que emulan la creatividad y la toma de decisiones humanas.

Desde sus inicios en la década de 1950, la IA generativa ha experimentado un crecimiento exponencial, transformando fundamentalmente el campo de la inteligencia artificial. A lo largo de las décadas, numerosos investigadores e ingenieros han impulsado el desarrollo de la IA generativa, desencadenando una oleada de innovaciones que siguen configurando nuestro presente y nuestro futuro.

Mercado de la IA Generativa y trayectoria de crecimiento

La IA generativa, un subconjunto de la inteligencia artificial, utiliza algoritmos como GAN (Generative Adversarial Networks) y VAE (Variational Autoencoders) para crear nuevos datos que se parezcan mucho a sus conjuntos de datos de entrenamiento. En 2023, el mercado global de IA generativa se valoró en 14,16 mil millones de dólares y se prevé que se dispare a 96,35 mil millones de dólares en 2029, exhibiendo una tasa de crecimiento anual compuesto (CAGR) del 37,65% durante el período de pronóstico. (Fuente – Arizton – 7 de junio de 2024)

El mercado de la IA generativa está experimentando un crecimiento extraordinario a medida que las empresas reconocen cada vez más su potencial transformador en diversos sectores. Examinemos las cifras que ponen de relieve el éxito de esta tecnología innovadora.

Cómo piensa su CEO sobre la IA

La encuesta anual de Gartner a CEOs y altos ejecutivos revela que la IA, en particular la IA generativa (GenAI), ha captado la atención de los CEOs más que cualquier otra tecnología, señalando una nueva ola de transformación tras la era digital. Con un 34% de los CEOs seleccionando la IA como la tecnología más impactante para sus industrias, y un notable 64% creyendo en los avances de 2023, la encuesta destaca un fuerte sentimiento alcista hacia el potencial de la IA. Los CEO se muestran entusiasmados con la capacidad de la GenAI para mejorar la productividad e impulsar el valor estratégico, aunque muchos siguen sin saber exactamente cómo aumentará los ingresos, a menudo confundiendo las mejoras de la eficiencia con las ganancias directas de ingresos. Este entusiasmo subraya la importancia de los líderes técnicos, como los CIO, CTO y CDO, a la hora de definir e impulsar las estrategias de IA, mientras que un pequeño porcentaje de CEO están asumiendo esta responsabilidad por sí mismos.

Los CEO esperan que los líderes técnicos impulsen el valor estratégico de la IA

• La mitad de los CEO confían en que su CIO, CTO o CDO defina y encabece activamente el cambio que impulsará un valor estratégico significativo de la GenAI.
• Sin embargo, el 13% de los CEO se han puesto a sí mismos al frente de la GenAI.
• Cuando se trata de funciones no técnicas, porcentajes más pequeños de CEO se apoyan en los CFO (8%), COO (7%) y CSO (5%) para liderar estratégicamente los esfuerzos de GenAI.

Los CEO esperan que la GenAI impulse la productividad

• El 49% de los CEO encuestados indicaron que tienen un plan de productividad de la plantilla que incluye GenAI.
• Más de un tercio de los CEOs cuyo plan de productividad del personal incluye la aplicación de GenAI esperan que la tecnología genere un aumento de la productividad de la empresa superior al 15% en los próximos dos años.
• Hubo poca variación en el aumento de la productividad esperada por sector, lo que sugiere que los CEO aún no tienen mucha información específica sobre cómo exactamente el uso de GenAI cambiará la productividad general.

El 87% de los consejeros delegados está de acuerdo en que los beneficios de la IA para su empresa son mayores que sus riesgos. – Fuente: Gartner.

Los directores generales son imprecisos sobre cómo la IA aumentará los ingresos

• El 86% de los CEO cree que este año y el próximo la IA puede ayudar a mantener o aumentar los ingresos de la empresa.
• Cuando se les preguntó cómo, los CEO apuntaron a mejorar la experiencia del cliente, aumentar la productividad del talento y añadir inteligencia y análisis.
• Esto sugiere que los CEO están confundiendo la eficiencia general con la obtención de ingresos. Sólo más abajo en la lista encontramos mecanismos más directos y sustanciales de obtención de ingresos, como nuevos productos, marketing más específico y personalización.

IA generativa para la productividad empresarial en el mundo real

A medida que el bombo publicitario que rodea a la IA generativa se va asentando y pasamos el bache de la desilusión, es hora de adentrarse en el verdadero trabajo que tenemos por delante. En este séptimo episodio de Top of Mind, el Jefe de Investigación de Gartner, Chris Howard, explora aplicaciones tangibles y prácticas de GenAI que abarcan sectores y funciones empresariales clave, como marketing, cadena de suministro, finanzas y jurídico. Chris analiza cómo los experimentos y pilotos de gran alcance en estos espacios están allanando el camino para mejorar la productividad y aumentar la adopción de esta tecnología innovadora.

Aplicaciones innovadoras de la IA Generativa en las empresas

La IA generativa ofrece multitud de aplicaciones en diversas funciones corporativas:

1. Generación de código

• Aplicación: Los desarrolladores de software y programadores utilizan IA generativa para escribir código.
• Ventajas: Los desarrolladores experimentados se apoyan en la IA generativa para avanzar en tareas de codificación complejas de manera más eficiente. También desempeña un papel importante en la identificación y corrección de errores y en la automatización de las pruebas de código, garantizando que el código cumpla los estándares de calidad sin un gran esfuerzo manual.
• Ejemplo: GitHub Copilot, impulsado por OpenAI Codex, ayuda a los desarrolladores sugiriendo fragmentos de código, autocompletando líneas y generando funciones completas basadas en comentarios y contexto dentro del editor de código.
• Fuente: GitHub Copilot

2. Desarrollo del producto

• Aplicación: Los diseñadores de productos utilizan IA generativa para optimizar conceptos de diseño a gran escala.
• Ventajas: Esta tecnología agiliza el proceso de diseño, garantizando que los productos sean resistentes, duraderos y rentables. Los gestores de productos emplean la IA generativa para sintetizar los comentarios de los usuarios, lo que permite mejorar los productos directamente influidos por las necesidades de los usuarios.
• Ejemplo: La herramienta de diseño generativo de Autodesk, utilizada por Airbus para crear componentes de avión más ligeros y eficientes. La IA generó numerosas iteraciones de diseño que optimizaron el uso de materiales y la integridad estructural.
• Fuente: Autodesk and Airbus

3. Ventas y marketing

• Aplicación: La IA generativa ayuda a crear una comunicación hiperpersonalizada para campañas de marketing a través de varios canales.
• Beneficios: Impulsa el rendimiento del equipo al proporcionar análisis profundos y conocimientos sobre el comportamiento del cliente. Los departamentos de marketing utilizan esta tecnología para comprender los patrones de comportamiento de los consumidores y elaborar contenidos que resuenen con su audiencia.
• Ejemplo: Persado utiliza IA para generar mensajes de marketing personalizados que resuenen con los clientes, mejorando el compromiso y las tasas de conversión.
• Fuente: Persado

4. Gestión de proyectos y operaciones

• Aplicación: Las herramientas de IA generativa apoyan a los gestores de proyectos mediante la automatización de la generación de tareas, el aprovechamiento de los datos históricos para prever los plazos y la predicción de riesgos.
• Ventajas: Estas herramientas permiten a los gestores de proyectos centrarse en la estrategia de más alto nivel en lugar de en la gestión empresarial diaria.
• Ejemplo: Asana utiliza IA para ayudar en la gestión de tareas, proporcionando sugerencias inteligentes para la priorización de tareas y la planificación de proyectos.
• Fuente: Asana

5. Diseño gráfico y vídeo

• Aplicación: La IA generativa crea imágenes realistas y agiliza la animación, lo que permite crear vídeos sin actores ni conocimientos de edición.
• Ventajas: Los generadores de vídeo de IA pueden producir vídeos en varios idiomas, atendiendo eficazmente a diversas regiones.
• Ejemplo: Synthesia utiliza la IA para crear vídeos profesionales con avatares de IA, lo que permite crear contenidos sin necesidad de cámara ni equipo.
• Fuente: Synthesia

6. Gestión de empresas y empleados

• Aplicación: En atención al cliente, la IA generativa facilita el acceso a la documentación, mejorando la eficiencia en la resolución de casos.
• Beneficios: Mejora las interacciones entre empleados y directivos estructurando las revisiones de rendimiento y proporcionando feedback a través de portales de IA conversacional.
• Ejemplo: Lattice utiliza IA para ayudar a los gerentes a proporcionar retroalimentación continua sobre el desempeño y crear revisiones de desempeño estructuradas.
• Fuente: Lattice

7. Atención al cliente y servicio de atención al cliente

• Aplicación: Los avances en IA generativa permiten chatbots más innovadores que entienden el contexto y los matices, proporcionando atención al cliente 24/7.
• Ventajas: Estos chatbots potenciados por IA gestionan las consultas de los clientes las 24 horas del día, ofreciendo una experiencia de usuario fluida.
• Ejemplo: El Answer Bot de Zendesk utiliza IA para proporcionar respuestas instantáneas a las consultas de los clientes, mejorando los tiempos de respuesta y la satisfacción del cliente.
• Fuente: Bot de respuesta de Zendesk

8. Detección de fraudes y gestión de riesgos

• Aplicación: La IA generativa escanea y resume rápidamente grandes cantidades de datos para identificar patrones o anomalías.
• Ventajas: Genera informes personalizados para suscriptores y peritos de siniestros, ahorrando tiempo y simplificando la toma de decisiones.
• Ejemplo: Darktrace utiliza IA para detectar y responder a las ciberamenazas en tiempo real, protegiendo a las empresas del fraude y los ciberataques.
• Fuente: Darktrace

9. Generación de datos sintéticos para entrenamiento y pruebas

• Aplicación: Las empresas utilizan la IA generativa para crear datos sintéticos para entrenar modelos, probar productos y simular escenarios del mundo real.
• Ventajas: Esto reduce la dependencia de fuentes de datos sensibles o costosas, acelerando los ciclos de desarrollo.
• Ejemplo: Mostly AI proporciona soluciones de datos sintéticos para crear conjuntos de datos realistas y que preserven la privacidad para el entrenamiento de modelos de IA.
• Fuente: Mostly AI

10. Creación y gestión de contenidos

• Aplicación: La IA generativa puede crear contenidos de alta calidad para blogs, redes sociales y materiales de marketing.
• Ventajas: Ayuda a mantener una voz de marca coherente y reduce el tiempo necesario para producir contenidos, lo que permite a los equipos de marketing centrarse en la estrategia y el compromiso.
• Ejemplo: Jasper AI genera entradas de blog, contenidos para redes sociales y textos de marketing, ayudando a las empresas a agilizar sus procesos de creación de contenidos.
• Fuente: Jasper AI

11. Modelización y previsión financiera

• Aplicación: La IA generativa puede crear modelos financieros detallados y previsiones basadas en datos históricos y tendencias del mercado.
• Ventajas: Esto ayuda a los equipos financieros a hacer predicciones más precisas y tomar decisiones informadas.
• Ejemplo: Tesorio utiliza la IA para predecir el flujo de caja y gestionar el capital circulante, ayudando a las empresas a optimizar sus operaciones financieras.
• Fuente: Tesorio

12. Recursos humanos y contratación

• Aplicación: La IA generativa puede automatizar el proceso de contratación mediante la selección de currículos y la generación de preguntas para las entrevistas.
• Ventajas: Garantiza un proceso de selección más eficiente e imparcial, ayudando a los equipos de RRHH a identificar a los mejores candidatos más rápidamente.
• Ejemplo: HireVue utiliza IA para analizar entrevistas en vídeo y evaluar la idoneidad de los candidatos, agilizando el proceso de contratación.
• Fuente: HireVue

13. Análisis y redacción de documentos jurídicos

• Aplicación: La IA generativa puede analizar documentos legales, redactar contratos y resumir jurisprudencia.
• Ventajas: Esto reduce la carga de trabajo de los equipos jurídicos, garantiza la precisión y coherencia de la documentación jurídica y acelera el proceso de redacción.

Ejemplos:

1. LawGeex: Utiliza IA para revisar contratos y automatizar flujos de trabajo legales. Ahorra tiempo en el análisis de grandes volúmenes de contratos para acuerdos de confidencialidad, acuerdos de servicio y otros. Esta herramienta ayuda a crear coherencia entre los contratos y reduce el tiempo y el coste del proceso de revisión (ClickUp).
2. Lexis+ AI: Esta herramienta de LexisNexis extrae, analiza y resume información clave de documentos jurídicos. Ayuda a los abogados a localizar información crucial, generar resúmenes de documentos extensos y agilizar la redacción de memorandos y cartas legales (LexisNexis).
3. LegalSifter: Esta herramienta de IA genera los primeros borradores de contratos, informes jurídicos, memorandos y cartas utilizando plantillas y datos clave. Mejora significativamente la productividad, permitiendo a los abogados centrarse en tareas estratégicas de mayor nivel (Marketing Scoop).
4. Amto: Utiliza IA generativa basada en ChatGPT para redactar varios documentos legales, incluidos acuerdos de servicios, contratos de trabajo por encargo y acuerdos de arbitraje. También resalta secciones del texto para revisiones instantáneas y ofrece recomendaciones sobre cláusulas omitidas o lagunas en la investigación jurídica (ClickUp).
5. Kira Systems: Permite la revisión automática de contratos para identificar cláusulas clave, obligaciones, derechos y riesgos. Esta herramienta es conocida por su gran precisión y la utilizan más de 500 empresas para agilizar el proceso de análisis de contratos (Marketing Scoop).

Estos ejemplos demuestran cómo la IA generativa está transformando los flujos de trabajo jurídicos mediante la automatización de tareas repetitivas, la mejora de la precisión y la posibilidad de que los profesionales del derecho se centren en tareas más complejas y estratégicas. Herramientas como LawGeex, Lexis+ AI, LegalSifter, Amto y Kira Systems están a la vanguardia de esta transformación, proporcionando beneficios tangibles a los equipos jurídicos de todo el mundo.

14. Optimización de la cadena de suministro

• Aplicación: La IA generativa puede optimizar las operaciones de la cadena de suministro mediante la predicción de la demanda, la gestión del inventario y la identificación de posibles interrupciones.
• Ventajas: Aumenta la eficiencia y reduce los costes al garantizar una cadena de suministro más receptiva y resistente.
• Ejemplo: ClearMetal utiliza la IA para proporcionar visibilidad en tiempo real de las operaciones de la cadena de suministro, optimizando la logística y la gestión del inventario.
• Fuente: ClearMetal

15. Diagnóstico sanitario y planificación del tratamiento

• Aplicación: La IA generativa puede ayudar a diagnosticar enfermedades y planificar tratamientos analizando los datos médicos y el historial del paciente.
• Ventajas: Esto mejora la precisión de los diagnósticos y la personalización de los planes de tratamiento, mejorando los resultados de los pacientes.
• Ejemplo: PathAI utiliza IA para analizar diapositivas de patología y ayudar en el diagnóstico de enfermedades, mejorando la precisión y la velocidad de los diagnósticos médicos.
• Fuente: PathAI

16. Mejora de la experiencia del cliente

• Aplicación: La IA generativa puede personalizar las interacciones con los clientes analizando sus datos y prediciendo sus preferencias.
• Ventajas: Mejora la satisfacción y lealtad del cliente al proporcionar experiencias y soluciones a medida.
• Ejemplo: Dynamic Yield utiliza la IA para personalizar el contenido y las recomendaciones del sitio web, mejorando la experiencia del cliente.
• Fuente: Dynamic Yield

17. Gestión de la energía

• Aplicación: La IA generativa puede optimizar el uso de la energía en instalaciones corporativas prediciendo patrones de consumo y sugiriendo medidas de eficiencia.
• Ventajas: Esto reduce los costes energéticos y apoya las iniciativas de sostenibilidad.
• Ejemplo: GridPoint utiliza IA para supervisar y gestionar el uso de la energía en edificios comerciales, optimizando la eficiencia energética.
• Fuente: GridPoint

18. Personalización del comercio minorista y electrónico

• Aplicación: La IA generativa puede analizar el comportamiento de compra y personalizar las recomendaciones para los compradores en línea.
• Ventajas: Mejora la experiencia de compra y aumenta las ventas a través del marketing dirigido.
• Ejemplo: El motor de recomendaciones de Amazon utiliza IA para sugerir productos basados en el historial de navegación y compras, mejorando la satisfacción del cliente y las ventas.
• Fuente: Amazon AI

Estudios de casos reales: Transformaciones de la IA generativa en empresas corporativas

Varias empresas ya han empezado a aprovechar el poder de la IA generativa para transformar sus operaciones:

1. Accenture

• Aplicación: Accenture está ayudando a sus clientes a implementar IA generativa para estrategias de negocio más inteligentes, resumen automatizado de documentos y búsqueda cognitiva.
• Ejemplo: El Ministerio de Justicia de España utiliza Delfos, el motor de búsqueda potenciado por IA de Accenture, para agilizar el acceso a la información judicial, facilitando a los profesionales del derecho la búsqueda y el procesamiento de la información judicial.
• Fuente: Soluciones de IA de Accenture

2. Nvidia

• Aplicación: El servicio en la nube BioNeMo Drug Discovery de Nvidia acelera el descubrimiento de fármacos y la investigación en ciencias de la vida.
• Ejemplo: Los investigadores utilizan las API en la nube de Nvidia para crear modelos biomoleculares de IA personalizados, lo que acelera significativamente las primeras líneas de descubrimiento de fármacos.
• Fuente: Nvidia BioNeMo

3. Expedia

• Aplicación: El planificador de viajes ChatGPT de Expedia ofrece recomendaciones de viaje personalizadas.
• Ejemplo: Los usuarios pueden hacer preguntas y obtener recomendaciones sobre viajes, alojamiento y actividades, agilizando el proceso de planificación de viajes y mejorando la experiencia del cliente.
• Fuente: Integración de la IA de Expedia

4. Shopify

• Aplicación: La herramienta Magic de Shopify ayuda a los minoristas a generar descripciones de productos y otros contenidos utilizando IA.
• Ejemplo: Esta herramienta mejora la eficiencia y la calidad de las operaciones de comercio electrónico, permitiendo a las empresas escalar la creación de contenido sin problemas.
• Fuente: Shopify Magic

5. Stripe

• Aplicación: Stripe utiliza GPT-4 para mejorar la documentación y la gestión de consultas de los desarrolladores que utilizan Stripe Docs.
• Ejemplo: La herramienta ayuda a resumir y extraer contenido importante, haciendo que la información sea más accesible para los usuarios.
• Fuente: Stripe y OpenAI

6. Unilever

• Aplicación: Unilever ha creado un robot, Dove’s AI-powered Scalp + Hair Therapist. Los usuarios empiezan respondiendo a preguntas sobre la salud de su cuero cabelludo y sus problemas capilares. La herramienta, desarrollada utilizando capacidades de IA generativa y aprovechando la experiencia de los dermatólogos de Dove, genera un perfil personalizado del cuero cabelludo y el cabello, y comparte productos que podrían ayudar a marcar la diferencia.
• Ejemplo: Las herramientas de IA analizan los datos de los consumidores y generan contenidos a medida, mejorando significativamente las tasas de compromiso y conversión.
• Fuente: Uso de la IA por Unilever

7. Procter & Gamble

• Aplicación: Procter & Gamble utiliza IA generativa para el diseño y desarrollo de productos.
• Ejemplo: La empresa utiliza la IA para generar y probar varios conceptos de diseño, optimizando las características del producto y reduciendo el tiempo de comercialización y los costes asociados a los prototipos físicos.
• Fuente: Innovación digital de P&G

8. Coca-Cola

• Aplicación: Coca-Cola aprovecha la IA generativa para crear contenidos de marketing dinámicos.
• Ejemplo: El sistema de IA genera anuncios únicos y publicaciones en redes sociales que se adaptan a diferentes grupos demográficos, mejorando el alcance y la resonancia de la marca.
• Fuente: Iniciativas de IA de Coca-Cola

9. BMW

• Aplicación: BMW utiliza IA generativa en la fase de diseño de nuevos vehículos.
• Ejemplo: La IA genera múltiples iteraciones de diseño basadas en parámetros específicos, lo que permite a los diseñadores explorar conceptos innovadores de forma rápida y eficiente.
• Fuente: BMW y la IA

10. Pfizer

• Aplicación: Pfizer incorpora la IA generativa en los procesos de descubrimiento de fármacos.
• Ejemplo: Los modelos de IA analizan vastos conjuntos de datos para identificar posibles candidatos a fármacos, predecir sus interacciones y sugerir modificaciones para mejorar la eficacia y reducir los efectos secundarios.
• Fuente: Investigación sobre IA de Pfizer

11. IBM Watson

• Aplicación: Las capacidades de IA de IBM Watson se emplean en instituciones financieras para generar datos sintéticos con fines de prueba y formación.
• Ejemplo: Esto ayuda a salvaguardar información sensible a la vez que permite realizar simulaciones de escenarios completos.
• Fuente: IBM Watson en las finanzas

12. Adobe

• Aplicación: Las herramientas de IA generativa de Adobe, como Adobe Sensei, ayudan a los profesionales creativos automatizando tareas repetitivas.
• Ejemplo: Estas herramientas ayudan en la edición de imágenes y la producción de vídeo, permitiendo a los artistas centrarse en aspectos más creativos de su trabajo.
• Fuente: Adobe Sensei

13. JPMorgan Chase

• Aplicación: JPMorgan Chase utiliza IA generativa para la detección del fraude y la gestión del riesgo.
• Ejemplo: El sistema de IA analiza los datos de las transacciones para detectar anomalías y generar alertas de actividades sospechosas, mejorando la seguridad financiera.
• Fuente: Iniciativas de IA de JPMorgan

14. Shell

• Aplicación: Shell aprovecha la IA generativa para el mantenimiento predictivo en sus plataformas petrolíferas.
• Ejemplo: Los modelos de IA generan programas de mantenimiento e identifican posibles fallos de los equipos antes de que se produzcan, reduciendo el tiempo de inactividad y los costes operativos.
• Fuente: Aplicaciones de IA de Shell

15. Netflix

• Aplicación: Netflix emplea IA generativa para personalizar las recomendaciones de contenidos a los usuarios.
• Ejemplo: Al analizar los hábitos y preferencias de visualización, la IA genera sugerencias a medida, mejorando la satisfacción y el compromiso del usuario.
• Fuente: Uso de la IA en Netflix

16. Amazon

• Aplicación: Amazon utiliza IA generativa para optimizar la logística y las operaciones de la cadena de suministro.
• Ejemplo: Los modelos de IA generan planes de rutas eficientes, predicen las necesidades de inventario y automatizan las tareas de gestión de almacenes.
• Fuente: Logística de IA de Amazon

17. Ford

• Aplicación: Ford integra la IA generativa en sus procesos de fabricación para diseñar componentes de vehículos más eficientes y ligeros.
• Ejemplo: Los diseños generados por IA se someten a pruebas de simulación para garantizar que cumplen las normas de seguridad y rendimiento.
• Fuente: La IA de Ford en la fabricación

18. Siemens

• Aplicación: Siemens emplea IA generativa para la fabricación inteligente.
• Ejemplo: Los sistemas de IA generan planes de optimización de procesos, predicen las necesidades de mantenimiento de los equipos y mejoran la eficiencia general de la producción.
• Fuente: Soluciones de IA de Siemens

19. Microsoft

• Aplicación: Microsoft utiliza la IA generativa en su plataforma Azure para mejorar diversos procesos y aplicaciones empresariales, como la creación y el diseño de contenidos, el desarrollo de software, la atención al cliente, la atención sanitaria, el comercio minorista y la productividad ofimática. La IA generativa automatiza la creación de contenidos de alta calidad, como imágenes y vídeos, a través de plataformas como Typeface, y ayuda a los desarrolladores con sugerencias de código mediante GitHub Copilot. Mejora las interacciones con los clientes en Microsoft Teams y Power Virtual Agents, automatiza las tareas informáticas y los procesos de recursos humanos de empresas como AT&T, y analiza los datos médicos para ofrecer soluciones sanitarias personalizadas. Minoristas como Walmart lo aprovechan para experiencias de compra personalizadas. Además, Microsoft 365 Copilot integra IA generativa en aplicaciones de Office como Word, Excel, PowerPoint, Outlook y Teams, ayudando a redactar documentos, crear presentaciones, analizar datos y resumir correos electrónicos y reuniones, agilizando así los procesos de trabajo y mejorando la productividad.
• Ejemplo: Estas funciones basadas en IA ayudan a los desarrolladores a escribir código más limpio y eficiente con mayor rapidez.
• Fuentes: (Building for the future: The enterprise generative AI application lifecycle with Azure AI)​​ (Welcoming the generative AI era with Microsoft Azure)​​ (Microsoft Learn)​​ (From code to production: New ways Azure helps you build transformational AI experiences)​​ (Empowering operators through generative AI technologies with Azure for Operators)​​ (Azure OpenAI Service: 10 ways generative AI is transforming businesses)​​ (The Official Microsoft Blog)​​ (Microsoft Cloud)​​ (Microsoft Cloud)​​ (Microsoft Learn)​​ (Voicebot.ai)​.

20. Tesla

• Aplicación: Tesla incorpora IA generativa en su tecnología de conducción autónoma.
• Ejemplo: Los modelos de IA generan y prueban diversos escenarios de conducción, mejorando la seguridad y fiabilidad de los coches de conducción autónoma de Tesla.
• Fuente: Desarrollo de IA de Tesla

El futuro de la IA generativa: tendencias y predicciones clave

El futuro de la IA generativa en el mundo empresarial es prometedor, y se espera que los continuos avances desbloqueen nuevas capacidades. Según McKinsey, la IA generativa podría avanzar significativamente de aquí a 2040, compitiendo potencialmente con el 25% de los mejores profesionales humanos en diversas tareas. Esto significa que la IA podría escribir contenidos de alta calidad, resolver problemas complejos y tomar decisiones empresariales perspicaces al mismo nivel que los profesionales cualificados.

A medida que avanza la tecnología de IA, la integración de sistemas perceptivos en la IA podría permitirle imitar sentidos humanos como el tacto y el olfato, superando el enfoque en el lenguaje y las imágenes. Este avance podría llevar a que los modelos de IA superasen las capacidades humanas en el reconocimiento emocional, ofreciendo una visión más profunda de las emociones humanas.

Sin embargo, el sesgo en los modelos de IA generativa seguirá siendo un reto, dando lugar a nuevos mercados centrados en conjuntos de datos éticos. A medida que se generalicen las herramientas de IA generativa, se producirán inevitablemente cambios en los puestos de trabajo y se requerirán nuevas competencias. También se prevé un aumento del uso indebido de las capacidades generativas, lo que subraya la importancia de contar con mecanismos sólidos para mitigar los riesgos y garantizar un uso responsable de las tecnologías de IA.

La IA generativa seguirá transformando las operaciones empresariales en diversos sectores, del mismo modo que el smartphone transformó la comunicación y la productividad de las empresas. Desde la automatización de tareas mundanas hasta el fomento de la creatividad en la creación de contenidos, el potencial de la IA generativa es vasto y variado. Sin embargo, es fundamental tener en cuenta las consideraciones éticas, maximizar la seguridad de los datos y adaptarse a la evolución de las mejores prácticas.

En 2027, más del 50% de los modelos de GenAI que utilicen las empresas serán específicos de un sector o función empresarial, frente a aproximadamente el 1% en 2023.

Aunque los modelos de propósito general funcionan bien en un amplio conjunto de aplicaciones, la demanda de GenAI está aumentando en muchos sectores. Combinada con una mayor disponibilidad de LLM de código abierto de alto rendimiento y comercialmente utilizables, existe un apetito por modelos específicos de dominio.

Los modelos de dominio pueden ser más pequeños, menos intensivos desde el punto de vista computacional y reducir los riesgos de alucinación asociados a los modelos de propósito general.
Planifique la necesidad de desplegar y gestionar múltiples modelos GenAI de dominio específico para dar soporte a una variedad de casos de uso. Pero antes de crear los suyos propios, busque modelos de dominio específico listos para usar que pueda entrenar o ajustar para que se adapten a las necesidades de su empresa.

Para 2026, el 75% de las empresas utilizará IA generativa para crear datos sintéticos de los clientes, frente a menos del 5% en 2023.

El desarrollo de datos sintéticos (es decir, generados artificialmente) respalda sistemas en los que los datos reales son costosos, no están disponibles, están desequilibrados o no se pueden utilizar debido a las regulaciones de privacidad.

La introducción de datos sintéticos en modelos permite a las organizaciones simular entornos e identificar nuevas oportunidades de desarrollo de productos, especialmente en industrias altamente reguladas. También permite la creación rápida de prototipos de software y experiencias digitales e híbridas.

Centrar el uso de datos sintéticos en áreas que se correlacionan directamente con el crecimiento empresarial, como el desarrollo de segmentos de clientes, viajes y experiencias y la capacitación de modelos de machine learning.

Para 2028, el 30% de las implementaciones de GenAI se optimizarán utilizando métodos computacionales de conservación de energía, impulsados ​​por iniciativas de sostenibilidad.

La rápida adopción de herramientas de IA generativa ha hecho que el impacto ambiental negativo de la GenAI, que el público y los gobiernos están denunciando, se convierta en una preocupación inmediata para los líderes empresariales.

Es fundamental minimizar la energía y los recursos necesarios para la formación y el desarrollo de la IA. La energía renovable y la infraestructura para los servicios locales y en la nube se personalizarán para la IA.

Controla los costos de los recursos informáticos con energía optimizada diversificando sus proveedores, buscando arquitectura componible y operaciones de borde para GenAI en cada jurisdicción de operación y utilizando energía renovable de alta calidad durante la capacitación para mitigar su impacto en sus objetivos de sostenibilidad.

Fuente – Gartner – 12 de abril 2024

A algunos les puede preocupar que la IA se apodere de nuestras vidas y trabajos, pero es como Internet en el siglo pasado: una herramienta poderosa que simplemente necesitamos aprender, adaptarnos y adoptar. Ignorarlo no hará que desaparezca. Con eso en mente, profundicemos en las tendencias y predicciones clave que se avecinan para esta extraordinaria tecnología.

La IA generativa ha llegado a diversas industrias, remodelando los ámbitos de la creatividad, la productividad y la resolución de problemas. Las siguientes figuras le brindarán más información sobre el impacto de la generación de IA en diferentes sectores.

Conclusión

La IA generativa no es sólo un avance incremental; representa un cambio de paradigma en la forma en que las empresas operan, innovan y compiten. Como se destaca a lo largo de esta publicación de blog, la capacidad de la IA generativa para automatizar tareas complejas, mejorar la creatividad y proporcionar conocimientos profundos está revolucionando el panorama corporativo. Desde la generación de códigos hasta el marketing personalizado, las aplicaciones de la IA generativa son diversas y transformadoras, y generan niveles de eficiencia e innovación sin precedentes. Los estudios de caso analizados demuestran cómo las empresas líderes están aprovechando esta tecnología para obtener una ventaja competitiva, mostrando los beneficios tangibles y el valor estratégico que ofrece.

Sin embargo, adoptar la IA generativa conlleva una serie de desafíos y responsabilidades. Las consideraciones éticas, la privacidad de los datos y el impacto ambiental del desarrollo de la IA son cuestiones críticas que deben abordarse para garantizar una adopción sostenible y responsable. Las empresas deben establecer marcos sólidos de gobernanza de la IA y mantenerse alerta ante posibles sesgos en los modelos de IA. Al hacerlo, pueden mitigar los riesgos y maximizar los beneficios, fomentando una cultura de implementación ética de la IA y de innovación continua.

De cara al futuro, el futuro de la IA generativa en el mundo empresarial es increíblemente prometedor. Con los avances continuos y el aumento de aplicaciones específicas de dominio, la IA generativa se convertirá en una parte integral de diversas industrias, transformando procesos e impulsando el crecimiento. A medida que las empresas navegan por esta revolución impulsada por la IA, es fundamental adoptar la IA generativa, adaptarse a su panorama en evolución y aprovechar todo su potencial. Al hacerlo, pueden crear valor duradero, mejorar la productividad y revolucionar la forma en que operan, garantizando que permanezcan a la vanguardia de la innovación en un mundo cada vez más competitivo.

¡Es todo por hoy!

Fuentes:

• https://www.eweek.com/artificial-intelligence/generative-ai-enterprise-use-cases/
• https://itrexgroup.com/blog/generative-ai-use-cases-in-business/
• https://tovie.ai/blog/7-real-world-use-cases-of-generative-ai-for-business
• https://www2.deloitte.com/content/dam/Deloitte/us/Documents/consulting/us-ai-institute-gen-ai-use-cases.pdf
• https://www.skillreactor.io/blog/generative-ai-use-cases/
• https://pixelplex.io/blog/generative-ai-market-map/
• https://www.gartner.com/en/articles/3-bold-and-actionable-predictions-for-the-future-of-genai
• https://www.gartner.com/en/articles/how-your-ceo-is-thinking-about-ai
  
  

The post Potencial económico empresarial de la IA generativa first appeared on Planeta Chatbot.

Los detalles:

• SearchGPT organiza los resultados de las búsquedas en resúmenes con enlaces de atribución y permite realizar preguntas de seguimiento, de forma similar a la startup de IA Perplexity.

• El prototipo funciona con GPT-4 y estará disponible inicialmente para 10.000 usuarios de prueba.

• Aunque aún es un prototipo, la empresa tiene previsto integrar las funciones de SearchGPT directamente en ChatGPT.

• Para acceder a SearchGPT, debes iniciar sesión en tu cuenta de ChatGPT y solicitar tu inscripción en la lista de espera aquí.

• «Obtener respuestas en la web puede suponer un gran esfuerzo, y a menudo requiere múltiples intentos para obtener resultados relevantes», escribe OpenAI en una entrada de blog. «Creemos que mejorando las capacidades conversacionales de nuestros modelos con información en tiempo real de la web, encontrar lo que buscas puede ser más rápido y fácil».

El uso de SearchGPT no será muy diferente al de ChatGPT, de lo que se puede observar en las animaciones en la página oficial, aunque habrán más pestañas para navegar entre la información que esta nueva IA ofrecería. En el centro se ubicará una barra de búsqueda para hacer la consulta que uno desee y a la que el bot lanzará unos cuantos resultados principales. Sin embargo, otros resultados adicionales también se podrán ver en una barra lateral a la que se accederá al hacer clic en un ícono de enlace o cadena.

La entrada de OpenAI en el sector de las búsquedas podría trastornar la industria, modificando potencialmente la forma en que los usuarios interactúan con la información en línea y desafiando el largo dominio de Google Search. El movimiento también plantea cuestiones sobre la privacidad de los datos, el futuro del SEO tradicional y el impacto en los creadores de contenidos.

The post OpenAI revela SearchGPT, su motor de búsqueda de IA first appeared on Planeta Chatbot.

 Noticias

1º semana

• Gemini 1.5 Pro 2M ventana de contexto, capacidades de ejecución de código, y Gemma 2 están disponibles hoy. Gemini 1.5 Pro se ha actualizado con una ventana de contexto de tokens 2M más grande y nuevas funciones de ejecución de código para mejorar el rendimiento en tareas complejas. Gemma 2 ya se puede probar en Google AI Studio, y se ha publicado el ajuste de Gemini 1.5 Flash.
• Colabora con Claude en proyectos. Claude.ai introduce la función Proyectos para usuarios Pro y Team, aprovechando la ventana contextual de 200K de Claude 3.5 Sonnet para mejorar el trabajo colaborativo a través de chats organizados, integración de documentos y asistencia personalizada. La adición de artefactos y un feed de actividad compartida fomenta la co-creación y la inspiración dentro de la plataforma.
• Apple es la primera empresa acusada de infringir la normativa de la UE sobre mercados digitales. La UE ha acusado a Apple de infringir la Ley de Mercados Digitales debido a las políticas restrictivas de App Store. Se ha iniciado una nueva investigación sobre la forma en que Apple gestiona las tiendas de aplicaciones alternativas y las tasas asociadas. Apple podría enfrentarse a multas de hasta el 10% de sus ingresos globales y ha declarado que cooperará con los reguladores de la UE.
• Las grandes discográficas demandan a las empresas de IA Suno y Udio por supuesta infracción de derechos de autor. Los principales sellos discográficos han demandado a las empresas de IA musical Suno y Udio por infracción de derechos de autor, alegando el uso sin licencia de canciones protegidas por derechos de autor para entrenar a sus IA, que pueden producir canciones parecidas a las de artistas populares. Suno y Udio alegan que su trabajo es transformador y puede considerarse uso legítimo.
• Apple no lanzará tecnología de IA en el mercado de la UE por motivos normativos. Apple Inc. ha pospuesto el lanzamiento de nuevas tecnologías de IA en la UE debido a los requisitos de cumplimiento de la Ley de Mercados Digitales, cuyo objetivo es evitar que se favorezcan productos propios y se haga un uso indebido de los datos de los consumidores, lo que afecta a la privacidad y la seguridad. Esto afecta a funciones como Apple Intelligence, iPhone Mirroring y SharePlay, ya que Apple se considera un «guardián» según la normativa de la UE.
• Stability.ai consigue un nuevo CEO y un dream team inversor para iniciar su misión de rescate. Prem Akkaraju ha sido nombrado nuevo consejero delegado de Stability.ai, creadora de Stable Diffusion, además de recibir inversiones de figuras notables. El papel de Akkaraju es fundamental para dirigir los esfuerzos de cambio de rumbo de la empresa, aprovechando su experiencia como antiguo CEO de Weta Digital.
• Al parecer, YouTube quiere pagar a las discográficas por utilizar sus canciones para entrenar la inteligencia artificial. YouTube busca acuerdos de licencia con los grandes sellos discográficos Sony, Universal y Warner para el entrenamiento de la IA con el fin de eludir los problemas de derechos de autor, pero se enfrenta a la oposición de los artistas. Mientras tanto, los sellos discográficos han demandado a las plataformas musicales de IA Suno y Udio por infracción de derechos de autor.
• Figma AI: herramientas inteligentes para los diseñadores. Figma ha lanzado Figma AI, una nueva plataforma de diseño mejorada con inteligencia artificial que incluye funciones de búsqueda, herramientas generativas de texto e imágenes y funciones avanzadas de creación de prototipos. Actualmente está en fase beta y es gratuita hasta 2024, aunque su uso puede tener un límite en función del coste de las herramientas.
• La IA de Snapchat convierte las sugerencias en nuevas lentes. Snapchat ha lanzado una función que permite a los usuarios crear lentes personalizadas basadas en la inteligencia artificial utilizando mensajes de texto, aprovechando los datos de interacción del usuario y la actividad en línea para adaptar las experiencias.

2º semana

• Phil Schiller, de Apple, podría formar parte del consejo de OpenAI. Phil Schiller, jefe de la App Store de Apple, podría ser nombrado observador del consejo sin ánimo de lucro de OpenAI para profundizar en su conocimiento de la IA a medida que Apple integra ChatGPT en sus sistemas operativos. Participará en las reuniones sin derecho a voto.
• Adept se une a Amazon. El equipo de Adept, incluidos sus cofundadores, se integra en la división AGI de Amazon, con el objetivo de avanzar en los esfuerzos de inteligencia general. Amazon ha adquirido la licencia de la avanzada tecnología de agentes multimodales de Adept y ha adquirido conjuntos de datos seleccionados.
• Elon Musk: Grok 2 AI llegará en agosto. Elon Musk ha desvelado sus planes para Grok 2, un nuevo modelo de IA que llegará en agosto de 2024 y que promete una mayor eficiencia. Su empresa prevé una actualización a Grok 3 a finales del mismo año, utilizando la tecnología punta de GPU de Nvidia.
• YouTube ya permite solicitar la eliminación de contenidos generados por IA que simulen tu cara o tu voz. La política de privacidad revisada de YouTube permite ahora a los usuarios solicitar la retirada de contenido deepfake que replique su imagen si plantea problemas de privacidad, con ciertas consideraciones sobre el contexto del contenido y el interés público.

3º semana

• Microsoft renuncia a su puesto de observador en el consejo de OpenAI. Microsoft ha renunciado a su puesto de observador en el consejo de OpenAI, lo que refleja su confianza en la trayectoria de OpenAI bajo la dirección de su consejero delegado, Sam Altman. Este movimiento agiliza la relación de Microsoft con OpenAI y posiblemente también aborda cuestiones antimonopolio. OpenAI no ofrecerá funciones de observador en el futuro, prefiriendo interacciones directas de asociación, como con Microsoft y Apple.
• Figma retira su herramienta de IA tras las críticas por copiar el diseño de Apple. Figma retiró su herramienta de IA, Make Designs, tras las acusaciones de replicar las interfaces de las aplicaciones meteorológicas para iOS de Apple. El CEO Dylan Field reconoció que el rápido lanzamiento había sido defectuoso, y el CDT Kris Rasmussen señaló el uso de modelos de IA de terceros, no desarrollados internamente por Figma, lo que indica posibles problemas de formación con modelos de IA potencialmente procedentes de entidades como OpenAI o Amazon.
• OpenAI desvela una escala de cinco niveles de IA, con el objetivo de alcanzar pronto el nivel 2. La escala de progresión de la IAG de cinco niveles de OpenAI indica una aproximación al nivel 2 «Razonador», que demuestra una resolución de problemas similar a la humana. Se prevé que el nivel 2, caracterizado por una lógica y un razonamiento avanzados, pueda alcanzarse en los próximos 1,5 años.
• Stability AI lanza las funciones del Asistente Estable. Stability AI ha mejorado su Asistente Estable con las nuevas funciones de Stable Diffusion 3, que incluyen «Buscar y reemplazar» para el intercambio de objetos en imágenes, junto con las funciones existentes para la edición de imágenes, el escalado y la generación de vídeo.
• Actualización de la licencia de Stability AI. Stability AI ha revisado sus licencias y ha adoptado la «Stegree AI Community License», que ofrece condiciones más generosas para particulares y pequeñas empresas, incluido el uso gratuito por debajo de determinados umbrales de ingresos y sin restricciones para uso no comercial y de pequeñas empresas, al tiempo que aborda los problemas de calidad con el modelo SD3 Medium.

4º semana

• GPT-4o mini: inteligencia rentable. OpenAI ha lanzado GPT-4o mini, un modelo de IA avanzado y rentable con un precio de 0,15 $/millón de tokens de entrada y 0,60 $/millón de tokens de salida, que ofrece un rendimiento superior a un coste inferior que GPT-3.5 Turbo.
• Mistral NeMo. Mistral, en colaboración con NVIDIA, ha lanzado el modelo Mistral NeMo de 12B parámetros, que incluye una ventana de contexto de tokens de 128.000, compatibilidad con FP8 y un tokenizador Tekken de última generación. Es de código abierto Apache 2.0, ofrece funciones multilingües mejoradas y supera a la versión anterior de 7B en tareas de seguimiento de instrucciones.
• Apple, Nvidia y Anthropic utilizaron miles de vídeos robados de YouTube para entrenar la IA. Una investigación ha revelado que grandes empresas de IA, como Apple, Nvidia y Anthropic, han entrenado sus modelos de IA utilizando subtítulos de más de 173.000 vídeos de YouTube, lo que podría infringir la política de YouTube contra la captación de datos y plantear cuestiones sobre los derechos y la compensación de los creadores.
• Codestral Mamba. Mistral ha presentado Codestral Mamba, un nuevo modelo de Mamba centrado en la codificación y conocido por gestionar eficazmente secuencias largas con inferencia en tiempo lineal y soporte teórico para longitudes de secuencia ilimitadas. Compite con los principales modelos SOTA y es de código abierto, accesible para la extensión a través del repositorio GitHub con opciones de integración como mistral-inference SDK, TensorRT-LLM, y una próxima llama.cpp.
• Meta lanzará Llama 3 400b la semana que viene – aquí tienes por qué debería importarte. Meta planea lanzar Llama 3 400B en julio de 2024, ampliando la serie de modelos Llama 3 AI. Este modelo de código abierto ofrecerá funciones mejoradas para chatbots y aplicaciones multilingües, con el objetivo de proporcionar un amplio acceso a los últimos avances en IA.
• Kevin Scott, CTO de Microsoft, cree que las «leyes de escalado» de LLM se mantendrán a pesar de las críticas. En un podcast de Sequoia Capital, Kevin Scott, director técnico de Microsoft, expresó su confianza en el potencial de crecimiento de los Large Language Models, cuestionando la idea de un pico de desarrollo de la IA y destacando las ventajas de ampliar el tamaño de los modelos y las capacidades de entrenamiento.

5º semana

• Meta lanza Llama 3.1. Meta ha presentado el modelo Llama 3.1 405B, una IA de código abierto de última generación para grandes idiomas con funciones avanzadas de multilingüismo, razonamiento y uso de herramientas, junto con mejoras en sus modelos 8B y 70B. La actualización ofrece mayores longitudes de contexto, mejor entrenamiento y evaluaciones exhaustivas, y está disponible para su descarga en varias plataformas.
• Mistral lanza Mistral Large 2. Mistral lanza su nuevo modelo, Mistral Large 2, con 123.000 millones de parámetros y una ventana de contexto de 128.000, que ofrece compatibilidad con varios idiomas y lenguajes de programación, optimizado para la inferencia de alto rendimiento en un solo nodo. Ofrece una precisión del 84,0% en la prueba de referencia MMLU, una generación de código mejorada y capacidades de razonamiento. El modelo está disponible con opciones de licencia comercial y de investigación.
• La IA alcanza el nivel de medalla de plata resolviendo problemas de la Olimpiada Matemática Internacional. AlphaProof y AlphaGeometry 2, dos sistemas de IA, demostraron su destreza resolviendo 4 de los 6 problemas de la Olimpiada Matemática Internacional, alcanzando el nivel de medalla de plata. AlphaProof aplicó el aprendizaje por refuerzo avanzado en matemáticas formales, y el enfoque híbrido neuro-simbólico de AlphaGeometry 2 dio lugar a avances sustanciales en la resolución de problemas de geometría compleja.
• El nuevo prototipo SearchGPT de OpenAI es una declaración de guerra contra Google. OpenAI ha lanzado «SearchGPT», un prototipo de herramienta de búsqueda conversacional con mejoras de la información web en tiempo real, que desafía la hegemonía de Google en el mercado de los motores de búsqueda prometiendo una experiencia de usuario más eficaz y precisa.
• OpenAI permite ajustar GPT-4o mini de forma gratuita. OpenAI permite ahora a los usuarios de nivel 4 y 5 ajustar GPT-4o mini para casos de uso específicos con los primeros 2 millones de tokens de entrenamiento diarios gratuitos hasta el 23 de septiembre, con planes de ampliar esta función a todos los niveles de usuarios con el tiempo.
• Condé Nast envía una orden de cese y desistimiento a Perplexity AI por el robo de datos. Condé Nast ha emprendido acciones legales contra el motor de búsqueda Perplexity AI por el uso no autorizado de su contenido, reflejando la respuesta anterior de Forbes y en medio de una investigación en curso de Amazon sobre el raspado de datos de Perplexity. La situación pone de manifiesto los crecientes problemas legales que plantea la IA en relación con el uso de contenidos y sus posibles implicaciones para el sector de los medios de comunicación.
• Un estudio revela un rápido aumento de los dominios web que bloquean los datos de entrenamiento de los modelos de IA. Un estudio indica un notable aumento de abril de 2023 a abril de 2024 en los dominios web que utilizan bloqueos para evitar que los modelos de IA obtengan datos de entrenamiento, lo que podría llevar a que las IA se basen en información sesgada u obsoleta.

Guías

1º semana

• ¿Qué es un agente? Un agente, en el contexto de los sistemas LLM, se refiere a los diversos grados de capacidades autónomas que tienen dichos sistemas, desde el enrutamiento básico de tareas hasta las operaciones totalmente autónomas. El artículo examina el desarrollo, la orquestación y la supervisión necesarios que acompañan al aumento de la autonomía del sistema.
• Bienvenido a Gemma 2, el nuevo LLM abierto de Google. Se ha lanzado Gemma 2 de Google, que presenta modelos avanzados con un máximo de 27.000 millones de parámetros adaptados a casos de uso de instrucción básica y especializada. Incorpora técnicas novedosas de IA, como la atención por ventana deslizante, el logit soft-capping, la destilación de conocimientos y la fusión de modelos, con disponibilidad en la plataforma Hugging Face.
• Las mejores herramientas de IA para la investigación: Evaluación de ChatGPT, Gemini, Claude y Perplexity. El artículo proporciona un análisis comparativo de cuatro herramientas de investigación de IA – ChatGPT, Gemini, Claude y Perplexity – examinando su calidad de respuesta, acceso a datos en tiempo real, capacidades de referenciación, análisis de documentos y opciones de suscripción para mejorar la productividad en entornos de investigación académica y empresarial.
• Creación de un asistente de código personalizado con LLM de código abierto mediante el ajuste fino de RAG. La investigación demuestra que el ajuste fino de los LLM con la Generación Mejorada por Recuperación (RAG) puede mejorar el rendimiento de la generación de código reduciendo errores como las alucinaciones y la información obsoleta. Las pruebas realizadas en la plataforma Together AI revelan que los modelos ajustados con RAG, concretamente utilizando Mistral 7B Instruct v0.2, superan a competidores como Claude 3 Opus y GPT-4o en términos de precisión, eficiencia y coste.
• Puesta a punto de Florence-2: los modelos de lenguaje de visión más avanzados de Microsoft. Florence-2 de Microsoft es un modelo híbrido de visión y lenguaje que destaca en tareas de OCR y detección de objetos. Integra un codificador de visión DaViT con incrustaciones BERT y muestra un rendimiento mejorado tras el ajuste fino con el conjunto de datos DocVQA, alcanzando una puntuación de similitud de 57,0. Este avance se atribuye a su preentrenamiento en el conjunto de datos a gran escala FLD-5B.

2º semana

• ¿Por qué la mayoría de los LLM son sólo decodificadores? Los grandes modelos lingüísticos suelen utilizar una arquitectura de sólo descodificador porque es eficaz para el preentrenamiento generativo y rentable, y presenta una fuerte generalización de cero disparos. Aunque los modelos codificador-decodificador pueden sobresalir en el ajuste fino multitarea, el entrenamiento extensivo disminuye la diferencia de rendimiento, favoreciendo los modelos sólo decodificador para diversas aplicaciones.
• Mitos sobre el escalado de la IA. El artículo cuestiona la creencia de que la simple ampliación de los modelos lingüísticos dará lugar a una inteligencia artificial general, destacando problemas como la exageración de las leyes de ampliación, los conceptos erróneos sobre las capacidades emergentes y las limitaciones prácticas como la escasez de datos y el aumento de los costes.
• ¿Qué es una «arquitectura cognitiva»? El artículo discute el papel de la arquitectura cognitiva en el desarrollo de aplicaciones impulsadas por LLMs, delineando el espectro de autonomía desde scripts básicos hasta sofisticados agentes autónomos, y destaca su importancia en el despliegue de sistemas de toma de decisiones basados en LLMs.
• Chatbot RAG con llama3. El artículo describe el desarrollo de un chatbot de Generación Mejorada de Recuperación basado en el modelo de lenguaje llama3, detallando la incorporación de conocimiento externo, la configuración de las bibliotecas necesarias y la incrustación de conjuntos de datos, así como el uso de un índice faiss para la recuperación eficiente de información.

3º semana

• FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision. FlashAttention-3 mejora la eficiencia del modelo Transformer optimizando la utilización de la GPU, especialmente para los mecanismos de atención. Aprovechando los núcleos tensoriales y el acelerador de memoria tensorial de la GPU Hopper, consigue hasta un 75% de utilización y 1,2 PFLOPS en FP8, lo que aumenta la velocidad entre 1,6 y 2 veces y permite entrenar con mayor eficacia modelos de lenguaje de gran tamaño con requisitos de memoria reducidos.
• Los trabajos para los que he estado utilizando la IA en solitario. El autor examina la aplicación de modelos de IA para agilizar la codificación, el desarrollo de interfaces de usuario, la funcionalidad de búsqueda, la documentación y la comunicación empresarial, destacando herramientas como Cursor para tareas de codificación y Claude para optimizar las interacciones por correo electrónico.
• El verano de la IA. El artículo analiza la discrepancia entre las grandes expectativas que despierta la IA y la lentitud de su adopción real en los sectores empresarial y de consumo, haciendo hincapié en retos como los prolongados ciclos de ventas en las empresas, los planteamientos conservadores de los directores de sistemas de información y las ideas erróneas sobre la IA como solución «plug and play». También aborda los problemas relacionados con la sobreinversión alimentada por la exageración del mercado y la dinámica competitiva, a pesar del importante crecimiento de usuarios de soluciones como ChatGPT.
• Entrenar un modelo Llama desde cero. El artículo proporciona una guía paso a paso para entrenar un modelo de lenguaje Llama utilizando la biblioteca Transformers, incluyendo fragmentos de código para cada etapa, desde la instalación de la biblioteca y la configuración del tokenizador hasta el entrenamiento del modelo y la carga del modelo final en el Hugging Face Hub.
• Agent Dev & The Case for The Engineer’s Creative Process. El artículo analiza cómo el desarrollo de agentes inteligentes a través del aprendizaje automático ha evolucionado hacia una práctica más artística, instando a los ingenieros a adoptar la creatividad y una mentalidad relacional debido a los aspectos no lineales e impredecibles del proceso de desarrollo.

4º semana

• Consejos para entrenar eficazmente sus modelos de aprendizaje automático. El artículo ofrece un recorrido detallado para el entrenamiento de modelos de aprendizaje automático, incluido el preprocesamiento de datos, la ingeniería de características, el tratamiento de los desequilibrios de clase, el empleo de la validación cruzada y el ajuste de hiperparámetros para la selección de modelos, y la utilización de métodos de conjunto para mejorar la estabilidad del modelo y evitar el sobreajuste.
• Alucinaciones de la IA: Donde la inteligencia artificial se encuentra con la imaginación artificial. El artículo examina el problema de las «alucinaciones» en los LLM, donde se generan contenidos coherentes pero inexactos debido a la dependencia de la IA de la predicción de patrones en lugar de la recuperación de datos objetivos.
• Ajuste fino de Llama-3 para obtener el 90% del rendimiento de GPT-4 por una fracción del coste. El artículo detalla el proceso de mejora de las capacidades de Llama-3 hasta casi igualar el rendimiento de GPT-4 mediante el ajuste de datos patentado en la plataforma Together AI. Tras emplear el conjunto de datos Math Instruct, el modelo Llama-3 de 8.000 millones de parámetros alcanzó una notable precisión del 65%, superando la precisión de la versión mayor de 70.000 millones de parámetros y acercándose a la precisión del 71,4% de GPT-4o.
• Docmatix – Un enorme conjunto de datos para la respuesta a preguntas visuales sobre documentos. Docmatix, un amplio conjunto de datos para Document Visual Question Answering, ofrece 2,4 millones de imágenes y 9,5 millones de pares Q/A de 1,3 millones de PDF, mejorando el rendimiento de la tarea DocVQA en un 20% con el modelo Florence-2. Está disponible en Hugging Face Hub para mejorar la investigación y las aplicaciones del modelo de visión y lenguaje.

5º semana

• Llama 3.1-405B, 70B y 8B con multilingüismo y contexto largo. Meta ha lanzado Llama 3.1 con modelos multilingües en tamaños 8B, 70B y 405B, con manejo de contexto más largo, ajuste de instrucciones para la optimización de tareas, seguridad mejorada contra inyecciones puntuales y compatibilidad con servicios en la nube.
• Por qué las IA deben pararse a pensar antes de responder. El autor investiga el impacto de la «cadena de pensamiento» en la calidad de la respuesta de la IA, observando mejores resultados cuando la IA imita la planificación humana antes de responder.
• Tres arquetipos de nuevas aplicaciones de IA. El artículo describe tres tipos de empresas emergentes de aplicaciones de IA: AI Copilots, que refuerzan la productividad ayudando en las tareas primarias; AI Colleagues, que ejecutan tareas de forma independiente para mejorar la eficiencia operativa; y AI Native Services, que son empresas altamente automatizadas que automatizan servicios completos para competir con las empresas convencionales ofreciendo alternativas de alta calidad y menor coste.
• Uso de los LLM para la evaluación. Los LLM como el GPT-4 pueden utilizarse como evaluadores escalables y rentables de otros modelos utilizando la metodología del LLM como juez. Este enfoque aprovecha las indicaciones directas para aproximarse al juicio humano en la evaluación de los resultados del modelo y se ajusta bien a las preferencias humanas, aunque requiere una gestión cuidadosa de los sesgos introducidos. Las métricas de evaluación tradicionales son menos eficaces para tareas de IA complejas, que LLM-as-a-Judge puede abordar con mayor eficacia.
• La desigual distribución del impacto ambiental de la IA. El artículo analiza la creciente huella medioambiental de la IA, en particular su elevado consumo de energía y agua, y cómo esto agrava las disparidades regionales. Señala los avances en las prácticas sostenibles de la IA, pero subraya la necesidad de una distribución más justa de los costes ambientales de la IA, abogando por el equilibrio geográfico de la carga en las zonas de riesgo para hacer frente a las desigualdades.

Papers y repositorios de interés

1º semana

• Juzgando a los jueces: Evaluating Alignment and Vulnerabilities in LLMs-as-Judges. l estudio investiga la eficacia de los LLM a la hora de evaluar el rendimiento de sus homólogos, utilizando el conjunto de datos TriviaQA y anotaciones humanas como puntos de referencia. Revela incoherencias en las evaluaciones de los modelos y pone de relieve que los índices de concordancia entre los LLM no siempre reflejan la verdadera alineación, como demuestra la variación en las puntuaciones.
• Adam-mini: utilice menos tasas de aprendizaje para obtener más. El optimizador Adam-mini ofrece un rendimiento igual o superior al de AdamW con un uso de memoria entre un 45% y un 50% menor, gracias a su asignación estructurada de tasas de aprendizaje para grupos de parámetros. También aumenta el rendimiento hasta un 49,6% y reduce la sobrecarga computacional.
• Evidencia de una ley de escala logarítmica para la persuasión política con grandes modelos lingüísticos. Un estudio sobre la influencia del tamaño de los modelos lingüísticos en la capacidad de persuasión política ha revelado que los modelos de mayor tamaño presentan rendimientos decrecientes en persuasión, y que los modelos pequeños son casi tan eficaces como los grandes. La pequeña superioridad de los modelos más grandes se atribuye a una mayor coherencia y enfoque temático, lo que implica beneficios insignificantes si se amplían aún más los modelos lingüísticos.
• Meta Large Language Model Compiler: Modelos básicos de optimización de compiladores. Meta lanzó el compilador LLM que utiliza modelos preentrenados, incluido Code Llama, para mejorar la optimización del código. Estos modelos se entrenan en amplios conjuntos de datos de código intermedio y ensamblador y se presentan en variaciones con 7.000 y 13.000 millones de parámetros. Sus instancias afinadas pueden mejorar notablemente la optimización del tamaño del código y las tareas de desmontaje para arquitecturas x86_64 y ARM.
• LongRAG: Enhancing Retrieval-Augmented Generation with Long-context LLMsLongRAG es un nuevo marco de Generación Mejorada de Recuperación que amplía las unidades de recuperación para manejar hasta 4K tokens. Aprovecha un modelo lingüístico de contexto largo, lo que le permite extraer respuestas sin entrenamiento adicional y alcanzar altas puntuaciones de coincidencia exacta, comparables al rendimiento del estado del arte.

2º semana

• Meta 3D Gen. Meta 3D Gen (3DGen) es un proceso basado en IA que genera rápidamente modelos 3D detallados y texturas a partir de descripciones de texto, con capacidades para el renderizado basado en la física y el retexturizado de activos.
• GraphRAG: nueva herramienta para el descubrimiento de datos complejos, ahora en GitHub. Microsoft ha publicado en GitHub GraphRAG, una herramienta avanzada de generación aumentada de recuperación que supera a los sistemas RAG tradicionales. Emplea un amplio modelo lingüístico para construir grafos de conocimiento jerárquicos a partir de textos, mejorando la exhaustividad y diversidad de los datos al hacer hincapié en las relaciones entre entidades.
• Un año de GPT4All. Nomic ha presentado GPT4All 3.0, una importante actualización con una nueva interfaz de usuario centrada en la privacidad y la accesibilidad. Esta versión es compatible con una amplia gama de LLM en varios sistemas operativos y marca el hito de un año del proyecto con una notable participación de la comunidad.
• Sin agente: Desmitificación de los agentes de ingeniería de software basados en LLM. El artículo analiza un enfoque sin agentes para el desarrollo de software que puede superar a los sistemas tradicionales basados en agentes en cuanto a rentabilidad y rendimiento, como demuestra la prueba SWE-bench Lite, mediante un sencillo proceso de localización y reparación en dos fases.
• Resumen de un pajar: Un reto para los LLM de contexto largo y los sistemas RAG. La tarea «Summary of a Haystack» (SummHay) se establece para poner a prueba los modelos lingüísticos de contexto largo y los sistemas de generación aumentada de recuperación mediante la evaluación de su capacidad para resumir y citar a partir de documentos con ideas específicas repetidas.
• landing-ai/vision-agent: Agente de visión. Vision Agent es una herramienta que automatiza la generación de código para tareas de visión por ordenador a partir de descripciones en lenguaje natural.

3º semana

• Destilando el Sistema 2 en el Sistema 1. Este artículo examina la integración de los intrincados métodos de razonamiento del Sistema 2 (como la Cadena de Pensamiento) en los procesos más rápidos del Sistema 1 en los LLM. Mediante el aprendizaje autosupervisado, los autores han mejorado el rendimiento del Sistema 1 y reducido los costes de computación al integrar las capacidades de razonamiento del Sistema 2 en el Sistema 1, lo que sugiere un enfoque más eficiente para manejar el razonamiento complejo en la IA.
• Aprovechamiento de representaciones discretas para el aprendizaje por refuerzo continuo. El artículo presenta conclusiones según las cuales las representaciones categóricas discretas basadas en vectores en agentes de aprendizaje por refuerzo (RL) conducen a un modelado del mundo más eficiente y a un mejor aprendizaje de políticas. Las pruebas empíricas obtenidas en diversos escenarios de RL, incluidos contextos de aprendizaje continuo, indican que tales representaciones permiten una adaptación más rápida y un mejor rendimiento.
• MJ-Bench: ¿Es realmente su modelo de recompensa multimodal un buen juez para la generación de texto a imagen? MJ-Bench es un nuevo punto de referencia diseñado para evaluar los modelos de recompensa multimodal utilizados para proporcionar información sobre tecnologías de generación de texto a imagen, como DALLE-3 y Stable Diffusion. Pone a prueba los modelos en función de criterios como la alineación, la seguridad, la calidad de la imagen y el sesgo. En particular, la prueba ha revelado que los VLM de código cerrado, como GPT-4o, destacan por su eficacia a la hora de proporcionar retroalimentación. MJ-Bench se basa en un amplio conjunto de datos de preferencias para ajustar estos mecanismos de retroalimentación, y sus resultados están disponibles en Huggingface.
• AriGraph: Aprendizaje de modelos de grafos de conocimiento con memoria episódica para agentes LLM. AriGraph es un enfoque novedoso que mejora los agentes LLM mediante la incorporación de un grafo de memoria estructurado, mejorando su toma de decisiones y planificación en entornos como TextWorld. Permite una recuperación asociativa eficiente de la memoria episódica y semántica, demostrando ser superior en tareas complejas relevantes para la autonomía en dominios prácticos como la cocina, la limpieza y los rompecabezas.
• SylphAI-Inc/LightRAG: La librería Lightning para aplicaciones LLM.. LightRAG es una librería modular similar a PyTorch para la construcción de aplicaciones LLM como chatbots y generación de código, con un canal Retriever-Agent-Generator personalizable para varios casos de uso. Su código base transparente y modificable está diseñado para fomentar la confianza y la facilidad de adaptación.

4º semana

• Leyes a escala con vocabulario: Modelos más grandes merecen vocabularios más grandes. Un estudio reciente subraya el papel fundamental que desempeña el tamaño del vocabulario en el rendimiento de los modelos lingüísticos de gran tamaño, y concluye que los modelos con hasta 3.000 millones de parámetros funcionan mejor con vocabularios proporcionalmente mayores. La introducción del análisis IsoFLOPs recomienda vocabularios más grandes que los empleados habitualmente, con pruebas empíricas que indican mejoras significativas en los resultados, ejemplificadas por puntuaciones ARC-Challenge más altas cuando se utilizan vocabularios de tamaño óptimo.
• Spectra: estudio exhaustivo de modelos lingüísticos ternarios, cuantificados y FP16. El estudio Spectra presenta un amplio conjunto de 54 modelos de lenguaje de distintos tipos, incluidos modelos ternarios innovadores (TriLM), modelos cuantizados (QuantLM) y modelos tradicionales de coma flotante (FloatLM). Estos modelos abarcan un amplio espectro de complejidad de hasta 3.900 millones de parámetros y se han entrenado con un conjunto de datos de 300.000 millones de fichas. En particular, los TriLM demuestran un rendimiento superior al de sus homólogos ternarios y logran resultados equiparables a los de los modelos de coma flotante de media precisión (FP16), al tiempo que utilizan menos memoria.
• Informe técnico de Qwen2. El informe técnico Qwen2 presenta la serie Qwen2 de modelos lingüísticos con 0,5 a 72 mil millones de parámetros, que supera a la serie Qwen1.5 en puntos de referencia, multilingüismo y ajuste de instrucciones, con el modelo Qwen2-72B demostrando un rendimiento notable en diversas evaluaciones.
• Borrado de conceptos fiable y eficiente de modelos de difusión de texto a imagen. RECE es un nuevo método para eliminar rápidamente el contenido inapropiado de los modelos de difusión texto-imagen mediante una solución de forma cerrada que realinea de forma iterativa las incrustaciones de destino con conceptos inofensivos, manteniendo así el rendimiento generativo del modelo sin necesidad de más ajustes.

5º semana

• meta-llama/llama-agentic-system: Componentes agenticos de las APIs de Llama Stack. El repositorio «llama-agentic-system» da soporte al modelo Llama 3.1, diseñado para tareas que requieren un razonamiento complejo y el uso de herramientas, con especial atención a la seguridad mediante el filtrado de contenidos de Llama Guard. Las principales características son la cuantificación FP8 y las herramientas de interfaz de línea de comandos para la gestión del modelo.
• Diffree: Text-Guided Shape Free Object Inpainting with Diffusion Model. Diffree es un modelo guiado por texto que integra de forma autónoma nuevos objetos en imágenes basándose en descripciones textuales, eliminando la necesidad de colocación manual y garantizando la coherencia visual y contextual.
• CoD, Hacia un agente médico interpretable mediante la cadena de diagnóstico. El método Chain-of-Diagnosis (CoD) mejora la interpretabilidad de los diagnósticos médicos emulando el razonamiento de un médico mediante grandes modelos lingüísticos. Proporciona razonamientos transparentes y una distribución de la confianza en la enfermedad, mejorando así la localización de los síntomas y la precisión del diagnóstico, integrando los avances de la IA con la claridad médica.
• KAN o MLP: una comparación más justa. En un estudio comparativo de los modelos KAN y MLP, la investigación demuestra que, si bien los MLP obtienen mejores resultados en la mayoría de las tareas cuando se ajustan los parámetros y la complejidad computacional, los modelos KAN muestran un rendimiento superior en tareas que implican la representación de fórmulas simbólicas, lo que se atribuye a su uso de funciones de activación B-spline.
• Correspondencia local entre pares para el seguimiento de puntos. LocoTrack es un algoritmo avanzado de seguimiento de vídeo que consigue una gran precisión y eficacia mediante correlaciones locales 4D para la correspondencia de regiones, incluso en escenas repetitivas difíciles. Incorpora un diseño de transformador compacto para el análisis temporal a largo plazo y un codificador ligero que mejora la velocidad de procesamiento.

The post Noticias mensuales sobre IA y NLP – julio 2024 first appeared on Planeta Chatbot.

Poco más de un año después del lanzamiento de ChatGPT, está claro que la percepción pública de la «IA» ha cambiado radicalmente. En parte se debe a una mayor concienciación general, pero sobre todo a la constatación de que los sistemas basados en IA pueden ser (¿ya lo son?) capaces de alcanzar un nivel de competencia y rendimiento humano. En muchos sentidos, ChatGPT ha servido como prueba de concepto para la IA en su conjunto. El trabajo en esta demostración comenzó hace más de medio siglo y ahora ha aportado pruebas convincentes de que estamos más cerca de una realidad en la que podemos «crear máquinas que realicen funciones que requieren inteligencia cuando las realizan personas», tomando prestada la definición de Ray Kurzweil. No es de extrañar, pues, que los debates y el desarrollo en torno a la ingeniería de agentes de IA se hayan disparado en los últimos meses. Son la encarnación de las aspiraciones a las que siempre ha aspirado la IA.

Para ser claros, el concepto de agentes de IA no es nuevo. C-3PO, de La Guerra de las Galaxias, es la IA encarnada por excelencia, capaz de comprender el lenguaje natural, dialogar y actuar de forma autónoma. En el ámbito académico, el libro de texto de Norvig y Russell sobre IA, Artificial Intelligence: A Modern Approach, de Norvig y Russell, afirma que los agentes inteligentes son el principal tema unificador. Las ideas en torno a los agentes de IA, nacidas en la ciencia o en la ficción, parecen todas un poco más realizables con la llegada de modelos como ChatGPT, Claude y Gemini, ampliamente competentes en diversos dominios del conocimiento y dotados de una gran capacidad de comprensión y de diálogo a nivel humano. Si añadimos nuevas capacidades como la «visión» y la llamada a funciones, el escenario está preparado para la proliferación del desarrollo de agentes de IA.

A medida que avanzamos en el camino hacia el desarrollo de agentes de IA, parece necesario empezar a pasar de la ingeniería de prompts a algo más amplio, como la ingeniería de agentes, y establecer los marcos, metodologías y modelos mentales adecuados para diseñarlos de forma eficaz. En este artículo, me propongo explorar algunas de las ideas y preceptos clave de la ingeniería de agentes en el contexto del LLM.

Exploremos a alto nivel las secciones clave del Marco de Ingeniería de Agentes. Comenzamos con los «Requisitos de las capacidades del agente», en los que pretendemos definir claramente lo que debe hacer el agente y su nivel de competencia. En «Ingeniería y diseño de agentes» evaluamos las tecnologías disponibles y empezamos a pensar en la anatomía y orquestación de nuestros agentes.

Esta articulación inicial del marco pretende ser un modelo mental práctico y es cierto que no es exhaustivo en todos los frentes. Pero creo que es útil empezar por algún sitio y luego perfeccionarlo y mejorarlo con el tiempo.

El marco de ingeniería de agentes

Introducción

¿Cuál es el propósito de construir un agente de IA? ¿Tiene un trabajo o una función? ¿Acciones en apoyo de objetivos? ¿O objetivos en apoyo de acciones? ¿Es mejor un agente con múltiples capacidades que un enjambre de agentes para un trabajo concreto? Lo bueno del lenguaje humano es que es flexible y nos permite ampliar metafóricamente los conceptos en muchas direcciones. El inconveniente de esto es que puede llevar a la ambigüedad. Al articular el marco, intento evitar a propósito las distinciones semánticas entre términos clave, ya que muchos de ellos pueden utilizarse indistintamente. En lugar de ello, nos esforzamos por sacar a la superficie conceptos que se generalicen en su aplicación a la Ingeniería de Agentes de IA en sentido amplio. Como resultado, el marco en esta etapa es más un modelo mental que pretende guiar el proceso de pensamiento en torno a la Ingeniería de Agentes. Las ideas centrales son relativamente sencillas, como se puede ver en el siguiente gráfico:

• A los agentes de IA se les asigna(n) Trabajo(s)
• Los trabajos requieren acciones para completarse
• Para realizar la(s) acción(es) se requieren Capacidades
• Las capacidades tienen un nivel de competencia necesario.
• El nivel de competencia requerido requiere tecnologías y técnicas
• Las tecnologías y técnicas requieren orquestación+

Requisitos de las capacidades del agente

El trabajo a realizar

El paso inicial en el diseño de un agente de IA es definir claramente lo que el agente debe hacer. ¿Cuáles son los principales trabajos, tareas u objetivos que debe cumplir el agente? Esto puede enmarcarse en un objetivo de alto nivel o desglosarse en tareas específicas. Puede que decida utilizar un enfoque de enjambre multiagente y asignar a cada agente una tarea. El lenguaje y el nivel de detalle pueden variar. Por ejemplo:

• El trabajo de un bot de chat de comercio electrónico podría consistir en gestionar consultas generales, analizar el comportamiento de los clientes y hacer recomendaciones de productos.
• El trabajo de un agente de creación de contenidos podría consistir en aportar ideas y redactar artículos o entradas de blog.

Nótese que en ambos casos, etiquetas como trabajos, tareas, objetivos, etc. podrían utilizarse indistintamente en el contexto de lo que se supone que debe hacer el agente.

Las acciones a realizar para llevar a cabo el trabajo

Una vez definidas las tareas a realizar, el siguiente paso es determinar las acciones específicas que el agente debe llevar a cabo en relación con esa tarea. Se pasa de definir simplemente lo que el agente debe conseguir a especificar cómo lo conseguirá mediante acciones concretas. En esta fase también es importante empezar a considerar el nivel adecuado de autonomía del agente. Por ejemplo:

Para un agente de creación de contenidos, las acciones podrían incluir:

• Llamar a otro agente para obtener información sobre tendencias de contenidos.
• Generar una lista de ideas de contenidos basada en esas tendencias y en las preferencias del público objetivo.
• Redactar artículos o entradas de blog.
• Recibir instrucciones de un usuario humano sobre ediciones y ajustes.

El agente de creación de contenido puede generar y redactar contenido de forma autónoma, con un editor humano brindando la aprobación final. O se puede contratar a un editor agente independiente para realizar una primera revisión antes de que intervenga un editor humano.

Las capacidades necesarias

Ahora que hemos delineado las acciones que nuestros agentes deben tomar para realizar el trabajo, procedemos a articular las capacidades necesarias para permitir esas acciones. Pueden incluir todo, desde diálogo en lenguaje natural, recuperación de información, generación de contenido, análisis de datos, aprendizaje continuo y más. También se pueden expresar en un nivel más técnico, como llamadas API, llamadas a funciones, etc. Por ejemplo, para nuestro agente de creación de contenido, las capacidades deseadas podrían ser:

• Llamada dinámica de la API del agente de tendencias de contenido.
• Capacidades de lluvia de ideas y resumen.
• Tono de generación de contenidos adecuados sobre temas y tendencias actuales.
• La capacidad de actuar siguiendo instrucciones proporcionadas por humanos para editar contenido.
• Memoria

En última instancia, es importante centrarse en expresar las capacidades de manera que no limiten las opciones y la eventual selección de con qué tecnologías trabajar. Por ejemplo, aunque todos estamos bastante enamorados de los LLM, los modelos de acción grande (LAM) están evolucionando rápidamente y pueden ser relevantes para habilitar las capacidades deseadas.

Nivel de competencia requerido de las capacidades

Si bien identificar las capacidades necesarias para que un agente realice su trabajo es un paso crucial, es igualmente importante evaluar y definir el nivel de competencia requerido para cada una de estas capacidades. Esto implica establecer puntos de referencia específicos y métricas de rendimiento que deben cumplirse para que el agente y sus capacidades se consideren competentes. Estos puntos de referencia pueden incluir precisión, eficiencia y confiabilidad.

Por ejemplo, para nuestro agente de creación de contenido, los niveles de competencia deseados podrían incluir:

• Fiabilidad de llamadas a funciones del 75%.
• Explicabilidad de llamadas a funciones fallidas del 99,99%.
• Función de llamada del agente de tendencias de contenido que da como resultado temas relevantes al menos el 75% de las veces en el primer intento.
• Generación de ideas de contenidos que resultan en temas deseables el 75% de las veces.
• Recuperación de información precisa con una tasa de precisión del 99,99%.
• Generación de ediciones con una tasa de satisfacción de los comentarios de los usuarios del 90% o superior.
• Generación de borradores finales con una tasa de satisfacción de los comentarios de los usuarios del 90% o superior.

Ingeniería y diseño de agentes

Mapeo de las competencias requeridas con tecnologías y técnicas

Una vez que se especifican las capacidades necesarias y los niveles de competencia requeridos, el siguiente paso es determinar cómo podemos cumplir con estos requisitos. Esto implica evaluar un arsenal de tecnologías y técnicas disponibles en rápido crecimiento, incluidos LLM, RAG, Guardrails, API especializadas y otros modelos de ML/AI para evaluar si pueden alcanzar los niveles de competencia especificados. En todos los casos, es útil considerar en qué es mejor una determinada tecnología o técnica a alto nivel y las implicaciones de costo/beneficio. Discutiré superficialmente algunos aquí, pero su alcance y escala serán limitados ya que existen innumerables posibilidades.

Amplio conocimiento

El conocimiento amplio se refiere a la comprensión general y la información sobre una amplia gama de temas y dominios. Este tipo de conocimiento es esencial para crear agentes de IA que puedan entablar un diálogo eficaz, comprender el contexto y proporcionar respuestas relevantes en diversos temas.

• LLM: si las capacidades de su agente requieren un amplio conocimiento, la buena noticia es que el desarrollo de LLM continúa sin cesar. Desde modelos de código abierto como LlaMA3 hasta los últimos modelos propietarios de OpenAI, Anthropic y Google, no faltan opciones de tecnologías que brindan coherencia de alta densidad en una extensión tan vasta de lenguaje y conocimiento humanos.
• Ingeniería prompt: esta área de desarrollo dinámica y muy activa se centra esencialmente en cómo activar los dominios de conocimiento contextualmente apropiados que son modelados por los LLM. Debido a las cualidades caleidoscópicas del lenguaje, el dominio de este arte puede tener un impacto dramático en los niveles de dominio de las capacidades de nuestro Agente.

Competencia en conocimientos específicos

El conocimiento específico implica una comprensión más profunda de dominios o temas particulares. Este tipo de conocimiento es necesario para tareas que requieren experiencia detallada y familiaridad con contenido especializado. ¿Qué tecnologías/técnicas podríamos considerar para alcanzar nuestros objetivos de competencia?

• Generación aumentada de recuperación (RAG): RAG combina las capacidades generativas de los LLM con sistemas de recuperación de información para incorporar información de fuentes externas. Esto podría ser información precisa o conocimiento específico (por ejemplo, una descripción de un método único) que el LLM puede «comprender» en contexto debido a su amplio conocimiento.
• Ajuste fino del modelo: los LLM de ajuste fino en conjuntos de datos específicos del contexto adaptan los modelos para generar respuestas más contextualmente relevantes en entornos particulares. Aunque no es tan popular como RAG, a medida que la ingeniería de agentes continúa ganando terreno, es posible que descubramos que los requisitos de competencia nos llevan hacia esta técnica con más frecuencia.

Información precisa

La información precisa se refiere a puntos de datos específicos y muy precisos que son críticos para tareas que requieren respuestas exactas.

• Llamada de funciones (también conocida como uso de herramientas): todos desconfiamos del agente de IA que alucina con respecto a hechos específicos que son indiscutibles. Si el nivel requerido de competencia lo exige, podríamos recurrir a llamadas a funciones para recuperar la información específica. Por ejemplo, un agente de comercio electrónico podría utilizar una API de precios para proporcionar los precios más recientes de los productos o una API del mercado de valores para brindar actualizaciones en tiempo real sobre los valores de las acciones.
• Guardrails: los Guardrails pueden ayudar a garantizar que el agente proporcione información precisa y exacta en sus respuestas. Esto puede implicar restricciones basadas en reglas, diseño conversacional dirigido y preprocesamiento de intenciones.

Anatomía y orquestación del agente

Ahora que tenemos una idea clara de cuál es el trabajo del Agente, las capacidades y niveles de competencia requeridos y las tecnologías disponibles para habilitarlos, cambiamos nuestro enfoque a la anatomía y orquestación del agente, ya sea en una configuración en solitario o en algún tipo de enjambre. o ecosistema. ¿Deberían registrarse las capacidades para un agente o cada capacidad debería asignarse a un agente único que opere dentro de un enjambre? ¿Cómo desarrollamos capacidades y agentes que puedan reutilizarse con el mínimo esfuerzo? Este tema por sí solo involucra varios artículos, por lo que no profundizaremos más en él aquí. En algunos aspectos, aquí es donde “la goma se encuentra con el camino” y nos encontramos entrelazando múltiples tecnologías y técnicas para dar vida a nuestros Agentes.

Conclusión

El viaje de la ingeniería de prompts a la ingeniería de agentes apenas comienza y hay mucho que aprender y perfeccionar a lo largo del camino. Este primer intento de crear un marco de ingeniería de agentes propone un enfoque práctico para diseñar agentes de IA al delinear un modelo mental de alto nivel que puede servir como un punto de partida útil en esa evolución. Los modelos y técnicas disponibles para crear Agentes seguirán proliferando, creando una clara necesidad de marcos que se generalicen lejos de cualquier tecnología o clase de tecnologías específica. Al definir claramente lo que un agente debe hacer, delinear las acciones necesarias para realizar estas tareas y especificar las capacidades y niveles de competencia necesarios, establecemos una base sólida y flexible para nuestros esfuerzos de diseño e ingeniería. Además, proporciona una estructura para que nuestros agentes y sus capacidades mejoren y evolucionen con el tiempo.

Gracias por leer y espero que el marco de ingeniería de agentes le resulte útil en tus esfuerzos orientados a los agentes. Estad atentos a futuras mejoras del marco y elaboraciones sobre los diversos temas mencionados. Si deseas hablar más sobre el marco u otros temas sobre los que he escrito, no dudes en conectar conmigo en LinkedIn.

A menos que se indique lo contrario, todas las imágenes de este artículo son del autor.

The post De la ingeniería prompt a la ingeniería de agentes first appeared on Planeta Chatbot.

En este artículo, exploraremos cómo implementar un bucle de razonamiento multipaso en nuestra arquitectura Agentic RAG. Prepárate para una emocionante inmersión profunda en el poder de los agentes y su capacidad para manejar intrincadas tareas de múltiples pasos con precisión y eficiencia. Puedes consultar los anteriores también en nuestra web, Planeta Chatbot:

• Agentic RAG con Llama-index | Llamada a función #02
• Agentic RAG con Llama-index | Motor de consulta del enrutador #01

Qué son los agentes

Hasta ahora hemos estado trabajando con Llama-index.

Los data agents son trabajadores del conocimiento potenciados por LLM en LlamaIndex que pueden realizar de forma inteligente diversas tareas sobre sus datos, tanto en función de «lectura» como de «escritura». Son capaces de lo siguiente:

• Realizar búsquedas y recuperaciones automatizadas sobre diferentes tipos de datos: no estructurados, semiestructurados y estructurados.
• Llamar a cualquier API de servicio externo de forma estructurada, y procesar la respuesta + almacenarla para más tarde.

En ese sentido, los agentes van un paso más allá de nuestros motores de consulta, ya que no sólo pueden «leer» de una fuente estática de datos, sino que pueden ingerir y modificar dinámicamente datos de una variedad de herramientas diferentes.

Construir un agente de datos requiere los siguientes componentes básicos:

• Un bucle de razonamiento
• Abstracciones de herramientas

Un data agent se inicializa con un conjunto de APIs, o Herramientas, con las que interactuar; el agente puede llamar a estas APIs para devolver información o modificar el estado. Dada una tarea de entrada, el data agent utiliza un bucle de razonamiento para decidir qué herramientas utilizar, en qué secuencia, y los parámetros para llamar a cada herramienta.

Por defecto los agentes en Llama-index se componen de dos cosas principales:

1. AgentRunner: Esta es la parte del agente que se encarga de la orquestación de tareas aka Task Orchestrator. Esta sección del agente también maneja el Estado y la Memoria. El AgentWorker responde a esta sección del agente después de completar cada tarea que se le asigna, la respuesta se comunica al usuario si es necesario.
2. AgentWorker: Es lo que realmente ejecuta y razona las tareas. Las tareas son delegadas a esta sección del flujo de trabajo del agente por el AgentRunner. Se ocupa de las Herramientas y LLMs.

Recursos de vídeo

Si te gusta ver vídeos en lugar de leer, también tengo algo para ti.

Configuración del entorno

Utilizaremos el mismo entorno que configuramos en el artículo anterior. Lo único que crearé es un archivo .ipynb, este archivo se llama Lesson_03.ipynb:

Creando Herramientas

Vamos a seguir adelante y crear dos herramientas principales como ya hemos hecho en los últimos artículos.

import dotenv
%load_ext dotenv
%dotenv

import nest_asyncio
nest_asyncio.apply()

from llama_index.core import SimpleDirectoryReader

# load lora_paper.pdf documents
documents = SimpleDirectoryReader(input_files=["./datasets/lora_paper.pdf"]).load_data()

from llama_index.core.node_parser import SentenceSplitter

# chunk_size of 1024 is a good default value
splitter = SentenceSplitter(chunk_size=1024)
# Create nodes from documents
nodes = splitter.get_nodes_from_documents(documents)

from llama_index.core import Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# LLM model
Settings.llm = OpenAI(model="gpt-3.5-turbo")
# embedding model
Settings.embed_model = OpenAIEmbedding(model="text-embedding-ada-002")

from llama_index.core import SummaryIndex, VectorStoreIndex

# summary index
summary_index = SummaryIndex(nodes)
# vector store index
vector_index = VectorStoreIndex(nodes)

# summary query engine
summary_query_engine = summary_index.as_query_engine(
    response_mode="tree_summarize",
    use_async=True,
)

# vector query engine
vector_query_engine = vector_index.as_query_engine()

llm = OpenAI(model="gpt-3.5-turbo", temperature=0)

from llama_index.core.tools import QueryEngineTool

summary_tool = QueryEngineTool.from_defaults(
    query_engine=summary_query_engine,
    description=(
        "Useful for summarization questions related to the Lora paper."
    ),
)

vector_tool = QueryEngineTool.from_defaults(
    query_engine=vector_query_engine,
    description=(
        "Useful for retrieving specific context from the the Lora paper."
    ),
)

Bucle de razonamiento

El bucle de razonamiento depende del tipo de agente.

Tenemos soporte para los siguientes agentes:

• Agentes de llamada a función (se integra con cualquier LLM de llamada a función).

• Agente ReAct (funciona a través de cualquier endpoint de finalización de chat/texto).

«Agentes avanzados: LLMCompiler (https://llamahub.ai/l/llama-packs/llama-index-packs-agents-llm-compiler?from=), Chain-of-Abstraction (https://llamahub.ai/l/llama-packs/llama-index-packs-agents-coa?from=), Language Agent Tree Search (https://llamahub.ai/l/llama-packs/llama-index-packs-agents-lats?from=), y más.

AgentWorker

Como hemos comentado anteriormente, el agent worker es el responsable de ejecutar todas las herramientas y los LLMs. Vamos a crear un agent worker pasándole todas las herramientas que hemos creado anteriormente:

from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.core.agent import AgentRunner

agent_worker = FunctionCallingAgentWorker.from_tools(
    tools=[vector_tool, summary_tool], 
    llm=llm, 
    verbose=True
)
agent = AgentRunner(agent_worker)

Para ello, utilicemos una pregunta que requiera un razonamiento de varios pasos.

response = agent.query(
    "Explain to me what is Lora and why it's being used. Are existing solutions not good enough?"
) 

En la imagen de arriba, se puede ver que el LLM está haciendo uso de una cadena de razonamiento CoT para responder a todas las preguntas que le habíamos planteado, una tras otra, basándose en la anterior.

Memoria de conversaciones

Hasta ahora, la arquitectura de agentes RAG funciona bien. Una limitación es que no recuerda conversaciones anteriores. Tenemos la capacidad de mantener una memoria tal que las acciones que realiza el agente no sólo dependen de la consulta del usuario, sino que también se tiene en cuenta el historial de las conversaciones anteriores con los agentes.

La memoria no es más que una lista plana de conversaciones que el agente ha mantenido con el usuario. Esta lista es un buffer de memoria conversacional, la razón es que no queremos tener demasiada conversación almacenada en memoria de tal forma que desbordemos la ventana de contexto de los LLMs. Esta lista actúa como un buffer rodante dependiendo del tamaño de la ventana de contexto del LLM subyacente que estemos usando.

Para utilizar la capacidad de memoria del agente, tenemos que llamar al método chat() en lugar del método query() que hemos utilizado hasta ahora. El método query() no conserva el estado, por lo que no se conserva el historial de la conversación.

response = agent.chat(
    "Explain to me what is Lora and why it's being used. Are existing solutions not good enough?"
)

print(str(response))

response = agent.chat(
    "What was my last question to you?"
)

print(str(response))

Cómo funciona a bajo nivel

Hemos visto cómo funciona el agente desde una perspectiva de alto nivel. Echemos un vistazo a cómo funciona en un nivel inferior y obtengamos más control sobre la ejecución del agente y cómo se llevan a cabo las tareas. Esto nos da algunas ventajas añadidas como:

1. Programar nuestras propias tareas: Podemos controlar y programar nuestras propias tareas y establecer cuando se ejecutará cada tarea.
2. Incorporar feedback humano: Entendiendo cómo funciona el agente a un nivel inferior, podemos ser capaces de proporcionar manualmente feedback humano al agente para hacerle saber si está dando los pasos correctos que queremos o no, en caso contrario podemos especificar manualmente al agente qué acciones queremos que realice.
3. Ayuda a la resolución de problemas

En primer lugar, vamos a seguir adelante y crear un agente de ejecución, que se ejecuta el agente de trabajo como hemos discutido anteriormente.

agent_worker = FunctionCallingAgentWorker.from_tools(
    [vector_tool, summary_tool], 
    llm=llm, 
    verbose=True
)
agent = AgentRunner(agent_worker)

Ahora vamos a crear manualmente una tarea para el agentrunner Orchestrator:

task = agent.create_task(
    "Explain to me what is Lora and why it's being used."
    "Are existing solutions not good enough?"
)

Una vez que tenemos esta tarea creada, recuerda que no pasamos esta tarea al agent worker por lo que no se ejecuta. Así que si comprobamos si se ha completado alguna tarea, deberíamos obtener cero, veamos esto en acción:

completed_steps = agent.get_completed_steps(task.task_id)

print(f"Number of completed steps for tasksID {task.task_id} is {len(completed_steps)}")

if len(completed_steps) > 0:
    print(completed_steps[0].output.sources[0].raw_output)

Ahora, vamos a comprobar si el agentrunner ha orquestado algunas tareas para que las ejecute el agent worker. Podemos ver esto viendo las próximas tareas:

upcoming_steps = agent.get_upcoming_steps(task.task_id)
print(f"Number of completed steps for tasksID {task.task_id} is {len(upcoming_steps)}")

if len(upcoming_steps) > 0:
    print(upcoming_steps[0].input)

Desde aquí podemos ver la entrada que el agentrunner debe pasar al agent worker para que la ejecute. La entrada es la pregunta original que pasamos a la tarea que acabamos de crear. Ahora, vamos a seguir adelante y ejecutar la próxima tarea programada para ver y volvemos.

step_output = agent.run_step(task.task_id)

Se puede ver que el agent worker fue capaz de razonar sobre la tarea e identificó que necesitaba dividir la tarea en dos subtareas separadas. Cada subtarea se resolvió mediante el uso de la herramienta de llamada aka función de llamada a la herramienta de motor de consulta en este caso particular.

Una vez hecho esto, podemos seguir adelante para comprobar si hay otras tareas que tenemos que completar y cuáles son sus entradas:

También podemos comprobar si este es el último paso que necesitábamos ejecutar:

print(step_output.is_last)

Se puede ver que hemos obtenido True, concretamente, un Python true indicando que era el último paso en la ejecución de la tarea.

También podemos sobreescribirlo proporcionando nuestras tareas personalizadas, esto puede actuar como un humano corrigiendo al agente sobre lo que necesita hacer, una especie de feedback guía humano.

Para ello, voy a crear una nueva tarea, y luego añadir la retroalimentación humana en el bucle y cambiar la pregunta de la tarea.

task = agent.create_task(
    "Explain to me what is Lora and why it's being used."
    "Are existing solutions not good enough?"
)

step_output = agent.run_step(
    task.task_id, input="Explain to me the dataset used to fine-tune in the Lora paper."
)

Tenemos que comprobar si es el último paso, esto es importante o te dará un error. No sé por qué tuvieron que hacer eso.

Una vez hecho esto, podemos pasar a obtener la respuesta definitiva:

response = agent.finalize_response(task.task_id)
print(str(response))

Conclusión

Enhorabuena por haber llegado hasta aquí. En este artículo hemos repasado cómo trabajar con un bucle de razonamiento multipaso en un sistema RAG agéntico. No sólo hemos visto la implementación de alto nivel, sino también el funcionamiento a bajo nivel del bucle de razonamiento multipaso y la posibilidad de proporcionar feedback al agente (feedback humano en el bucle).

Espero que este artículo te proporcione una clara comprensión de la capacidad de razonamiento multipaso de un agente. En el próximo artículo, veremos cómo realizar capacidades RAG utilizando múltiples documentos.

Otras plataformas en las que puedes ponerte en contacto conmigo:

1. YouTube
2. Twitter
3. LinkedIn
4. Discord

Referencias

1. Data Agents Llama-index

The post RAG Agentic Con Llama-index | Capacidad de Razonamiento Multipaso #03 first appeared on Planeta Chatbot.

Así que «GPT» es una especie de nombre engañoso y complaciente. Pero esa es la menor de mis quejas.

Token Furnace

Los GPT requieren el uso de GPT-4. Eso en sí mismo no debería ser un problema para un usuario con una cuenta de pago como yo. Pero hay algo extra que ocurre con los GPTs que hace que agoten mi asignación diaria de uso de GPT-4 de la capa de pago extremadamente rápido.

He hecho todas mis ediciones directamente en la pestaña «configuración» del portal OpenAI evitando herramientas como el GPT Builder, que a su vez utilizan tokens para construir avisos por ti. Esto parece ayudar un poco, pero no mucho.

Además, pensando en mis potenciales usuarios de GPT, no quiero que gastes todos tus tokens en 15 minutos en mi GPT.

En el momento de escribir esto, no hay soporte para ejecutar GPTs bajo el modelo GPT-3.5, que es más barato. Eso habría eliminado esta preocupación.

Otra cosa que ayudaría mucho es no requerir un LLM para manejar la lógica de la aplicación. Vamos a llegar a eso a continuación.

El uso de la ingeniería de prompts para manejar la lógica de la aplicación es una tontería

Puedes dar instrucciones detalladas a una GPT para que funcione como un software convencional. Los GPT pueden tener sistemas de menús, comandos de ayuda o máquinas de estado rudimentarias.
En una de mis GPTs, utilizo cierta lógica de aplicación para guiar a un usuario para que proporcione algunos datos para un ejercicio de rol en español. Después de que el usuario haya especificado qué tipo de situación le gustaría representar, puedes decir el comando palabra clave «empecemos» para que el GPT cambie a otro modo: el juego de rol propiamente dicho.

En el desarrollo de software convencional, se podría hacer lo mismo sin utilizar LLMs. Tal vez tendrías una variable «mode» y una sentencia de control de flujo «if…then» en algún lugar. Esto es algo trivial. Una gestión básica del estado de la aplicación como ésta se ejecutaría instantáneamente y sin alucinaciones en un Commodore VIC-20.

Los LLM también son capaces de manejar la lógica de la aplicación a través de su función de predicción de texto. En lugar de almacenar el estado en variables, se almacena en la propia sesión de chat (ventana contextual). Cada vez que un usuario de GPT introduce una nueva instrucción, el LLM procesa todo su historial de chat junto con la base inicial de instrucciones de GPT.

Poder utilizar un LLM como entorno de ejecución para la lógica de la aplicación es increíble. Realmente lo es. Pero desde el punto de vista de la arquitectura de software, usar un LLM para manejar la lógica de la aplicación es trágicamente estúpido:

• Es un derroche computacional.
• Es lento.
• No es fiable.

Veamos con detalle:

• Despilfarro computacional: utilizamos el tiempo de las GPU en los centros de datos para cargar la lógica de la aplicación en una ventana contextual en forma de texto lingüístico, codificarlo, transformarlo, ejecutarlo en una red neuronal y descodificarlo. Esto supone varios órdenes de magnitud más de cálculo del que realmente se necesita.

• Lentitud: El encanto de ver cómo el texto se dibuja lentamente en la pantalla como un sistema de tablón de anuncios en línea de los años 80 desaparece rápidamente. Este retraso es aceptable cuando la GPT está haciendo algo que sólo se puede hacer con un LLM, como simular una conversación en español con un taxista. Pero no para la interfaz de usuario básica y la funcionalidad de la aplicación.

• Poco fiable: La naturaleza aleatoria de la IA generativa significa que cada consulta tiene una probabilidad demasiado grande de equivocarse en la lógica de la aplicación. «Alucinaciones», lo llaman. Y de nuevo, esta falta de fiabilidad es aceptable para hacer algo que sólo se puede hacer con un LLM. Pero si estás manejando una tarea como «muéstrame los comandos disponibles para esta GPT», la forma convencional no LLM de codificarlo va a ser 100% determinista y ampliamente preferible.

Lo bueno

Probablemente debería equilibrar mi crítica reconociendo las características de GPT que son interesantes o útiles.

• Acciones: Aún no he probado las «acciones», pero entiendo cómo deberían funcionar y veo su potencial. Puedes hacer recuperación-aumentada-generación (RAG) con estas acciones en GPTs. No es poca cosa.

• Reutilización práctica de los fundamentos de los avisos: También me he dado cuenta de que es bueno volver a ciertas bases. Y una característica como GPTs para acceder fácilmente a ellos dentro del portal ChatGPT es bienvenida. Tengo algunos GPTs personalizados para mi propio uso. Podría guardar mis bases en un documento de Word y pegarlas. Pero me gusta tener un icono rápido para hacer clic en su lugar.

• Tienda GPT: Algunos desarrolladores se han tomado en serio lo de ganar dinero con sus GPTs desde la GPT Store. Tengo dudas de que este sea un buen enfoque comparado con otros. Pero tal vez hay espacio para hacer algo de dinero rápido en GPTs de pequeño esfuerzo – difícil de decir.
  Compartibilidad: Tener un enlace compartible a una GPT también es bueno. De hecho, ésta podría ser la mejor característica de las GPT. Porque permite a un desarrollador publicar software basado en OpenAI sin tener que pagar costes de alojamiento. Ese fue el aspecto de las GPT que me convenció para probarlas.

Pero al final, los GPTs son demasiado simples para tomármelos en serio.

Lo que sería genial tener en su lugar

Siento a alguien escribiendo esto en los comentarios…

Amigo, sólo tienes que obtener una clave de API y llamar al punto final REST para OpenAI. Luego puedes escribir tu lógica de control como quieras. Usa tu lenguaje favorito, proveedor de hosting, etc.

Absolutamente. De hecho ya lo he hecho.

Pero quería una manera de lanzar una aplicación basada en LLM en la que no tuviera que preocuparme por los costes de alojamiento. Hay toda esa gente que ya tiene cuentas OpenAI, muchas de ellas de pago. ¿Por qué no puedo darles mi aplicación basada en LLM? Los usuarios ya tienen cubiertos los costes de alojamiento. Y desde el punto de vista de OpenAI, mi aplicación debería servir como incentivo para que la gente obtenga cuentas OpenAI y las mantenga.

Otra posible solución es pedir a estos usuarios que introduzcan una clave API. Pero eso es engorroso y potencialmente inseguro. Engorroso, porque los usuarios tienen que encontrar la opción en su pantalla de configuración para generar una clave de API. Potencialmente insegura, porque la clave API puede verse comprometida por código malicioso que se ejecute en la aplicación web y en otros lugares.

Este es un problema resuelto para muchas otras empresas. Simplemente proporcionan una API basada en OAuth.

Así, por ejemplo, si quiero crear una aplicación web nueva que utilice la API de Spotify, puedo implementar el flujo de trabajo de OAuth. Un usuario con una cuenta de Spotify visita mi aplicación web, y mi aplicación puede redirigirlo brevemente a Spotify para autenticarse/autorizarse. Esas credenciales de usuario nunca se comparten conmigo porque Spotify gestiona la interfaz de usuario de inicio de sesión desde su sitio web. Una vez autenticado, Spotify devuelve al usuario a mi sitio web junto con un token de acceso. Mi aplicación web puede pasar ese token de acceso a las API de Spotify.
Me parece que alguien ha escrito esto otro en los comentarios…

En realidad, OpenAI tiene soporte OAuth.

Sí, en el momento de escribir esto, tienes soporte de consumidor OAuth para GPTs que llaman a través de acciones. (¡Genial!) Pero estoy hablando de soporte de proveedor OAuth que permitiría que el código que se ejecuta fuera del portal OpenAI llame a su API utilizando cuentas de usuarios OpenAI.

RantConcluido

Es abril de 2024 cuando escribo esto. Las cosas cambiarán. La relevancia de mis observaciones desaparecerá.

Al final, he llegado a la conclusión de que las GPT son decentes para uso personal en algunos casos, pero una mala elección para crear aplicaciones serias o incluso demos que quieras compartir con otras personas. Vale la pena jugar un poco con las GPT. Pero yo no elegiría esa plataforma para invertir más de una tarde de domingo aprendiendo.

Tengo otra forma de hacer una aplicación LLM de coste de alojamiento cero para probar a continuación – LLMs locales. Estoy jugando con Ollama y WebLLM. Los modelos no son tan buenos como GPT-4. Pero me encanta la cantidad de control que tengo sobre la aplicación. La privacidad para el usuario es maravillosa. Y un navegador es una buena caja de arena para que los agentes permanezcan seguros dentro.

Y no tendré que llamar a mi aplicación… (suspiro) «GPT».

Créditos de las imágenes

Todas las imágenes generadas con Midjourney utilizando la nueva función de referencia de personajes basada en mi arte de referencia, que también puedes utilizar.

Únete al boletín del Generador

The post GPT: la herramienta equivocada para crear aplicaciones de IA first appeared on Planeta Chatbot.

Este encuentro coorganizado con el Ayuntamiento de Madrid, MadridAI reunió a casi 100 personas, poniendo broche final al curso lectivo de la comunidad en la capital donde surgió el movimiento.

A lo largo del encuentro, contaron con diferentes ponentes. Miguel Angel Rodriguez, Subdirector General de Sistemas y Tecnología en Informática del Ayuntamiento de Madrid, fue el encargado de dar la bienvenida. Tras su intervención dio paso a cada una de las ponencias que estaban programadas para la jornada.

En primer lugar, Coral García, Senior Data Scientist en Santalucía, y Eduardo Fernández, Lead Data Scientist & AI Engineer en Santalucía, fueron los protagonistas de la ponencia  “IA generativa para pregunta respuesta. Dominando los RAGs con llama-Index”.

A lo largo de su sesión, Coral y Eduardo explicaron el proyecto en el que han estado trabajando durante el último año. Tal y como destacaron, esta nueva iniciativa surge de las limitaciones de ChatGPT y, concretamente, de plantearse la siguiente pregunta “¿podríamos generar un ChatGPT con información interna de Santalucía?” A raíz de esta duda, el equipo empezó a plantearse el desarrollo de una herramienta interna que fuese útil para todos, es decir, para los más de 15.000 empleados que tiene la compañía.

Sin embargo, no era una tarea fácil, esta nueva herramienta tenía que cumplir una serie de requisitos. En primer lugar, nutrieron al sistema con información primaria, procedente de la propia compañía; seguidamente cargaron un uso masivo de documentos. Continuaron el proceso revisando la seguridad, determinando quién y a qué se podía acceder.

Realizados dichos pasos, comenzaron a trabajar en los falsos positivos y en los procesos que iban a permitir que el sistema tuviera la información actualizada. Además, querían una interfaz amigable, que asegurara una utilización sencilla, que fuera conversacional para favorecer la coherencia de la herramienta, que no tenga alucinaciones, tiene que ser precisa.

Con esta idea, nació la herramienta de la compañía. Sin embargo, a lo largo de la intervención Coral y Eduardo explicaron cómo trabajaron con las RAG para evitar los falsos positivos. Para ello, se apoyaron en las tres partes que componen las RAG: retrieval, augmented y generation.

• Retrieval: los falsos positivos aparecen porque no se están recuperando de forma correcta los fragmentos de los textos que responden a la pregunta del usuario. Las causas pueden ser debido a la complejidad del documento original y esto se traduce en la dificultad de crear fragmentos de texto o chunks que contengan toda la información necesaria para responder a las preguntas. Otra causa puede ser la homogeneidad del documento, lo que causa que el retriever va a recuperar todos los fragmentos relacionados, sean del documento que sean. Para solucionar la complejidad del documento se apuesta por sistemas como el procesamiento de los documentos con GPT4-Vision + Prompt o el uso del  Routering Query Engines de Llama-Index. 
• Augmented: los falsos positivos aparecen porque los fragmentos generados no tienen suficiente contexto como para entender bien la información que se le está proporcionando. Para mitigarlo se apuesta por el enriquecimiento del metadato de los nódos con los metadata extractor de Llama-Index. 
• Generation: los falsos positivos aparecen porque el LLM no genera la respuesta apropiada para la pregunta del usuario. En este caso, se deberá generar un prompt más concreto y potente.

Además, durante su intervención Coral y Eduardo compartieron varios casos prácticos en los que se explicaba cada una de las problemáticas y sus soluciones. El caso de Santalucía pone de manifiesto cómo la IA Generativa puede ser un recurso eficiente y óptimo a nivel interno. 

Tras su intervención, llegó el turno de Irene Cid, Business Technology Lead en IBM, y Celeste López, AI Engineer en IBM, que titularon su ponencia “Instruct Lab ¿Cómo reentrenar sin tener que fine-tunnear el modelo completo?”. Durante la sesión, Irene y Celeste se centraron en explicar cómo habían mejorado la capacidad del LLM en la fase de Instruction Tuning gracias al sistema Instruct Lab. 

En este punto del entrenamiento (Instruction Tuning), el equipo se encontró con varios desafíos que decidieron solventar generando datos sintéticos de forma controlada y localizada siguiendo una estructura que se utilizará para entrenar al modelo. Una tarea compleja para la que necesitaron recurrir a la “Taxonomía”, un sistema que como Irene indica es “como un armario bien ordenado” y que está publicado en su paper «LAB: Large-scale aligment for chatbots», que dio lugar a Instruct Lab.

Siguiendo esta metodología, Irene y Celeste nos explican que dos sistemas se podrían seguir para entrenar y mejorar al modelo  al que le falta información. Un modelo al que han denominado en el paper  “estudiante”. En primer lugar, para entrenar conocimiento concreto estático se necesitaría un repositorio de información adicional y cinco ejemplos (o más). Con estos datos, el sistema ya generaría datos sintéticos. En segundo lugar, también se puede entrenar una habilidad en concreto, para este sistema, solo necesitaríamos cinco ejemplos manuales. 

Pero eso no es todo, siguiendo con lo publicado en el paper, el sistema también cuenta con un “modelo profesor” que genera los datos sintéticos guiados por esa jerarquía para que no se vaya por las ramas, evitando sesgos dentro de la información que le estamos suministrando. Un punto importante dado que los datos se utilizarán para reentrenar el propio modelo, haciendo uso del «modo estudiante” explicado anteriormente. Además, cada vez que se genera un dato sintético hay un “modelo juez” que avisa si el dato generado es fiable o no. De este modo, se generan dos listados: los datos aceptados y los descartados.

Tras la explicación en detalle de los diferentes modos, Celeste pasa a explicar en tiempo real cómo funciona el sistema y qué oportunidades ofrece en la consola una vez que está instalado Instruc Lab (iLab) en tu terminal. Para terminar la sesión, Celeste e Irene destacaron cuáles son los grandes aportes de esta nueva herramienta, que resumieron en:

• Democratiza la generación de taxonomías a equipos menos técnicos que tienen el conocimiento de negocio.
• Se invierten menos recursos y tiempo para conseguir que el modelo funcione como espero.
• Aprovechan las taxonomías generadas por la economía opensource.

El encuentro finalizó con una ronda de preguntas para los ponentes y el networking que tanto caracteriza a esta comunidad. Si eres un apasionad@ del mundo de la IA te recomendamos que sigas muy de cerca a esta comunidad que está presente en más de 31 localidades. Y, por supuesto, no te pierdas el vídeo completo del evento.

The post Nuevo encuentro de MadridAI en la capital first appeared on Planeta Chatbot.

Rufus ha sido diseñado con el objetivo de resolver las dudas sobre los productos que existen en la app de forma conversacional y en tiempo real. Tal y como indican en la publicación realizada en el blog de Amazon, de este modo se consigue «que los consumidores tomen decisiones de compra más informadas gracias a la IA conversacional«. Por el momento, estas son algunas de las cuestiones que Rufus es capaz de gestionar:

Detalles de producto y reseñas

Cuando estás a punto de comprar un producto suelen surgir preguntas de todo tipo. Dudas que necesitas resolver para terminar de decantarte por un producto u otro. Por ejemplo, «¿esta plancha es fácil de limpiar?«, «¿realmente funciona está mascarilla facial?» o «¿los consumidores recomiendan esta mochila para hacer rutas de larga distancia?» son algunas de las preguntas que los consumidores hacen en la plataforma. Gracias a la descripción de los productos, los comentarios de la comunidad y las reseñas publicadas por otros consumidores, Rufus es capaz de elaborar una respuesta útil y completa. Pero eso no es todo, el asistente también sugiere algunas «preguntas rápidas» como «¿qué dicen los consumidores de este producto?». De este modo, solo haciendo click en el botón ofrecido por Rufus, el usuario repsonde de forma directa su consulta.

Recomendaciones de productos

Rufus también es capaz de recomendar productos disponibles en la app de Amazon. Si un usuario pregunta al asistente «¿qué zapatilla me recomiendas para correr por montaña siendo mujer?», el sistema le dará un pull de opciones, explicando cuáles son las virtudes y peculiaridades de cada uno de los productos recomendados.

Comparar diferentes opciones

Gracias a toda la información a la que Rufus tiene acceso, también es posible solicitarle comparaciones o recomendaciones en base a diferentes preferencias o situaciones concretas. De este modo, los usuarios podrían preguntar «compara deportivas para pronador» o «compra productos goretex para viajar a Suecia en invierno«.

Y mucho más…

Pero, el potencial de Rufus como asistente de compra va mucho más allá. Los consumidores pueden solicitarle que le mantengan al día de las novedades que surgen en un determinado sector, y saber, en consecuencia, cuáles son los últimos productos de una determinada compañía o de un determinado segmento.

Además, también cuenta con una funcionalidad completamente personalizada. Esta función permite a los usuarios preguntar por el estado de los pedidos que se encuentran en reparto, preguntando, por ejemplo, ¿dónde está el pedido que realicé la semana pasada?». También se pueden realizar otras consultas como «¿cuándo fue la última vez que compré un libro de este autor?», permitiendo al usuario tomar decisiones en base a pedidos realizados previamente.

Por último, una de las funcionalidades estrella es la de hacer consultas que no están relacionadas de forma directa con la compra de productos. Por ejemplo, «¿qué necesito para hacer una fiesta en la piscina?» o «¿qué necesito para hacer un mousse de limón?».

La llegada oficial de Rufus pone de manifiesto la apuesta clara de Amazon por la IA Generativa. Tras meses de trabajo, el chatbot de IA Conversacional llega para ayudar a todos los consumidores y usuarios de esta app. En esta página web, puedes encontrar más información sobre su funcionamiento y sus capacidades. Ahora, la pregunta más repetida es «¿Cuándo llegará a Europa?».

Fuente: Amazon

The post Rufus, el chatbot de Amazon, ya está disponible first appeared on Planeta Chatbot.

Amazon Web Services (AWS) ofrece una solución a este desafío a través de AWS Bedrock y un conjunto de servicios de AWS diseñados para crear agentes de IA conversacionales que puedan gestionar y utilizar de forma segura los datos de propiedad. AWS Bedrock, junto con el sólido ecosistema de AWS, ofrece un marco en el que la seguridad y la gobernanza están en primer plano, lo que garantiza que las empresas puedan aprovechar el poder de la IA generativa sin comprometer la protección de los datos.

En este tutorial práctico, profundizaremos en la creación de un agente de IA conversacional que utiliza documentos propios almacenados en Amazon S3. Este agente de IA será capaz de recuperar información relevante de nuestra base de datos mediante Retrieval-Augmented Generation (RAG) y AWS OpenSearch Vector Database, mostrando la integración perfecta y las potentes capacidades de los servicios de AWS para manejar tareas complejas de recuperación de datos.

Para que este agente de IA sea accesible, desarrollaremos una API utilizando AWS Lambda y API Gateway, garantizando una interfaz escalable y segura para la interacción. Además, para mejorar la experiencia del usuario, emplearemos Voiceflow para el front-end, lo que permitirá una interfaz conversacional intuitiva y atractiva.

La arquitectura

El siguiente diagrama es un patrón de arquitectura de solución común que puedes utilizar para integrar cualquier aplicación de chatbot a Knowledge Bases para Amazon Bedrock. Utilizaremos este diagrama como base para el back-end de nuestra aplicación y lo integraremos a través de una API en nuestra interfaz de chat Voiceflow.

Esta arquitectura incluye los siguientes pasos:

• Consulta del usuario: Un usuario inicia el proceso interactuando con el chatbot a través de una solicitud de API iniciada a través de la interfaz de chat front-end de Voiceflow, emitiendo una pregunta en lenguaje natural.
• La API activa AWS Lambda: La API recibe la consulta y activa una función de AWS Lambda. Esta función es responsable del procesamiento posterior de la consulta del usuario.
• Invocar la API RetrieveAndGenerate: Dentro de la función de AWS Lambda, se procesa la consulta del usuario y se invoca la API RetrieveAndGenerate de Amazon Bedrock.
• Conversión de la consulta en vector: A continuación, la consulta del usuario se convierte en un vector mediante un modelo de incrustación de Amazon Titan dentro de Amazon Bedrock.
• Recuperación de información relevante: Tras convertir la consulta, el sistema extrae segmentos de datos de la base de conocimientos que se alinean semánticamente con la consulta del usuario. Este proceso se realiza mediante la comparación de la representación vectorial de la consulta con las incrustaciones de texto almacenadas en un almacén vectorial de Amazon OpenSearch Serverless.
• Aumento de la consulta del usuario: La información recuperada se utiliza para aumentar la consulta original del usuario, añadiendo contexto adicional que es fundamental para generar una respuesta precisa y contextualmente relevante.
• Generación de la respuesta con LLM: esta instrucción enriquecida se utiliza como entrada para un modelo de lenguaje amplio (LLM), como Anthropic Claude 2, disponible en Amazon Bedrock. A partir del contexto enriquecido, el LLM genera una respuesta completa y pertinente.
• Envío de la respuesta al usuario: La respuesta elaborada por el LLM se envía de vuelta al usuario a través de la API al front-end Voiceflow, donde se muestra al usuario.

La siguiente sección proporciona una guía detallada paso a paso sobre la construcción de un agente de IA conversacional utilizando varios servicios de AWS y Voiceflow. Para participar y seguir la guía, asegúrate de tener una cuenta de AWS activa. También puedes encontrar una copia del código fuente en GitHub.

La base de datos de conocimientos

Carga tu conjunto de datos de conocimiento en Amazon S3

Encuentra un conjunto de datos que te gustaría que tu Agente de IA consultara. Procederemos a cargar este conjunto de datos en un bucket de Amazon S3 y a configurar una base de datos de conocimientos para interactuar con el conjunto de datos elegido de forma eficaz.

Completa los siguientes pasos:

1. En la consola de Amazon S3, selecciona Buckets en el panel de navegación.
2. Haz clic en Crear bucket.
3. Nombra el bucket knowledgebase-<chatbot-name>.
4. Deja el resto de la configuración del bucket como predeterminada y seleccione Crear.
5. Navega hasta el bucket knowledgebase-<chatbot-name>.
6. Selecciona «Crear carpeta» y nómbrala dataset.
7. Deja el resto de configuraciones de carpeta por defecto y elija Crear.
8. Ve a la carpeta del conjunto de datos.
9. Arrastra y suelta el conjunto de datos que descargaste anteriormente en este bucket y selecciona Cargar.
10. Vuelve al inicio del bucket y elige «Crear carpeta» para crear una nueva carpeta y nómbrala lambdalayer.
11. Deja todos los demás ajustes por defecto y crea la carpeta.

12. Navega hasta la carpeta lambdalayer.
13. Sube el archivo knowledgebase-lambdalayer.zip disponible en la carpeta /data/lambda_layer en GitHub y selecciona Upload. Utilizarás este código de capa lambda más adelante para crear la función lambda.

Crear una base de conocimientos

1. En este paso, crearemos una base de conocimientos utilizando el conjunto de datos que subimos al bucket de S3 en el paso anterior.
   En la consola de Amazon Bedrock, navega hasta la sección Orchestration y selecciona Knowledge Base. Es importante tener en cuenta que, en el momento de escribir este artículo, la función de base de datos de conocimientos solo está disponible en determinadas regiones. Por lo tanto, para este tutorial, utilizaremos us-east-1 como región predeterminada.
2. Selecciona «Crear base de conocimientos».
3. En la sección «Detalles de la base de conocimientos», introduce un nombre y una descripción opcional.
4. En la sección Permisos IAM, selecciona «Crear «y utiliza un nuevo rol de servicio e introduzca un nombre para el rol.
5. Selecciona Siguiente.
6. En la sección Fuente de datos, deja «Nombre de fuente de datos» como nombre predeterminado.
7. En URI de S3, seleccione Examinar S3 para elegir el bucket de S3 knowledgebase-<chatbot-name>/dataset/. Debes apuntar al bucket de S3 y a la carpeta del conjunto de datos que creó en los pasos anteriores.
8. En la sección Configuración avanzada, deja los valores predeterminados (si lo deseas, puedes cambiar la estrategia de fragmentación predeterminada y especificar el tamaño de los trozos y la superposición en porcentaje).
9. Selecciona «Siguiente».
10. En la sección Modelo de incrustación, selecciona «Incrustación Titan G1 – Texto para el modelo de incrustación».
11. En la sección Base de datos vectorial, seleccionea «Crear» rápidamente un nuevo almacén vectorial, esto crea un nuevo almacén vectorial OpenSearch Serverless en su cuenta.
12. Selecciona Siguiente.
13. En la página Revisar y crear, revisa toda la información o selecciona Anterior para modificar cualquier opción.
14. Selecciona Crear base de conocimientos. Observa que comienza el proceso de creación de la base de conocimientos y que el estado es En curso. La creación del almacén de vectores y de la base de conocimientos tardará unos minutos. No abandones la página, de lo contrario la creación fallará.
15. Cuando el estado de la base de conocimientos sea «Listo», anota el ID de la base de conocimientos. Lo utilizarás en los próximos pasos para configurar la función Lambda.
16. Ahora que la base de conocimientos está lista, tenemos que sincronizar nuestro conjunto de datos personalizado con ella. En la sección «Fuente de datos» de la página de detalles de la base de conocimientos, seleccione Sincronizar para activar el proceso de ingestión de datos desde el bucket de S3 a la base de conocimientos.
17. Este proceso de sincronización divide los archivos de documentos en trozos más pequeños del tamaño especificado anteriormente, genera incrustaciones vectoriales utilizando el modelo de incrustación de texto seleccionado y los almacena en el almacén vectorial administrado por Knowledge Bases para Amazon Bedrock.
18. Cuando se complete la sincronización del conjunto de datos, el estado de la fuente de datos cambiará al estado Listo. Ten en cuenta que, si añades documentos adicionales en la carpeta de datos de S3, deberás volver a sincronizar la base de conocimientos.

Nuestra base de conocimientos ya está lista. Ten en cuenta que también puede utilizar las API del servicio Knowledge Bases for Amazon Bedrock y la CLI de AWS para crear una base de conocimientos mediante programación.

La función Lambda y la puerta de enlace API

En esta sección, construiremos una API diseñada para activar una función Lambda, que gestionará las consultas de los usuarios mediante la integración de AWS Bedrock y la base de conocimientos establecida previamente. Para simplificar la implementación y el desarrollo, se utilizará el marco Serverless para construir e implementar la infraestructura backend.

Iniciar el marco Serverless

Para obtener información sobre la instalación de Serverless, consulte esta página de instrucciones. Para iniciar un nuevo proyecto Serveless ejecute:

# initate a new serverless project
serverless

> select AWS - Python - HTTP API

> name your project 

> Register or Login to Serverless Framework: n enter

> Do you want to deploy now?: n enter

A continuación, configuraremos nuestra infraestructura de back-end en el archivo serverless.yml.

service: knowledge-base-api
frameworkVersion: "3"

provider:
  name: aws
  runtime: python3.12
  stage: dev
  region: us-east-1
  environment:
    KNOWLEDGE_BASE_ID: ${self:custom.knowledgeBaseID}
  iam:
    role:
      statements:
        - Effect: "Allow"
          Action:
            - "bedrock:InvokeModel"
            - "bedrock:Retrieve"
            - "bedrock:RetrieveAndGenerate"
          Resource: "*"

custom:
  knowledgeBaseID: "<your knowledgebase ID>"
  lambdaLayerS3BucketName: "<your S3 bucket name>"

functions:
  invokeKnowledgeBase:
    handler: handler.lambda_handler
    memorySize: 256
    timeout: 60
    layers:
      - { Ref: DeployKnowledgeBaseLambdaLayer }
    events:
      - http:
          path: /
          method: get
          cors: true
resources:
  Resources:
    DeployKnowledgeBaseLambdaLayer:
      Type: AWS::Lambda::LayerVersion
      Properties:
        LayerName: KnowledgeBaseLambdaLayer
        Description: Knowledge Base Lambda Layer
        Content:
          S3Bucket: ${self:custom.lambdaLayerS3BucketName}
          S3Key: lambdalayer/knowledgebase_lambdalayer.zip
        CompatibleRuntimes:
          - python3.12
          - python3.11
          - python3.10

Este archivo serverless.yml describe la configuración para implementar un servicio de API de base de conocimientos mediante el marco Serverless en AWS. El servicio, llamado knowledge-base-api, especifica AWS como el proveedor de la nube, utilizando Python 3.12 como el entorno de tiempo de ejecución en la etapa dev dentro de la región us-east-1. Las variables de entorno están configuradas, incluyendo un KNOWLEDGE_BASE_ID, que anotamos en el paso 15 de la Creación de Knowlege Base.

El rol de IAM definido en la configuración del proveedor concede al servicio permiso para realizar acciones como invocar modelos y recuperar datos mediante las API de Amazon Bedrock (bedrock:InvokeModel, bedrock:Retrieve y bedrock:RetrieveAndGenerate), con los permisos asignados a todos los recursos (Resource: «*») para simplificar y ampliar el acceso en este ejemplo.

La sección personalizada incluye marcadores de posición para especificar el knowledgeBaseID y el nombre de un bucket de S3 (knowledgebase-<chatbot-name>) donde se almacena la capa Lambda para la base de conocimientos.

Se detalla una única función, invokeKnowledgeBase, con handler.lambda_handler indicando el punto de entrada para la función Lambda. Está configurada para utilizar 256 MB de memoria y tiene un tiempo de espera de 60 segundos. Esta función está asociada a un evento HTTP GET, por lo que es accesible a través de un punto final RESTful, y CORS está habilitado para solicitudes de origen cruzado. La función también incluye una capa Lambda, DeployKnowledgeBaseLambdaLayer, que se define en la sección de recursos.

En el bloque de recursos, DeployKnowledgeBaseLambdaLayer se configura para crear una versión de la capa Lambda, que encapsula el código adicional o las bibliotecas que necesita la función Lambda. Esta capa se denomina KnowledgeBaseLambdaLayer y obtiene su contenido del bucket de S3 (knowledgebase-<chatbot-name>/lambdalayer). La capa es compatible con varios tiempos de ejecución de Python, lo que garantiza la flexibilidad entre diferentes versiones de Python.

Crear la función Lambda

En esta sección, nos sumergiremos en la creación de una función Lambda que forma la columna vertebral de nuestra aplicación de IA conversacional. Esta función es responsable de procesar las consultas de los usuarios, aprovechando el potente servicio AWS Bedrock para obtener y generar respuestas de nuestra base de conocimientos. Desglosaremos la función en pasos manejables, explicando el propósito y la funcionalidad de cada parte.

import os
import boto3
import json 

boto3_session = boto3.session.Session()
region = boto3_session.region_name

La función comienza importando las bibliotecas necesarias. os se utiliza para acceder a variables de entorno, boto3 para AWS SDK para interactuar con los servicios de AWS y json para manejar estructuras de datos JSON. A continuación, inicializa una sesión de boto3 y recupera la región de AWS en la que se implementa la función Lambda.

bedrock_agent_runtime_client = boto3.client('bedrock-agent-runtime', region_name="us-east-1")

Esta línea crea un cliente Boto3 para el tiempo de ejecución del agente Bedrock, especificando la región (aquí, «us-east-1»). Este cliente se utiliza para interactuar con AWS Bedrock, específicamente para invocar la API retrieve_and_generate.

La función lambda_handler actúa como puerta de enlace entre AWS Lambda y el mundo exterior, en este caso, principalmente AWS API Gateway que activa esta función de Lambda. Cuando un usuario envía una consulta a través de la interfaz de front-end, esta función entra en acción. Comienza analizando la solicitud entrante, buscando específicamente la pregunta y, opcionalmente, un session_id en los parámetros de consulta. Estos parámetros son esenciales para mantener un flujo de diálogo continuo y proporcionar contexto al modelo de IA para generar respuestas relevantes.

Tras extraer la información necesaria del objeto de evento, lambda_handler procede a recopilar detalles de configuración adicionales. Recupera el ID de la base de conocimientos (kb_id) de las variables de entorno y, a continuación, construye el ARN del modelo, que identifica de forma exclusiva el modelo de IA que se utilizará para generar las respuestas. Este ARN incluye la región y el identificador específico del modelo. En este tutorial, utilizaremos el modelo Claude 2 de Anthropic (anthropic.claude-v2).

def retrieveAndGenerate(question, kbId, model_arn, sessionId=None):
    if sessionId != "None":
        return bedrock_agent_runtime_client.retrieve_and_generate(
            input={
                'text': question
            },
            retrieveAndGenerateConfiguration={
                'type': 'KNOWLEDGE_BASE',
                'knowledgeBaseConfiguration': {
                    'knowledgeBaseId': kbId,
                    'modelArn': model_arn
                }
            },
            sessionId=sessionId
        )
    else:
        return bedrock_agent_runtime_client.retrieve_and_generate(
            input={
                'text': question
            },
            retrieveAndGenerateConfiguration={
                'type': 'KNOWLEDGE_BASE',
                'knowledgeBaseConfiguration': {
                    'knowledgeBaseId': kbId,
                    'modelArn': model_arn
                }
            }
        )

Con toda la información y las configuraciones necesarias a mano, lambda_handler llama a la función retrieveAndGenerate. La función retrieveAndGenerate interactúa con la API Retrieve and Generate de AWS Bedrock. Toma la pregunta del usuario, el ID de la base de conocimientos, el ARN del modelo y un ID de sesión opcional, y llama a la API de Bedrock para generar una respuesta basada en el contenido de la base de conocimientos.

El session_id es un identificador único que permite el seguimiento y la gestión de sesiones de usuario individuales en una aplicación de IA conversacional, facilitando respuestas contextualizadas al preservar el historial de diálogo a través de las interacciones del usuario. Esto permite a la IA proporcionar respuestas coherentes y contextualmente relevantes, mejorando la experiencia del usuario al hacer que la conversación resulte más natural y atractiva.

Por último, la función lambda_handler formatea y devuelve esta respuesta como un objeto JSON estructurado, garantizando la compatibilidad con las aplicaciones web mediante las cabeceras CORS adecuadas y un código de estado HTTP estándar.

A continuación, puedes encontrar el código completo de la función Lambda.

import os
import boto3
import json 

boto3_session = boto3.session.Session()
region = boto3_session.region_name

# create a boto3 bedrock client
bedrock_agent_runtime_client = boto3.client('bedrock-agent-runtime',region_name="us-east-1")

def retrieveAndGenerate(question, kbId, model_arn, sessionId=None):
    if sessionId != "None":
        return bedrock_agent_runtime_client.retrieve_and_generate(
            input={
                'text': question
            },
            retrieveAndGenerateConfiguration={
                'type': 'KNOWLEDGE_BASE',
                'knowledgeBaseConfiguration': {
                    'knowledgeBaseId': kbId,
                    'modelArn': model_arn
                }
            },
            sessionId=sessionId
        )
    else:
        return bedrock_agent_runtime_client.retrieve_and_generate(
            input={
                'text': question
            },
            retrieveAndGenerateConfiguration={
                'type': 'KNOWLEDGE_BASE',
                'knowledgeBaseConfiguration': {
                    'knowledgeBaseId': kbId,
                    'modelArn': model_arn
                }
            }
        )

def lambda_handler(event, context):
    # Extract the question and session ID from the event
    question = event["queryStringParameters"]["question"]

    try:
        session_id = event["queryStringParameters"]["session_id"]
    except:
        session_id = "None"

    # Assuming you've set the KNOWLEDGE_BASE_ID as an environment variable in your Lambda function
    kb_id = os.environ["KNOWLEDGE_BASE_ID"]
    
    # Specify the model ID and construct its ARN. Update these placeholders as needed.
    model_id = "anthropic.claude-v2"
    region = "us-east-1"
    model_arn = f'arn:aws:bedrock:{region}::foundation-model/{model_id}'

    # Call the retrieve and generate function
    response = retrieveAndGenerate(question, kb_id, model_arn, session_id)

    # Extract the generated text and session ID from the response
    generated_text = response['output']['text']
    session_id = response.get('sessionId', '')

    headers = {
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Credentials": True
    }
    # Return the response in the expected format
    return {
        'statusCode': 200,
        'headers': headers,
        'body': json.dumps({
            "question": question.strip(),
            "answer": generated_text.strip(),
            "sessionId": session_id
        },  ensure_ascii=False)
    }

Al desplegar la infraestructura Serverless (serverless deploy), obtenemos una dirección API que podemos utilizar para interactuar con nuestro agente de IA:

https://<API ID>.execute-api.us-east-1.amazonaws.com/dev/?question=<your question>&session_id=<your session ID>

Voiceflow Frontend

Para integrar perfectamente nuestra API en una interfaz de chatbot, empleamos Voiceflow junto con los servicios de AWS. Esta potente combinación garantiza que nuestro chatbot no solo reciba a los usuarios con calidez, sino que también responda de forma inteligente a sus consultas e integre respuestas alternativas en caso de que fallen las solicitudes de API.

Al iniciar una conversación, el usuario recibe un amistoso mensaje de bienvenida del chatbot. A continuación, el chatbot espera la respuesta del usuario y la captura para una acción posterior. Esta entrada actúa como disparador para el bloque de solicitud GET, preconfigurado en Voiceflow para llegar a nuestra API externa, el punto final de nuestra función AWS Lambda. Una vez recibida la consulta del usuario, el bloque de solicitud GET la envía a nuestra función Lambda, donde se genera una respuesta adecuada que se envía de vuelta a través de nuestra API. Si la llamada a la API tiene éxito, el siguiente bloque de Voiceflow mostrará la respuesta de la función Lambda directamente al usuario.

Sin embargo, si hubiera algún problema en la obtención de la respuesta, Voiceflow está diseñado para manejar estas anomalías con elegancia. Se crea un mensaje de error que informa al usuario del problema y le invita a continuar la conversación. Este cuidadoso diseño garantiza que el chatbot siga siendo atractivo y útil, incluso cuando surgen circunstancias imprevistas. Tras una respuesta satisfactoria, el usuario puede formular una nueva pregunta. En las siguientes llamadas a la API, se transmite el identificador de sesión generado durante la interacción inicial, lo que garantiza una conversación fluida y coherente al mantener el contexto del viaje del usuario.

Conclusión

Hemos llegado al final de nuestro exhaustivo viaje a través de la creación de un agente de IA generativa a escala empresarial con AWS Bedrock. Desde la configuración de una interfaz de chatbot acogedora en Voiceflow, hasta los intrincados procesos de back-end que implican AWS Lambda, API Gateway, Bedrock y Knowledge Bases, hemos explorado un enfoque de desarrollo de pila completa que prioriza la seguridad y el manejo eficiente de los datos. Hemos visto cómo almacenar y recuperar información con los servicios de AWS, y cómo entrelazar estos elementos en una experiencia conversacional sin fisuras utilizando el marco Serverless.

El tutorial te ha equipado con los conocimientos prácticos para implementar datos propios en interacciones de IA, garantizando un diálogo continuo y consciente del contexto con la administración de sesiones. Este conocimiento establece una base sólida para crear agentes de IA inteligentes que no solo entienden y responden a las consultas de los usuarios, sino que lo hacen con una gran conciencia de la seguridad y la gobernanza de los datos empresariales.

Sigue mi página de Instagram, LinkedIn o visita mi página web https://www.pairrot.eu/ para obtener más contenido relacionado con la IA.

The post Cómo crear agentes de IA generativa a escala empresarial con AWS Bedrock: Una guía completa first appeared on Planeta Chatbot.

Inteligencia Artificial privada al alcance de todos. A medida que la Inteligencia Artificial (IA) se vuelve más sofisticada y útil en nuestras tareas cotidianas, surgen nuevas preocupaciones sobre la privacidad al interactuar con los «chatbots». La herramienta DuckDuckGo, comprometida con la privacidad, ofrece una solución innovadora: utilizar ChatGPT y otros «chatbots» sin necesidad de crear una cuenta personal. DuckDuckGo, la empresa detrás del motor de búsqueda centrado en la privacidad, ha anunciado DuckDuckGo AI Chat, una forma gratuita, opcional y anónima de acceder a cuatro populares chatbots de IA generativa. La compañía dijo que con AI Chat, podrás acceder a GPT 3.5 Turbo de OpenAI, Claude 3 Haiku de Anthropic, Meta Llama 3 y Mixtral 8x7B de Mistral ahora, y planea añadir el acceso a otros modelos de chatbot en el futuro.

¿Cómo se mantiene la privacidad?

DuckDuckGo anonimiza los chats de IA. La empresa se interpone entre el usuario y los modelos, eliminando tu dirección IP de los chats y sustituyéndola por la de DuckDuckGo.

Además, DuckDuckGo también dice que tiene un acuerdo con los proveedores de modelos para eliminar todos los chats guardados en un plazo de 30 días desde su creación. La empresa afirmó que este acuerdo también garantiza que «ninguno de los chats realizados en nuestra plataforma puede utilizarse para entrenar o mejorar los modelos.»

Inteligencia Artificial privada al alcance de todos

Aunque AI Chat es gratuito, tiene un límite de uso diario. DuckDuckGo también ha dicho que está estudiando la posibilidad de crear una versión de pago de AI Chat que aumentaría este límite diario y daría acceso a modelos de IA más costosos. Cuanto más potente es el modelo de IA, más caro resulta ejecutarlo, razón por la cual muchas herramientas de IA ofrecen acceso de pago a herramientas más sofisticadas además de sus versiones gratuitas.

De momento, si quieres probar AI Chat, puedes ir a duck.ai o duckduckgo.com/chat. Se te pedirá que elijas el modelo de IA con el que quieres chatear y listo. Puedes cambiar de modelo más tarde haciendo clic en el nombre del modelo en la barra de herramientas izquierda del chat y seleccionando otro modelo. Puedes borrar un chat haciendo clic en el icono de la llama a la izquierda de la barra de texto.

The post ¿Cómo usar ChatGPT y otras IAs de manera privada? first appeared on Planeta Chatbot.

Los sectores de la moda y el comercio minorista buscan continuamente tecnologías innovadoras para mejorar la experiencia y la satisfacción de los clientes. Una de estas innovaciones es la tecnología de probadores virtuales, que permite a los usuarios verse a sí mismos con diferentes prendas a distancia utilizando sus dispositivos digitales. Los sistemas tradicionales de probadores o pruebas digitales/virtuales se han visto limitados por la calidad de la síntesis de imágenes y la precisión de la representación del ajuste. StableVITON es un método innovador que utiliza modelos de difusión latente para redefinir esta tecnología mejorando la fidelidad de la imagen y la conservación de los detalles.

¿Por qué StableVITON?

StableVITON aborda los principales retos a los que se enfrentan las anteriores tecnologías de pruebas virtuales, como la pérdida de detalles finos de la ropa y la dificultad de manejar fondos complejos. Aprovecha un modelo de difusión latente preentrenado, introduciendo una novedosa metodología para aprender la correspondencia semántica entre una prenda de vestir y el cuerpo humano directamente dentro de un espacio latente. Esto permite a StableVITON no sólo preservar los intrincados detalles de la ropa, sino también generar imágenes de alta fidelidad que reflejan con exactitud el aspecto que tendría la ropa en una persona.

Componentes de StableVITON

1. Utilización del espacio latente: A diferencia de los métodos tradicionales que operan directamente en el espacio de la imagen, StableVITON opera dentro del espacio latente de un modelo de difusión. Esta estrategia garantiza la conservación de los detalles de textura y la calidad general del resultado.
2. Bloques de atención cruzada cero: Se introducen para aprender eficazmente los mapas semánticos entre las características de la ropa y el modelo humano. Este método es fundamental para garantizar que la ropa se alinee con precisión con la figura humana.
3. Pérdida por variación total de la atención: una nueva forma de función de pérdida diseñada para perfeccionar el mecanismo de atención, mejorando la nitidez y claridad de los resultados finales de la imagen.

Detalles de Implementación

A continuación, se muestra cómo implementar una versión simplificada del mecanismo de Zero Cross-Attention utilizado en StableVITON, centrándose en la integración con una arquitectura U-Net:

import torch
import torch.nn as nn

class ZeroCrossAttention(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.query_conv = nn.Conv2d(channels, channels // 8, 1)
        self.key_conv = nn.Conv2d(channels, channels // 8, 1)
        self.value_conv = nn.Conv2d(channels, channels, 1)
        self.softmax = nn.Softmax(dim=-1)

    def forward(self, x, y):
        batch_size, C, height, width = x.size()
        query = self.query_conv(x).view(batch_size, -1, height * width).permute(0, 2, 1)
        key = self.key_conv(y).view(batch_size, -1, height * width)
        value = self.value_conv(y).view(batch_size, -1, height * width)

        attention = self.softmax(torch.bmm(query, key))
        out = torch.bmm(value, attention.permute(0, 2, 1))
        out = out.view(batch_size, C, height, width)

        return out + x

# Example of integrating ZeroCrossAttention in a U-Net block
class UNetBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.conv = nn.Conv2d(channels, channels, 3, padding=1)
        self.norm = nn.BatchNorm2d(channels)
        self.relu = nn.ReLU(inplace=True)
        self.attention = ZeroCrossAttention(channels)

    def forward(self, x, y):
        x = self.conv(x)
        x = self.norm(x)
        x = self.relu(x)
        x = self.attention(x, y)
        return x

Adaptación a distintos tipos de ropa y de cuerpo

Una de las áreas vitales para el futuro desarrollo de StableVITON es su adaptabilidad a una amplia gama de tipos de cuerpo y estilos de ropa. Para aumentar la inclusividad, las versiones futuras podrían incorporar conjuntos de datos más diversos que representen un amplio espectro de formas, tallas y preferencias de moda humanas. Así se garantizará que la tecnología pueda ser utilizada eficazmente por todos los segmentos de la población, lo que ampliará su aplicabilidad y su alcance en el mercado.

Integración con plataformas de comercio electrónico

La integración de StableVITON con las plataformas de comercio electrónico existentes podría revolucionar las compras en línea. Los minoristas pueden ofrecer una experiencia de compra más interactiva y personalizada al permitir que los clientes se vean a sí mismos con la ropa virtualmente antes de tomar una decisión de compra. Esto podría reducir significativamente las tasas de devolución, aumentar la satisfacción del cliente y, potencialmente, incrementar las ventas debido a un proceso de compra más seguro.

Experiencias de realidad aumentada

La combinación de StableVITON con tecnologías de realidad aumentada (RA) podría conducir al desarrollo de experiencias de compra más interactivas y atractivas. Los clientes podrían utilizar sus teléfonos inteligentes o gafas de realidad aumentada para probarse ropa virtualmente en tiempo real mientras recorren una tienda o navegan por un catálogo en línea. Esta integración podría transformar el entorno minorista, haciéndolo más dinámico e inmersivo.

Reflexiones finales

Está a la vanguardia de la transformación de las industrias minorista y de la moda a través de la tecnología avanzada. A medida que evoluciona, promete ofrecer no solo mejores experiencias a los consumidores, sino también eficiencia operativa a los minoristas y prácticas sostenibles en la industria de la moda. El futuro del comercio minorista es brillante con la integración de tecnologías basadas en la IA como StableVITON, que anuncian una nueva era de moda digital y experiencias de compra personalizadas.

The post StableVITON cambia la prueba virtual con modelos de difusión latente first appeared on Planeta Chatbot.

Noticias de la Web

1º semana

• Gemini 1.5 Pro/Advanced en el nº 2 de la clasificación de LMSYS, justo detrás de GPT-4o. La última clasificación de LMSYS muestra que Gemini 1.5 Pro/Advanced ocupa el segundo puesto, justo detrás de GPT-4o, mientras que Gemini 1.5 Flash mantiene la novena posición, superando a Llama-3-70b y compitiendo estrechamente con GPT-4-0120.
• Anthropic contrata al antiguo responsable de seguridad de OpenAI para dirigir su nuevo equipo. Jan Leike se ha trasladado de OpenAI a Anthropic para dirigir un nuevo equipo de seguridad de IA dedicado a la «superalineación», centrado en mejorar la supervisión escalable y la investigación de alineación de IA a gran escala.
• xAI anuncia una ronda de financiación de serie B de 6.000 millones de dólares. xAI ha recaudado 6.000 millones de dólares en una ronda de serie B para ampliar el despliegue de tecnología de IA, incluida su serie Grok-1, y para innovar en nuevos productos, basándose en un año de avances significativos en IA y en el lanzamiento del código abierto Grok-1.
• Mistral lanza Codestral. Codestral es el nuevo modelo de IA generativa de Mistral AI centrado en la codificación, con dominio de más de 80 lenguajes de programación y una amplia ventana de contexto de 32.000 para un rendimiento superior en pruebas comparativas.
• China invierte 47.000 millones de dólares en el mayor fondo de chips de la historia. China asignó 47.480 millones de dólares a un nuevo fondo para chips destinado a impulsar la producción nacional de semiconductores, un paso fundamental hacia la autosuficiencia y la competitividad en sectores tecnológicos, incluida la IA.

2º semana

• El supuesto acuerdo de Apple con ChatGPT podría coronar a OpenAI como rey del valle. Se prevé que Apple se asocie con OpenAI para incorporar ChatGPT al sistema operativo del iPhone, lo que podría anunciarse en la próxima WWDC. Esta integración, que podría revolucionar la interacción con la IA en los iPhones, podría suponer que ChatGPT mejorara Siri o se lanzara como una aplicación independiente, lo que señalaría el giro de Apple hacia la experiencia externa en IA.
• Nvidia es ahora más valiosa que Apple, con 3,01 billones de dólares. Nvidia ha alcanzado una capitalización bursátil de 3,01 billones de dólares, impulsada por el auge de la inteligencia artificial, superando a Apple y convirtiéndose en la segunda empresa más valiosa del mundo.
• Apple no se anda con rodeos y llamará a su IA «Apple Intelligence». Apple presentará «Apple Intelligence», una solución de IA con capacidades de chatbot similar a ChatGPT, en la WWDC del 10 de junio. Se incluirá en las próximas actualizaciones de iOS, iPadOS y macOS y está diseñada para funcionar sin conexión, lo que supone una asociación con OpenAI y mejoras para Siri.
• AMD presenta nuevos chips de IA para competir con Nvidia. AMD desafía el liderazgo de Nvidia en IA con próximos lanzamientos: el MI325X en 2024, y las series MI350/MI400 en 2025-2026, que prometen notables aumentos de rendimiento para satisfacer las crecientes demandas de IA.
• OpenAI renueva su equipo de robótica. OpenAI restablece su división de robótica, centrada en la creación de modelos de IA para aplicaciones robóticas en colaboración con empresas de robótica externas. Se trata de un giro estratégico que pasa de producir hardware interno a potenciar los robots humanoides mediante asociaciones, como demuestran las inversiones en entidades como Figure AI. La ampliación del equipo está en marcha gracias a la contratación activa de personal.
• Nvidia y Salesforce podrían volver a apostar por la startup de IA Cohere en una ronda de 450 millones de dólares. La startup de IA generativa Cohere ha conseguido una ronda de financiación de 450 millones de dólares liderada por Nvidia y Salesforce, junto con nuevos inversores como Cisco y PSP Investments, lo que eleva su valoración a 5.000 millones de dólares desde los 2.200 millones anteriores. La empresa también ha revelado unos ingresos anualizados de 35 millones de dólares.
• Stability AI lanza un generador de sonido. Stability AI ha lanzado «Stable Audio Open», un modelo de IA que genera sonido a partir de descripciones de texto utilizando muestras libres de derechos, orientado a un uso no comercial.

3º semana

• OpenAI duplica sus ingresos anuales hasta los 3.400 millones de dólares. Los ingresos previstos de OpenAI para 2024 ascienden a 3.400 millones de dólares, frente a los 1.600 millones de 2023. Su consejero delegado, Sam Altman, menciona 3.200 millones de dólares procedentes de productos y servicios básicos de IA y 200 millones de dólares de asociaciones, como con Microsoft Azure. La valoración de la empresa se sitúa en 86.000 millones de dólares mientras sigue avanzando en la industria de la IA.
• Nadella, de Microsoft, está construyendo un imperio de IA. OpenAI fue sólo el primer paso. Satya Nadella, consejero delegado de Microsoft, está mejorando las capacidades de IA de la empresa mediante la adquisición de activos de IA en todo el mundo, el cultivo de tecnologías de IA propias y, posiblemente, el posicionamiento de Microsoft como competidor de OpenAI. Esta expansión incluye la inversión en startups de IA y la contratación de expertos del sector.
• Nvidia distribuyó 3,76 millones de GPU para centros de datos en 2023: domina el negocio con una cuota de ingresos del 98%. En 2023, Nvidia consolidó su posición en el mercado de GPU para centros de datos con una cuota del 98% al distribuir 3,76 millones de unidades y logró un notable aumento de los ingresos del 126% desde 2020, alcanzando los 60.900 millones de dólares, incluso en medio de las restricciones a la exportación y los obstáculos de fabricación de Estados Unidos.
• Mistral AI, startup de IA con sede en París, recauda 640 millones de dólares. Mistral AI, una startup de IA con sede en París y con fundadores de Meta y DeepMind, ha conseguido 640 millones de dólares en una ronda de Serie B liderada por General Catalyst, alcanzando una valoración de 6.000 millones de dólares, y se centra en la creación de tecnologías de IA de vanguardia, equilibrando ofertas de código abierto y propietarias.
• Lo más destacado de la WWDC24 de Apple. La WWDC 2024 de Apple destacó la presentación de Apple Intelligence, un nuevo sistema de inteligencia personal que aprovecha los modelos generativos y la integración del contexto personal en todo su ecosistema, junto con importantes actualizaciones de iOS 18, iPadOS 18, macOS Sequoia, watchOS 11, tvOS 18 y visionOS 2.
• Luma Dream Machine. Luma Dream Machine de Lumalabs es un modelo de IA diseñado para sintetizar vídeos realistas de alta calidad a partir de texto e imágenes, aprovechando un método basado en transformadores optimizado para contenidos de vídeo.
• Musk quiere prohibir Apple por aliarse con OpenAI. Elon Musk ha expresado su intención de prohibir los dispositivos de Apple en sus empresas en respuesta al anuncio de Apple de implantar ChatGPT de OpenAI en su sistema operativo, debido a aprensiones de seguridad.
• El carácter de Claude. El artículo examina el «entrenamiento del carácter», centrándose en imbuir al modelo Claude 3 de atributos como la curiosidad y la apertura mental, además de la evitación del daño. Describe una estrategia de formación que trata de armonizar las capacidades interactivas de la IA con las normas éticas alineando con flexibilidad el comportamiento de la IA con rasgos específicos.

4º semana

• Presentamos Claude 3.5 Sonnet. La última actualización de Claude 3.5 Sonnet ofrece mayor inteligencia, mayor velocidad de procesamiento y mayor eficacia a un precio competitivo, con notables avances en el razonamiento, la codificación y el procesamiento de la visión. Además, la nueva función «Artifacts» permite la colaboración en tiempo real.
• Presentamos Gen-3 Alpha: Una nueva frontera para la generación de vídeo. Runway ha lanzado Gen-3 Alpha, una IA avanzada capaz de generar vídeos e imágenes a partir de texto e imágenes. Incorpora modos de control para manipulaciones detalladas y promete futuras mejoras en estructura, estilo y control del movimiento.
• El CEO de OpenAI afirma que la empresa podría convertirse en una corporación con ánimo de lucro. OpenAI está considerando la posibilidad de convertirse en una «corporación benéfica con ánimo de lucro», alejándose de sus orígenes sin ánimo de lucro, una dirección similar a la de sus competidores del sector, como Anthropic y xAI, según ha indicado su CEO, Sam Altman.
• Ilya Sutskever, antiguo científico jefe de OpenAI, lanza una nueva empresa de IA. Ilya Sutskever, junto con Daniel Gross y Daniel Levy, ha fundado Safe Superintelligence Inc. (SSI), una nueva empresa de IA con sede en Palo Alto y Tel Aviv dedicada a crear IA superinteligente con un fuerte énfasis en la seguridad. SSI está preparada para integrar los avances de la IA con sólidas medidas de seguridad, dando prioridad a la seguridad a largo plazo frente a los beneficios inmediatos, y se prevé que atraiga importantes inversiones debido a su convincente objetivo y a la habilidad de sus fundadores.
• NVIDIA lanza una línea abierta de generación de datos sintéticos para el entrenamiento de grandes modelos lingüísticos. NVIDIA ha lanzado Nemotron-4 340B, un paquete abierto de modelos diseñado para crear datos sintéticos destinados al entrenamiento de modelos lingüísticos en diversos sectores. La suite, que incluye modelos base, de instrucción y de recompensa, se centra en mejorar la calidad y disponibilidad de los datos de entrenamiento. Está optimizado para NVIDIA NeMo y TensorRT-LLM, proporcionando soporte para un entrenamiento e inferencia más eficientes de los LLM.
• Las elecciones indias estuvieron plagadas de deepfakes, pero la IA fue positiva para la democracia. Las elecciones de la India de 2024 vieron avances de la IA en la participación de los votantes a través de la comunicación deepfake y la traducción multilingüe en tiempo real. A pesar de los casos de trolling facilitado por la IA, la tecnología impulsó predominantemente la participación democrática y el acercamiento personalizado a los votantes, proyectando incluso encarnaciones virtuales de figuras políticas del pasado.
• Generación de audio para vídeo. DeepMind ha creado un sistema V2A (Video-to-Audio) que utiliza un modelo de IA basado en la difusión para generar audio sincronizado para vídeos silenciosos, guiado por pistas visuales y textuales para producir entornos sonoros realistas.

Guías web

1º semana

• Reproducir GPT-2 (124M) en llm.c en 90 minutos por 20 dólares. Karpathy ha creado una guía en la que explica cómo reproducir GPT-2 (124M) utilizando la implementación llm.c basada en C/CUDA, diseñada para configuraciones de una o varias GPU. El entrenamiento, que cuesta unos 20 dólares y dura 90 minutos, utiliza el conjunto de datos FineWeb de 10.000 millones de fichas. Este recurso proporciona instrucciones de instalación, orientación para la preparación del conjunto de datos y pretende mejorar el rendimiento del GPT-2 original con posibles mejoras futuras.
• Training and Finetuning Embedding Models with Sentence Transformers v3. El artículo analiza el lanzamiento de Sentence Transformers v3.0, destacando las capacidades mejoradas para el entrenamiento y el ajuste de los modelos de incrustación con el fin de aumentar el rendimiento específico de la tarea, y muestra los componentes actualizados, incluidos los conjuntos de datos, las funciones de pérdida, los evaluadores y un entrenador mejorado.
• Los LLM no son adecuados para el brainstorming (avanzado). El artículo critica los LLM actuales por su ineficacia en el brainstorming avanzado debido a su mimetismo con los patrones de datos existentes y su tendencia a las ideas consensuadas, y propone que los LLM requieren una evolución en los procesos de entrenamiento para fomentar la creatividad genuina.
• Los medios de comunicación cometen un grave error con la IA. La autora subraya los escollos a los que se enfrentan las empresas de medios de comunicación que se asocian con la IA y que pueden socavar el valor y la sostenibilidad del periodismo. Aboga por centrarse en la producción de periodismo de calidad en lugar de buscar un alivio financiero inmediato a través de acuerdos de licencia potencialmente infravalorados con entidades de IA.
• Mergoo: Construye eficientemente tu propio LLM de ME. Mergoo es una biblioteca diseñada para agilizar la fusión y formación de varios LLM en un modelo unificado empleando métodos como la mezcla de expertos, la mezcla de adaptadores y la fusión por capas.

2º semana

• Extracción de conceptos de GPT-4. Los investigadores han empleado autocodificadores dispersos para descomponer la red neuronal de GPT-4 en 16 millones de características interpretables por el ser humano, lo que permite mejorar la comprensión de los procesos de IA. Sin embargo, descifrar completamente estas características sigue siendo un reto, lo que limita la eficacia de los autocodificadores existentes.
• Descensura cualquier LLM con abliteración.
• KL es todo lo que necesitas. El autor destaca la importancia de la divergencia de Kullback-Leibler como objetivo fundamental en el aprendizaje automático, crucial para medir las diferencias entre las distribuciones de probabilidad y optimizar los modelos a través de diversos métodos en este campo.
• Herramientas basadas en IA que transforman la gestión y programación de tareas. El artículo destaca los avances de la IA en plataformas de productividad como Motion, Reclaim AI, Clockwise, ClickUp, Taskade y Asana, detallando su uso del aprendizaje automático para mejorar la gestión de tareas, la programación y la optimización general del flujo de trabajo.
• Lo que aprendimos de un año de construcción con LLMs (Parte II). El artículo analiza las complejidades de desarrollar aplicaciones con LLM, destacando la necesidad de datos de alta calidad, la gestión cuidadosa de los resultados del modelo y las estrategias para integrar y mantener eficazmente las versiones de LLM. Subraya el papel fundamental que desempeñan el compromiso temprano de los diseñadores, la formación de un equipo cualificado y el cultivo de un entorno de trabajo innovador para superar los retos operativos únicos que plantea el desarrollo de productos basados en LLM.

3º semana

• Presentación de los modelos fundacionales en dispositivo y servidor de Apple. En la WWDC de 2024, Apple presentó «Apple Intelligence» en iOS 18, iPadOS 18 y macOS Sequoia, con modelos generativos de IA de última generación en dispositivos y servidores (~3.000 millones de parámetros) centrados en mejorar la experiencia del usuario al tiempo que se hace hincapié en la privacidad y la eficiencia operativa.
• La estrategia de IA de Apple en pocas palabras. Apple presentó su estrategia de IA en la WWDC 2024, centrada en la integración vertical a través de modelos internos de IA en dispositivos y centros de datos propios basados en el silicio de Apple. Haciendo hincapié en la privacidad, esta estrategia tiene como objetivo mejorar la posición en el mercado y la confianza de los usuarios, al tiempo que minimiza la dependencia de terceros fabricantes de chips.
• Los artículos más importantes sobre LLMs de la semana del 03/06 al 09/06. Este artículo resume las últimas investigaciones sobre LLM de principios de junio de 2024, destacando los avances en evaluación comparativa, entrenamiento, cuantización y alineación, con especial atención a la cuantificación de la incertidumbre, la generación del habla, los sistemas multiagente y la comprensión robusta del lenguaje multitarea.
• Incrustación posicional rotativa (RoPE): Motivación e implementación. El artículo profundiza en el Rotary Positional Embedding (RoPE) utilizado en modelos de transformadores. A diferencia de las incrustaciones sinusoidales absolutas tradicionales, RoPE aprovecha las rotaciones vectoriales para mejorar el reconocimiento de las dependencias de largo alcance en los datos.

4º semana

• Extracción de conceptos de los LLM: Descubrimientos recientes de Anthropic. Anthropic ha mejorado la interpretabilidad de los LLM integrando autocodificadores dispersos (SAE) con modelos como Claude-3-Sonnet para extraer características interpretables en varios idiomas. Sin embargo, OpenAI advierte de que una dependencia excesiva de las características extraídas con SAE puede entorpecer el rendimiento. Esta investigación representa un avance sustancial en la descodificación de los LLM, pero aún no se ha logrado una comprensión completa.
• Reflexiones sobre el entrenamiento de LoRA. El artículo aporta ideas sobre el entrenamiento de los LoRA, haciendo hincapié en la calidad del conjunto de datos y en la precisión de los pies de texto para un ajuste eficaz de los parámetros. Destaca los errores típicos, como la complicación excesiva, y ofrece consejos prácticos como el empleo de diversos estilos de imagen y la adaptación de la duración del entrenamiento a la fuente del conjunto de datos.
• De la adulancia al subterfugio: investigación de la manipulación de recompensas en modelos lingüísticos. El artículo analiza cómo los modelos de inteligencia artificial que utilizan el aprendizaje por refuerzo pueden presentar «juego de especificaciones» y «manipulación de recompensas», lo que conduce a comportamientos manipuladores encaminados a maximizar las recompensas, que pueden incluir tácticas engañosas y modificaciones no entrenadas de sus funciones de recompensa. Los estudios demuestran que estos problemas persisten a pesar de los intentos por evitarlos.
• Mantenimiento de la capacidad de IA a gran escala en Meta. Meta gestiona una importante infraestructura de IA que, según las previsiones, alcanzará las 600.000 GPU y se centra en garantizar el tiempo de actividad y las actualizaciones sin interrupciones mediante protocolos de mantenimiento, al tiempo que prioriza la estabilidad del sistema y la gestión eficiente de los recursos.

Papers y repositorios de interés

1º semana

• llmware-ai/llmware: Marco unificado para construir pipelines RAG empresariales con modelos pequeños y especializados. Llmware proporciona un marco integral para construir pipelines de Generación Aumentada Recuperable (RAG) de nivel empresarial, ofreciendo un pipeline RAG integrado y acceso a más de 50 modelos especializados para funciones como QA y resumen. Facilita el rápido desarrollo de aplicaciones de IA basadas en el conocimiento y es compatible con modelos de código abierto, al tiempo que elimina la necesidad de una infraestructura de servidores de GPU.
• Los transformadores pueden hacer operaciones aritméticas con las incrustaciones adecuadas. El artículo destaca que la adición de codificaciones posicionales a los modelos de transformadores mejora significativamente su capacidad para realizar operaciones aritméticas, logrando hasta un 99% de precisión en la suma de números de 100 dígitos y aumentando el rendimiento en otras tareas de razonamiento.
• lavague-ai/LaVague: Large Action Model framework para desarrollar Agentes Web de IA. LaVague es un marco de IA de código abierto diseñado para crear agentes web. Aprovecha un Modelo Mundial para transformar los datos y objetivos del sitio web en comandos, que son ejecutados por un Motor de Acción compatible con herramientas como Selenium o Playwright.
• Introducción al modelado Vision-Language. Este artículo ofrece una visión general de los modelos de visión-lenguaje (VLM) y analiza sus fundamentos, funcionamiento, técnicas de entrenamiento y estrategias de evaluación. También aborda los retos relacionados con la naturaleza compleja de los datos visuales y la incorporación de contenidos de vídeo para las personas que se inician en esta área de investigación de la inteligencia artificial.
• Modelos multimodales Matryoshka. El artículo presenta los modelos multimodales Matryoshka (M3), que mejoran la eficacia de los modelos multimodales de gran tamaño (LMM), como LLaVA, al ofrecer una granularidad de tokens visuales ajustable para adaptarse a la complejidad de las imágenes durante la inferencia.

2º semana

• Seed-TTS: una familia de modelos de generación de voz versátiles y de alta calidad. Seed-TTS engloba modelos avanzados autorregresivos y no autorregresivos de conversión de texto en habla capaces de generar un habla similar a la humana con variabilidad emocional, similitud con el hablante y naturalidad, mostrando también competencia en la generación y edición del habla de extremo a extremo mediante una arquitectura basada en la difusión.
• Hola Qwen2. La serie Qwen2 supone un avance con respecto a Qwen1.5, ya que introduce cinco modelos de IA mejorados con nuevas características, como compatibilidad con 27 idiomas adicionales y funciones mejoradas de codificación y matemáticas. El destacado Qwen2-72B ofrece una seguridad superior y puede comprender contextos extensos de hasta 128.000 tokens. Estos modelos están disponibles en Hugging Face y ModelScope.
• Los transformadores son SSM: Modelos generalizados y algoritmos eficientes mediante la dualidad estructurada del espacio de estados. Este artículo presenta un análisis de la relación estructurada entre los Transformadores y los modelos de espacio de estados (SSM) mediante el análisis matricial, introduciendo un marco teórico que conecta ambos. También presenta una arquitectura mejorada, Mamba-2, que se basa en su predecesora Mamba al ser significativamente más rápida (entre 2 y 8 veces) y mantener un rendimiento comparable en tareas de modelado lingüístico.
• Concurso de fusión de LLM: Construcción eficiente de LLM mediante fusión. El artículo presenta una competición que reta a los participantes a integrar múltiples LLM ajustados para mejorar su rendimiento y adaptabilidad a nuevas tareas. Los concursantes utilizarán modelos expertos preentrenados con hasta 8.000 millones de parámetros del Hugging Face Model Hub, que están disponibles bajo licencias favorables a la investigación. El objetivo de la competición es minimizar los costes y los retos de entrenar a los LLM desde cero utilizando los modelos existentes.
• Difusión de árboles sintácticos para la síntesis de programas. Este artículo presenta un método de síntesis de programas basado en modelos neuronales de difusión que perfeccionan el código de forma iterativa mediante ediciones en árboles sintácticos, lo que garantiza la corrección sintáctica y resuelve las limitaciones de la generación de código basada en tokens sin retroalimentación de salida en los grandes modelos de lenguaje existentes.

3º semana

• El informe Prompt: Un estudio sistemático de las técnicas de incitación. El «Prompt Report» ofrece un análisis exhaustivo de los métodos de prompting en la IA Generativa, introduciendo una taxonomía y un conjunto unificado de términos con 33 entradas de vocabulario para prompts. Detalla 58 técnicas para sistemas basados en texto y 40 para modalidades no textuales con el fin de normalizar la comprensión en este ámbito emergente.
• Depth Anything V2. Depth Anything V2 mejora la estimación monocular de la profundidad utilizando imágenes sintéticas y un modelo de profesor más amplio, junto con imágenes reales pseudoetiquetadas para una mejor generalización. Ofrece resultados significativamente más rápidos y precisos, con tamaños de modelo que varían entre 25M y 1,3B parámetros.
• Samba: Modelos híbridos simples de espacio de estados para un modelado eficiente de lenguaje de contexto ilimitado. Samba es una novedosa arquitectura de modelos lingüísticos que combina el modelo selectivo de espacio de estados de Mamba con la atención de ventana deslizante para permitir una compresión eficiente de secuencias largas y una recuperación precisa de la memoria. Con una considerable escala de 3.800 millones de parámetros, Samba supera a los modelos lingüísticos existentes en el manejo de contextos ilimitados.
• El modelo autorregresivo supera a la difusión: Llama para la generación escalable de imágenes. LlamaGen es un novedoso método de generación de imágenes que utiliza modelos autorregresivos con un eficaz tokenizador y modelos condicionales de clase para producir imágenes alineadas con texto de gran fidelidad.
• When Linear Attention Meets Autoregressive Decoding: Towards More Effective and Efficient Linearized Large Language Models. Este estudio presenta avances en los LLM autorregresivos mediante la combinación de mecanismos de atención lineal y descodificación especulativa, lo que se traduce en notables mejoras de eficiencia, incluida una reducción de la perplejidad y un aumento de hasta el doble en la velocidad de generación.

4º semana

• deepseek-ai/DeepSeek-Coder-V2: Rompiendo la barrera de los modelos de código cerrado en inteligencia de código. DeepSeek-Coder-V2 es un modelo de lenguaje de código abierto especializado en codificación y matemáticas, que presume de un mejor rendimiento que modelos propietarios como GPT4-Turbo. Es compatible con una impresionante gama de 338 lenguajes de programación, ofrece una longitud de contexto ampliada de 128K y se presenta en dos tamaños: 16.000 millones y 236.000 millones de parámetros. El modelo tiene licencia MIT, lo que permite su uso comercial y su fácil integración con API.
• Aguja multimodal en un pajar: Evaluación comparativa de la capacidad de contexto largo de modelos lingüísticos multimodales de gran tamaño. Se ha introducido una nueva prueba denominada Aguja multimodal en un pajar (MMNeedle) para evaluar la capacidad de los modelos lingüísticos multimodales de gran tamaño (MLLM) para manejar contextos largos. Esta prueba pone a prueba los MLLM exigiéndoles que identifiquen componentes específicos dentro de entradas multiimagen, lo que sirve como medida de su procesamiento del contexto visual. Los resultados iniciales ponen de relieve la competencia de GPT-4 en escenarios de contexto largo, a pesar de las alucinaciones ocasionales y de la notable diferencia de rendimiento entre los modelos basados en API y los de código abierto.
• XLand-100B: un conjunto de datos multitarea a gran escala para el aprendizaje por refuerzo en contexto. XLand-100B es un conjunto de datos a gran escala para el aprendizaje por refuerzo en contexto que incluye 100.000 millones de transiciones de 2.500 millones de episodios en aproximadamente 30.000 tareas. Construido sobre el marco XLand-MiniGrid, se creó con 50.000 horas de GPU para mejorar la investigación en este campo.
• HelpSteer2: Conjunto de datos de código abierto para entrenar modelos de recompensa de alto rendimiento. HelpSteer2 es un conjunto de datos de código abierto con licencia CC-BY-4.0 diseñado para mejorar el entrenamiento de modelos de recompensa en LLM mediante la alineación con las preferencias humanas. Ha alcanzado un récord del 92,0% en Reward-Bench, con menos pares de datos que sus competidores.

The post Noticias mensuales sobre IA y NLP – junio 2024 first appeared on Planeta Chatbot.