diff --git "a/pythonanalysis.ipynb" "b/pythonanalysis.ipynb" new file mode 100644--- /dev/null +++ "b/pythonanalysis.ipynb" @@ -0,0 +1,1152 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "kz8lLSv6mVQo" + }, + "source": [ + "# **NETFLIX SUCCESS ADVISOR - PYTHON ANALYSIS**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f48c8f8c", + "outputId": "4cc7d997-08be-4aac-b5f7-2f00efb1f464" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (2.2.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n", + "Requirement already satisfied: seaborn in /usr/local/lib/python3.12/dist-packages (0.13.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (2.0.2)\n", + "Requirement already satisfied: textblob in /usr/local/lib/python3.12/dist-packages (0.19.0)\n", + "Collecting faker\n", + " Downloading faker-40.12.0-py3-none-any.whl.metadata (16 kB)\n", + "Requirement already satisfied: transformers in /usr/local/lib/python3.12/dist-packages (5.0.0)\n", + "Collecting vaderSentiment\n", + " Downloading vaderSentiment-3.3.2-py2.py3-none-any.whl.metadata (572 bytes)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.0)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n", + "Requirement already satisfied: nltk>=3.9 in /usr/local/lib/python3.12/dist-packages (from textblob) (3.9.1)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from transformers) (3.25.2)\n", + "Requirement already satisfied: huggingface-hub<2.0,>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (1.7.1)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.12/dist-packages (from transformers) (6.0.3)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.12/dist-packages (from transformers) (2025.11.3)\n", + "Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (0.22.2)\n", + "Requirement already satisfied: typer-slim in /usr/local/lib/python3.12/dist-packages (from transformers) (0.24.0)\n", + "Requirement already satisfied: safetensors>=0.4.3 in /usr/local/lib/python3.12/dist-packages (from transformers) (0.7.0)\n", + "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.12/dist-packages (from transformers) (4.67.3)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from vaderSentiment) (2.32.4)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (2025.3.0)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.4.2 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (1.4.2)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.28.1)\n", + "Requirement already satisfied: typer in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.24.1)\n", + "Requirement already satisfied: typing-extensions>=4.1.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (4.15.0)\n", + "Requirement already satisfied: click in /usr/local/lib/python3.12/dist-packages (from nltk>=3.9->textblob) (8.3.1)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.12/dist-packages (from nltk>=3.9->textblob) (1.5.3)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (3.4.6)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (2026.2.25)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (4.12.1)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (1.0.9)\n", + "Requirement already satisfied: h11>=0.16 in /usr/local/lib/python3.12/dist-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (0.16.0)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (1.5.4)\n", + "Requirement already satisfied: rich>=12.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (13.9.4)\n", + "Requirement already satisfied: annotated-doc>=0.0.2 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (0.0.4)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (2.19.2)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (0.1.2)\n", + "Downloading faker-40.12.0-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m19.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading vaderSentiment-3.3.2-py2.py3-none-any.whl (125 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m126.0/126.0 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: faker, vaderSentiment\n", + "Successfully installed faker-40.12.0 vaderSentiment-3.3.2\n" + ] + } + ], + "source": [ + "!pip install pandas matplotlib seaborn numpy textblob faker transformers vaderSentiment\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 1. Install and import packages\n", + "# ============================================================\n", + "!pip install pandas matplotlib numpy vaderSentiment scikit-learn statsmodels\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "import warnings\n", + "\n", + "from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.metrics import classification_report, accuracy_score, confusion_matrix\n", + "import statsmodels.api as sm\n", + "from itertools import product" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p-75OmA2LZth", + "outputId": "8001fb48-6683-4dfd-bf57-43f4afd6cdf3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (2.2.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (2.0.2)\n", + "Requirement already satisfied: vaderSentiment in /usr/local/lib/python3.12/dist-packages (3.3.2)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n", + "Requirement already satisfied: statsmodels in /usr/local/lib/python3.12/dist-packages (0.14.6)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.0)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from vaderSentiment) (2.32.4)\n", + "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.3)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (3.6.0)\n", + "Requirement already satisfied: patsy>=0.5.6 in /usr/local/lib/python3.12/dist-packages (from statsmodels) (1.0.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (3.4.6)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->vaderSentiment) (2026.2.25)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 2. Load your Netflix datasets\n", + "# ============================================================\n", + "df_reviews = pd.read_csv(\"synthetic_netflix_reviews.csv\", encoding=\"latin1\", engine=\"python\")\n", + "df_views = pd.read_csv(\"synthetic_views_data.csv\", encoding=\"latin1\", engine=\"python\")\n", + "df_final = pd.read_csv(\"netflix_title_level_features.csv\", encoding=\"latin1\", engine=\"python\")\n", + "df_monthly_views = pd.read_csv(\"netflix_monthly_views_series.csv\", encoding=\"latin1\", engine=\"python\")\n", + "\n", + "print(df_reviews.head())\n", + "print(df_views.head())\n", + "print(df_final.head())\n", + "print(df_monthly_views.head())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6FwZ79B4LhWU", + "outputId": "89f7724c-6205-47b8-d5ec-1c9ce42a1cd5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " title sentiment_label \\\n", + "0 Dick Johnson Is Dead negative \n", + "1 Dick Johnson Is Dead negative \n", + "2 Dick Johnson Is Dead negative \n", + "3 Dick Johnson Is Dead negative \n", + "4 Dick Johnson Is Dead negative \n", + "\n", + " review_text engagement_score \\\n", + "0 It started badly and never improved. 32.086519 \n", + "1 It started badly and never improved. 32.086519 \n", + "2 I wouldn’t recommend it. 32.086519 \n", + "3 I really struggled to get through this show. 32.086519 \n", + "4 Very forgettable and frustrating to watch. 32.086519 \n", + "\n", + " success_label \n", + "0 Low \n", + "1 Low \n", + "2 Low \n", + "3 Low \n", + "4 Low \n", + " title month views sentiment_label\n", + "0 Dick Johnson Is Dead 2025-04 498641 negative\n", + "1 Dick Johnson Is Dead 2025-05 251696 negative\n", + "2 Dick Johnson Is Dead 2025-06 595248 negative\n", + "3 Dick Johnson Is Dead 2025-07 252778 negative\n", + "4 Dick Johnson Is Dead 2025-08 220674 negative\n", + " title type release_year rating \\\n", + "0 Dick Johnson Is Dead Movie 2020 PG-13 \n", + "1 Blood & Water TV Show 2021 TV-MA \n", + "2 Ganglands TV Show 2021 TV-MA \n", + "3 Jailbirds New Orleans TV Show 2021 TV-MA \n", + "4 Kota Factory TV Show 2021 TV-MA \n", + "\n", + " genre \\\n", + "0 Documentaries \n", + "1 International TV Shows, TV Dramas, TV Mysteries \n", + "2 Crime TV Shows, International TV Shows, TV Act... \n", + "3 Docuseries, Reality TV \n", + "4 International TV Shows, Romantic TV Shows, TV ... \n", + "\n", + " description completion_rate \\\n", + "0 As her father nears the end of his life, filmm... 0.388067 \n", + "1 After crossing paths at a party, a Cape Town t... 0.877104 \n", + "2 To protect his family from a powerful drug lor... 0.906194 \n", + "3 Feuds, flirtations and toilet talk go down amo... 0.589619 \n", + "4 In a city of coaching centers known to train I... 0.552353 \n", + "\n", + " engagement_score sentiment_label success_label avg_views total_views \\\n", + "0 32.086519 negative Low 3.987008e+05 4784409 \n", + "1 90.903477 positive High 2.618546e+06 31422548 \n", + "2 90.602326 positive High 3.264182e+06 39170190 \n", + "3 28.480085 negative Low 4.310197e+05 5172236 \n", + "4 41.599908 negative Low 2.366609e+05 2839931 \n", + "\n", + " months_observed share_positive share_neutral share_negative \\\n", + "0 12 0.0 0.0 1.0 \n", + "1 12 1.0 0.0 0.0 \n", + "2 12 1.0 0.0 0.0 \n", + "3 12 0.0 0.0 1.0 \n", + "4 12 0.0 0.0 1.0 \n", + "\n", + " total_reviews \n", + "0 10 \n", + "1 10 \n", + "2 10 \n", + "3 10 \n", + "4 10 \n", + " month total_views\n", + "0 2025-04 9150846813\n", + "1 2025-05 9250124447\n", + "2 2025-06 9315787407\n", + "3 2025-07 9421684591\n", + "4 2025-08 9515594070\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 3. Quality check function\n", + "# ============================================================\n", + "def quality_check(df, name=\"DataFrame\"):\n", + " print(f\"\\nQuality Check Report for: {name}\")\n", + " print(\"=\" * (25 + len(name)))\n", + " print(f\"\\nShape: {df.shape}\")\n", + " print(\"\\nColumn Types:\")\n", + " print(df.dtypes)\n", + " print(\"\\nMissing Values:\")\n", + " print(df.isnull().sum())\n", + " print(\"\\nDuplicate Rows:\", df.duplicated().sum())\n", + " print(\"\\nSummary Statistics:\")\n", + " print(df.describe(include='all').transpose())\n", + " print(\"\\nSample Rows:\")\n", + " print(df.sample(min(5, len(df))))\n", + "\n", + "quality_check(df_reviews, \"df_reviews\")\n", + "quality_check(df_views, \"df_views\")\n", + "quality_check(df_final, \"df_final\")\n", + "quality_check(df_monthly_views, \"df_monthly_views\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "N_o_VljyL2qH", + "outputId": "8488c482-bf2c-4092-c9f6-08dd1ceb5c77" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Quality Check Report for: df_reviews\n", + "===================================\n", + "\n", + "Shape: (88030, 5)\n", + "\n", + "Column Types:\n", + "title object\n", + "sentiment_label object\n", + "review_text object\n", + "engagement_score float64\n", + "success_label object\n", + "dtype: object\n", + "\n", + "Missing Values:\n", + "title 0\n", + "sentiment_label 0\n", + "review_text 0\n", + "engagement_score 0\n", + "success_label 0\n", + "dtype: int64\n", + "\n", + "Duplicate Rows: 17312\n", + "\n", + "Summary Statistics:\n", + " count unique top freq \\\n", + "title 88030 8803 Zubaan 10 \n", + "sentiment_label 88030 3 negative 33760 \n", + "review_text 88030 60 A dull and poorly executed series. 1739 \n", + "engagement_score 88030.0 NaN NaN NaN \n", + "success_label 88030 3 Low 40320 \n", + "\n", + " mean std min 25% 50% \\\n", + "title NaN NaN NaN NaN NaN \n", + "sentiment_label NaN NaN NaN NaN NaN \n", + "review_text NaN NaN NaN NaN NaN \n", + "engagement_score 62.412513 20.737318 4.28599 46.31916 62.610689 \n", + "success_label NaN NaN NaN NaN NaN \n", + "\n", + " 75% max \n", + "title NaN NaN \n", + "sentiment_label NaN NaN \n", + "review_text NaN NaN \n", + "engagement_score 78.980908 100.0 \n", + "success_label NaN NaN \n", + "\n", + "Sample Rows:\n", + " title sentiment_label \\\n", + "28028 Caliphate negative \n", + "41096 The 43 negative \n", + "9002 Money, Explained negative \n", + "72506 La Bamba positive \n", + "69997 Hostages positive \n", + "\n", + " review_text engagement_score \\\n", + "28028 The story was messy and hard to care about. 35.581836 \n", + "41096 I really struggled to get through this show. 39.565880 \n", + "9002 Too long, too repetitive, and not rewarding. 24.136665 \n", + "72506 Smart, entertaining, and emotionally powerful. 78.253439 \n", + "69997 One of the best series I've watched this year. 80.274419 \n", + "\n", + " success_label \n", + "28028 Low \n", + "41096 Low \n", + "9002 Low \n", + "72506 Medium \n", + "69997 High \n", + "\n", + "Quality Check Report for: df_views\n", + "=================================\n", + "\n", + "Shape: (105636, 4)\n", + "\n", + "Column Types:\n", + "title object\n", + "month object\n", + "views int64\n", + "sentiment_label object\n", + "dtype: object\n", + "\n", + "Missing Values:\n", + "title 0\n", + "month 0\n", + "views 0\n", + "sentiment_label 0\n", + "dtype: int64\n", + "\n", + "Duplicate Rows: 0\n", + "\n", + "Summary Statistics:\n", + " count unique top freq mean \\\n", + "title 105636 8803 Zubaan 12 NaN \n", + "month 105636 12 2025-04 8803 NaN \n", + "views 105636.0 NaN NaN NaN 1096755.995238 \n", + "sentiment_label 105636 3 negative 40512 NaN \n", + "\n", + " std min 25% 50% 75% max \n", + "title NaN NaN NaN NaN NaN NaN \n", + "month NaN NaN NaN NaN NaN NaN \n", + "views 922974.054937 0.0 317233.75 882304.5 1660379.0 4144161.0 \n", + "sentiment_label NaN NaN NaN NaN NaN NaN \n", + "\n", + "Sample Rows:\n", + " title month views sentiment_label\n", + "67703 Under the Shadow 2026-03 304104 negative\n", + "99179 The Darkest Dawn 2026-03 1071327 neutral\n", + "31666 الف مبروك 2026-02 1560964 neutral\n", + "54294 Tales From the Hood 2 2025-10 428300 negative\n", + "66631 Toro 2025-11 3076171 positive\n", + "\n", + "Quality Check Report for: df_final\n", + "=================================\n", + "\n", + "Shape: (8803, 17)\n", + "\n", + "Column Types:\n", + "title object\n", + "type object\n", + "release_year int64\n", + "rating object\n", + "genre object\n", + "description object\n", + "completion_rate float64\n", + "engagement_score float64\n", + "sentiment_label object\n", + "success_label object\n", + "avg_views float64\n", + "total_views int64\n", + "months_observed int64\n", + "share_positive float64\n", + "share_neutral float64\n", + "share_negative float64\n", + "total_reviews int64\n", + "dtype: object\n", + "\n", + "Missing Values:\n", + "title 0\n", + "type 0\n", + "release_year 0\n", + "rating 0\n", + "genre 0\n", + "description 0\n", + "completion_rate 0\n", + "engagement_score 0\n", + "sentiment_label 0\n", + "success_label 0\n", + "avg_views 0\n", + "total_views 0\n", + "months_observed 0\n", + "share_positive 0\n", + "share_neutral 0\n", + "share_negative 0\n", + "total_reviews 0\n", + "dtype: int64\n", + "\n", + "Duplicate Rows: 0\n", + "\n", + "Summary Statistics:\n", + " count unique \\\n", + "title 8803 8803 \n", + "type 8803 2 \n", + "release_year 8803.0 NaN \n", + "rating 8803 17 \n", + "genre 8803 514 \n", + "description 8803 8771 \n", + "completion_rate 8803.0 NaN \n", + "engagement_score 8803.0 NaN \n", + "sentiment_label 8803 3 \n", + "success_label 8803 3 \n", + "avg_views 8803.0 NaN \n", + "total_views 8803.0 NaN \n", + "months_observed 8803.0 NaN \n", + "share_positive 8803.0 NaN \n", + "share_neutral 8803.0 NaN \n", + "share_negative 8803.0 NaN \n", + "total_reviews 8803.0 NaN \n", + "\n", + " top freq \\\n", + "title Zubaan 1 \n", + "type Movie 6129 \n", + "release_year NaN NaN \n", + "rating TV-MA 3207 \n", + "genre Dramas, International Movies 362 \n", + "description Paranormal activity at a lush, abandoned prope... 4 \n", + "completion_rate NaN NaN \n", + "engagement_score NaN NaN \n", + "sentiment_label negative 3376 \n", + "success_label Low 4032 \n", + "avg_views NaN NaN \n", + "total_views NaN NaN \n", + "months_observed NaN NaN \n", + "share_positive NaN NaN \n", + "share_neutral NaN NaN \n", + "share_negative NaN NaN \n", + "total_reviews NaN NaN \n", + "\n", + " mean std min 25% \\\n", + "title NaN NaN NaN NaN \n", + "type NaN NaN NaN NaN \n", + "release_year 2014.179825 8.821247 1925.0 2013.0 \n", + "rating NaN NaN NaN NaN \n", + "genre NaN NaN NaN NaN \n", + "description NaN NaN NaN NaN \n", + "completion_rate 0.626782 0.18585 0.300196 0.467819 \n", + "engagement_score 62.412513 20.738378 4.28599 46.319684 \n", + "sentiment_label NaN NaN NaN NaN \n", + "success_label NaN NaN NaN NaN \n", + "avg_views 1096755.995238 899815.863604 4401.666667 299669.583333 \n", + "total_views 13161071.94286 10797790.363247 52820.0 3596035.0 \n", + "months_observed 12.0 0.0 12.0 12.0 \n", + "share_positive 0.309213 0.462195 0.0 0.0 \n", + "share_neutral 0.307282 0.461393 0.0 0.0 \n", + "share_negative 0.383506 0.486267 0.0 0.0 \n", + "total_reviews 10.0 0.0 10.0 10.0 \n", + "\n", + " 50% 75% max \n", + "title NaN NaN NaN \n", + "type NaN NaN NaN \n", + "release_year 2017.0 2019.0 2021.0 \n", + "rating NaN NaN NaN \n", + "genre NaN NaN NaN \n", + "description NaN NaN NaN \n", + "completion_rate 0.627822 0.785909 0.949864 \n", + "engagement_score 62.610689 78.972411 100.0 \n", + "sentiment_label NaN NaN NaN \n", + "success_label NaN NaN NaN \n", + "avg_views 893905.666667 1618566.916667 3427059.5 \n", + "total_views 10726868.0 19422803.0 41124714.0 \n", + "months_observed 12.0 12.0 12.0 \n", + "share_positive 0.0 1.0 1.0 \n", + "share_neutral 0.0 1.0 1.0 \n", + "share_negative 0.0 1.0 1.0 \n", + "total_reviews 10.0 10.0 10.0 \n", + "\n", + "Sample Rows:\n", + " title type release_year rating \\\n", + "7732 Phir Se Movie 2015 TV-14 \n", + "8745 Winter Sun TV Show 2014 TV-MA \n", + "4004 Edoardo Ferrario: Temi Caldi Movie 2019 TV-MA \n", + "7232 Krisha Movie 2015 R \n", + "8801 Zoom Movie 2006 PG \n", + "\n", + " genre \\\n", + "7732 International Movies, Romantic Movies \n", + "8745 International TV Shows, TV Dramas, TV Thrillers \n", + "4004 Stand-Up Comedy \n", + "7232 Dramas, Independent Movies \n", + "8801 Children & Family Movies, Comedies \n", + "\n", + " description completion_rate \\\n", + "7732 The paths of a man and a woman, who have both ... 0.891966 \n", + "8745 Years after ruthless businessmen kill his fath... 0.695565 \n", + "4004 Italian comedian Edoardo Ferrario riffs on lif... 0.789110 \n", + "7232 After 10 years away from her family, Krisha re... 0.693808 \n", + "8801 Dragged from civilian life, a former superhero... 0.574008 \n", + "\n", + " engagement_score sentiment_label success_label avg_views \\\n", + "7732 79.723122 positive Medium 2.200100e+06 \n", + "8745 56.979441 neutral Low 1.371443e+06 \n", + "4004 88.006661 positive High 1.829376e+06 \n", + "7232 72.097354 neutral Medium 6.174418e+05 \n", + "8801 55.590278 neutral Low 8.804484e+05 \n", + "\n", + " total_views months_observed share_positive share_neutral \\\n", + "7732 26401200 12 1.0 0.0 \n", + "8745 16457317 12 0.0 1.0 \n", + "4004 21952510 12 1.0 0.0 \n", + "7232 7409302 12 0.0 1.0 \n", + "8801 10565381 12 0.0 1.0 \n", + "\n", + " share_negative total_reviews \n", + "7732 0.0 10 \n", + "8745 0.0 10 \n", + "4004 0.0 10 \n", + "7232 0.0 10 \n", + "8801 0.0 10 \n", + "\n", + "Quality Check Report for: df_monthly_views\n", + "=========================================\n", + "\n", + "Shape: (12, 2)\n", + "\n", + "Column Types:\n", + "month object\n", + "total_views int64\n", + "dtype: object\n", + "\n", + "Missing Values:\n", + "month 0\n", + "total_views 0\n", + "dtype: int64\n", + "\n", + "Duplicate Rows: 0\n", + "\n", + "Summary Statistics:\n", + " count unique top freq mean std \\\n", + "month 12 12 2025-04 1 NaN NaN \n", + "total_views 12.0 NaN NaN NaN 9654743026.083334 331152717.4108 \n", + "\n", + " min 25% 50% 75% \\\n", + "month NaN NaN NaN NaN \n", + "total_views 9150846813.0 9395210295.0 9668642394.0 9916891009.25 \n", + "\n", + " max \n", + "month NaN \n", + "total_views 10184138280.0 \n", + "\n", + "Sample Rows:\n", + " month total_views\n", + "2 2025-06 9315787407\n", + "0 2025-04 9150846813\n", + "1 2025-05 9250124447\n", + "8 2025-12 9901737522\n", + "6 2025-10 9701153171\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 4. Sentiment analysis using VADER\n", + "# ============================================================\n", + "analyzer = SentimentIntensityAnalyzer()\n", + "\n", + "def get_sentiment_label(text):\n", + " score = analyzer.polarity_scores(text)[\"compound\"]\n", + " if score >= 0.05:\n", + " return \"positive\"\n", + " elif score <= -0.05:\n", + " return \"negative\"\n", + " else:\n", + " return \"neutral\"\n", + "\n", + "df_reviews[\"predicted_sentiment\"] = df_reviews[\"review_text\"].apply(get_sentiment_label)\n", + "\n", + "print(df_reviews[[\"review_text\", \"sentiment_label\", \"predicted_sentiment\"]].head())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t1vXq3ZzL8UF", + "outputId": "7f8b5657-2ce5-4858-91f6-aec0c76d51e5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " review_text sentiment_label \\\n", + "0 It started badly and never improved. negative \n", + "1 It started badly and never improved. negative \n", + "2 I wouldn’t recommend it. negative \n", + "3 I really struggled to get through this show. negative \n", + "4 Very forgettable and frustrating to watch. negative \n", + "\n", + " predicted_sentiment \n", + "0 negative \n", + "1 negative \n", + "2 positive \n", + "3 negative \n", + "4 negative \n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 5. Visualize sentiment distribution\n", + "# ============================================================\n", + "sentiment_counts = df_reviews[\"predicted_sentiment\"].value_counts()\n", + "\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(sentiment_counts.index, sentiment_counts.values)\n", + "plt.title(\"Sentiment Distribution of Synthetic Netflix Reviews\")\n", + "plt.xlabel(\"Sentiment\")\n", + "plt.ylabel(\"Number of Reviews\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "jgCqaIHmMAxK", + "outputId": "37ce3a3c-df53-4032-ca36-02ed715517cf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 6. Visualize monthly views over time\n", + "# ============================================================\n", + "df_monthly_views[\"month\"] = pd.to_datetime(df_monthly_views[\"month\"])\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(df_monthly_views[\"month\"], df_monthly_views[\"total_views\"], marker=\"o\")\n", + "plt.title(\"Total Netflix Monthly Views Over Time\")\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"Total Views\")\n", + "plt.xticks(rotation=45)\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 543 + }, + "id": "7ODByMeZMFgt", + "outputId": "bfd5cac7-8ec4-4d13-c32b-864f509e2cef" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/tmp/ipykernel_1847/3856895425.py:4: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df_monthly_views[\"month\"] = pd.to_datetime(df_monthly_views[\"month\"])\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 7. Prepare data for Random Forest classification\n", + "# ============================================================\n", + "df_model = df_final[[\n", + " \"type\",\n", + " \"release_year\",\n", + " \"rating\",\n", + " \"completion_rate\",\n", + " \"engagement_score\",\n", + " \"avg_views\",\n", + " \"total_views\",\n", + " \"share_positive\",\n", + " \"share_neutral\",\n", + " \"share_negative\",\n", + " \"total_reviews\",\n", + " \"success_label\"\n", + "]].copy()\n", + "\n", + "df_model = df_model.dropna()\n", + "\n", + "le_type = LabelEncoder()\n", + "le_rating = LabelEncoder()\n", + "le_target = LabelEncoder()\n", + "\n", + "df_model[\"type\"] = le_type.fit_transform(df_model[\"type\"])\n", + "df_model[\"rating\"] = le_rating.fit_transform(df_model[\"rating\"])\n", + "df_model[\"success_label\"] = le_target.fit_transform(df_model[\"success_label\"])\n", + "\n", + "print(df_model.head())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Sa__mBywMKIM", + "outputId": "85fbc497-c7e3-4bc0-fea7-78f57b3775a7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " type release_year rating completion_rate engagement_score \\\n", + "0 0 2020 7 0.388067 32.086519 \n", + "1 1 2021 11 0.877104 90.903477 \n", + "2 1 2021 11 0.906194 90.602326 \n", + "3 1 2021 11 0.589619 28.480085 \n", + "4 1 2021 11 0.552353 41.599908 \n", + "\n", + " avg_views total_views share_positive share_neutral share_negative \\\n", + "0 3.987008e+05 4784409 0.0 0.0 1.0 \n", + "1 2.618546e+06 31422548 1.0 0.0 0.0 \n", + "2 3.264182e+06 39170190 1.0 0.0 0.0 \n", + "3 4.310197e+05 5172236 0.0 0.0 1.0 \n", + "4 2.366609e+05 2839931 0.0 0.0 1.0 \n", + "\n", + " total_reviews success_label \n", + "0 10 1 \n", + "1 10 0 \n", + "2 10 0 \n", + "3 10 1 \n", + "4 10 1 \n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 8. Define X and y, then split train/test\n", + "# ============================================================\n", + "X = df_model.drop([\"success_label\", \"engagement_score\"], axis=1)\n", + "y = df_model[\"success_label\"]\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42\n", + ")\n", + "\n", + "print(\"Training rows:\", len(X_train))\n", + "print(\"Testing rows:\", len(X_test))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "U-_r1koUMZcE", + "outputId": "0e03ffc3-1a64-4740-8a25-a5a3a2c759ce" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training rows: 7042\n", + "Testing rows: 1761\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 9. Train Random Forest model\n", + "# ============================================================\n", + "rf_model = RandomForestClassifier(\n", + " n_estimators=100,\n", + " random_state=42\n", + ")\n", + "\n", + "rf_model.fit(X_train, y_train)\n", + "\n", + "y_pred = rf_model.predict(X_test)\n", + "\n", + "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n", + "print(\"\\nClassification Report:\\n\")\n", + "print(classification_report(y_test, y_pred))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Jk_QB-USMcuE", + "outputId": "4384acf2-01b8-472a-8a7d-799be4532976" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Accuracy: 0.8375922771152754\n", + "\n", + "Classification Report:\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.79 0.92 0.85 408\n", + " 1 0.94 0.86 0.90 797\n", + " 2 0.74 0.74 0.74 556\n", + "\n", + " accuracy 0.84 1761\n", + " macro avg 0.82 0.84 0.83 1761\n", + "weighted avg 0.84 0.84 0.84 1761\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 10. Feature importance\n", + "# ============================================================\n", + "importances = pd.DataFrame({\n", + " \"feature\": X.columns,\n", + " \"importance\": rf_model.feature_importances_\n", + "}).sort_values(by=\"importance\", ascending=False)\n", + "\n", + "print(importances)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.barh(importances[\"feature\"], importances[\"importance\"])\n", + "plt.gca().invert_yaxis()\n", + "plt.title(\"Random Forest Feature Importance\")\n", + "plt.xlabel(\"Importance\")\n", + "plt.ylabel(\"Feature\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 760 + }, + "id": "MYe0urvbMjGb", + "outputId": "e1fde1a4-1785-4b9d-b070-b017b123899f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " feature importance\n", + "4 avg_views 0.226906\n", + "5 total_views 0.174361\n", + "3 completion_rate 0.172466\n", + "8 share_negative 0.163747\n", + "6 share_positive 0.107694\n", + "7 share_neutral 0.077254\n", + "1 release_year 0.043744\n", + "2 rating 0.027949\n", + "0 type 0.005881\n", + "9 total_reviews 0.000000\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 11. ARIMA forecasting on total monthly views\n", + "# ============================================================\n", + "def find_best_arima(series, p_range=(0, 3), d_range=(0, 2), q_range=(0, 2)):\n", + " best_aic = float(\"inf\")\n", + " best_order = None\n", + " best_model = None\n", + "\n", + " for p, d, q in product(\n", + " range(p_range[0], p_range[1] + 1),\n", + " range(d_range[0], d_range[1] + 1),\n", + " range(q_range[0], q_range[1] + 1)\n", + " ):\n", + " try:\n", + " model = sm.tsa.ARIMA(series, order=(p, d, q))\n", + " results = model.fit()\n", + " if results.aic < best_aic:\n", + " best_aic = results.aic\n", + " best_order = (p, d, q)\n", + " best_model = results\n", + " except:\n", + " continue\n", + "\n", + " return best_order, best_model\n", + "\n", + "series = df_monthly_views[\"total_views\"]\n", + "\n", + "with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\")\n", + " best_order, best_model = find_best_arima(series)\n", + "\n", + "print(\"Best ARIMA order:\", best_order)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7ney6ywmMnhX", + "outputId": "db18e999-223b-4236-f2dd-5c2a4b1994c4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Best ARIMA order: (0, 2, 0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 12. Forecast future monthly views\n", + "# ============================================================\n", + "forecast = best_model.get_forecast(steps=6)\n", + "forecast_values = forecast.predicted_mean\n", + "\n", + "last_month = df_monthly_views[\"month\"].max()\n", + "forecast_index = pd.date_range(start=last_month + pd.DateOffset(months=1), periods=6, freq=\"MS\")\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(df_monthly_views[\"month\"], df_monthly_views[\"total_views\"], label=\"Observed\")\n", + "plt.plot(forecast_index, forecast_values, linestyle=\"--\", label=\"Forecast\")\n", + "plt.title(\"ARIMA Forecast of Netflix Monthly Views\")\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"Total Views\")\n", + "plt.xticks(rotation=45)\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 488 + }, + "id": "v0emM5uQMvxo", + "outputId": "593af635-47ec-4ef9-b350-2db76041060a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ============================================================\n", + "# 13. Rule-based business recommendation\n", + "# ============================================================\n", + "def content_decision(row):\n", + " if row[\"avg_views\"] >= 1500000 and row[\"share_positive\"] >= 0.6:\n", + " return \"Promote / Invest More\"\n", + " elif row[\"avg_views\"] <= 500000 and row[\"share_negative\"] >= 0.4:\n", + " return \"Reduce Investment\"\n", + " else:\n", + " return \"Maintain\"\n", + "\n", + "df_decision = df_final[[\"title\", \"avg_views\", \"share_positive\", \"share_negative\"]].copy()\n", + "df_decision[\"content_action\"] = df_decision.apply(content_decision, axis=1)\n", + "\n", + "print(df_decision.head(10))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uNJPgfAVM1hl", + "outputId": "20914363-782f-4875-f13a-365ae64b7638" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " title avg_views share_positive \\\n", + "0 Dick Johnson Is Dead 3.987008e+05 0.0 \n", + "1 Blood & Water 2.618546e+06 1.0 \n", + "2 Ganglands 3.264182e+06 1.0 \n", + "3 Jailbirds New Orleans 4.310197e+05 0.0 \n", + "4 Kota Factory 2.366609e+05 0.0 \n", + "5 Midnight Mass 3.776080e+05 0.0 \n", + "6 My Little Pony: A New Generation 6.370002e+05 0.0 \n", + "7 Sankofa 8.098868e+05 0.0 \n", + "8 The Great British Baking Show 2.086155e+06 1.0 \n", + "9 The Starling 1.331037e+06 1.0 \n", + "\n", + " share_negative content_action \n", + "0 1.0 Reduce Investment \n", + "1 0.0 Promote / Invest More \n", + "2 0.0 Promote / Invest More \n", + "3 1.0 Reduce Investment \n", + "4 1.0 Reduce Investment \n", + "5 1.0 Reduce Investment \n", + "6 0.0 Maintain \n", + "7 0.0 Maintain \n", + "8 0.0 Promote / Invest More \n", + "9 0.0 Maintain \n" + ] + } + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "jpASMyIQMaAq", + "NZd99NpKkKyp", + "TTxUKDYINPxV", + "Qy3Hqm-FojvT", + "rmgylC1ENCHy", + "SKBcx3fyCFly", + "WTkP2_-EApev" + ], + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file