1-DatasetsPreparation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notebooks\n",
    "import nbimporter\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# Functions from src\n",
    "module_path = os.path.abspath(os.path.join('..'))\n",
    "if module_path not in sys.path:\n",
    "    sys.path.append(module_path)\n",
    "    \n",
    "# Defined Functions\n",
    "from utils import *\n",
    "\n",
    "# Pandas, matplotlib, pickle, seaborn\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Sklearn\n",
    "from sklearn import preprocessing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global variables\n",
    "train_test_split = 0.7 # for main train/validation split\n",
    "random_state = 100 # randome seed\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Occutherm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Participant_No  Temperature (Fahrenheit)  SkinTemperature  \\\n",
      "count     2067.000000               2067.000000      2067.000000   \n",
      "mean        40.233188                 71.388912        85.144962   \n",
      "std         23.315812                  6.227013         5.236758   \n",
      "min          1.000000                 60.070000        62.986781   \n",
      "25%         20.000000                 65.500000        81.980755   \n",
      "50%         41.000000                 70.199997        85.382000   \n",
      "75%         60.000000                 77.599998        88.465402   \n",
      "max         80.000000                 85.000000       110.235782   \n",
      "\n",
      "       ClothingInsulation   Height(cm)  Shoulder Circumference(cm)  \\\n",
      "count         2067.000000  2067.000000                 2067.000000   \n",
      "mean             0.565070   170.134736                  109.284857   \n",
      "std              0.192765     9.651437                   10.906837   \n",
      "min              0.000000   151.000000                   89.500000   \n",
      "25%              0.410000   163.650000                  101.000000   \n",
      "50%              0.530000   170.000000                  106.900000   \n",
      "75%              0.710000   176.700000                  115.000000   \n",
      "max              1.150000   191.200000                  133.000000   \n",
      "\n",
      "       Weight(lbs)       Gender  Temperature_outside  Humidity_outside  \\\n",
      "count  2067.000000  2067.000000          2067.000000       2067.000000   \n",
      "mean    152.995694     0.429608            49.554141         69.509434   \n",
      "std      30.811844     0.495140            20.873649         13.202796   \n",
      "min      90.000000     0.000000             6.790000         33.500000   \n",
      "25%     126.000000     0.000000            35.980000         60.799999   \n",
      "50%     146.000000     0.000000            46.889999         69.000000   \n",
      "75%     173.000000     1.000000            66.339996         78.500000   \n",
      "max     236.600000     1.000000            91.400002        100.000000   \n",
      "\n",
      "       Discrete Thermal Comfort_TA  \n",
      "count                  2067.000000  \n",
      "mean                     -0.286405  \n",
      "std                       0.863492  \n",
      "min                      -2.000000  \n",
      "25%                      -1.000000  \n",
      "50%                       0.000000  \n",
      "75%                       0.000000  \n",
      "max                       2.000000  \n"
     ]
    }
   ],
   "source": [
    "# load TCS dataset\n",
    "df_tcs = pd.read_pickle(\"data/occutherm/df_feature1.pkl\")\n",
    "\n",
    "test_size_percentage = 0.2 # for CV within train split\n",
    "user_split = True #split train and test user-based or completely stratfied\n",
    "use_heuristics_participants = False\n",
    "\n",
    "print(df_tcs.describe())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Original labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complete Participants: [1, 2, 4, 5, 6, 7, 8, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 30, 31, 32, 33, 34, 35, 40, 41, 42, 43, 44, 45, 46, 49, 50, 51, 52, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80]\n",
      "Total number of complete participants: 65\n",
      "Num participants in test set: 20\n",
      "Testing on participants:\n",
      "[ 4  7  8 21 25 29 40 41 43 57 58 59 61 64 66 68 70 71 73 80]\n",
      "Total number of instances: 2067\n",
      " 0    1152\n",
      "-1     452\n",
      "-2     217\n",
      " 1     198\n",
      " 2      48\n",
      "Name: Discrete Thermal Comfort_TA, dtype: int64\n",
      "\n",
      "Number of training instances: 1508\n",
      " 0    818\n",
      "-1    303\n",
      "-2    172\n",
      " 1    171\n",
      " 2     44\n",
      "Name: Discrete Thermal Comfort_TA, dtype: int64\n",
      "\n",
      "Number of testing instances: 559\n",
      " 0    334\n",
      "-1    149\n",
      "-2     45\n",
      " 1     27\n",
      " 2      4\n",
      "Name: Discrete Thermal Comfort_TA, dtype: int64\n",
      "['Temperature (Fahrenheit)' 'SkinTemperature' 'ClothingInsulation'\n",
      " 'Height(cm)' 'Shoulder Circumference(cm)' 'Weight(lbs)' 'Gender'\n",
      " 'Temperature_outside' 'Humidity_outside' 'Discrete Thermal Comfort_TA']\n",
      "Temperature (Fahrenheit)       float64\n",
      "SkinTemperature                float64\n",
      "ClothingInsulation             float64\n",
      "Height(cm)                     float64\n",
      "Shoulder Circumference(cm)     float64\n",
      "Weight(lbs)                    float64\n",
      "Gender                           int64\n",
      "Temperature_outside            float64\n",
      "Humidity_outside               float64\n",
      "Discrete Thermal Comfort_TA      int64\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "df_aux_65 = pd.read_csv(\"data/occutherm/TCS_65_participants_outsideData.csv\", delimiter = \",\")\n",
    "\n",
    "list_complete_participants = list(df_aux_65['Participant_No'].unique())\n",
    "\n",
    "if use_heuristics_participants:\n",
    "    list_complete_participants.append(10)\n",
    "    list_complete_participants.append(26)\n",
    "    list_complete_participants.append(28)\n",
    "    list_complete_participants.append(36)\n",
    "    list_complete_participants.append(37)\n",
    "    list_complete_participants.append(39)\n",
    "    list_complete_participants.append(47)\n",
    "    list_complete_participants.append(48)\n",
    "    list_complete_participants.append(53)\n",
    "\n",
    "num_complete_participants = len(list_complete_participants)\n",
    "print(\"Complete Participants: {}\".format(list_complete_participants))\n",
    "print(\"Total number of complete participants: {}\".format(num_complete_participants))\n",
    "\n",
    "df_tcs_train, df_tcs_test, _, _ = train_test_split_holistics(df_tcs, list_complete_participants,\n",
    "                                                               user_split = user_split, train_test_split = train_test_split)\n",
    "print(\"Total number of instances: {}\".format(df_tcs.shape[0]))\n",
    "print(df_tcs['Discrete Thermal Comfort_TA'].value_counts())\n",
    "\n",
    "print(\"\\nNumber of training instances: {}\".format(df_tcs_train.shape[0]))\n",
    "print(df_tcs_train['Discrete Thermal Comfort_TA'].value_counts())\n",
    "\n",
    "print(\"\\nNumber of testing instances: {}\".format(df_tcs_test.shape[0]))\n",
    "print(df_tcs_test['Discrete Thermal Comfort_TA'].value_counts())\n",
    "\n",
    "print(df_tcs_train.columns.values)\n",
    "print(df_tcs_train.dtypes)\n",
    "\n",
    "df_tcs_train.to_pickle('data/occutherm/df_feature1_train.pkl')\n",
    "df_tcs_test.to_pickle('data/occutherm/df_feature1_test.pkl')\n",
    "df_tcs_train.to_csv('data/occutherm/df_feature1_train.csv', index=False, header=False)\n",
    "df_tcs_test.to_csv('data/occutherm/df_feature1_test.csv', index=False, header=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduced labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remap_occutherm(x):\n",
    "    if x > 0:\n",
    "        return 1\n",
    "    elif x < 0:\n",
    "        return -1\n",
    "    else:\n",
    "        return 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_tcs_train_reduced = df_tcs_train.copy()\n",
    "df_tcs_test_reduced = df_tcs_test.copy()\n",
    "\n",
    "df_tcs_train_reduced['Discrete Thermal Comfort_TA'] = df_tcs_train_reduced['Discrete Thermal Comfort_TA'].apply(remap_occutherm)\n",
    "df_tcs_test_reduced['Discrete Thermal Comfort_TA'] = df_tcs_test_reduced['Discrete Thermal Comfort_TA'].apply(remap_occutherm)\n",
    "\n",
    "df_tcs_train_reduced.to_pickle('data/occutherm/df_feature1_train_reduced.pkl')\n",
    "df_tcs_test_reduced.to_pickle('data/occutherm/df_feature1_test_reduced.pkl')\n",
    "df_tcs_train_reduced.to_csv('data/occutherm/df_feature1_train_reduced.csv', index=False, header=False)\n",
    "df_tcs_test_reduced.to_csv('data/occutherm/df_feature1_test_reduced.csv', index=False, header=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cresh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The preprocessing of the data is already done in [this paper](https://www.researchgate.net/publication/338527635_Indoor_Comfort_Personalities_Scalable_Occupant_Preference_Capture_Using_Micro_Ecological_Momentary_Assessments).\n",
    "\n",
    "We chose the most comprehensive featureset (FS2) since it contains all sensor measurements deployed during the data collection experiment `Feature Set2: Time + Sensing (IoT) + Heart Rate (smartwatch) + mbient (nearbody temperature sensor on smartwatch)`. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thermal comfort as targert variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Original labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of instances: 1474\n",
      "10.0    937\n",
      "11.0    336\n",
      "9.0     201\n",
      "Name: thermal_cozie, dtype: int64\n",
      "\n",
      "Number of training instances: 1159\n",
      "10.0    713\n",
      "11.0    280\n",
      "9.0     166\n",
      "Name: thermal_cozie, dtype: int64\n",
      "\n",
      "Number of testing instances: 315\n",
      "10.0    224\n",
      "11.0     56\n",
      "9.0      35\n",
      "Name: thermal_cozie, dtype: int64\n",
      "['heartRate_cozie' 'humidity_sensing' 'light_sensing' 'noise_sensing'\n",
      " 'temperature_sensing' 'temperature_mbient' 'hour_sin' 'hour_cos'\n",
      " 'day_of_week_sin' 'day_of_week_cos' 'thermal_cozie']\n",
      "heartRate_cozie        float64\n",
      "humidity_sensing       float64\n",
      "light_sensing          float64\n",
      "noise_sensing          float64\n",
      "temperature_sensing    float64\n",
      "temperature_mbient     float64\n",
      "hour_sin               float64\n",
      "hour_cos               float64\n",
      "day_of_week_sin        float64\n",
      "day_of_week_cos        float64\n",
      "thermal_cozie          float64\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# load Cresh dataset\n",
    "df_cresh = pd.read_csv(\"data/cresh/2019-11-15_fs2.csv\")\n",
    "\n",
    "# drop user id\n",
    "df_cresh.drop(columns='user_id', axis=1, inplace=True)\n",
    "\n",
    "df_cresh_train = pd.read_csv(\"data/cresh/2019-11-15_fs2_train.csv\")\n",
    "df_cresh_train.drop(columns='user_id', axis=1, inplace=True)\n",
    "\n",
    "df_cresh_test = pd.read_csv(\"data/cresh/2019-11-15_fs2_val.csv\")\n",
    "df_cresh_test.drop(columns='user_id', axis=1, inplace=True)\n",
    "\n",
    "# drop light and noise subjective feedback\n",
    "df_cresh.drop(columns='light_cozie', axis=1, inplace=True)\n",
    "df_cresh.drop(columns='noise_cozie', axis=1, inplace=True)\n",
    "\n",
    "df_cresh_train.drop(columns='light_cozie', axis=1, inplace=True)\n",
    "df_cresh_train.drop(columns='noise_cozie', axis=1, inplace=True)\n",
    "\n",
    "df_cresh_test.drop(columns='light_cozie', axis=1, inplace=True)\n",
    "df_cresh_test.drop(columns='noise_cozie', axis=1, inplace=True)\n",
    "\n",
    "print(\"Total number of instances: {}\".format(df_cresh.shape[0]))\n",
    "print(df_cresh['thermal_cozie'].value_counts())\n",
    "\n",
    "# move thermal comfort response to the end of the dataframe\n",
    "# train and test split already have this format\n",
    "df_cresh_y = df_cresh.pop('thermal_cozie')\n",
    "df_cresh['thermal_cozie'] = df_cresh_y\n",
    "\n",
    "print(\"\\nNumber of training instances: {}\".format(df_cresh_train.shape[0]))\n",
    "print(df_cresh_train['thermal_cozie'].value_counts())\n",
    "\n",
    "print(\"\\nNumber of testing instances: {}\".format(df_cresh_test.shape[0]))\n",
    "print(df_cresh_test['thermal_cozie'].value_counts())\n",
    "\n",
    "print(df_cresh.columns.values)\n",
    "print(df_cresh_train.dtypes)\n",
    "df_cresh_train.iloc[:, -1] = df_cresh_train.iloc[:, -1].astype('int64') \n",
    "\n",
    "df_cresh.to_pickle('data/cresh/cresh.pkl')\n",
    "df_cresh_train.to_pickle('data/cresh/cresh_train.pkl')\n",
    "df_cresh_train.to_csv('data/cresh/cresh_train.csv', index=False, header=False) # for TGAN\n",
    "df_cresh_test.to_pickle('data/cresh/cresh_test.pkl')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ASHRAE Thermal Comfort Database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of datapoints: 107583\n",
      "['Thermal sensation' 'SET' 'Clo' 'Met' 'Air temperature (¡C)'\n",
      " 'Relative humidity (%)' 'Air velocity (m/s)']\n"
     ]
    }
   ],
   "source": [
    "df_ashrae_raw = pd.read_csv(\"data/ashrae/ashrae_db2.01.csv\", low_memory=False, encoding=\"cp1252\")\n",
    "ashrae_columns = [\"Air temperature (¡C)\",\n",
    "                  'SET',\n",
    "                  'Relative humidity (%)',\n",
    "                  'Clo',\n",
    "                  'Air velocity (m/s)',\n",
    "                  'Met',\n",
    "                  'Thermal sensation' \n",
    "                 ]\n",
    "\n",
    "df_ashrae_filtered = df_ashrae_raw[df_ashrae_raw.columns.intersection(ashrae_columns)]\n",
    "print(\"total number of datapoints: {}\".format(len(df_ashrae_filtered)))\n",
    "# original size (107583, 70)\n",
    "print(df_ashrae_filtered.columns.values)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of datapoints without a single nan: 66397 or 61.71699989775337\n",
      "['SET' 'Clo' 'Met' 'Air temperature (¡C)' 'Relative humidity (%)'\n",
      " 'Air velocity (m/s)' 'Thermal sensation rounded']\n",
      "                SET           Clo           Met  Air temperature (¡C)  \\\n",
      "count  66397.000000  66397.000000  66397.000000          66397.000000   \n",
      "mean      25.772715      0.696338      1.212996             24.357408   \n",
      "std        3.200367      0.283474      0.235523              3.574222   \n",
      "min        6.550000      0.030000      0.650000              0.600000   \n",
      "25%       23.720000      0.510000      1.100000             22.300000   \n",
      "50%       25.540000      0.660000      1.200000             23.800000   \n",
      "75%       27.630000      0.780000      1.300000             26.200000   \n",
      "max       61.530000      2.870000      6.830000             48.800000   \n",
      "\n",
      "       Relative humidity (%)  Air velocity (m/s)  Thermal sensation rounded  \n",
      "count           66397.000000        66397.000000               66397.000000  \n",
      "mean               46.654853            0.153913                   0.186017  \n",
      "std                14.651001            0.400901                   1.274920  \n",
      "min                 0.500000            0.000000                  -3.000000  \n",
      "25%                35.700000            0.040000                   0.000000  \n",
      "50%                46.300000            0.080000                   0.000000  \n",
      "75%                57.200000            0.160000                   1.000000  \n",
      "max               100.000000           56.170000                   3.000000  \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/matias/miniconda3/envs/gen-methods/lib/python3.7/site-packages/pandas/core/indexing.py:376: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self.obj[key] = _infer_fill_value(value)\n",
      "/Users/matias/miniconda3/envs/gen-methods/lib/python3.7/site-packages/pandas/core/indexing.py:576: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self.obj[item_labels[indexer[info_axis]]] = value\n"
     ]
    }
   ],
   "source": [
    "# removing nans\n",
    "df_ashrae_filtered_nonull = df_ashrae_filtered[\n",
    "                                               (df_ashrae_filtered['Thermal sensation'].notna()) &\n",
    "                                               (df_ashrae_filtered['SET'].notna()) &\n",
    "                                               (df_ashrae_filtered['Air velocity (m/s)'].notna())] # remove nans rows\n",
    "\n",
    "df_ashrae_filtered_nonull.loc[:, 'Thermal sensation rounded'] = df_ashrae_filtered.loc[:, 'Thermal sensation'].round(0)\n",
    "del df_ashrae_filtered_nonull['Thermal sensation']\n",
    "\n",
    "print(\"total number of datapoints without a single nan: {} or {}\".format(len(df_ashrae_filtered_nonull), \n",
    "                                                                         len(df_ashrae_filtered_nonull) / len(df_ashrae_raw) * 100))\n",
    "print(df_ashrae_filtered_nonull.columns.values)\n",
    "print(df_ashrae_filtered_nonull.describe())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Original labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Number of instances: 66397\n",
      " 0.0    27470\n",
      " 1.0    12727\n",
      "-1.0    10406\n",
      " 2.0     6998\n",
      "-2.0     4014\n",
      " 3.0     3068\n",
      "-3.0     1714\n",
      "Name: Thermal sensation rounded, dtype: int64\n",
      "\n",
      "Number of training instances: 46477\n",
      " 0.0    19271\n",
      " 1.0     8872\n",
      "-1.0     7289\n",
      " 2.0     4889\n",
      "-2.0     2790\n",
      " 3.0     2161\n",
      "-3.0     1205\n",
      "Name: Thermal sensation rounded, dtype: int64\n",
      "\n",
      "Number of testing instances: 19920\n",
      " 0.0    8199\n",
      " 1.0    3855\n",
      "-1.0    3117\n",
      " 2.0    2109\n",
      "-2.0    1224\n",
      " 3.0     907\n",
      "-3.0     509\n",
      "Name: Thermal sensation rounded, dtype: int64\n",
      "['SET' 'Clo' 'Met' 'Air temperature (¡C)' 'Relative humidity (%)'\n",
      " 'Air velocity (m/s)' 'Thermal sensation rounded']\n",
      "SET                          float64\n",
      "Clo                          float64\n",
      "Met                          float64\n",
      "Air temperature (¡C)         float64\n",
      "Relative humidity (%)        float64\n",
      "Air velocity (m/s)           float64\n",
      "Thermal sensation rounded    float64\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# shuffle the dataset\n",
    "df_ashrae_filtered_nonull = df_ashrae_filtered_nonull.sample(frac=1, random_state=random_state).reset_index(drop=True)\n",
    "# determine split\n",
    "idx_split = int(df_ashrae_filtered_nonull.shape[0] * train_test_split)\n",
    "\n",
    "# split the dataframe\n",
    "df_ashrae_train = df_ashrae_filtered_nonull.iloc[:idx_split, :]\n",
    "df_ashrae_test = df_ashrae_filtered_nonull.iloc[idx_split:, :]\n",
    "\n",
    "# shuffle \n",
    "df_ashrae_train = df_ashrae_train.sample(frac=1, random_state=random_state).reset_index(drop=True)\n",
    "df_ashrae_test = df_ashrae_test.sample(frac=1, random_state=random_state).reset_index(drop=True)\n",
    "\n",
    "\n",
    "df_ashrae_filtered_nonull.to_pickle('data/ashrae/ashrae.pkl')\n",
    "df_ashrae_train.to_pickle('data/ashrae/ashrae_train.pkl')\n",
    "df_ashrae_train.to_csv('data/ashrae/ashrae_train.csv', index=False, header=False) # for TGAN\n",
    "df_ashrae_test.to_pickle('data/ashrae/ashrae_test.pkl')\n",
    "\n",
    "print(\"\\nNumber of instances: {}\".format(df_ashrae_filtered_nonull.shape[0]))\n",
    "print(df_ashrae_filtered_nonull['Thermal sensation rounded'].value_counts())\n",
    "\n",
    "print(\"\\nNumber of training instances: {}\".format(df_ashrae_train.shape[0]))\n",
    "print(df_ashrae_train['Thermal sensation rounded'].value_counts())\n",
    "\n",
    "print(\"\\nNumber of testing instances: {}\".format(df_ashrae_test.shape[0]))\n",
    "print(df_ashrae_test['Thermal sensation rounded'].value_counts())\n",
    "\n",
    "print(df_ashrae_filtered_nonull.columns.values)\n",
    "print(df_ashrae_train.dtypes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "label_str = \"Thermal sensation rounded\"\n",
    "\n",
    "fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(12, 8))\n",
    "values = df_ashrae_filtered_nonull[label_str].value_counts()\n",
    "indices = values.index.values\n",
    "axes.bar(indices, values)\n",
    "axes.set_title(label_str)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduced labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remap_ashrae(x):\n",
    "    if x > 0.0:\n",
    "        return 1.0\n",
    "    elif x < 0.0:\n",
    "        return -1.0\n",
    "    else:\n",
    "        return 0.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ashrae_filtered_nonull_reduced = df_ashrae_filtered_nonull.copy()\n",
    "df_ashrae_train_reduced = df_ashrae_train.copy()\n",
    "df_ashrae_test_reduced = df_ashrae_test.copy()\n",
    "\n",
    "df_ashrae_filtered_nonull_reduced['Thermal sensation rounded'] = df_ashrae_filtered_nonull_reduced['Thermal sensation rounded'].apply(remap_ashrae)\n",
    "df_ashrae_train_reduced['Thermal sensation rounded'] = df_ashrae_train_reduced['Thermal sensation rounded'].apply(remap_ashrae)\n",
    "df_ashrae_test_reduced['Thermal sensation rounded'] = df_ashrae_test_reduced['Thermal sensation rounded'].apply(remap_ashrae)\n",
    "\n",
    "df_ashrae_train_reduced.to_pickle('data/ashrae/ashrae_train_reduced.pkl')\n",
    "df_ashrae_train_reduced.to_csv('data/ashrae/ashrae_train_reduced.csv', index=False, header=False) # for TGAN\n",
    "df_ashrae_test_reduced.to_pickle('data/ashrae/ashrae_test_reduced.pkl')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "label_str = \"Thermal sensation rounded\"\n",
    "\n",
    "fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(12, 8))\n",
    "values = df_ashrae_filtered_nonull_reduced[label_str].value_counts()\n",
    "indices = values.index.values\n",
    "axes.bar(indices, values)\n",
    "axes.set_title(label_str)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gen-methods",
   "language": "python",
   "name": "gen-methods"
  },
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}