Descarga pixeltable - Descarga del código fuente pixeltable

Pixeltable es una biblioteca de Python que proporciona una interfaz declarativa para datos multimodales (texto, imágenes, audio, vídeo). Cuenta con control de versiones integrado, seguimiento de linaje y actualizaciones incrementales, lo que permite a los usuarios almacenar , transformar , indexar e iterar datos para sus flujos de trabajo de aprendizaje automático.

Las transformaciones de datos, la inferencia de modelos y la lógica personalizada están integradas como columnas calculadas .

Cargar/consultar todos los tipos de datos : interactuar con datos de vídeo a nivel de fotograma y documentos a nivel de fragmento
Actualizaciones incrementales para la transformación de datos : mantenga un índice de inserción colocado con sus datos
Evaluación diferida y gestión de caché : elimina la necesidad de extracción manual de fotogramas
Se integra con cualquier biblioteca de Python : use funciones integradas y personalizadas (UDF) sin canalizaciones complejas
Independiente del formato de datos y extensibilidad : acceda a tablas como archivos Parquet, conjuntos de datos PyTorch o anotaciones COCO.

? Instalación

 pip install pixeltable

Pixeltable es persistente. A diferencia de las bibliotecas de Python en memoria como Pandas, Pixeltable es una base de datos.

Empezando

Aprenda a crear tablas, completarlas con datos y mejorarlas con transformaciones integradas o definidas por el usuario.

Tema	Computadora portátil	Tema	Computadora portátil
Tour de 10 minutos por Pixeltable		Tablas y operaciones de datos
Funciones definidas por el usuario (UDF)		Modelos de detección de objetos
Ingeniería rápida incremental		Trabajar con archivos externos
Integración con Label Studio		Indexación de transcripciones de audio/vídeo
Aplicación multimodal		Indexación de documentos y RAG
Bot de discordia consciente del contexto		Búsqueda de similitud de imagen/texto

? Ejemplos de código

Importe datos multimedia a Pixeltable (vídeos, imágenes, audio...)

 import pixeltable as pxt

v = pxt . create_table ( 'external_data.videos' , { 'video' : pxt . Video })

prefix = 's3://multimedia-commons/'
paths = [
    'data/videos/mp4/ffe/ffb/ffeffbef41bbc269810b2a1a888de.mp4' ,
    'data/videos/mp4/ffe/feb/ffefebb41485539f964760e6115fbc44.mp4' ,
    'data/videos/mp4/ffe/f73/ffef7384d698b5f70d411c696247169.mp4'
]
v . insert ({ 'video' : prefix + p } for p in paths )

Aprenda a trabajar con datos en Pixeltable.

Detección de objetos en imágenes usando el modelo DETR.

 import pixeltable as pxt
from pixeltable . functions import huggingface

# Create a table to store data persistently
t = pxt . create_table ( 'image' , { 'image' : pxt . Image })

# Insert some images
prefix = 'https://upload.wikimedia.org/wikipedia/commons'
paths = [
    '/1/15/Cat_August_2010-4.jpg' ,
    '/e/e1/Example_of_a_Dog.jpg' ,
    '/thumb/b/bf/Bird_Diversity_2013.png/300px-Bird_Diversity_2013.png'
]
t . insert ({ 'image' : prefix + p } for p in paths )

# Add a computed column for image classification
t . add_computed_column ( classification = huggingface . detr_for_object_detection (
    t . image ,
    model_id = 'facebook/detr-resnet-50'
))

# Retrieve the rows where cats have been identified
t . select ( animal = t . image ,
         classification = t . classification . label_text [ 0 ]) 
. where ( t . classification . label_text [ 0 ] == 'cat' ). head ()

Obtenga más información sobre las columnas calculadas y la detección de objetos: Comparación de modelos de detección de objetos.

Amplíe las capacidades de Pixeltable con funciones definidas por el usuario

 @ pxt . udf
