Delete augment_dataset.py

augment_dataset.py

@@ -1,481 +0,0 @@
-# /// 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)
-            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)))
-
-
-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)
-
-
-if __name__ == "__main__":
-    typer.run(main)