Construya un agente de marco de datos con Gemini para el análisis de datos del lenguaje natural con pandas y langchain

En este tutorial, aprenderemos cómo aprovechar el poder de los modelos Gemini de Google junto con la flexibilidad de los pandas. Realizaremos análisis de datos directos y sofisticados en el clásico conjunto de datos Titanic. Al combinar el cliente ChatGoogleGenerativeai con el agente experimental de datos de pandas de Langchain, configuraremos un “agente” interactivo que puede interpretar consultas en idioma natural. Inspeccionará los datos, calculará estadísticas, descubrirá correlaciones y generará ideas visuales, sin escribir código manual para cada tarea. Caminaremos por los pasos de exploración básicos (como contar filas o calcular las tasas de supervivencia). Profundizaremos en análisis avanzados, como las tasas de supervivencia por segmentos demográficos y correlaciones de tarifas. Luego compararemos modificaciones en múltiples marcos de datos. Finalmente, construiremos rutinas personalizadas de puntuación y minería de patrones para extraer ideas novedosas.

!pip install langchain_experimental langchain_google_genai pandas


import os
import pandas as pd
import numpy as np
from langchain.agents.agent_types import AgentType
from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
from langchain_google_genai import ChatGoogleGenerativeAI


os.environ["GOOGLE_API_KEY"] = "Use Your Own API Key"

Primero, instalamos las bibliotecas requeridas, langchain_experimental, langchain_google_genai y pandas, utilizando PIP para habilitar DataFrame Agent y Google Gemini Integration. Luego importe los módulos centrales. A continuación, configure su variable de entorno Google_API_Key, y estamos listos para instanciar un agente PANDAS con Géminis para el análisis de datos conversacionales.

def setup_gemini_agent(df, temperature=0, model="gemini-1.5-flash"):
    llm = ChatGoogleGenerativeAI(
        model=model,
        temperature=temperature,
        convert_system_message_to_human=True
    )
   
    agent = create_pandas_dataframe_agent(
        llm=llm,
        df=df,
        verbose=True,
        agent_type=AgentType.OPENAI_FUNCTIONS,
        allow_dangerous_code=True
    )
    return agent

Esta función de ayuda inicializa un cliente LLM con Gemini con nuestro modelo y temperatura elegidos. Luego lo envuelve en un agente de marco de datos Langchain Pandas que puede ejecutar consultas en el lenguaje natural (incluido el código “peligroso”) contra nuestro marco de datos. Simplemente pase nuestro marco de datos para recuperar un agente interactivo listo para el análisis de conversación.

def load_and_explore_data():
    print("Loading Titanic Dataset...")
    df = pd.read_csv(
        "https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv"
    )
    print(f"Dataset shape: {df.shape}")
    print(f"Columns: {list(df.columns)}")
    return df

Esta función obtiene el CSV Titanic directamente del repositorio de Pandas Github. También imprime sus dimensiones y nombres de columnas para una rápida verificación de cordura. Luego devuelve el marco de datos cargado para que podamos comenzar inmediatamente nuestro análisis exploratorio.

def basic_analysis_demo(agent):
    print("\nBASIC ANALYSIS DEMO")
    print("=" * 50)
   
    queries = [
        "How many rows and columns are in the dataset?",
        "What's the survival rate (percentage of people who survived)?",
        "How many people have more than 3 siblings?",
        "What's the square root of the average age?",
        "Show me the distribution of passenger classes"
    ]
   
    for query in queries:
        print(f"\nQuery: {query}")
        try:
            result = agent.invoke(query)
            print(f"Result: {result['output']}")
        except Exception as e:
            print(f"Error: {e}")

Esta rutina de demostración inicia una sesión de “análisis básico” al imprimir un encabezado. Luego itera a través de un conjunto de consultas exploratorias comunes, como dimensiones del conjunto de datos, tasas de supervivencia, recuentos familiares y distribuciones de clase, contra nuestro agente de marco de datos Titanic. Para cada mensaje de idioma natural, invoca al agente. Más tarde, captura su salida e imprime el resultado o un error.

def advanced_analysis_demo(agent):
    print("\nADVANCED ANALYSIS DEMO")
    print("=" * 50)
   
    advanced_queries = [
        "What's the correlation between age and fare?",
        "Create a survival analysis by gender and class",
        "What's the median age for each passenger class?",
        "Find passengers with the highest fares and their details",
        "Calculate the survival rate for different age groups (0-18, 18-65, 65+)"
    ]
   
    for query in advanced_queries:
        print(f"\nQuery: {query}")
        try:
            result = agent.invoke(query)
            print(f"Result: {result['output']}")
        except Exception as e:
            print(f"Error: {e}")

Esta función de “análisis avanzado” imprime un encabezado, luego ejecuta una serie de consultas más sofisticadas. Calcula las correlaciones, realiza análisis de supervivencia estratificados, calcula estadísticas medias y realiza un filtrado detallado contra nuestro agente de marco de datos con Gemini. El bucle invoca cada mensaje de idioma natural, captura las respuestas del agente e imprime los resultados (o errores). Por lo tanto, demuestra con qué facilidad podemos aprovechar la IA conversacional para obtener información más profunda y segmentada en nuestro conjunto de datos.

