Ml_Model_for_Binary.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vuou6RrWUVxs",
        "outputId": "c859028f-39fa-489d-fb69-b2cdb379db57"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Training RF classifier...\n",
            "\n",
            "Training SVM classifier...\n",
            "\n",
            "Training LR classifier...\n",
            "\n",
            "RF Classifier Results:\n",
            "Accuracy: 0.6400\n",
            "\n",
            "Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "       False       0.85      0.67      0.75       120\n",
            "        True       0.29      0.53      0.37        30\n",
            "\n",
            "    accuracy                           0.64       150\n",
            "   macro avg       0.57      0.60      0.56       150\n",
            "weighted avg       0.74      0.64      0.67       150\n",
            "\n",
            "\n",
            "SVM Classifier Results:\n",
            "Accuracy: 0.7467\n",
            "\n",
            "Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "       False       0.85      0.82      0.84       120\n",
            "        True       0.38      0.43      0.41        30\n",
            "\n",
            "    accuracy                           0.75       150\n",
            "   macro avg       0.62      0.63      0.62       150\n",
            "weighted avg       0.76      0.75      0.75       150\n",
            "\n",
            "\n",
            "LR Classifier Results:\n",
            "Accuracy: 0.6733\n",
            "\n",
            "Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "       False       0.87      0.70      0.77       120\n",
            "        True       0.32      0.57      0.41        30\n",
            "\n",
            "    accuracy                           0.67       150\n",
            "   macro avg       0.59      0.63      0.59       150\n",
            "weighted avg       0.76      0.67      0.70       150\n",
            "\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split, cross_val_score\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.metrics import classification_report, accuracy_score\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.utils import class_weight\n",
        "from typing import Tuple, Any, Dict\n",
        "\n",
        "class MultiAlgorithmClassifier:\n",
        "    def __init__(self, algorithm: str = 'rf', max_features: int = 1500):\n",
        "        \"\"\"\n",
        "        Initialize the classifier with choice of algorithm.\n",
        "\n",
        "        Args:\n",
        "            algorithm (str): 'rf' for Random Forest, 'svm' for Support Vector Machine,\n",
        "                           'lr' for Logistic Regression\n",
        "            max_features (int): Maximum features for TF-IDF\n",
        "        \"\"\"\n",
        "        self.algorithm = algorithm\n",
        "\n",
        "        # Configure the classifier based on algorithm choice\n",
        "        if algorithm == 'rf':\n",
        "            classifier = RandomForestClassifier(\n",
        "                n_estimators=200,\n",
        "                max_depth=20,\n",
        "                min_samples_split=5,\n",
        "                min_samples_leaf=2,\n",
        "                class_weight='balanced',\n",
        "                random_state=42,\n",
        "                n_jobs=-1  # Use all available cores\n",
        "            )\n",
        "        elif algorithm == 'svm':\n",
        "            classifier = SVC(\n",
        "                kernel='rbf',\n",
        "                C=10.0,\n",
        "                gamma='scale',\n",
        "                class_weight='balanced',\n",
        "                random_state=42,\n",
        "                probability=True\n",
        "            )\n",
        "        else:  # Default to logistic regression\n",
        "            classifier = LogisticRegression(\n",
        "                random_state=42,\n",
        "                max_iter=1000,\n",
        "                class_weight='balanced',\n",
        "                C=1.0,\n",
        "                solver='liblinear'\n",
        "            )\n",
        "\n",
        "        self.pipeline = Pipeline([\n",
        "            ('vectorizer', TfidfVectorizer(\n",
        "                max_features=max_features,\n",
        "                ngram_range=(1, 3),\n",
        "                stop_words='english',\n",
        "                min_df=2,\n",
        "                max_df=0.95\n",
        "            )),\n",
        "            ('classifier', classifier)\n",
        "        ])\n",
        "\n",
        "    def prepare_data(self, df: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:\n",
        "        \"\"\"Prepare the data for training/testing.\"\"\"\n",
        "        X = df['query'].str.lower().values\n",
        "        y = df['is_legal'].values\n",
        "        return X, y\n",
        "\n",
        "    def train_model(self, X_train: np.ndarray, y_train: np.ndarray) -> None:\n",
        "        \"\"\"Train the model.\"\"\"\n",
        "        self.pipeline.fit(X_train, y_train)\n",
        "\n",
        "    def predict(self, queries: list) -> Tuple[np.ndarray, np.ndarray]:\n",
        "        \"\"\"Make predictions with probability scores.\"\"\"\n",
        "        queries = [q.lower() for q in queries]\n",
        "        predictions = self.pipeline.predict(queries)\n",
        "        probabilities = self.pipeline.predict_proba(queries)\n",
        "        return predictions, probabilities\n",
        "\n",
        "def compare_algorithms(df: pd.DataFrame, test_size: float = 0.2) -> Dict:\n",
        "    \"\"\"\n",
        "    Compare different algorithms on the same data.\n",
        "\n",
        "    Args:\n",
        "        df (pd.DataFrame): Input DataFrame with queries and labels\n",
        "        test_size (float): Proportion of data for testing\n",
        "\n",
        "    Returns:\n",
        "        Dict: Performance metrics for each algorithm\n",
        "    \"\"\"\n",
        "    # Prepare data once\n",
        "    X = df['query'].str.lower().values\n",
        "    y = df['is_legal'].values\n",
        "\n",
        "    # Split data\n",
        "    X_train, X_test, y_train, y_test = train_test_split(\n",
        "        X, y, test_size=test_size, random_state=42, stratify=y\n",
        "    )\n",
        "\n",
        "    # Test each algorithm\n",
        "    algorithms = ['rf', 'svm', 'lr']\n",
        "    results = {}\n",
        "\n",
        "    for algo in algorithms:\n",
        "        print(f\"\\nTraining {algo.upper()} classifier...\")\n",
        "        classifier = MultiAlgorithmClassifier(algorithm=algo)\n",
        "        classifier.train_model(X_train, y_train)\n",
        "        predictions, probabilities = classifier.predict(X_test)\n",
        "\n",
        "        results[algo] = {\n",
        "            'accuracy': accuracy_score(y_test, predictions),\n",
        "            'classification_report': classification_report(y_test, predictions),\n",
        "            'classifier': classifier\n",
        "        }\n",
        "\n",
        "    return results\n",
        "\n",
        "# Example usage\n",
        "if __name__ == \"__main__\":\n",
        "    # Load your data\n",
        "    df = pd.read_csv('generated_legal_queries.csv')\n",
        "\n",
        "    # Compare algorithms\n",
        "    results = compare_algorithms(df)\n",
        "\n",
        "    # Print results\n",
        "    for algo, metrics in results.items():\n",
        "        print(f\"\\n{algo.upper()} Classifier Results:\")\n",
        "        print(f\"Accuracy: {metrics['accuracy']:.4f}\")\n",
        "        print(\"\\nClassification Report:\")\n",
        "        print(metrics['classification_report'])\n",
        ""
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "    example_queries = [\n",
        "        \"I just crashed my vehicle what is next legal procedure?\",\n",
        "        \"What's the best pizza in Chicago?\",\n",
        "        \"Can my landlord evict me without notice?\",\n",
        "        \"I want to eat Paneer kadhai for dinner\"\n",
        "    ]\n",
        "\n",
        "    # Use Random Forest for predictions (or choose the best performing model)\n",
        "    best_classifier = results['rf']['classifier']  # You can change this based on results\n",
        "    predictions, probabilities = best_classifier.predict(example_queries)\n",
        "\n",
        "    print(\"\\nPredictions using Random Forest:\")\n",
        "    for query, prediction, prob in zip(example_queries, predictions, probabilities):\n",
        "        confidence = prob[1] if prediction else prob[0]\n",
        "        print(f\"\\nQuery: {query}\")\n",
        "        print(f\"Is Legal: {prediction}\")\n",
        "        print(f\"Confidence: {confidence:.4f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QlaiUwJrUcyf",
        "outputId": "6e14f837-9960-4f51-c143-7b25163cca33"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Predictions using Random Forest:\n",
            "\n",
            "Query: I just crashed my vehicle what is next legal procedure?\n",
            "Is Legal: True\n",
            "Confidence: 0.5193\n",
            "\n",
            "Query: What's the best pizza in Chicago?\n",
            "Is Legal: False\n",
            "Confidence: 0.8766\n",
            "\n",
            "Query: Can my landlord evict me without notice?\n",
            "Is Legal: True\n",
            "Confidence: 0.5359\n",
            "\n",
            "Query: I want to eat Paneer kadhai for dinner\n",
            "Is Legal: False\n",
            "Confidence: 0.5856\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zDIzaQbhVVLg"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}