Upload folder using huggingface_hub

scripts/evaluate.py

@@ -0,0 +1,205 @@
+"""
+Evaluation script for trained model with comprehensive analysis
+"""
+import argparse
+import sys
+import os
+import numpy as np
+import pandas as pd
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src import (
+    load_config, 
+    compute_metrics_factory, 
+    plot_confusion_matrix, 
+    print_classification_report
+)
+from src.data_loader import prepare_datasets_for_training
+
+
+def analyze_errors(
+    test_dataset,
+    predictions: np.ndarray,
+    labels: np.ndarray,
+    id2label: dict,
+    tokenizer,
+    top_n: int = 10
+) -> pd.DataFrame:
+    """
+    Analyze misclassified examples.
+    
+    Args:
+        test_dataset: Test dataset
+        predictions: Predicted labels
+        labels: True labels
+        id2label: Label mapping
+        tokenizer: Tokenizer to decode text
+        top_n: Number of examples to show per error type
+        
+    Returns:
+        DataFrame with error analysis
+    """
+    errors = []
+    for i, (pred, true_label) in enumerate(zip(predictions, labels)):
+        if pred != true_label:
+            # Decode the comment (approximate, as original text is removed)
+            # Note: This is a limitation - we'd need to keep original text
+            errors.append({
+                'index': i,
+                'true_label': id2label[true_label],
+                'predicted_label': id2label[pred],
+                'error_type': f"{id2label[true_label]} -> {id2label[pred]}"
+            })
+    
+    error_df = pd.DataFrame(errors)
+    if len(error_df) > 0:
+        print(f"\nError Analysis:")
+        print(f"Total errors: {len(error_df)}")
+        print(f"\nError type distribution:")
+        print(error_df['error_type'].value_counts())
+    
+    return error_df
+
+
+def evaluate_model(
+    model_path: str, 
+    config_path: str = "config.yaml",
+    save_plots: bool = True
+):
+    """
+    Evaluate trained model on test set with comprehensive analysis.
+    
+    Args:
+        model_path: Path to the trained model
+        config_path: Path to configuration file
+        save_plots: Whether to save visualization plots
+    """
+    print("=" * 60)
+    print("Model Evaluation")
+    print("=" * 60)
+    
+    # Load config
+    config = load_config(config_path)
+    
+    # Create output directory
+    output_dir = config['training'].get('output_dir', './results')
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Load datasets
+    print("\n[1/5] Loading datasets...")
+    tokenized_datasets, label2id, id2label, _ = prepare_datasets_for_training(config_path)
+    test_dataset = tokenized_datasets['test']
+    print(f"✓ Test samples: {len(test_dataset)}")
+    
+    # Load model and tokenizer
+    print("\n[2/5] Loading trained model...")
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    model = AutoModelForSequenceClassification.from_pretrained(model_path)
+    print(f"✓ Model loaded from {model_path}")
+    
+    # Create trainer for evaluation
+    print("\n[3/5] Running evaluation...")
+    compute_metrics_fn = compute_metrics_factory(id2label)
+    trainer = Trainer(
+        model=model,
+        tokenizer=tokenizer,
+        compute_metrics=compute_metrics_fn
+    )
+    
+    # Get predictions
+    predictions_output = trainer.predict(test_dataset)
+    predictions = np.argmax(predictions_output.predictions, axis=1)
+    labels = predictions_output.label_ids
+    
+    # Print metrics
+    print("\n[4/5] Computing detailed metrics...")
+    print("\n" + "=" * 60)
+    print("Test Set Results")
+    print("=" * 60)
+    
+    metrics = predictions_output.metrics
+    
+    # Overall metrics
+    print("\nOverall Metrics:")
+    overall_metrics = ['accuracy', 'f1_weighted', 'f1_macro', 'precision_weighted', 'recall_weighted']
+    for metric in overall_metrics:
+        key = f'test_{metric}'
+        if key in metrics:
+            print(f"  {metric.replace('_', ' ').title()}: {metrics[key]:.4f}")
+    
+    # Per-class metrics
+    print("\nPer-Class Metrics:")
+    label_names = [id2label[i] for i in range(len(id2label))]
+    for label_name in label_names:
+        precision_key = f'test_precision_{label_name}'
+        recall_key = f'test_recall_{label_name}'
+        f1_key = f'test_f1_{label_name}'
+        if precision_key in metrics:
+            print(f"\n  {label_name.upper()}:")
+            print(f"    Precision: {metrics[precision_key]:.4f}")
+            print(f"    Recall:    {metrics[recall_key]:.4f}")
+            print(f"    F1-Score:  {metrics[f1_key]:.4f}")
+            print(f"    Support:   {metrics.get(f'test_support_{label_name}', 'N/A')}")
+    
+    # Detailed classification report
+    print("\n" + "=" * 60)
+    print_classification_report(labels, predictions, label_names)
+    
+    # Plot confusion matrix
+    print("\n[5/5] Generating visualizations...")
+    if save_plots:
+        plot_confusion_matrix(
+            labels,
+            predictions,
+            label_names,
+            save_path=os.path.join(output_dir, "confusion_matrix.png"),
+            normalize=False
+        )
+        
+        # Also save normalized version
+        plot_confusion_matrix(
+            labels,
+            predictions,
+            label_names,
+            save_path=os.path.join(output_dir, "confusion_matrix_normalized.png"),
+            normalize=True
+        )
+    
+    # Error analysis
+    error_df = analyze_errors(test_dataset, predictions, labels, id2label, tokenizer)
+    if len(error_df) > 0 and save_plots:
+        error_path = os.path.join(output_dir, "error_analysis.csv")
+        error_df.to_csv(error_path, index=False)
+        print(f"✓ Error analysis saved to {error_path}")
+    
+    print("\n" + "=" * 60)
+    print("Evaluation Complete! 🎉")
+    print("=" * 60)
+    print(f"\nResults saved to: {output_dir}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Evaluate trained model")
+    parser.add_argument(
+        "--model-path",
+        type=str,
+        default="./results/final_model",
+        help="Path to the trained model"
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        default="config.yaml",
+        help="Path to configuration file"
+    )
+    parser.add_argument(
+        "--no-plots",
+        action="store_true",
+        help="Skip generating visualization plots"
+    )
+    args = parser.parse_args()
+    
+    evaluate_model(args.model_path, args.config, save_plots=not args.no_plots)

