quick-sentiments 0.4.8__tar.gz → 0.5.2__tar.gz

{quick_sentiments-0.4.8/quick_sentiments.egg-info → quick_sentiments-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quick-sentiments
-Version: 0.4.8
+Version: 0.5.2
 Summary: Sentiment Analysis pipeline
 Author: Alabhya Dahal
 Author-email: Alabhya Dahal <alabhya.dahal@gmail.com>

{quick_sentiments-0.4.8 → quick_sentiments-0.5.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quick-sentiments"
-version = "0.4.8" # pipeline is efficient
+version = "0.5.2" # manual hyperparameter enabled
 authors = [
   { name="Alabhya Dahal", email="alabhya.dahal@gmail.com" },
 ]

quick_sentiments-0.5.2/quick_sentiments/ml_algo/XGB.py

@@ -0,0 +1,135 @@
+# ml_algo/XGB.py
+
+from xgboost import XGBClassifier
+from sklearn.model_selection import GridSearchCV
+from sklearn.metrics import classification_report
+import numpy as np
+
+def train_and_predict(
+    X_train, 
+    y_train, 
+    X_test, 
+    perform_tuning=False, 
+    param_grid=None,
+    interactive_mode=True,
+    random_state=42
+):
+    """
+    Trains XGBoostClassifier model (with optional hyperparameter tuning) and predicts on test data.
+
+    Args:
+        X_train: training features (e.g., NumPy array or sparse matrix).
+        y_train: training labels (numerical, e.g., 0, 1, 2...).
+        X_test: test features (e.g., NumPy array or sparse matrix).
+        perform_tuning (bool): If True, performs GridSearchCV. If False, trains
+                               the model with default parameters. Defaults to False.
+        param_grid (dict): Optional custom dictionary for GridSearchCV.
+        interactive_mode (bool): If True, prompts for fallback on grid failure.
+
+    Returns:
+        y_pred: predicted labels for test set.
+        best_model: The best trained XGBoostClassifier model (either from GridSearchCV or simple fit).
+    """
+    print("   - Starting XGBoost training...")
+
+    # Determine objective and eval_metric based on number of unique classes
+    num_classes = len(np.unique(y_train))
+    
+    if num_classes == 2:
+        xgb_objective = 'binary:logistic'
+        xgb_eval_metric = 'logloss'
+        scoring_metric = 'f1_weighted'
+    else:
+        xgb_objective = 'multi:softmax'
+        xgb_eval_metric = 'mlogloss'
+        scoring_metric = 'f1_weighted' # Or 'accuracy'
+
+    # Base XGBClassifier model
+    # verbosity=0 to suppress excessive output from XGBoost itself during GridSearchCV
+    xgb_model = XGBClassifier(
+        objective=xgb_objective,
+        eval_metric=xgb_eval_metric,
+        use_label_encoder=False, # Suppress warning for newer versions
+        random_state=random_state,
+        num_class=num_classes if num_classes > 2 else None,
+        verbosity=0 
+    )
+
+    # A safe defined grid in case none is provided, ensuring the function can run without errors
+    default_grid = {
+        'n_estimators': [100, 200],
+        'learning_rate': [0.05, 0.1, 0.2],
+        'max_depth': [3, 5, 7],
+        'subsample': [0.8, 1.0],
+        'colsample_bytree': [0.8, 1.0]
+    }
+
+    if perform_tuning:
+        if param_grid is None:
+            print("   - Starting XGBoost training with DEFAULT PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = default_grid
+        else:
+            print("   - Starting XGBoost training with CUSTOM PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = param_grid
+
+        grid_search = GridSearchCV(
+            estimator=xgb_model,
+            param_grid=target_grid,
+            cv=5,
+            scoring=scoring_metric,
+            n_jobs=-1,
+            verbose=1 
+        )
+
+        # The Safety Net
+        try:
+            grid_search.fit(X_train, y_train)
+            
+        except Exception as e:  # <-- Catch Exception because XGBoost throws XGBoostError
+            # If a custom grid was passed and it failed...
+            if param_grid is not None:
+                print(f"\n[ERROR] Your custom hyperparameter grid failed: {e}")
+                
+                if interactive_mode:
+                    # The Beginner Path: Ask for permission to fall back
+                    user_choice = input("Would you like to fall back to the default parameter grid? (Y/N): ").strip().lower()
+                    
+                    if user_choice in ['y', 'yes']:
+                        print("   - Falling back to default parameters...")
+                        grid_search = GridSearchCV(
+                            estimator=xgb_model,
+                            param_grid=default_grid,
+                            cv=5,
+                            scoring=scoring_metric,
+                            n_jobs=-1,
+                            verbose=1
+                        )
+                        grid_search.fit(X_train, y_train)
+                    else:
+                        print("   - Aborting execution.")
+                        raise e 
+                else:
+                    # The Production Path: Fail fast
+                    print("   - Interactive mode is off. Aborting execution.")
+                    raise e
+            else:
+                # If the default grid itself failed, crash it.
+                raise e
+
+        best_model = grid_search.best_estimator_
+
+        print("\n   - Best Hyperparameters found:")
+        print(grid_search.best_params_)
+        print(f"   - Best Cross-Validation Score ({scoring_metric}): {grid_search.best_score_:.4f}")
+        
+    else:
+        print("   - Training XGBoost with default parameters (no hyperparameter tuning)...")
+        best_model = xgb_model 
+        best_model.fit(X_train, y_train) 
+        print("   - Model trained with default parameters.")
+
+    # Make predictions on the test set
+    y_pred = best_model.predict(X_test)
+    print("Best model parameters:", best_model.get_params())
+
+    return y_pred, best_model

quick_sentiments-0.5.2/quick_sentiments/ml_algo/logit.py

@@ -0,0 +1,110 @@
+# MLAlgo/logistic_regression_model.py
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import GridSearchCV # Import GridSearchCV
+from sklearn.metrics import classification_report # For evaluation metrics
+import numpy as np # For type hinting
+
+def train_and_predict(X_train, 
+                      y_train, 
+                      X_test, 
+                      perform_tuning=False, 
+                      param_grid=None,
+                      interactive=True,
+                      random_state=42):
+    """
+        Trains Logistic Regression model (with optional hyperparameter tuning) and predicts on test data.
+
+    Args:
+        X_train: training features (e.g., NumPy array or sparse matrix).
+        y_train: training labels (list or NumPy array).
+        X_test: test features (e.g., NumPy array or sparse matrix).
+        perform_tuning (bool): If True, performs GridSearchCV. If False, trains
+                               the model with default parameters. Defaults to True.
+        param_grid (dict): Optional custom dictionary for GridSearchCV.
+        interactive_mode (bool): If True, prompts for fallback on grid failure.
+
+    Returns:
+        y_pred: predicted labels for test set.
+        best_model: The best trained LogisticRegression model (either from GridSearchCV or simple fit).
+    """
+    lr_model = LogisticRegression(random_state=random_state) # Base model for training
+    
+    # A safe defined grid in case none is provided, ensuring the function can run without errors
+    
+    default_grid = {
+            'solver': ['liblinear', 'lbfgs'],
+            'C': [0.1, 1.0, 10.0],
+            'class_weight': [None, 'balanced'],
+            'max_iter': [500, 1000]
+        }    
+    
+    if perform_tuning:
+        if param_grid is None:
+            print("   - Starting Logistic Regression training with DEFAULT PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = default_grid
+        else:
+            print("   - Starting Logistic Regression training with CUSTOM PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = param_grid
+
+
+        print("   - Starting Logistic Regression training with GridSearchCV...")
+
+        grid_search = GridSearchCV(
+            estimator=lr_model,
+            param_grid=target_grid,
+            cv=5,
+            scoring='f1_weighted',
+            n_jobs=-1,
+            verbose=1
+        )
+
+        # Check if grid parameters are valid before fitting
+        try:
+            grid_search.fit(X_train, y_train)
+            
+        except ValueError as e:
+            # If a custom grid was passed and it failed...
+            if param_grid is not None:
+                print(f"\n[ERROR] Your custom hyperparameter grid failed: {e}")
+                
+                if interactive:
+                    # The Beginner Path: Ask for permission to fall back
+                    user_choice = input("Would you like to fall back to the default parameter grid? (Y/N): ").strip().lower()
+                    
+                    if user_choice in ['y', 'yes']:
+                        print("   - Falling back to default parameters...")
+                        grid_search = GridSearchCV(
+                            estimator=lr_model,
+                            param_grid=default_grid,
+                            cv=5,
+                            scoring='f1_weighted',
+                            n_jobs=-1,
+                            verbose=1
+                        )
+                        grid_search.fit(X_train, y_train)
+                    else:
+                        print("   - Aborting execution.")
+                        raise e 
+                else:
+                    # The Production Path: Fail fast
+                    print("   - Interactive mode is off. Aborting execution.")
+                    raise e
+            else:
+                # If the default grid itself failed (likely a data shape issue), crash it.
+                raise e
+
+        best_model = grid_search.best_estimator_
+        print("\n   - Best Hyperparameters found:")
+        print(grid_search.best_params_)
+        print(f"   - Best Cross-Validation Score (F1-weighted): {grid_search.best_score_:.4f}")
+    else:
+        print("   - Training Logistic Regression with default parameters (no hyperparameter tuning)...")
+        best_model = lr_model # Use the base model directly
+        best_model.fit(X_train, y_train) # Fit it on X_train, y_train
+        print("   - Model trained with default parameters.")
+
+    y_pred = best_model.predict(X_test)
+    print("Best model parameters:", best_model.get_params())
+
+    return y_pred, best_model

quick_sentiments-0.5.2/quick_sentiments/ml_algo/nb.py

@@ -0,0 +1,112 @@
+# MLAlgo/nb.py
+
+from sklearn.naive_bayes import MultinomialNB, GaussianNB
+from sklearn.model_selection import GridSearchCV
+import warnings
+import numpy as np
+
+def train_and_predict(
+    X_train, 
+    y_train, 
+    X_test, 
+    perform_tuning=False, 
+    param_grid=None,
+    interactive_mode=True,
+    random_state=42
+):
+    """
+    Automatically selects GaussianNB for embeddings (Word2Vec) 
+    and MultinomialNB for counts (Bag of Words), with safe fallback tuning.
+    """
+    
+    # STEP 1: Check for Negative Values (The "Word2Vec" Detector)
+    # Using .min() is safer for sparse matrices than np.min()
+    if X_train.min() < 0:
+        model_type = "Gaussian"
+        print("   - Detected negative values (Embeddings). Switching to Gaussian Naive Bayes.")
+        nb_model = GaussianNB()
+        
+        # Dynamically assign the Gaussian default grid
+        default_grid = {
+            'var_smoothing': [1e-9, 1e-8, 1e-7, 1e-6, 1e-5]
+        }
+    else:
+        model_type = "Multinomial"
+        print("   - Detected all positive values (Counts). Using Multinomial Naive Bayes.")
+        nb_model = MultinomialNB()
+        
+        # Dynamically assign the Multinomial default grid
+        default_grid = {
+            'alpha': [0.01, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0],
+            'fit_prior': [True, False]
+        }
+
+    # STEP 2: Training with optional Tuning
+    if perform_tuning:
+        if param_grid is None:
+            print(f"   - Starting {model_type} Naive Bayes training with DEFAULT PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = default_grid
+        else:
+            print(f"   - Starting {model_type} Naive Bayes training with CUSTOM PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = param_grid
+
+        grid_search = GridSearchCV(
+            estimator=nb_model,
+            param_grid=target_grid,
+            cv=5,
+            scoring='f1_weighted',
+            n_jobs=-1,
+            verbose=1
+        )
+
+        # The Safety Net
+        try:
+            grid_search.fit(X_train, y_train)
+            
+        except ValueError as e:
+            # If a custom grid was passed and it failed...
+            if param_grid is not None:
+                print(f"\n[ERROR] Your custom hyperparameter grid failed: {e}")
+                
+                if interactive_mode:
+                    # The Beginner Path: Ask for permission to fall back
+                    user_choice = input("Would you like to fall back to the default parameter grid? (Y/N): ").strip().lower()
+                    
+                    if user_choice in ['y', 'yes']:
+                        print("   - Falling back to default parameters...")
+                        grid_search = GridSearchCV(
+                            estimator=nb_model,
+                            param_grid=default_grid,
+                            cv=5,
+                            scoring='f1_weighted',
+                            n_jobs=-1,
+                            verbose=1
+                        )
+                        grid_search.fit(X_train, y_train)
+                    else:
+                        print("   - Aborting execution.")
+                        raise e 
+                else:
+                    # The Production Path: Fail fast
+                    print("   - Interactive mode is off. Aborting execution.")
+                    raise e
+            else:
+                # If the default grid itself failed (likely a data shape issue), crash it.
+                raise e
+
+        best_model = grid_search.best_estimator_
+        print("\n   - Best Hyperparameters found:")
+        print(grid_search.best_params_)
+        print(f"   - Best Cross-Validation Score (F1-weighted): {grid_search.best_score_:.4f}")
+        
+    else:
+        print(f"   - Training {model_type} Naive Bayes with default parameters (no hyperparameter tuning)...")
+        best_model = nb_model
+        best_model.fit(X_train, y_train)
+        print("   - Model trained with default parameters.")
+
+    # STEP 3: Predict
+    y_pred = best_model.predict(X_test)
+    print("Best model parameters:", best_model.get_params())
+    
+    return y_pred, best_model

quick_sentiments-0.5.2/quick_sentiments/ml_algo/nn.py

@@ -0,0 +1,112 @@
+# MLAlgo/nn.py
+
+from sklearn.neural_network import MLPClassifier
+from sklearn.model_selection import GridSearchCV
+from sklearn.metrics import classification_report
+import warnings
+import numpy as np 
+
+def train_and_predict(
+    X_train, 
+    y_train, 
+    X_test, 
+    perform_tuning=False, 
+    param_grid=None,
+    interactive_mode=True,
+    random_state=42
+):
+    """
+    Trains a Multi-layer Perceptron (MLP) Classifier model (Neural Network)
+    (with optional hyperparameter tuning) and predicts on test data.
+
+    Args:
+        X_train: training features (e.g., NumPy array or sparse matrix).
+        y_train: training labels (list or NumPy array).
+        X_test: test features (e.g., NumPy array or sparse matrix).
+        perform_tuning (bool): If True, performs GridSearchCV. If False, trains
+                               the model with default parameters. Defaults to False.
+        param_grid (dict): Optional custom dictionary for GridSearchCV.
+        interactive_mode (bool): If True, prompts for fallback on grid failure.
+
+    Returns:
+        y_pred: predicted labels for test set.
+        best_model: The best trained MLPClassifier model (either from GridSearchCV or simple fit).
+    """
+    # Base model for training, with a max_iter for convergence
+    mlp_model = MLPClassifier(random_state=random_state, max_iter=1000)
+
+    # A safe defined grid in case none is provided, ensuring the function can run without errors
+    default_grid = {
+        'hidden_layer_sizes': [(50,), (100,), (50, 50)],
+        'activation': ['relu', 'tanh'],
+        'solver': ['adam', 'sgd'],
+        'alpha': [0.0001, 0.001, 0.01]
+    }
+
+    if perform_tuning:
+        if param_grid is None:
+            print("   - Starting MLPClassifier training with DEFAULT PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = default_grid
+        else:
+            print("   - Starting MLPClassifier training with CUSTOM PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = param_grid
+
+        # Initialize GridSearchCV
+        grid_search = GridSearchCV(
+            estimator=mlp_model,
+            param_grid=target_grid,
+            cv=3,  # Using 3-fold cross-validation for speed
+            scoring='f1_weighted',
+            n_jobs=-1,
+            verbose=1
+        )
+
+        # Check if grid parameters are valid before fitting
+        try:
+            grid_search.fit(X_train, y_train)
+            
+        except ValueError as e:
+            # If a custom grid was passed and it failed...
+            if param_grid is not None:
+                print(f"\n[ERROR] Your custom hyperparameter grid failed: {e}")
+                
+                if interactive_mode:
+                    # The Beginner Path: Ask for permission to fall back
+                    user_choice = input("Would you like to fall back to the default parameter grid? (Y/N): ").strip().lower()
+                    
+                    if user_choice in ['y', 'yes']:
+                        print("   - Falling back to default parameters...")
+                        grid_search = GridSearchCV(
+                            estimator=mlp_model,
+                            param_grid=default_grid,
+                            cv=3,
+                            scoring='f1_weighted',
+                            n_jobs=-1,
+                            verbose=1
+                        )
+                        grid_search.fit(X_train, y_train)
+                    else:
+                        print("   - Aborting execution.")
+                        raise e 
+                else:
+                    # The Production Path: Fail fast
+                    print("   - Interactive mode is off. Aborting execution.")
+                    raise e
+            else:
+                # If the default grid itself failed (likely a data shape issue), crash it.
+                raise e
+
+        best_model = grid_search.best_estimator_
+        print("\n   - Best Hyperparameters found:")
+        print(grid_search.best_params_)
+        print(f"   - Best Cross-Validation Score (F1-weighted): {grid_search.best_score_:.4f}")
+    else:
+        print("   - Training MLPClassifier with default parameters (no hyperparameter tuning)...")
+        best_model = mlp_model # Use the base model directly
+        best_model.fit(X_train, y_train) # Fit it on X_train, y_train
+        print("   - Model trained with default parameters.")
+
+    y_pred = best_model.predict(X_test)
+    print("Best model parameters:", best_model.get_params())
+
+    return y_pred, best_model

quick_sentiments-0.5.2/quick_sentiments/ml_algo/rf.py

@@ -0,0 +1,114 @@
+# MLAlgo/random_forest_model.py
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import GridSearchCV
+from sklearn.metrics import classification_report
+import warnings
+import numpy as np
+
+def train_and_predict(
+    X_train, 
+    y_train, 
+    X_test, 
+    perform_tuning=False, 
+    param_grid=None,
+    interactive_mode=True,
+    random_state=42
+):
+    """
+    Trains RandomForestClassifier model (with optional hyperparameter tuning) and predicts on test data.
+
+    Args:
+        X_train: training features (e.g., NumPy array or sparse matrix).
+        y_train: training labels (list or NumPy array).
+        X_test: test features (e.g., NumPy array or sparse matrix).
+        perform_tuning (bool): If True, performs GridSearchCV. If False, trains
+                               the model with default parameters. Defaults to True.
+        param_grid (dict): Optional custom dictionary for GridSearchCV.
+        interactive_mode (bool): If True, prompts for fallback on grid failure.
+
+    Returns:
+        y_pred: predicted labels for test set.
+        best_model: The best trained RandomForestClassifier model (either from GridSearchCV or simple fit).
+    """
+    # Base model for training
+    rf_model = RandomForestClassifier(n_jobs=-1, random_state=random_state) 
+
+    # A safe defined grid in case none is provided, ensuring the function can run without errors
+    default_grid = {
+        'n_estimators': [100, 200, 300],
+        'max_depth': [10, 20, None],
+        'min_samples_split': [2, 5],
+        'min_samples_leaf': [1, 2],
+        'class_weight': [None, 'balanced']
+    }
+
+    if perform_tuning:
+        if param_grid is None:
+            print("   - Starting Random Forest training with DEFAULT PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = default_grid
+        else:
+            print("   - Starting Random Forest training with CUSTOM PARAMETER, GridSearchCV for hyperparameter tuning...")
+            target_grid = param_grid
+
+        grid_search = GridSearchCV(
+            estimator=rf_model,
+            param_grid=target_grid,
+            cv=5,
+            scoring='f1_weighted',
+            n_jobs=-1,
+            verbose=1
+        )
+
+        # Check if grid parameters are valid before fitting
+        try:
+            grid_search.fit(X_train, y_train)
+            
+        except ValueError as e:
+            # If a custom grid was passed and it failed...
+            if param_grid is not None:
+                print(f"\n[ERROR] Your custom hyperparameter grid failed: {e}")
+                
+                if interactive_mode:
+                    # The Beginner Path: Ask for permission to fall back
+                    user_choice = input("Would you like to fall back to the default parameter grid? (Y/N): ").strip().lower()
+                    
+                    if user_choice in ['y', 'yes']:
+                        print("   - Falling back to default parameters...")
+                        grid_search = GridSearchCV(
+                            estimator=rf_model,
+                            param_grid=default_grid,
+                            cv=5,
+                            scoring='f1_weighted',
+                            n_jobs=-1,
+                            verbose=1
+                        )
+                        grid_search.fit(X_train, y_train)
+                    else:
+                        print("   - Aborting execution.")
+                        raise e 
+                else:
+                    # The Production Path: Fail fast
+                    print("   - Interactive mode is off. Aborting execution.")
+                    raise e
+            else:
+                # If the default grid itself failed (likely a data shape issue), crash it.
+                raise e
+
+        best_model = grid_search.best_estimator_
+        print("\n   - Best Hyperparameters found:")
+        print(grid_search.best_params_)
+        print(f"   - Best Cross-Validation Score (F1-weighted): {grid_search.best_score_:.4f}")
+
+    else:
+        print("   - Training Random Forest with default parameters (no hyperparameter tuning)...")
+        best_model = rf_model # Use the base model directly
+        best_model.fit(X_train, y_train) # Fit it on X_train, y_train
+        print("   - Model trained with default parameters.")
+
+    # Make predictions on the test set using the best model (tuned or default)
+    y_pred = best_model.predict(X_test)
+    print("Best model parameters:", best_model.get_params())
+
+    # Return both the predictions and the best model object
+    return y_pred, best_model