regression_parameter_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pathlib import Path\n",
    "from enum import Enum\n",
    "from dataclasses import dataclass\n",
    "from typing import Optional\n",
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbaloneDataColumnsTypes(Enum):\n",
    "    SEX = 'Sex' \n",
    "    LEN = 'Length'\n",
    "    DIAM = 'Diameter'\n",
    "    HEIGHT =  'Height'\n",
    "    W_WEIGHT =  'Whole weight'\n",
    "    SHUCK_WEIGHT = 'Shucked weight'\n",
    "    V_WEIGHT = 'Viscera weight'\n",
    "    SHELL_WEIGHT = 'Shell weight'\n",
    "    RINGS = 'Rings'\n",
    "\n",
    "    def __str__(self) -> str:\n",
    "        return self.value\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class CommonParams:\n",
    "    data_path = Path('./data')\n",
    "\n",
    "    num_iterations = 1000\n",
    "    selection_ratio = 0.1\n",
    "    exclude_columns = [AbaloneDataColumnsTypes.SEX]\n",
    "    predict_column = AbaloneDataColumnsTypes.RINGS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_abalone_dataset(path: Path, abaloneDataColumns) -> pd.DataFrame:\n",
    "    dataset_features_path = path / 'abalone' / 'abalone.data'\n",
    "\n",
    "    dataset = pd.read_csv(dataset_features_path, header = None)\n",
    "    dataset.columns = abaloneDataColumns\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_abalone_dataset(dataset: pd.DataFrame, exclude_columns: Optional[AbaloneDataColumnsTypes] = None\n",
    "                               ) -> pd.DataFrame:\n",
    "    if exclude_columns:\n",
    "        for column in exclude_columns:\n",
    "            dataset = dataset.drop(columns=column.value)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_random_subset(dataset: pd.DataFrame, selection_ratio: float) -> pd.DataFrame:\n",
    "    dataset_size = len(dataset)\n",
    "    subset_size = int(dataset_size * selection_ratio)\n",
    "    subset = dataset.sample(subset_size)\n",
    "    return subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def x_y_split(dataset: pd.DataFrame, predicted_column: AbaloneDataColumnsTypes) -> tuple[pd.DataFrame, pd.DataFrame]:\n",
    "    data_x = dataset.copy()\n",
    "    data_x = data_x.drop(columns=[predicted_column.value])\n",
    "\n",
    "    data_y = dataset[predicted_column.value]\n",
    "    return data_x, data_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scaleMinMax(frame: pd.DataFrame) -> pd.DataFrame:\n",
    "    return (frame - frame.min()) / (frame.max() - frame.min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def selectValuable(dataset: pd.DataFrame,\n",
    "                   quantiles: tuple[float, float] = (0.5, 0.95),\n",
    "                   max_delta: float = 0.25) -> pd.DataFrame:\n",
    "    scaled_dataset = scaleMinMax(dataset)\n",
    "    delta = abs(scaled_dataset.quantile(quantiles[0]) - scaled_dataset.quantile(quantiles[1]))\n",
    "    absolute_delta = abs(delta)\n",
    "    selected_parameters = absolute_delta.loc[absolute_delta < max_delta]\n",
    "    return selected_parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Viscera weight    0.203565\n",
       "Shucked weight    0.227526\n",
       "Length            0.228401\n",
       "Shell weight      0.243445\n",
       "dtype: float64"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params = CommonParams()\n",
    "\n",
    "abaloneDataColumns = [str(columnType) for columnType in AbaloneDataColumnsTypes]\n",
    "\n",
    "abaloneProcessedDataColumns = [str(columnType) for columnType in AbaloneDataColumnsTypes\n",
    "                               if columnType is not params.predict_column and columnType not in params.exclude_columns]\n",
    "\n",
    "dataset = get_abalone_dataset(params.data_path, abaloneDataColumns)\n",
    "processed_dataset = preprocess_abalone_dataset(dataset, params.exclude_columns)\n",
    "\n",
    "coef_history = []\n",
    "for iteration in range(params.num_iterations):\n",
    "    subset = get_random_subset(processed_dataset, params.selection_ratio)\n",
    "    \n",
    "    data_x, data_y = x_y_split(subset, params.predict_column)\n",
    "    regression = LinearRegression()\n",
    "    regression.fit(data_x, data_y)\n",
    "    coef_history.append(regression.coef_)\n",
    "\n",
    "frameHistory = pd.DataFrame(coef_history, columns=abaloneProcessedDataColumns)\n",
    "important_parameters = selectValuable(frameHistory).sort_values()\n",
    "important_parameters"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}