Hugging Face's logo

Hub documentation

fenic

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

fenic

fenic es un marco de DataFrames inspirado en PySpark, diseñado para crear aplicaciones de IA y agentes de producción. fenic ofrece soporte para leer conjuntos de datos directamente desde Hugging Face Hub.

Primeros pasos

Para empezar, instala fenic con pip:

pip install fenic

Crear una sesión

Instancia una sesión de fenic con la configuración predeterminada (suficiente para leer conjuntos de datos y otras operaciones no semánticas):

import fenic as fc

session = fc.Session.get_or_create(fc.SessionConfig())

Resumen

fenic es un marco de procesamiento de datos con una opinión definida que combina:

  • API de DataFrame: operaciones inspiradas en PySpark para la manipulación de datos familiar
  • Operaciones semánticas: Operaciones integradas de IA/LLM que incluyen funciones semánticas, embeddings y clustering
  • Integración de modelos: soporte nativo para proveedores de IA (Anthropic, OpenAI, Cohere, Google)
  • Optimización de consultas: Optimización automática mediante transformaciones del plan lógico

Leer desde Hugging Face Hub

fenic puede leer conjuntos de datos directamente desde Hugging Face Hub usando el protocolo hf://. Esta funcionalidad está integrada en la interfaz DataFrameReader de fenic.

Formatos admitidos

fenic admite la lectura de los siguientes formatos desde Hugging Face:

  • Archivos Parquet (.parquet)
  • Archivos CSV (.csv)

Lectura de conjuntos de datos

Para leer un conjunto de datos desde el Hugging Face Hub:

import fenic as fc

session = fc.Session.get_or_create(fc.SessionConfig())

# Read a CSV file from a public dataset
df = session.read.csv("hf://datasets/datasets-examples/doc-formats-csv-1/data.csv")

# Read Parquet files using glob patterns
df = session.read.parquet("hf://datasets/cais/mmlu/astronomy/*.parquet")

# Read from a specific dataset revision
df = session.read.parquet("hf://datasets/datasets-examples/doc-formats-csv-1@~parquet/**/*.parquet")

Lectura con gestión de esquemas

# Read multiple CSV files with schema merging
df = session.read.csv("hf://datasets/username/dataset_name/*.csv", merge_schemas=True)

# Read multiple Parquet files with schema merging
df = session.read.parquet("hf://datasets/username/dataset_name/*.parquet", merge_schemas=True)

Nota: En fenic, un esquema es el conjunto de nombres de columnas y sus tipos de datos. Cuando se habilita merge_schemas, fenic intenta reconciliar las diferencias entre archivos rellenando las columnas faltantes con valores nulos y ampliando los tipos de datos cuando es posible. Algunos diseños de datos aún no se pueden fusionar; consulte la documentación de fenic sobre las limitaciones de la fusión de esquemas CSV y las limitaciones de la fusión de esquemas Parquet.

Autenticación

Para leer conjuntos de datos privados, debes establecer tu token de Hugging Face como variable de entorno:

export HF_TOKEN="your_hugging_face_token_here"

Formato de ruta

El formato de ruta de Hugging Face en fenic sigue esta estructura:

hf://{repo_type}/{repo_id}/{path_to_file}

También puede especificar revisiones o versiones del conjunto de datos:

hf://{repo_type}/{repo_id}@{revision}/{path_to_file}

Características:

  • Admite patrones glob (*, **)
  • Revisiones/Versiones de conjuntos de datos usando la notación @ :
    • Commit específico: @d50d8923b5934dc8e74b66e6e4b0e2cd85e9142e
    • Rama: @refs/convert/parquet
    • Alias de rama: @~parquet
  • Requiere la variable de entorno HF_TOKEN para conjuntos de datos privados

Mezcla de fuentes de datos

fenic te permite combinar múltiples fuentes de datos en una sola operación de lectura, incluyendo la mezcla de diferentes protocolos:

# Mix HF and local files in one read call
df = session.read.parquet([
    "hf://datasets/cais/mmlu/astronomy/*.parquet",
    "file:///local/data/*.parquet",
    "./relative/path/data.parquet"
])

Esta flexibilidad te permite combinar sin problemas datos del Hugging Face Hub y archivos locales en tu pipeline de procesamiento de datos.

Procesar datos de Hugging Face

Una vez cargado desde Hugging Face, puedes usar la API completa de DataFrame de fenic:

Operaciones básicas de DataFrame

import fenic as fc

session = fc.Session.get_or_create(fc.SessionConfig())

# Load IMDB dataset from Hugging Face
df = session.read.parquet("hf://datasets/imdb/plain_text/train-*.parquet")

# Filter and select
positive_reviews = df.filter(fc.col("label") == 1).select("text", "label")

# Group by and aggregate
label_counts = df.group_by("label").agg(
    fc.count("*").alias("count")
)

Operaciones impulsadas por IA

Para usar operaciones semánticas y de incrustación, configure los modelos de lenguaje y de incrustación en su SessionConfig. Una vez configurado:

import fenic as fc

# Requires OPENAI_API_KEY to be set for language and embedding calls
session = fc.Session.get_or_create(
    fc.SessionConfig(
        semantic=fc.SemanticConfig(
            language_models={
                "gpt-4o-mini": fc.OpenAILanguageModel(
                    model_name="gpt-4o-mini",
                    rpm=60,
                    tpm=60000,
                )
            },
            embedding_models={
                "text-embedding-3-small": fc.OpenAIEmbeddingModel(
                    model_name="text-embedding-3-small",
                    rpm=60,
                    tpm=60000,
                )
            },
        )
    )
)

# Load a text dataset from Hugging Face
df = session.read.parquet("hf://datasets/imdb/plain_text/train-00000-of-00001.parquet")

# Add embeddings to text columns
df_with_embeddings = df.select(
    "*",
    fc.semantic.embed(fc.col("text")).alias("embedding")
)

# Apply semantic functions for sentiment analysis
df_analyzed = df_with_embeddings.select(
    "*",
    fc.semantic.analyze_sentiment(
        fc.col("text"),
        model_alias="gpt-4o-mini",  # Optional: specify model
    ).alias("sentiment")
)

Ejemplo: Análisis del conjunto de datos MMLU

import fenic as fc

# Requires OPENAI_API_KEY to be set for semantic calls
session = fc.Session.get_or_create(
    fc.SessionConfig(
        semantic=fc.SemanticConfig(
            language_models={
                "gpt-4o-mini": fc.OpenAILanguageModel(
                    model_name="gpt-4o-mini",
                    rpm=60,
                    tpm=60000,
                )
            },
        )
    )
)

# Load MMLU astronomy subset from Hugging Face
df = session.read.parquet("hf://datasets/cais/mmlu/astronomy/*.parquet")

# Process the data
processed_df = (df
    # Filter for specific criteria
    .filter(fc.col("subject") == "astronomy")
    # Select relevant columns
    .select("question", "choices", "answer")
    # Add difficulty analysis using semantic.map
    .select(
        "*",
        fc.semantic.map(
            "Rate the difficulty of this question from 1-5: {{question}}",
            question=fc.col("question"),
            model_alias="gpt-4o-mini"  # Optional: specify model
        ).alias("difficulty")
    )
)

# Show results
processed_df.show()

Recursos

Update on GitHub

←Atlas de incrustaciones FiftyOne→