Upload view_parquet.py

view_parquet.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+
+import pandas as pd
+import argparse
+from pathlib import Path
+from collections import Counter
+
+
+def analyze_parquet(parquet_file, rows_to_display=10):
+    """View and analyze the operator_input_models parquet file."""
+    
+    print(f"Reading parquet file: {parquet_file}")
+    df = pd.read_parquet(parquet_file)
+    
+    print(f"\n{'='*80}")
+    print("DATASET OVERVIEW")
+    print(f"{'='*80}")
+    print(f"Total rows: {len(df):,}")
+    print(f"Columns: {list(df.columns)}")
+    print(f"Memory usage: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")
+    
+    print(f"\n{'='*80}")
+    print("UNIQUE COUNTS")
+    print(f"{'='*80}")
+    print(f"Unique operators: {df['operator name'].nunique():,}")
+    print(f"Unique models: {df['used in model'].nunique():,}")
+    print(f"Unique argument configurations: {df['args'].nunique():,}")
+    
+    print(f"\n{'='*80}")
+    print("MODEL SOURCE BREAKDOWN")
+    print(f"{'='*80}")
+    
+    # Extract model sources
+    model_sources = {
+        'HuggingFace': [],
+        'TorchBench': [],
+        'Timm': [],
+        'Other': []
+    }
+    
+    unique_models = df['used in model'].unique()
+    
+    for model in unique_models:
+        if model.startswith('HuggingFace/'):
+            model_sources['HuggingFace'].append(model)
+        elif model.startswith('TorchBench/'):
+            model_sources['TorchBench'].append(model)
+        elif model.startswith('Timm/'):
+            model_sources['Timm'].append(model)
+        else:
+            model_sources['Other'].append(model)
+    
+    # Print source statistics
+    for source, models in model_sources.items():
+        if models:
+            print(f"\n{source}: {len(models)} models")
+            # Count total rows per source
+            source_rows = df[df['used in model'].isin(models)]
+            print(f"  - Total operator instances: {len(source_rows):,}")
+            print(f"  - Unique operators used: {source_rows['operator name'].nunique()}")
+            # Show sample models
+            sample_models = sorted(models)[:5]
+            for model in sample_models:
+                print(f"    • {model}")
+            if len(models) > 5:
+                print(f"    ... and {len(models) - 5} more")
+    
+    print(f"\n{'='*80}")
+    print("TOP OPERATORS BY USAGE")
+    print(f"{'='*80}")
+    operator_counts = df['operator name'].value_counts().head(10)
+    for i, (op, count) in enumerate(operator_counts.items(), 1):
+        print(f"{i:2}. {op:<50} {count:5} uses")
+    
+    print(f"\n{'='*80}")
+    print("TOP MODELS BY OPERATOR COUNT")
+    print(f"{'='*80}")
+    model_counts = df['used in model'].value_counts().head(10)
+    for i, (model, count) in enumerate(model_counts.items(), 1):
+        print(f"{i:2}. {model:<50} {count:5} operators")
+    
+    print(f"\n{'='*80}")
+    print(f"SAMPLE DATA (first {rows_to_display} rows)")
+    print(f"{'='*80}")
+    
+    # Display sample with truncated args for readability
+    sample_df = df.head(rows_to_display).copy()
+    sample_df['args'] = sample_df['args'].apply(lambda x: x[:100] + '...' if len(x) > 100 else x)
+    
+    pd.set_option('display.max_columns', None)
+    pd.set_option('display.width', None)
+    pd.set_option('display.max_colwidth', 50)
+    
+    print(sample_df.to_string(index=False))
+    
+    return df, model_sources
+
+
+def main():
+    parser = argparse.ArgumentParser(description='View and analyze operator_input_models parquet file')
+    parser.add_argument('--input', '-i', 
+                        default='operator_input_models_mapping.parquet',
+                        help='Input Parquet file (default: operator_input_models_mapping.parquet)')
+    parser.add_argument('--rows', '-r',
+                        type=int,
+                        default=10,
+                        help='Number of sample rows to display (default: 10)')
+    parser.add_argument('--query', '-q',
+                        help='Filter by operator name (partial match)')
+    parser.add_argument('--model', '-m',
+                        help='Filter by model name (partial match)')
+    
+    args = parser.parse_args()
+    
+    # Check if input file exists
+    if not Path(args.input).exists():
+        print(f"Error: Input file '{args.input}' not found")
+        return 1
+    
+    # Analyze the parquet file
+    df, model_sources = analyze_parquet(args.input, args.rows)
+    
+    # Apply filters if specified
+    if args.query or args.model:
+        print(f"\n{'='*80}")
+        print("FILTERED RESULTS")
+        print(f"{'='*80}")
+        
+        filtered_df = df.copy()
+        
+        if args.query:
+            filtered_df = filtered_df[filtered_df['operator name'].str.contains(args.query, case=False)]
+            print(f"Filtering for operator containing: '{args.query}'")
+        
+        if args.model:
+            filtered_df = filtered_df[filtered_df['used in model'].str.contains(args.model, case=False)]
+            print(f"Filtering for model containing: '{args.model}'")
+        
+        if len(filtered_df) > 0:
+            print(f"\nFound {len(filtered_df)} matching entries")
+            sample_df = filtered_df.head(args.rows).copy()
+            sample_df['args'] = sample_df['args'].apply(lambda x: x[:100] + '...' if len(x) > 100 else x)
+            print(sample_df.to_string(index=False))
+        else:
+            print("No matching entries found")
+    
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())