scripts/generate_data.py

@@ -0,0 +1,190 @@
+"""
+Generate synthetic training data for Code Comment Quality Classifier
+"""
+import pandas as pd
+import os
+import random
+
+
+# Example comments for each category
+EXCELLENT_COMMENTS = [
+    "This function calculates the Fibonacci sequence using dynamic programming to avoid redundant calculations. Time complexity: O(n), Space complexity: O(n)",
+    "Validates user input against SQL injection attacks using parameterized queries. Returns True if safe, False otherwise. Raises ValueError for invalid input types.",
+    "Binary search implementation for sorted arrays. Uses divide-and-conquer approach. Params: arr (sorted list), target (value). Returns: index or -1 if not found.",
+    "Implements the Singleton pattern to ensure only one instance of DatabaseConnection exists. Thread-safe using double-checked locking.",
+    "Parses JSON configuration file and validates against schema. Handles nested objects and arrays. Raises ConfigurationError if validation fails.",
+    "Asynchronous HTTP request handler with retry logic and exponential backoff. Max retries: 3. Timeout: 30s. Returns: Response object or None on failure.",
+    "Generates secure random tokens for authentication using CSPRNG. Length: 32 bytes. Returns: hex-encoded string. Used in password reset flows.",
+    "Custom hook that debounces state updates to prevent excessive re-renders. Delay: configurable ms. Returns: debounced value and setter function.",
+    "Optimized matrix multiplication using Strassen's algorithm. Suitable for large matrices (n > 64). Time complexity: O(n^2.807).",
+    "Decorator that caches function results with LRU eviction policy. Max size: 128 entries. Thread-safe. Improves performance for expensive computations.",
+]
+
+HELPFUL_COMMENTS = [
+    "Calculates the sum of two numbers and returns the result",
+    "This function sorts the array in ascending order",
+    "Checks if the user is logged in before proceeding",
+    "Converts temperature from Celsius to Fahrenheit",
+    "Returns the current timestamp in UTC format",
+    "Validates email format using regex pattern",
+    "Fetches user data from the database by ID",
+    "Updates the UI when data changes",
+    "Handles file upload and saves to storage",
+    "Generates a random string of specified length",
+    "Removes duplicates from the list",
+    "Encrypts password before storing in database",
+    "Sends email notification to user",
+    "Formats date string for display",
+    "Calculates total price including tax",
+]
+
+UNCLEAR_COMMENTS = [
+    "does stuff",
+    "magic happens here",
+    "don't touch this",
+    "idk why this works but it does",
+    "temporary solution",
+    "quick fix",
+    "handles things",
+    "processes data",
+    "important function",
+    "legacy code",
+    "weird edge case",
+    "not sure what this does",
+    "complicated logic",
+    "TODO",
+    "fix me",
+    "helper method",
+    "utility function",
+    "wrapper",
+    "handler",
+    "manager",
+]
+
+OUTDATED_COMMENTS = [
+    "DEPRECATED: Use the new API endpoint instead",
+    "This will be removed in version 2.0",
+    "TODO: Refactor this to use async/await",
+    "Old implementation - kept for backwards compatibility",
+    "NOTE: This approach is no longer recommended",
+    "FIXME: Memory leak issue - needs update",
+    "Uses legacy authentication system",
+    "WARNING: This method is obsolete",
+    "Replaced by getUserInfo() in v1.5",
+    "Temporary workaround - pending proper fix",
+    "DEPRECATED: Direct database access - use ORM instead",
+    "Old validation logic - update to new schema",
+    "Uses outdated library - migrate to modern alternative",
+    "This was for Python 2 compatibility",
+    "FIXME: Security vulnerability - needs immediate update",
+]
+
+
+def generate_variations(base_comments: list, num_variations: int = 5) -> list:
+    """Generate variations of base comments to increase dataset size."""
+    variations = []
+    
+    prefixes = ["", "Note: ", "Important: ", "Info: ", ""]
+    suffixes = ["", ".", "...", " // end", ""]
+    
+    for comment in base_comments:
+        variations.append(comment)
+        for _ in range(num_variations - 1):
+            prefix = random.choice(prefixes)
+            suffix = random.choice(suffixes)
+            varied = f"{prefix}{comment}{suffix}"
+            variations.append(varied)
+    
+    return variations
+
+
+def generate_dataset(output_path: str = "./data/comments.csv", samples_per_class: int = 250):
+    """
+    Generate synthetic training dataset.
+    
+    Args:
+        output_path: Path to save the CSV file
+        samples_per_class: Number of samples to generate per class
+    """
+    print("=" * 60)
+    print("Generating Synthetic Training Data")
+    print("=" * 60)
+    
+    # Create data directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    # Generate variations
+    print("\nGenerating comment variations...")
+    excellent_samples = generate_variations(EXCELLENT_COMMENTS, samples_per_class // len(EXCELLENT_COMMENTS))
+    helpful_samples = generate_variations(HELPFUL_COMMENTS, samples_per_class // len(HELPFUL_COMMENTS))
+    unclear_samples = generate_variations(UNCLEAR_COMMENTS, samples_per_class // len(UNCLEAR_COMMENTS))
+    outdated_samples = generate_variations(OUTDATED_COMMENTS, samples_per_class // len(OUTDATED_COMMENTS))
+    
+    # Ensure we have exactly samples_per_class for each
+    excellent_samples = excellent_samples[:samples_per_class]
+    helpful_samples = helpful_samples[:samples_per_class]
+    unclear_samples = unclear_samples[:samples_per_class]
+    outdated_samples = outdated_samples[:samples_per_class]
+    
+    # Create DataFrame
+    data = {
+        'comment': (
+            excellent_samples + 
+            helpful_samples + 
+            unclear_samples + 
+            outdated_samples
+        ),
+        'label': (
+            ['excellent'] * len(excellent_samples) +
+            ['helpful'] * len(helpful_samples) +
+            ['unclear'] * len(unclear_samples) +
+            ['outdated'] * len(outdated_samples)
+        )
+    }
+    
+    df = pd.DataFrame(data)
+    
+    # Shuffle the dataset
+    df = df.sample(frac=1, random_state=42).reset_index(drop=True)
+    
+    # Save to CSV
+    df.to_csv(output_path, index=False)
+    
+    print(f"\n✓ Dataset generated successfully!")
+    print(f"✓ Total samples: {len(df)}")
+    print(f"✓ Saved to: {output_path}")
+    
+    print("\nClass distribution:")
+    print(df['label'].value_counts().sort_index())
+    
+    print("\nSample comments:")
+    print("-" * 60)
+    for label in ['excellent', 'helpful', 'unclear', 'outdated']:
+        sample = df[df['label'] == label].iloc[0]['comment']
+        print(f"\n[{label.upper()}]")
+        print(f"  {sample}")
+    
+    print("\n" + "=" * 60)
+    print("Data generation complete! 🎉")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Generate synthetic training data")
+    parser.add_argument(
+        "--output",
+        type=str,
+        default="./data/comments.csv",
+        help="Output path for the CSV file"
+    )
+    parser.add_argument(
+        "--samples-per-class",
+        type=int,
+        default=250,
+        help="Number of samples to generate per class"
+    )
+    args = parser.parse_args()
+    
+    generate_dataset(args.output, args.samples_per_class)

scripts/publish_to_hub.py

@@ -0,0 +1,247 @@
+"""
+Comprehensive script to publish model and codebase to Hugging Face Hub
+"""
+import argparse
+import os
+import sys
+from pathlib import Path
+from huggingface_hub import HfApi, create_repo, upload_folder, upload_file
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+
+def publish_to_hub(
+    model_path: str,
+    repo_id: str,
+    private: bool = False,
+    upload_code: bool = True,
+    upload_model: bool = True
+):
+    """
+    Publish model and codebase to Hugging Face Hub.
+    
+    Args:
+        model_path: Path to the trained model
+        repo_id: Full repository ID (e.g., "username/repo-name")
+        private: Whether to make the repository private
+        upload_code: Whether to upload code files
+        upload_model: Whether to upload the model
+    """
+    print("=" * 70)
+    print("Publishing to Hugging Face Hub")
+    print("=" * 70)
+    print(f"\nRepository: {repo_id}")
+    print(f"Private: {private}")
+    print(f"Upload Model: {upload_model}")
+    print(f"Upload Code: {upload_code}")
+    
+    api = HfApi()
+    
+    # Create repository
+    print("\n[1/4] Creating/verifying repository...")
+    try:
+        create_repo(
+            repo_id=repo_id,
+            repo_type="model",
+            exist_ok=True,
+            private=private
+        )
+        print(f"✓ Repository ready: {repo_id}")
+    except Exception as e:
+        print(f"✗ Error creating repository: {e}")
+        print("\nMake sure you're logged in:")
+        print("  huggingface-cli login")
+        return False
+    
+    # Upload model and tokenizer
+    if upload_model:
+        print("\n[2/4] Uploading model and tokenizer...")
+        try:
+            if not os.path.exists(model_path):
+                print(f"✗ Model path not found: {model_path}")
+                print("  Skipping model upload. You can upload it later.")
+            else:
+                tokenizer = AutoTokenizer.from_pretrained(model_path)
+                model = AutoModelForSequenceClassification.from_pretrained(model_path)
+                
+                model.push_to_hub(repo_id)
+                tokenizer.push_to_hub(repo_id)
+                print("✓ Model and tokenizer uploaded")
+        except Exception as e:
+            print(f"✗ Error uploading model: {e}")
+            print("  You can upload the model separately later.")
+    else:
+        print("\n[2/4] Skipping model upload (--no-model flag)")
+    
+    # Upload code files
+    if upload_code:
+        print("\n[3/4] Uploading code files...")
+        try:
+            repo_root = Path(__file__).parent.parent
+            
+            # Files to upload
+            code_files = [
+                "train.py",
+                "inference.py",
+                "config.yaml",
+                "requirements.txt",
+                "setup.py",
+                "README.md",
+                "MODEL_CARD.md",
+                "LICENSE",
+                ".gitignore"
+            ]
+            
+            # Directories to upload
+            code_dirs = [
+                "src",
+                "scripts"
+            ]
+            
+            uploaded_count = 0
+            
+            # Upload individual files
+            for file_name in code_files:
+                file_path = repo_root / file_name
+                if file_path.exists():
+                    try:
+                        upload_file(
+                            path_or_fileobj=str(file_path),
+                            path_in_repo=file_name,
+                            repo_id=repo_id,
+                            repo_type="model"
+                        )
+                        print(f"  ✓ Uploaded {file_name}")
+                        uploaded_count += 1
+                    except Exception as e:
+                        print(f"  ⚠ Could not upload {file_name}: {e}")
+            
+            # Upload directories
+            for dir_name in code_dirs:
+                dir_path = repo_root / dir_name
+                if dir_path.exists() and dir_path.is_dir():
+                    try:
+                        upload_folder(
+                            folder_path=str(dir_path),
+                            path_in_repo=dir_name,
+                            repo_id=repo_id,
+                            repo_type="model",
+                            ignore_patterns=["__pycache__", "*.pyc", ".DS_Store"]
+                        )
+                        print(f"  ✓ Uploaded {dir_name}/")
+                        uploaded_count += 1
+                    except Exception as e:
+                        print(f"  ⚠ Could not upload {dir_name}/: {e}")
+            
+            print(f"\n✓ Uploaded {uploaded_count} code files/directories")
+            
+        except Exception as e:
+            print(f"✗ Error uploading code: {e}")
+    else:
+        print("\n[3/4] Skipping code upload (--no-code flag)")
+    
+    # Final summary
+    print("\n[4/4] Publishing complete!")
+    print("\n" + "=" * 70)
+    print("Success! 🎉")
+    print("=" * 70)
+    print(f"\nYour model is now available at:")
+    print(f"https://huggingface.co/{repo_id}")
+    
+    if upload_model:
+        print("\nTo use your model:")
+        print(f"""
+from transformers import pipeline
+
+classifier = pipeline("text-classification", model="{repo_id}")
+
+# Classify a comment
+result = classifier("This function uses dynamic programming for O(n) time complexity")
+print(result)
+""")
+    
+    return True
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Publish model and codebase to Hugging Face Hub",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Publish everything (model + code)
+  python scripts/publish_to_hub.py --repo-id Snaseem2026/code-comment-classifier
+  
+  # Publish only code (no model)
+  python scripts/publish_to_hub.py --repo-id Snaseem2026/code-comment-classifier --no-model
+  
+  # Publish only model (no code)
+  python scripts/publish_to_hub.py --repo-id Snaseem2026/code-comment-classifier --no-code
+  
+  # Private repository
+  python scripts/publish_to_hub.py --repo-id Snaseem2026/code-comment-classifier --private
+        """
+    )
+    parser.add_argument(
+        "--model-path",
+        type=str,
+        default="./results/final_model",
+        help="Path to the trained model"
+    )
+    parser.add_argument(
+        "--repo-id",
+        type=str,
+        default="Snaseem2026/code-comment-classifier",
+        help="Full repository ID (e.g., 'username/repo-name')"
+    )
+    parser.add_argument(
+        "--private",
+        action="store_true",
+        help="Make the repository private"
+    )
+    parser.add_argument(
+        "--no-code",
+        action="store_true",
+        help="Skip uploading code files"
+    )
+    parser.add_argument(
+        "--no-model",
+        action="store_true",
+        help="Skip uploading model files"
+    )
+    parser.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt"
+    )
+    
+    args = parser.parse_args()
+    
+    print("\n" + "=" * 70)
+    print("Hugging Face Hub Publishing")
+    print("=" * 70)
+    print("\nBefore publishing, make sure you:")
+    print("1. Have a Hugging Face account")
+    print("2. Are logged in: huggingface-cli login")
+    print("3. Have reviewed MODEL_CARD.md and README.md")
+    print(f"4. Model path exists: {args.model_path} ({'✓' if os.path.exists(args.model_path) else '✗'})")
+    
+    if not args.yes:
+        print("\n" + "=" * 70)
+        response = input(f"\nProceed with publishing to {args.repo_id}? (yes/no): ")
+        if response.lower() not in ['yes', 'y']:
+            print("Publishing cancelled.")
+            sys.exit(0)
+    
+    success = publish_to_hub(
+        model_path=args.model_path,
+        repo_id=args.repo_id,
+        private=args.private,
+        upload_code=not args.no_code,
+        upload_model=not args.no_model
+    )
+    
+    if not success:
+        sys.exit(1)

scripts/upload_to_hub.py

@@ -0,0 +1,134 @@
+"""
+Upload trained model to Hugging Face Hub
+"""
+import argparse
+import sys
+import os
+from huggingface_hub import HfApi, create_repo
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# Add parent directory to path (if needed)
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+
+def upload_to_hub(
+    model_path: str,
+    repo_name: str,
+    organization: str = None,
+    private: bool = False
+):
+    """
+    Upload model to Hugging Face Hub.
+    
+    Args:
+        model_path: Path to the trained model
+        repo_name: Name for the repository on Hugging Face Hub
+        organization: Organization name (optional)
+        private: Whether to make the repository private
+    """
+    print("=" * 60)
+    print("Uploading Model to Hugging Face Hub")
+    print("=" * 60)
+    
+    # Create full repo ID
+    if organization:
+        repo_id = f"{organization}/{repo_name}"
+    else:
+        repo_id = repo_name
+    
+    print(f"\nRepository: {repo_id}")
+    print(f"Private: {private}")
+    
+    # Load model and tokenizer
+    print("\n[1/3] Loading model...")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(model_path)
+        model = AutoModelForSequenceClassification.from_pretrained(model_path)
+        print("✓ Model loaded successfully")
+    except Exception as e:
+        print(f"✗ Error loading model: {e}")
+        return
+    
+    # Create repository
+    print("\n[2/3] Creating repository...")
+    try:
+        create_repo(
+            repo_id=repo_id,
+            repo_type="model",
+            exist_ok=True,
+            private=private
+        )
+        print(f"✓ Repository created/verified: {repo_id}")
+    except Exception as e:
+        print(f"✗ Error creating repository: {e}")
+        print("\nMake sure you're logged in:")
+        print("  huggingface-cli login")
+        return
+    
+    # Push to hub
+    print("\n[3/3] Uploading model and tokenizer...")
+    try:
+        model.push_to_hub(repo_id)
+        tokenizer.push_to_hub(repo_id)
+        print("✓ Upload complete!")
+    except Exception as e:
+        print(f"✗ Error uploading: {e}")
+        return
+    
+    print("\n" + "=" * 60)
+    print("Success! 🎉")
+    print("=" * 60)
+    print(f"\nYour model is now available at:")
+    print(f"https://huggingface.co/{repo_id}")
+    
+    print("\nTo use your model:")
+    print(f"""
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+tokenizer = AutoTokenizer.from_pretrained("{repo_id}")
+model = AutoModelForSequenceClassification.from_pretrained("{repo_id}")
+""")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Upload model to Hugging Face Hub")
+    parser.add_argument(
+        "--model-path",
+        type=str,
+        default="./results/final_model",
+        help="Path to the trained model"
+    )
+    parser.add_argument(
+        "--repo-name",
+        type=str,
+        required=True,
+        help="Name for the repository on Hugging Face Hub"
+    )
+    parser.add_argument(
+        "--organization",
+        type=str,
+        default=None,
+        help="Organization name (optional)"
+    )
+    parser.add_argument(
+        "--private",
+        action="store_true",
+        help="Make the repository private"
+    )
+    args = parser.parse_args()
+    
+    print("\nBefore uploading, make sure you:")
+    print("1. Have a Hugging Face account")
+    print("2. Are logged in: huggingface-cli login")
+    print("3. Have reviewed the model card (MODEL_CARD.md)")
+    
+    response = input("\nProceed with upload? (yes/no): ")
+    if response.lower() in ['yes', 'y']:
+        upload_to_hub(
+            args.model_path,
+            args.repo_name,
+            args.organization,
+            args.private
+        )
+    else:
+        print("Upload cancelled.")