def draw_boxes ( img : PIL . Image . Image , boxes : list [ list [ float ]]) -> PIL . Image . Image :
    result = img . copy ()  # Create a copy of `img`
    d = PIL . ImageDraw . Draw ( result )
    for box in boxes :
        d . rectangle ( box , width = 3 )  # Draw bounding box rectangles on the copied image
    return result

Obtenga más información sobre las funciones definidas por el usuario: UDF en Pixeltable.

Automatizar operaciones de datos con vistas, por ejemplo, dividir documentos en fragmentos

 # In this example, the view is defined by iteration over the chunks of a DocumentSplitter
chunks_table = pxt . create_view (
    'rag_demo.chunks' ,
    documents_table ,
    iterator = DocumentSplitter . create (
        document = documents_table . document ,
        separators = 'token_limit' , limit = 300 )
)

Aprenda a aprovechar las vistas para desarrollar su flujo de trabajo RAG.

Evaluar el rendimiento del modelo

 # The computation of the mAP metric can become a query over the evaluation output
frames_view . select ( mean_ap ( frames_view . eval_yolox_tiny ), mean_ap ( frames_view . eval_yolox_m )). show ()

Aprenda cómo aprovechar Pixeltable para el análisis de modelos.

Trabajar con servicios de inferencia

 chat_table = pxt . create_table ( 'together_demo.chat' , { 'input' : pxt . String })

# The chat-completions API expects JSON-formatted input:
messages = [{ 'role' : 'user' , 'content' : chat_table . input }]

# This example shows how additional parameters from the Together API can be used in Pixeltable
chat_table . add_computed_column (
    output = chat_completions (
        messages = messages ,
        model = 'mistralai/Mixtral-8x7B-Instruct-v0.1' ,
        max_tokens = 300 ,
        stop = [ ' n ' ],
        temperature = 0.7 ,
        top_p = 0.9 ,
        top_k = 40 ,
        repetition_penalty = 1.1 ,
        logprobs = 1 ,
        echo = True
    )
)
chat_table . add_computed_column (
    response = chat_table . output . choices [ 0 ]. message . content
)

# Start a conversation
chat_table . insert ([
    { 'input' : 'How many species of felids have been classified?' },
    { 'input' : 'Can you make me a coffee?' }
])
chat_table . select ( chat_table . input , chat_table . response ). head ()

Aprenda a interactuar con servicios de inferencia como Together AI en Pixeltable.

Búsqueda de similitud de texto e imágenes en fotogramas de vídeo con índices integrados

 import pixeltable as pxt
from pixeltable . functions . huggingface import clip_image , clip_text
from pixeltable . iterators import FrameIterator
import PIL . Image

video_table = pxt . create_table ( 'videos' , { 'video' : pxt . Video })

video_table . insert ([{ 'video' : '/video.mp4' }])

frames_view = pxt . create_view (
    'frames' , video_table , iterator = FrameIterator . create ( video = video_table . video ))

@ pxt . expr_udf
def embed_image ( img : PIL . Image . Image ):
    return clip_image ( img , model_id = 'openai/clip-vit-base-patch32' )

@ pxt . expr_udf
def str_embed ( s : str ):
    return clip_text ( s , model_id = 'openai/clip-vit-base-patch32' )

# Create an index on the 'frame' column that allows text and image search
frames_view . add_embedding_index ( 'frame' , string_embed = str_embed , image_embed = embed_image )

# Now we will retrieve images based on a sample image
sample_image = '/image.jpeg'
sim = frames_view . frame . similarity ( sample_image )
frames_view . order_by ( sim , asc = False ). limit ( 5 ). select ( frames_view . frame , sim = sim ). collect ()

# Now we will retrieve images based on a string
sample_text = 'red truck'
sim = frames_view . frame . similarity ( sample_text )
frames_view . order_by ( sim , asc = False ). limit ( 5 ). select ( frames_view . frame , sim = sim ). collect ()

Aprenda a trabajar con incrustaciones y índices vectoriales.

