frascuchon's picture
frascuchon HF Staff
Upload folder using huggingface_hub
4beb2d4 verified
# /// script
# requires-python = ">=3.12"
# dependencies = [
# "datasets",
# "huggingface-hub",
# "rich",
# "typer",
# ]
# ///
from pathlib import Path
import yaml
from huggingface_hub import InferenceClient
from datasets import Dataset, load_dataset
from collections import defaultdict, deque
from concurrent.futures import ThreadPoolExecutor, as_completed
import time
import requests
import traceback
from rich.console import Console
from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
from rich.panel import Panel
from rich import print as rprint
import multiprocessing
import random
import typer
class Pipeline:
"""A parallel pipeline for generating dataset rows using language models."""
def __init__(
self,
*,
repo_id: str,
subset: str | None = None,
split: str = "train",
config: str | None = None,
num_rows: int | None = None,
bill_to: str | None = None,
max_workers: int | None = None,
debug: bool = False,
request_delay: float = 0
) -> None:
"""
Initialize the pipeline.
Args:
config: Path or URL to YAML configuration file
num_rows: Number of rows to generate (if None with source_dataset, uses entire dataset)
max_workers: Maximum number of concurrent workers (defaults to CPU count - 1)
debug: Enable debug logging (default: False)
request_delay: Delay in seconds between API requests (default: 0)
Raises:
ValueError: If no root nodes are found in the dependency graph
"""
self.debug = debug
self.console = Console()
self.request_delay = request_delay
self.bill_to = bill_to
with self.console.status("[bold green]Loading configuration..."):
self.config = self._load_config(config)
# Handle source dataset if specified
self.source_dataset = self._load_source_dataset(repo_id=repo_id, subset=subset, split=split)
self.source_columns = set()
# Get columns from source dataset
available_columns = set(self.source_dataset.features.keys())
self.source_columns = available_columns
self.num_rows = num_rows
# If num_rows is None, get the dataset size
if self.num_rows is None:
self.num_rows = self._get_dataset_size(repo_id, split, subset)
# Validate no overlap between source and generated columns
generated_columns = set(self.config.get('columns', {}).keys())
if overlap := (self.source_columns & generated_columns):
raise ValueError(f"Columns defined in both source dataset and generation config: {overlap}")
self.results: list[dict] = []
self.max_workers = max_workers or max(1, multiprocessing.cpu_count() - 1)
# Build dependency graph
self._build_dependency_graph()
self._display_configuration_summary()
def _get_dataset_size(self, repo_id: str, split: str, subset: str | None = None) -> int | None:
# Load dataset info (not the actual dataset)
from datasets import load_dataset_builder
builder = load_dataset_builder(repo_id, subset)
info = builder.info
# Get the number of examples in the specified split
if hasattr(info, 'splits') and split in info.splits:
return info.splits[split].num_examples
else:
# Fallback if split info is not available
self.console.print("[yellow]Warning: Could not determine dataset size. Using streaming mode.")
return None
@staticmethod
def _load_config(yml_source: str) -> dict:
"""Load and parse YAML configuration from file or URL."""
if yml_source.startswith(('http://', 'https://')):
response = requests.get(
yml_source,
headers={'Accept': 'application/x-yaml; application/json'}
)
response.raise_for_status()
return yaml.safe_load(response.text)
with open(yml_source) as f:
return yaml.safe_load(f)
def _build_dependency_graph(self) -> None:
"""Build directed dependency graph from configuration."""
self.graph = defaultdict(list)
self.reverse_graph = defaultdict(list)
all_nodes = set()
dependent_nodes = set()
# Add source columns as potential dependencies
all_nodes.update(self.source_columns)
for col, config in self.config.get('columns', {}).items():
all_nodes.add(col)
if deps := config.get('columnsReferences'):
# Validate dependencies exist in either source or generated columns
invalid_deps = set(deps) - (self.source_columns | set(self.config['columns'].keys()))
if invalid_deps:
raise ValueError(f"Invalid dependencies for {col}: {invalid_deps}")
for dep in deps:
self.graph[dep].append(col)
self.reverse_graph[col].append(dep)
# Only mark as dependent if it depends on non-source columns
if dep not in self.source_columns:
dependent_nodes.add(col)
# A node is a root if it:
# 1. Is not a source column AND
# 2. Either has no dependencies OR only depends on source columns
self.root_nodes = [
node for node in self.config.get('columns', {}).keys()
if node not in dependent_nodes
]
if not self.root_nodes and self.config.get('columns'):
raise ValueError("No root nodes found! Circular dependencies may exist.")
def get_client_for_node(self, node, bill_to: str | None = None) -> InferenceClient:
config = self.config['columns'][node]
return InferenceClient(
provider=config['modelProvider'],
bill_to=bill_to,
)
def _debug_log(self, message: str) -> None:
"""Print debug message if debug mode is enabled."""
if self.debug:
rprint(message)
def process_node(self, node: str, row: dict, bill_to: str | None = None) -> tuple[str, str]:
"""Process a single node in the pipeline."""
try:
if node in self.source_columns:
return node, row[node]
self._debug_log(f"[cyan]Processing node {node} with row data: {row}")
config = self.config['columns'][node]
prompt = self._prepare_prompt(config['prompt'], row)
self._debug_log(f"[cyan]Getting client for {node}...")
client = self.get_client_for_node(node, bill_to=bill_to)
self._debug_log(f"[cyan]Generating completion for {node} with prompt: {prompt}")
result = self._generate_completion(client, config['modelName'], prompt)
if not result or result.isspace():
raise ValueError(f"Empty or whitespace-only response from model")
self._debug_log(f"[green]Completed {node} with result: {result[:100]}...")
return node, result
except Exception as e:
self._log_error(node, e)
raise
def _prepare_prompt(self, prompt: str, row: dict) -> str:
"""Prepare prompt template by filling in values from row."""
for key, value in row.items():
placeholder = f"{{{{{key}}}}}"
if placeholder in prompt:
self._debug_log(f"[cyan]Replacing {placeholder} with: {value}")
prompt = prompt.replace(placeholder, str(value))
self._debug_log(f"[yellow]Final prompt:\n{prompt}")
return prompt
def _generate_completion(self, client: InferenceClient, model: str, prompt: str) -> str:
"""Generate completion using the specified model."""
messages = [{"role": "user", "content": prompt}]
# Implement retry with exponential backoff for rate limiting
max_retries = 5
retry_count = 0
base_delay = self.request_delay or 1.0 # Use request_delay if set, otherwise default to 1 second
while retry_count < max_retries:
try:
# Add delay if specified to avoid rate limiting
if retry_count > 0 or self.request_delay > 0:
# Calculate exponential backoff with jitter
if retry_count > 0:
delay = base_delay * (2 ** retry_count) + random.uniform(0, 1)
self._debug_log(
f"[yellow]Rate limit hit. Retrying in {delay:.2f} seconds (attempt {retry_count + 1}/{max_retries})")
else:
delay = base_delay
time.sleep(delay)
completion = client.chat.completions.create(
model=model,
messages=messages,
)
return completion.choices[0].message.content
except Exception as e:
# Check if it's a rate limit error
if "429" in str(e) or "rate_limit" in str(e).lower():
retry_count += 1
if retry_count >= max_retries:
self._debug_log(f"[red]Max retries reached for rate limit. Giving up.")
raise
else:
# Not a rate limit error, re-raise
raise
# Should not reach here, but just in case
raise Exception("Failed to generate completion after maximum retries")
def generate_row(self, progress, task_nodes, row_num, row_data=None):
"""Process a single node in the pipeline."""
try:
row = {}
if row_data:
row.update(row_data)
progress.update(task_nodes, description=f"[cyan]Row {row_num}: Loaded source data")
queue = deque(self.root_nodes)
in_progress = set()
processed_nodes = set()
with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
while queue or in_progress:
ready_nodes = [
node for node in queue
if node not in processed_nodes
and node not in in_progress
and all(dep in row for dep in self.reverse_graph[node])
]
for node in ready_nodes:
queue.remove(node)
progress.update(task_nodes, description=f"[cyan]Row {row_num}: Processing {node}")
futures = {
executor.submit(self.process_node, node, row, self.bill_to): node
for node in ready_nodes
}
in_progress.update(futures.values())
for future in as_completed(futures):
node = futures[future]
try:
node, result = future.result()
row[node] = result
in_progress.remove(node)
processed_nodes.add(node)
progress.advance(task_nodes)
for dependent in self.graph[node]:
if (dependent not in processed_nodes and
dependent not in queue and
dependent not in in_progress):
queue.append(dependent)
except Exception as e:
in_progress.remove(node)
processed_nodes.add(node)
progress.update(task_nodes, description=f"[red]Row {row_num}: Failed {node}")
raise
return row
except Exception as e:
self._debug_log(f"\n[red]Error processing row {row_num}: {str(e)}")
raise
def run(self):
start_time = time.time()
with Progress(
SpinnerColumn(),
TextColumn("[progress.description]{task.description}"),
BarColumn(complete_style="green", finished_style="green"),
TaskProgressColumn(),
console=self.console,
expand=True
) as progress:
task_rows = progress.add_task("[bold cyan]Generating dataset rows", total=self.num_rows)
task_nodes = progress.add_task("[cyan]Processing nodes (per row)", total=len(self.config['columns']))
with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
# If num_rows is None, use the entire dataset
if self.num_rows is None:
dataset_iter = enumerate(self.source_dataset)
# Update progress bar with unknown total
progress.update(task_rows, total=None)
else:
dataset_iter = enumerate(self.source_dataset.take(self.num_rows))
futures = {
executor.submit(
self.generate_row,
progress,
task_nodes,
i + 1,
dict(source_row) # Convert to dict if streaming
): i
for i, source_row in dataset_iter
}
for future in as_completed(futures):
i = futures[future]
row_num = i + 1
try:
row = future.result()
self.results.append(row)
progress.advance(task_rows)
progress.update(task_rows,
description=f"[bold green]✓ Completed {len(self.results)}/{self.num_rows} rows")
progress.reset(task_nodes) # Reset node progress for next row
except Exception as e:
progress.update(task_rows, description=f"[bold red]✗ Row {row_num} failed")
rprint(f"\n[red]Error in row {row_num}: {str(e)}")
continue
total_time = time.time() - start_time
minutes = int(total_time // 60)
seconds = int(total_time % 60)
if len(self.results) == self.num_rows:
rprint(Panel(
f"[bold green]✓[/] Successfully generated all {self.num_rows} rows!\nTotal time: {minutes}m {seconds}s"))
else:
rprint(Panel(
f"[bold yellow]![/] Completed with {len(self.results)}/{self.num_rows} rows generated\nTotal time: {minutes}m {seconds}s"))
# Create Hugging Face dataset with both source and generated columns
dataset_dict = {}
# Add source columns first
for col in self.source_columns:
dataset_dict[col] = [row.get(col) for row in self.results]
# Add generated columns
for col in self.config['columns']:
dataset_dict[col] = [row.get(col) for row in self.results]
dataset = Dataset.from_dict(dataset_dict)
return dataset
@staticmethod
def _log_error(node: str, e: Exception) -> None:
print(f"\n❌ Error in node {node}:")
print(f"Error type: {type(e).__name__}")
print(f"Error message: {str(e)}")
print(f"Full traceback:")
traceback.print_exc()
@staticmethod
def _load_source_dataset(
repo_id: str,
subset: str | None = None,
split: str = "train"
) -> Dataset:
"""Load the source dataset from Hugging Face Hub."""
return load_dataset(
repo_id,
subset,
split=split,
streaming=True
)
def _display_configuration_summary(self) -> None:
summary = [
f"[bold green]Pipeline Configuration Summary[/]",
f"• Source columns: [cyan]{len(self.source_columns)}[/]",
f"• Generated columns: [cyan]{len(self.config.get('columns', {}))}[/]",
f"• Worker threads: [cyan]{self.max_workers}[/]",
f"• Rows to generate: [cyan]{self.num_rows}[/]",
]
if self.source_columns:
summary.append("\n[bold blue]Source Dataset:[/]")
for col in sorted(self.source_columns):
summary.append(f"• [cyan]{col}[/]")
if self.config.get('columns'):
summary.append("\n[bold blue]Models and Providers:[/]")
# Add model and provider information for each generated node
for node, config in self.config['columns'].items():
model_name = config['modelName']
provider = config['modelProvider']
summary.append(f"• [cyan]{node}[/]: {model_name} ({provider})")
summary.append("\n[bold blue]Node Dependencies:[/]")
# Add dependency information for each node
for node in self.config['columns']:
deps = self.reverse_graph[node]
if deps:
summary.append(f"• [cyan]{node}[/] ← {', '.join(deps)}")
else:
summary.append(f"• [cyan]{node}[/] (root node)")
rprint(Panel("\n".join(summary)))
@staticmethod
def _is_sheets_dataset_url(url: str) -> bool:
"""Check if the URL points to a (AI)Sheets dataset."""
return "/home/dataset/" in url and "/json" not in url
def main(
*,
repo_id: str,
split: str = "train",
config: str = './config.yml',
destination: str,
destination_split: str = "train",
create_pr: bool = False,
num_rows: int | None = None,
bill_to: str | None = None,
max_workers: int | None = None,
debug: bool = False,
):
"""
Main entry point for the dataset augmentation pipeline.
Args:
repo_id: The dataset repository ID to augment (e.g., "fka/awesome-chatgpt-prompts").
split: Dataset split to use (default: "train").
config: Path to the YAML configuration file for the pipeline.
destination: Destination repository ID for the augmented dataset.
destination_split: Split name for the destination dataset (default: "train").
create_pr: Whether to create a pull request for the destination dataset (default: False).
bill_to: Billing account for the inference client (if applicable).
num_rows: Number of rows to use (if None, uses entire dataset).
max_workers: Maximum number of concurrent workers (defaults to CPU count - 1).
debug: Enable debug logging (default: False).
"""
pipeline = Pipeline(
repo_id=repo_id,
subset=None,
split=split,
config=config,
num_rows=num_rows,
bill_to=bill_to,
request_delay=0.5,
max_workers=max_workers,
debug=debug,
)
augmented_dataset = pipeline.run()
augmented_dataset.push_to_hub(destination, split=destination_split, create_pr=create_pr)
rprint(
f"\n[bold green]✓[/] Successfully pushed augmented dataset to [cyan] https://huggingface.co/datasets/{destination}[/].")
if __name__ == "__main__":
typer.run(main)