linear-regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Linear Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import config as config\n",
    "from models.linear_regression import LinearRegressionManager \n",
    "from model_evaluator import ModelEvaluator\n",
    "\n",
    "import pprint\n",
    "p = pprint.PrettyPrinter(indent=4)\n",
    "\n",
    "\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing utilities object & building dataset \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run utilities.py\n",
    "util = Utilities({}, use_json=False)\n",
    "master_DF = util.get_master_dataframe()\n",
    "\n",
    "# add constructed features  \n",
    "master_DF = util.generate_energy_measure(master_DF)\n",
    "master_DF = util.generate_dance_measure(master_DF)\n",
    "\n",
    "# normalize numeric values \n",
    "master_norm_DF = util.normalize_numeric_columns(master_DF) \n",
    "\n",
    "\n",
    "# partition into train, crossvalidation, and test sets \n",
    "train, cv, test = util.split_master_df(master_norm_DF)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross validation to choose model features optimal for prediction \n",
    "+ acoustic features \n",
    "+ metadata features \n",
    "+ combination "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "linreg_manager = LinearRegressionManager()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acoustic features "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index([u'tempo', u'loudness', u'tatums_avg', u'segments_avg', u'beats_avg',\n",
       "        u'sections_avg'],\n",
       "       dtype='object'), 0.04640727173639492)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acoustic_df, score = linreg_manager.find_optimal_acoustic(train, cv)\n",
    "acoustic_df.columns, score "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metadata features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index([u'artist_hotttnesss', u'artist_familiarity'], dtype='object'),\n",
       " 0.20064171274608644)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metadata_df, score = linreg_manager.find_optimal_metadata(train, cv)\n",
    "metadata_df.columns, score "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constructed features (energy and dance) + metadata "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index([u'energy', u'artist_hotttnesss', u'artist_familiarity'], dtype='object'),\n",
       " 0.20064171274608655)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "constructed_df, score = linreg_manager.find_optimal_constructed(train, cv)\n",
    "constructed_df.columns, score "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### All features for maximum overfitting "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.21716837694880586"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# super long \n",
    "all_feature_list = config.acoustic_features + config.metadata_feaures + config.constructed_features\n",
    "all_model = LinearRegressionManager()\n",
    "X = train[all_feature_list]\n",
    "y = train['song_hotttnesss']\n",
    "\n",
    "X_cv = cv[all_feature_list]\n",
    "y_cv = cv['song_hotttnesss']\n",
    "\n",
    "all_model.train(X, y)\n",
    "all_model.R2_score(X_cv, y_cv)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Error on test set using best model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False),\n",
       " {'MSE': 0.029787661194220556,\n",
       "  'mean_abs': 0.14163152854532676,\n",
       "  'mean_err': 0.17259102292477602},\n",
       " {'MSE': 0.031597548320455665,\n",
       "  'mean_abs': 0.1456913738343797,\n",
       "  'mean_err': 0.1777569923250719},\n",
       " 0.21336283906958015)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linreg_manager.errors(train, test, all_feature_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = train['artist_hotttnesss artist_familiarity'.split()]\n",
    "y = train['song_hotttnesss']\n",
    "\n",
    "X_cv = cv['artist_hotttnesss artist_familiarity'.split()]\n",
    "y_cv = cv['song_hotttnesss']\n",
    "\n",
    "X_test = test['artist_hotttnesss artist_familiarity'.split()]\n",
    "y_test = test['song_hotttnesss']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### using acoustic features "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False),\n",
       " {'MSE': 0.041378565491573295,\n",
       "  'mean_abs': 0.17095619326406314,\n",
       "  'mean_err': 0.20341722024345257},\n",
       " {'MSE': 0.044982198972326304,\n",
       "  'mean_abs': 0.1795937322532547,\n",
       "  'mean_err': 0.21209007278118017},\n",
       " 0.21336283906958015)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allsegs = 'segments_avg tatums_avg beats_avg bars_avg sections_avg'.split()\n",
    "\n",
    "linreg_manager.errors(train, test, allsegs)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False),\n",
       " {'MSE': 0.040223003736958966,\n",
       "  'mean_abs': 0.1681829667409854,\n",
       "  'mean_err': 0.20055673445925212},\n",
       " {'MSE': 0.043387147113216194,\n",
       "  'mean_abs': 0.17489961709359192,\n",
       "  'mean_err': 0.2082958163603297},\n",
       " 0.21336283906958015)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allrawacous = 'key loudness duration tempo time_signature'.split()\n",
    "\n",
    "linreg_manager.errors(train, test, allrawacous)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finding the best energy measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index([u'energy2', u'energy3', u'energy4'], dtype='object'),\n",
       " 0.19664635783183815)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meval = ModelEvaluator()\n",
    "energy_names = ['energy1', 'energy2', 'energy3', 'energy4', 'energy']\n",
    "energy_df, score = linreg_manager.find_optimal_featureset(train, cv, energy_names) \n",
    "\n",
    "energy_df.columns, score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## lets play with the dance measure now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index([u'dance1', u'dance2', u'dance4'], dtype='object'), 0.15530004079837956)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dance_names = ['dance1', 'dance2', 'dance3', 'dance4']\n",
    "dance_df, score = linreg_manager.find_optimal_featureset(train, cv, dance_names) \n",
    "\n",
    "dance_df.columns, score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combine energy and dance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index([u'dance1', u'dance3', u'dance4', u'energy2', u'energy3', u'energy4'], dtype='object'),\n",
       " 0.2145037495787977)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dance_energy_list = dance_names + energy_names \n",
    "df, score = linreg_manager.find_optimal_featureset(train, cv, dance_energy_list) \n",
    "\n",
    "df.columns, score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Highest performing predictor used on test set "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'MSE': 0.032043770456529376,\n",
       " 'mean_abs': 0.14715002012726816,\n",
       " 'mean_err': 0.17900773853811286}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features = df.columns\n",
    "model, training_err, testing_err, hot_std = linreg_manager.errors(train, test, features)\n",
    "testing_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.29525990557423476"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test = test[features]\n",
    "y_test = test['song_hotttnesss']\n",
    "\n",
    "model.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}