Comparación de pilas de IA

Flujos de trabajo de visión por computadora

Requisito	Tradicional	mesa de píxeles
Extracción de cuadros	ffmpeg + código personalizado	Automático a través de FrameIterator
Detección de objetos	Múltiples scripts + almacenamiento en caché	Columna única calculada
Indexación de vídeos	Tuberías personalizadas + Vector DB	Búsqueda de similitud nativa
Gestión de anotaciones	Herramientas separadas + código personalizado	Integración de Label Studio
Evaluación del modelo	Canalización de métricas personalizadas	Cálculo de mapas incorporado

? Flujos de trabajo del LLM

Requisito	Tradicional	mesa de píxeles
Fragmentación de documentos	Herramienta + código personalizado	Divisor de documentos nativo
Generación integrada	Canalización separada + almacenamiento en caché	Columnas calculadas
Búsqueda de vectores	DB vectorial externo	Indexación de vectores incorporada
Gestión Rápida	Solución de seguimiento personalizada	Columnas controladas por versión
Gestión de cadena	Herramienta + código personalizado	DAG de columna calculada

? Flujos de trabajo multimodales

Requisito	Tradicional	mesa de píxeles
Tipos de datos	Múltiples sistemas de almacenamiento	Interfaz de tabla unificada
Búsqueda multimodal	Integración compleja	Soporte de similitud nativa
Orquestación de tuberías	Múltiples herramientas (flujo de aire, etc.)	Interfaz declarativa única
Gestión de activos	Sistema de seguimiento personalizado	Linaje automático
Control de calidad	Múltiples herramientas de validación	Columnas de validación calculadas

❓ Preguntas frecuentes

¿Qué es Pixeltable?

Pixeltable unifica el almacenamiento, el control de versiones y la indexación de datos con la orquestación y el control de versiones de modelos bajo una interfaz de tabla declarativa, con transformaciones, inferencia de modelos y lógica personalizada representadas como columnas calculadas.

¿Qué problemas resuelve Pixeltable?

Las soluciones actuales para el desarrollo de aplicaciones de IA requieren una extensa codificación personalizada y una infraestructura integral. El seguimiento del linaje y las versiones entre transformaciones, modelos e implementaciones de datos es engorroso. Pixeltable permite a los ingenieros de aprendizaje automático y científicos de datos centrarse en la exploración, el modelado y el desarrollo de aplicaciones sin tener que lidiar con la distribución de datos habitual.

¿Qué me proporciona Pixeltable? Pixeltable proporciona:

Almacenamiento de datos y control de versiones.
Linaje combinado de datos y modelos
Indexación (por ejemplo, incorporación de vectores) y recuperación de datos
Orquestación de cargas de trabajo multimodales
Actualizaciones incrementales
El código está automáticamente listo para producción

¿Por qué deberías utilizar Pixeltable?

Te da transparencia y reproducibilidad.
- Todos los datos generados se registran y versionan automáticamente
- Nunca necesitará volver a ejecutar una carga de trabajo porque perdió la pista de los datos de entrada
Te ahorra dinero
- Todos los cambios de datos son automáticamente incrementales.
- Nunca necesitará volver a ejecutar canalizaciones desde cero porque está agregando datos
Se integra con cualquier código o biblioteca Python existente.
- Traiga su código y cargas de trabajo en constante cambio
- Usted elige los modelos, las herramientas y las prácticas de IA (por ejemplo, su modelo de incorporación para un índice vectorial); Pixeltable organiza los datos

¿Qué no proporciona Pixeltable?

Pixeltable no es una solución de IA prescriptiva y de bajo código. Le permitimos utilizar los mejores marcos y técnicas para sus necesidades específicas.
No pretendemos reemplazar su conjunto de herramientas de IA existente, sino mejorarlo optimizando la infraestructura y la orquestación de datos subyacentes.

Consejo

Consulte la sección Integraciones y no dude en enviar una solicitud para obtener otras adicionales.