4_Chinook_Bivariate_Analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dBalag/Chinook/blob/main/4_Chinook_Bivariate_Analysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Bivariate Analytical Techniques**.\n",
        "Involves the analysis of two variables to understand the relationship between them."
      ],
      "metadata": {
        "id": "YAIOENYd866t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Correlation Analysis:\n",
        "This technique helps you understand the linear relationship between two numerical variables x example: quantity x unit price from Invoice_line dataset and bytes x unit_price from Track dataset.\n"
      ],
      "metadata": {
        "id": "rzibKzlj9lDh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the files\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Load datasets\n",
        "media_type = pd.read_csv('media_type.csv')\n",
        "playlist = pd.read_csv('playlist.csv')\n",
        "playlist_track = pd.read_csv('playlist_track.csv')\n",
        "album = pd.read_csv('album.csv')\n",
        "artist = pd.read_csv('artist.csv')\n",
        "employee_cleaned = pd.read_csv('employee_cleaned.csv')\n",
        "invoice_cleaned = pd.read_csv('invoice_cleaned.csv')\n",
        "invoice_line = pd.read_csv('invoice_line.csv')\n",
        "track_cleaned = pd.read_csv('track_cleaned.csv')\n",
        "genre = pd.read_csv('genre.csv')\n",
        "customer_cleaned = pd.read_csv('customer_cleaned.csv')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 420
        },
        "id": "IO-NiEfiCCt8",
        "outputId": "96be9140-a14c-4ace-e6bc-d79b6703ce65"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-956ba829-d701-4dcd-b653-c796aff2c8ab\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-956ba829-d701-4dcd-b653-c796aff2c8ab\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving album.csv to album.csv\n",
            "Saving artist.csv to artist.csv\n",
            "Saving customer_cleaned.csv to customer_cleaned.csv\n",
            "Saving employee_cleaned.csv to employee_cleaned.csv\n",
            "Saving genre.csv to genre.csv\n",
            "Saving invoice_cleaned.csv to invoice_cleaned.csv\n",
            "Saving invoice_line.csv to invoice_line.csv\n",
            "Saving media_type.csv to media_type.csv\n",
            "Saving playlist.csv to playlist.csv\n",
            "Saving playlist_track.csv to playlist_track.csv\n",
            "Saving track_cleaned.csv to track_cleaned.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Correlation matrix of 'unit_price' vs 'quantity' from Invoice_line dataset"
      ],
      "metadata": {
        "id": "r9fd2bHaHjOc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate correlation matrix\n",
        "correlation_matrix = invoice_line[['unit_price', 'quantity']].corr()\n",
        "print(correlation_matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UvKuG4iWCTYz",
        "outputId": "f2b6ffa5-bf19-48aa-cb6c-c50b349d472a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "            unit_price  quantity\n",
            "unit_price         1.0       NaN\n",
            "quantity           NaN       NaN\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Diagonals (unit_price x unit_price & quantity x quantity) both should be 1.0 meaning that are correlated, but quantity column is not numerical, we need to convert it.\n"
      ],
      "metadata": {
        "id": "jRDYAeuSC1Eo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert column to numeric\n",
        "invoice_line['quantity'] = pd.to_numeric(invoice_line['quantity'], errors='coerce')\n",
        "invoice_line['unit_price'] = pd.to_numeric(invoice_line['unit_price'], errors='coerce')\n"
      ],
      "metadata": {
        "id": "WK6xq8SCFCYm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Recalculate the correlation between 'quantity' and 'unit_price'\n",
        "correlation = invoice_line[['quantity', 'unit_price']].corr()\n",
        "print(\"Correlation matrix between 'quantity' and 'unit_price':\")\n",
        "print(correlation)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TX6s5QtEFT8g",
        "outputId": "605d458c-a67b-4b69-d002-b2e68282d710"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Correlation matrix between 'quantity' and 'unit_price':\n",
            "            quantity  unit_price\n",
            "quantity         NaN         NaN\n",
            "unit_price       NaN         1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Hadn't been solved the issue. Let's check for unique values in 'quantity'\n",
        "print(\"\\nUnique values in 'quantity' column:\")\n",
        "print(invoice_line['quantity'].unique())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K4YbyN5sGFyX",
        "outputId": "94f4a29f-6359-479a-8fd9-1650e3428cad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Unique values in 'quantity' column:\n",
            "[1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Since the quantity column contains only a single unique value [1], it explains why the correlation calculation with unit_price returns NaN. Correlation requires variability in the data, and having a single unique value means there is no variability in the quantity column, making it impossible to compute a meaningful correlation.\n"
      ],
      "metadata": {
        "id": "RIsZl95fGupW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Correlation Matrix of 'bytes' and 'unit_price' from Tracks dataset."
      ],
      "metadata": {
        "id": "NMCkwA1nHyOh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the correlation\n",
        "correlation = track_cleaned[['bytes', 'unit_price']].corr()\n",
        "print(\"Correlation matrix between 'bytes' and 'unit_price':\")\n",
        "print(correlation)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rd6pyTBLG0rZ",
        "outputId": "b2927ec6-c64d-45bc-abd3-0f676dd58746"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Correlation matrix between 'bytes' and 'unit_price':\n",
            "               bytes  unit_price\n",
            "bytes       1.000000    0.938482\n",
            "unit_price  0.938482    1.000000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "*   Value Range: The Pearson correlation coefficient ranges from -1 to 1:\n",
        "\n",
        "      1 indicates a perfect positive correlation.\n",
        "\n",
        "      (-1) indicates a perfect negative correlation.\n",
        "\n",
        "      0 indicates no correlation.\n",
        "\n",
        "*   0.938482: This value is very close to 1, indicating a strong positive correlation between 'bytes' and 'unit_price'.\n",
        "\n",
        "    This means that as the number of bytes increases, the unit price also tends to increase. Conversely, if the bytes decrease, the unit price tends to decrease as well.\n"
      ],
      "metadata": {
        "id": "naQx_LB2HUld"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Assuming invoice_line_cleaned is the dataframe containing the data\n",
        "plt.figure(figsize=(10, 6))\n",
        "sns.scatterplot(x='bytes', y='unit_price', data=track_cleaned)\n",
        "plt.title('Scatter Plot of Bytes vs. Unit Price')\n",
        "plt.xlabel('Bytes')\n",
        "plt.ylabel('Unit Price')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "uJ3eFMPzJJ3w",
        "outputId": "e75e6c52-2988-4885-979b-c3430e825f05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This scatter plot helps us visually assess the strong positive correlation between 'bytes' and 'unit_price'."
      ],
      "metadata": {
        "id": "51scZLC6Joir"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Box Plot\n",
        "can be used to compare the distribution of a numerical variable across the categories of a categorical variable."
      ],
      "metadata": {
        "id": "5u_wOpi4Ju0I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Box plot of total invoice amount by country\n",
        "sns.boxplot(data=invoice_cleaned, x='billing_country', y='total')\n",
        "plt.title('Box Plot of Total Invoice Amount by Country')\n",
        "plt.xlabel('Country')\n",
        "plt.ylabel('Total Invoice Amount')\n",
        "plt.xticks(rotation=90)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 569
        },
        "id": "vPWHPzVyKNVX",
        "outputId": "3a11332b-8a41-4ff0-955e-6561fb359451"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "  1. Median (the line inside each box): This is the middle value of the invoice amounts for each country. If the line is closer to the top of the box, then the majority of the data is skewed towards higher invoice amounts, x example Finland.\n",
        "  If it’s closer to the bottom, it’s skewed towards lower amounts, x ex rest of the countries.\n",
        "\n",
        "  2.Interquartile Range (the box itself): This range contains the middle 50% of the invoice amounts for each country. A larger box means that the invoice amounts are more spread out, x example Chile; a smaller box means they’re more concentrated.\n",
        "\n",
        "  3.Whiskers (the lines extending from the box): These represent the range of the invoice amounts that fall within 1.5 times the IQR. If the whiskers are long, it means there is a large variability in invoice amounts, x ex. USA; short whiskers mean the amounts are more consistent, x ex. Norway.\n",
        "\n",
        "  4.Outliers (the points beyond the whiskers): These are invoice amounts that fall outside 1.5 times the IQR. They could indicate unusually high or low invoices compared to the rest, x ex. Czech Republic"
      ],
      "metadata": {
        "id": "FGD6JWA6KeyO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Bar Plot\n",
        "Bar plots can be used to compare the mean or sum of a numerical variable across categories of a categorical variable."
      ],
      "metadata": {
        "id": "lsk5V1fcMHKM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Merge datasets to get total invoice x customer country.\n",
        "merged_df = pd.merge(invoice_cleaned, customer_cleaned, on='customer_id')\n",
        "\n",
        "# Bar plot\n",
        "sns.barplot(data=merged_df, x='country', y=total', estimator=sum)\n",
        "plt.title('Total Invoice Amount by Country')\n",
        "plt.xlabel('Country')\n",
        "plt.ylabel('Total Invoice Amount')\n",
        "plt.xticks(rotation=90)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 569
        },
        "id": "oTAzWJ6uMTkg",
        "outputId": "6e76bf11-a9c7-4ab3-eaf8-b769b5c6d97e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Group By and Aggregate\n",
        "Using group by and aggregate functions to summarize data."
      ],
      "metadata": {
        "id": "5ijBXkqcNMjf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by country and calculate the total invoice amount\n",
        "country_invoice_total = merged_df.groupby('country')['total'].sum().reset_index()\n",
        "print(country_invoice_total)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M5bBoTuiNSOz",
        "outputId": "a50c0e8c-7cd1-471f-9188-fa22a6520fc8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "           country   total\n",
            "0        Argentina   37.62\n",
            "1        Australia   37.62\n",
            "2          Austria   42.62\n",
            "3          Belgium   37.62\n",
            "4           Brazil  190.10\n",
            "5           Canada  303.96\n",
            "6            Chile   46.62\n",
            "7   Czech Republic   90.24\n",
            "8          Denmark   37.62\n",
            "9          Finland   41.62\n",
            "10          France  195.10\n",
            "11         Germany  156.48\n",
            "12         Hungary   45.62\n",
            "13           India   75.26\n",
            "14         Ireland   45.62\n",
            "15           Italy   37.62\n",
            "16     Netherlands   40.62\n",
            "17          Norway   39.62\n",
            "18          Poland   37.62\n",
            "19        Portugal   77.24\n",
            "20           Spain   37.62\n",
            "21          Sweden   38.62\n",
            "22             USA  523.06\n",
            "23  United Kingdom  112.86\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Merge the two datasets on 'customer_id'\n",
        "merged_df = pd.merge(invoice_cleaned, customer_cleaned, on='customer_id')\n",
        "\n",
        "# Create a new column for customer full name\n",
        "merged_df['customer_name'] = merged_df['first_name'] + ' ' + merged_df['last_name']\n",
        "\n",
        "# Group by customer name and calculate the total invoice amount\n",
        "total_invoice_amount = merged_df.groupby('customer_name')['total'].sum().reset_index()\n",
        "\n",
        "# Sort the customers by total invoice amount in descending order and get the top 5\n",
        "top_customers = total_invoice_amount.sort_values(by='total', ascending=False).head(5)\n",
        "\n",
        "# Print the result\n",
        "print(top_customers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z-ky5p-3OLEI",
        "outputId": "4bcb94ce-ec6f-4fb1-eebd-20af23bdfdce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "         customer_name  total\n",
            "22         Helena Holý  49.62\n",
            "50  Richard Cunningham  47.62\n",
            "37          Luis Rojas  46.62\n",
            "23       Hugh O'Reilly  45.62\n",
            "34     Ladislav Kovács  45.62\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5.Pair Plot\n",
        "Pair plots show the pairwise relationships between multiple numerical variables in the dataset."
      ],
      "metadata": {
        "id": "UhJXtQvBRK8W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Pair plot of numerical columns in invoice_line_cleaned\n",
        "sns.pairplot(track_cleaned[['unit_price', 'bytes']])\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 513
        },
        "id": "QE175E8YRQHv",
        "outputId": "78df6670-138f-4ee3-8482-7161fde91e71"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x500 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "  1. ‘unit_price’ vs ‘bytes’: Lower-priced units tend to have more variability in bytes. As the unit price increases, the variability in bytes decreases.\n",
        "\n",
        "  2.‘bytes’ vs ‘bytes’: There are many instances where the byte size is small, but few where it is large, with no discernible trend or correlation.\n",
        "\n",
        "  3.‘unit_price’ vs ‘unit_price’: Units with lower prices and smaller sizes (in bytes) are more common. There is an outlier representing a unit with a high price and large size.\n",
        "\n",
        "These plots suggest that in the context of streamline music marketplace unit price might affect data size preferences or offerings."
      ],
      "metadata": {
        "id": "1PmyVVGJS2gd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 6. Crosstab\n",
        "Crosstabs are used to compute frequency, this case invoices x city and country."
      ],
      "metadata": {
        "id": "64h4fJDsUBn-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Crosstab of billing country and billing city\n",
        "crosstab = pd.crosstab(invoice_cleaned['billing_country'], invoice_cleaned['billing_city'])\n",
        "print(crosstab)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xTzvaWLVTzxi",
        "outputId": "7bbbd44c-7475-493c-c8ee-433d2aec5785"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "billing_city     Amsterdam  Bangalore  Berlin  Bordeaux  Boston  Brasília  \\\n",
            "billing_country                                                             \n",
            "Argentina                0          0       0         0       0         0   \n",
            "Australia                0          0       0         0       0         0   \n",
            "Austria                  0          0       0         0       0         0   \n",
            "Belgium                  0          0       0         0       0         0   \n",
            "Brazil                   0          0       0         0       0         7   \n",
            "Canada                   0          0       0         0       0         0   \n",
            "Chile                    0          0       0         0       0         0   \n",
            "Czech Republic           0          0       0         0       0         0   \n",
            "Denmark                  0          0       0         0       0         0   \n",
            "Finland                  0          0       0         0       0         0   \n",
            "France                   0          0       0         7       0         0   \n",
            "Germany                  0          0      14         0       0         0   \n",
            "Hungary                  0          0       0         0       0         0   \n",
            "India                    0          6       0         0       0         0   \n",
            "Ireland                  0          0       0         0       0         0   \n",
            "Italy                    0          0       0         0       0         0   \n",
            "Netherlands              7          0       0         0       0         0   \n",
            "Norway                   0          0       0         0       0         0   \n",
            "Poland                   0          0       0         0       0         0   \n",
            "Portugal                 0          0       0         0       0         0   \n",
            "Spain                    0          0       0         0       0         0   \n",
            "Sweden                   0          0       0         0       0         0   \n",
            "USA                      0          0       0         0       7         0   \n",
            "United Kingdom           0          0       0         0       0         0   \n",
            "\n",
            "billing_city     Brussels  Budapest  Buenos Aires  Chicago  ...  Stuttgart  \\\n",
            "billing_country                                             ...              \n",
            "Argentina               0         0             7        0  ...          0   \n",
            "Australia               0         0             0        0  ...          0   \n",
            "Austria                 0         0             0        0  ...          0   \n",
            "Belgium                 7         0             0        0  ...          0   \n",
            "Brazil                  0         0             0        0  ...          0   \n",
            "Canada                  0         0             0        0  ...          0   \n",
            "Chile                   0         0             0        0  ...          0   \n",
            "Czech Republic          0         0             0        0  ...          0   \n",
            "Denmark                 0         0             0        0  ...          0   \n",
            "Finland                 0         0             0        0  ...          0   \n",
            "France                  0         0             0        0  ...          0   \n",
            "Germany                 0         0             0        0  ...          7   \n",
            "Hungary                 0         7             0        0  ...          0   \n",
            "India                   0         0             0        0  ...          0   \n",
            "Ireland                 0         0             0        0  ...          0   \n",
            "Italy                   0         0             0        0  ...          0   \n",
            "Netherlands             0         0             0        0  ...          0   \n",
            "Norway                  0         0             0        0  ...          0   \n",
            "Poland                  0         0             0        0  ...          0   \n",
            "Portugal                0         0             0        0  ...          0   \n",
            "Spain                   0         0             0        0  ...          0   \n",
            "Sweden                  0         0             0        0  ...          0   \n",
            "USA                     0         0             0        7  ...          0   \n",
            "United Kingdom          0         0             0        0  ...          0   \n",
            "\n",
            "billing_city     São José dos Campos  São Paulo  Toronto  Tucson  Vancouver  \\\n",
            "billing_country                                                               \n",
            "Argentina                          0          0        0       0          0   \n",
            "Australia                          0          0        0       0          0   \n",
            "Austria                            0          0        0       0          0   \n",
            "Belgium                            0          0        0       0          0   \n",
            "Brazil                             7         14        0       0          0   \n",
            "Canada                             0          0        7       0          7   \n",
            "Chile                              0          0        0       0          0   \n",
            "Czech Republic                     0          0        0       0          0   \n",
            "Denmark                            0          0        0       0          0   \n",
            "Finland                            0          0        0       0          0   \n",
            "France                             0          0        0       0          0   \n",
            "Germany                            0          0        0       0          0   \n",
            "Hungary                            0          0        0       0          0   \n",
            "India                              0          0        0       0          0   \n",
            "Ireland                            0          0        0       0          0   \n",
            "Italy                              0          0        0       0          0   \n",
            "Netherlands                        0          0        0       0          0   \n",
            "Norway                             0          0        0       0          0   \n",
            "Poland                             0          0        0       0          0   \n",
            "Portugal                           0          0        0       0          0   \n",
            "Spain                              0          0        0       0          0   \n",
            "Sweden                             0          0        0       0          0   \n",
            "USA                                0          0        0       7          0   \n",
            "United Kingdom                     0          0        0       0          0   \n",
            "\n",
            "billing_city     Vienne  Warsaw  Winnipeg  Yellowknife  \n",
            "billing_country                                         \n",
            "Argentina             0       0         0            0  \n",
            "Australia             0       0         0            0  \n",
            "Austria               7       0         0            0  \n",
            "Belgium               0       0         0            0  \n",
            "Brazil                0       0         0            0  \n",
            "Canada                0       0         7            7  \n",
            "Chile                 0       0         0            0  \n",
            "Czech Republic        0       0         0            0  \n",
            "Denmark               0       0         0            0  \n",
            "Finland               0       0         0            0  \n",
            "France                0       0         0            0  \n",
            "Germany               0       0         0            0  \n",
            "Hungary               0       0         0            0  \n",
            "India                 0       0         0            0  \n",
            "Ireland               0       0         0            0  \n",
            "Italy                 0       0         0            0  \n",
            "Netherlands           0       0         0            0  \n",
            "Norway                0       0         0            0  \n",
            "Poland                0       7         0            0  \n",
            "Portugal              0       0         0            0  \n",
            "Spain                 0       0         0            0  \n",
            "Sweden                0       0         0            0  \n",
            "USA                   0       0         0            0  \n",
            "United Kingdom        0       0         0            0  \n",
            "\n",
            "[24 rows x 53 columns]\n"
          ]
        }
      ]
    }
  ]
}