def multi_dataframe_demo():
    print("\nMULTI-DATAFRAME DEMO")
    print("=" * 50)
   
    df = pd.read_csv(
        "https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv"
    )
   
    df_filled = df.copy()
    df_filled["Age"] = df_filled["Age"].fillna(df_filled["Age"].mean())
   
    agent = setup_gemini_agent([df, df_filled])
   
    queries = [
        "How many rows in the age column are different between the two datasets?",
        "Compare the average age in both datasets",
        "What percentage of age values were missing in the original dataset?",
        "Show summary statistics for age in both datasets"
    ]
   
    for query in queries:
        print(f"\nQuery: {query}")
        try:
            result = agent.invoke(query)
            print(f"Result: {result['output']}")
        except Exception as e:
            print(f"Error: {e}")

Esta demostración ilustra cómo girar un agente con Géminis a través de múltiples marcos de datos. En este caso, incluye los datos Titanic originales y una versión con edades faltantes imputadas. Por lo tanto, podemos hacer preguntas de comparación entre datasetes entre dataset (como las diferencias en los recuentos de filas, las comparaciones de la edad promedio, los porcentajes de valor faltante y las estadísticas de resumen de lado a lado) utilizando indicaciones simples de lenguaje natural.

def custom_analysis_demo(agent):
    print("\nCUSTOM ANALYSIS DEMO")
    print("=" * 50)
   
    custom_queries = [
        "Create a risk score for each passenger based on: Age (higher age = higher risk), Gender (male = higher risk), Class (3rd class = higher risk), Family size (alone or large family = higher risk). Then show the top 10 highest risk passengers who survived",
       
        "Analyze the 'deck' information from the cabin data: Extract deck letter from cabin numbers, Show survival rates by deck, Which deck had the highest survival rate?",
       
        "Find interesting patterns: Did people with similar names (same surname) tend to survive together? What's the relationship between ticket price and survival? Were there any age groups that had 100% survival rate?"
    ]
   
    for i, query in enumerate(custom_queries, 1):
        print(f"\nCustom Analysis {i}:")
        print(f"Query: {query[:100]}...")
        try:
            result = agent.invoke(query)
            print(f"Result: {result['output']}")
        except Exception as e:
            print(f"Error: {e}")

Esta rutina inicia una sesión de “análisis personalizado” caminando a través de tres indicaciones complejas de varios pasos. Construye un modelo de anotación de riesgos de pasajeros, extracta y evalúa las tasas de supervivencia basadas en la plataforma, y ​​las minas de los patrones de supervivencia basados ​​en el nombre de los apellidos y los valores atípicos de tarifas/edad. Por lo tanto, podemos ver con qué facilidad nuestro agente con Géminis maneja investigaciones a medida y específicas del dominio con consultas en idioma natural.

def main():
    print("Advanced Pandas Agent with Gemini Tutorial")
    print("=" * 60)
   
    if not os.getenv("GOOGLE_API_KEY"):
        print("Warning: GOOGLE_API_KEY not set!")
        print("Please set your Gemini API key as an environment variable.")
        return
   
    try:
        df = load_and_explore_data()
        print("\nSetting up Gemini Agent...")
        agent = setup_gemini_agent(df)
       
        basic_analysis_demo(agent)
        advanced_analysis_demo(agent)
        multi_dataframe_demo()
        custom_analysis_demo(agent)
       
        print("\nTutorial completed successfully!")
       
    except Exception as e:
        print(f"Error: {e}")
        print("Make sure you have installed all required packages and set your API key.")


if __name__ == "__main__":
    main()

La función Main () sirve como punto de partida para el tutorial. Verifica que nuestra tecla API Gemini se establezca, carga y explora el conjunto de datos Titanic, e inicializa el agente de pandas conversacional. Luego ejecuta secuencialmente las demostraciones básicas, avanzadas, multidataframe y de análisis personalizados. Por último, envuelve todo el flujo de trabajo en un Bloque de prueba/excepto para atrapar e informar cualquier error antes de señalar la finalización exitosa.

df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
agent = setup_gemini_agent(df)


agent.invoke("What factors most strongly predicted survival?")
agent.invoke("Create a detailed survival analysis by port of embarkation")
agent.invoke("Find any interesting anomalies or outliers in the data")

Finalmente, cargamos directamente los datos de Titanic, instanciamos a nuestro agente de pandas con Gemini, y disparamos tres consultas únicas. Identificamos predictores de supervivencia clave, desglosan la supervivencia por puerto de embarque y descubrimos anomalías o valores atípicos. Logramos todo esto sin modificar ninguna de nuestras funciones de demostración.

En conclusión, la combinación de pandas con Gemini a través de un agente de marco de datos Langchain transforma la exploración de datos de la redacción del código de calderas en la elaboración de consultas claras y de lenguaje natural. Ya sea que estamos calculando estadísticas de resumen, construyendo puntajes de riesgo personalizados, comparando múltiples marcos de datos o perforaciones en análisis de supervivencia matizados, la transformación es evidente. Con solo unas pocas líneas de configuración, obtenemos un asistente de análisis interactivo que pueda adaptarse a nuevas preguntas sobre la marcha. Puede surgir patrones ocultos y acelerar nuestro flujo de trabajo.

Mira el Computadora portátil. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro 99k+ ml de subreddit y suscribirse a Nuestro boletín.