Support_vector_regressor_raw_data_train_and_test_matrix_with_personalization_latest.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.svm import LinearSVR\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "\n",
    "sync_confirmed_list_train_all = [[23,27,28,29,30,32,33,37,38,39,40,41,42,45,46,50,53,56,57,59,62,63,66,67,68,69,71,72,73],\n",
    "                                [9,10,11,14,15,17,18,24,25,29,31,39,40,41,42,50,53,56,57,59,62,63,66,67,68,69,71,72,73],\n",
    "                                [9,10,11,14,15,17,18,23,24,25,27,28,30,31,32,33,37,38,45,46,56,57,62,67,68,69,71,72,73],\n",
    "                                [9,10,11,14,15,17,18,23,24,25,27,28,29,30,31,32,33,37,38,39,40,41,42,45,46,50,53,59,63,66]]\n",
    "\n",
    "sync_confirmed_list_test_all = [[9,10,11,14,15,17,18,24,25,31],\n",
    "                               [23,27,28,30,32,33,37,38,45,46],\n",
    "                               [29,39,40,41,42,50,53,59,63,66],\n",
    "                               [56,57,62,67,68,69,71,72,73]]\n",
    "\n",
    "\n",
    "\n",
    "# sync_confirmed_list_train_all = [[23,27,28,29,30,32,33,37,38,39,40,41,42,45,46,50,53,56,57,59,62,63,66,67],[50,53,56,57,59,62,63,66,67,68,69,71,72,73,9,10,11,14,15,17,18,24,25,31],[23,27,28,29,30,32,33,37,38,39,40,41,72,73,9,10,11,14,15,17,18,24,25,31],[23,27,29,30,33,37,39,40,42,45,50,53,57,59,63,66,68,69,72,73,10,11,15,17]]\n",
    "\n",
    "# sync_confirmed_list_test_all = [[68,69,71,72,73,9,10,11,14,15,17,18,24,25,31],[23,27,28,29,30,32,33,37,38,39,40,41,42,45,46],[42,45,46,50,53,56,57,59,62,63,66,67,68,69,71],[28,32,38,41,46,56,62,67,71,9,14,24,25,31,18]]\n",
    "\n",
    "sync_confirmed_list_train = sync_confirmed_list_train_all[3]\n",
    "sync_confirmed_list_test = sync_confirmed_list_test_all[3]\n",
    "\n",
    "tolerance_degree = 0\n",
    "\n",
    "# Participant_file_name = 'ML-PersRef_ML_Final_dataset/datapoints_rawdata_first_middle_points_with_building_width_outlier_removed_'\n",
    "#Participant_file_name = 'ML-PersRef_ML_Final_dataset/datapoints_rawdata_first_middle_points_with_building_width_splitted_near_'\n",
    "#Participant_file_name = 'ML-PersRef_ML_Final_dataset/datapoints_rawdata_first_middle_points_with_building_width_splitted_far_'\n",
    "\n",
    "Participant_file_name = 'ML-PersRef_ML_Final_dataset/datapoints_rawdata_first_middle_points_with_building_width_'\n",
    "\n",
    "\n",
    "# sync_confirmed_list_train, sync_confirmed_list_test = train_test_split(sync_confirmed_list, test_size=0.38, random_state=42)\n",
    "print(sync_confirmed_list_train)\n",
    "print(sync_confirmed_list_test)\n",
    "\n",
    "dataset = []\n",
    "dataset_test = []\n",
    "\n",
    "for z in sync_confirmed_list_train:\n",
    "    dataset.append(pd.read_csv(Participant_file_name + str(z)+'.csv'))\n",
    "    \n",
    "for j in sync_confirmed_list_test:\n",
    "    dataset_test.append(pd.read_csv(Participant_file_name + str(j)+'.csv'))\n",
    "    \n",
    "dataset = pd.concat(dataset).reset_index(drop=True)\n",
    "dataset_test = pd.concat(dataset_test).reset_index(drop=True)\n",
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressor = SVR(kernel='rbf', epsilon=2)\n",
    "#regressor = SVR(kernel='rbf', epsilon=5)\n",
    "\n",
    "\n",
    "xtrain = dataset.iloc[:,1:5].values.astype(float)\n",
    "ytrain = dataset.iloc[:,6].values.astype(float)\n",
    "ytrain_width = dataset.iloc[:,7].values.astype(float)\n",
    "\n",
    "sc_xtrain = StandardScaler()\n",
    "#sc_xtrain = MinMaxScaler()\n",
    "\n",
    "xtrain = sc_xtrain.fit_transform(xtrain)\n",
    "\n",
    "xtest = dataset_test.iloc[:,1:5].values.astype(float)\n",
    "ytest = dataset_test.iloc[:,6].values.astype(float)\n",
    "ytest_width = dataset_test.iloc[:,7].values.astype(float)\n",
    "\n",
    "sc_xtest = StandardScaler()\n",
    "#sc_xtest = MinMaxScaler()\n",
    "xtest = sc_xtest.fit_transform(xtest)\n",
    "\n",
    "print(xtrain.shape, xtest.shape, ytrain.shape, ytest.shape)\n",
    "\n",
    "xtrain_eye_gaze = xtrain[:,-1].reshape(-1, 1)\n",
    "xtest_eye_gaze = xtest[:,-1].reshape(-1, 1)\n",
    "xtrain_pointing = xtrain[:,0:3]\n",
    "xtest_pointing = xtest[:,0:3]\n",
    "ytrain = ytrain\n",
    "ytest = ytest\n",
    "\n",
    "\n",
    "\n",
    "#print(xtrain, xtest, xtrain_eye_gaze, xtest_eye_gaze, xtrain_pointing, xtest_pointing, ytrain, ytest)\n",
    "print(xtrain.shape, xtest.shape, xtrain_eye_gaze.shape, xtest_eye_gaze.shape, xtrain_pointing.shape, xtest_pointing.shape, ytrain.shape, ytest.shape)\n",
    "\n",
    "print(np.percentile(ytest_width,50))\n",
    "print(ytest_width.mean())\n",
    "\n",
    "print(\"========================\")\n",
    "print(\"---------train----------\")\n",
    "\n",
    "regressor.fit(xtrain,ytrain)\n",
    "\n",
    "print('-----------------')\n",
    "print(regressor.support_vectors_.shape)\n",
    "pred=regressor.predict(xtrain)\n",
    "print(r2_score(ytrain,pred))\n",
    "print(mean_squared_error(ytrain, pred))\n",
    "print('-----------------')\n",
    "\n",
    "print('================================================')\n",
    "#print(ytrain,pred)\n",
    "#print(abs(ytrain-pred))\n",
    "#print(ytrain_width)\n",
    "relative_width = abs(ytrain-pred)/(ytrain_width + tolerance_degree)\n",
    "#print(relative_width)\n",
    "print(relative_width.mean())\n",
    "print(relative_width.std())\n",
    "print('================================================')\n",
    "\n",
    "xtrain_fuse = regressor.support_vectors_\n",
    "ytrain_fuse = ytrain[regressor.support_]\n",
    "\n",
    "regressor.fit(xtrain_pointing,ytrain)\n",
    "print(regressor.support_vectors_.shape)\n",
    "pred=regressor.predict(xtrain_pointing)\n",
    "print(r2_score(ytrain,pred))\n",
    "print(mean_squared_error(ytrain, pred))\n",
    "print('-----------------')\n",
    "\n",
    "print('================================================')\n",
    "#print(ytrain,pred)\n",
    "#print(abs(ytrain-pred))\n",
    "#print(ytrain_width)\n",
    "relative_width = abs(ytrain-pred)/(ytrain_width + tolerance_degree)\n",
    "#print(relative_width)\n",
    "print(relative_width.mean())\n",
    "print(relative_width.std())\n",
    "print('================================================')\n",
    "\n",
    "xtrain_pointing = regressor.support_vectors_\n",
    "ytrain_pointing = ytrain[regressor.support_]\n",
    "\n",
    "regressor.fit(xtrain_eye_gaze,ytrain)\n",
    "print(regressor.support_vectors_.shape)\n",
    "pred=regressor.predict(xtrain_eye_gaze)\n",
    "print(r2_score(ytrain,pred))\n",
    "print(mean_squared_error(ytrain, pred))\n",
    "print('-----------------')\n",
    "\n",
    "print('================================================')\n",
    "#print(ytrain,pred)\n",
    "#print(abs(ytrain-pred))\n",
    "#print(ytrain_width)\n",
    "relative_width = abs(ytrain-pred)/(ytrain_width + tolerance_degree)\n",
    "#print(relative_width)\n",
    "print(relative_width.mean())\n",
    "print(relative_width.std())\n",
    "print('================================================')\n",
    "\n",
    "xtrain_eye_gaze = regressor.support_vectors_\n",
    "ytrain_eye_gaze = ytrain[regressor.support_]\n",
    "\n",
    "print(\"========================\")\n",
    "print(\"----------test----------\")\n",
    "\n",
    "regressor.fit(xtrain_fuse,ytrain_fuse)\n",
    "print('-----------------')\n",
    "print(regressor.support_vectors_.shape)\n",
    "pred=regressor.predict(xtest)\n",
    "print(r2_score(ytest,pred))\n",
    "print(mean_squared_error(ytest, pred))\n",
    "print('-----------------')\n",
    "\n",
    "print('================================================')\n",
    "#print(ytest,pred)\n",
    "#print(abs(ytest-pred))\n",
    "#print(ytest_width)\n",
    "relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "#print(relative_width)\n",
    "print(relative_width.mean())\n",
    "print(relative_width.std())\n",
    "print('================================================')\n",
    "\n",
    "regressor.fit(xtrain_pointing,ytrain_pointing)\n",
    "print(regressor.support_vectors_.shape)\n",
    "pred=regressor.predict(xtest_pointing)\n",
    "print(r2_score(ytest,pred))\n",
    "print(mean_squared_error(ytest, pred))\n",
    "print('-----------------')\n",
    "\n",
    "print('================================================')\n",
    "#print(ytest,pred)\n",
    "#print(abs(ytest-pred))\n",
    "#print(ytest_width)\n",
    "relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "#print(relative_width)\n",
    "print(relative_width.mean())\n",
    "print(relative_width.std())\n",
    "print('================================================')\n",
    "\n",
    "regressor.fit(xtrain_eye_gaze,ytrain_eye_gaze)\n",
    "print(regressor.support_vectors_.shape)\n",
    "pred=regressor.predict(xtest_eye_gaze)\n",
    "print(r2_score(ytest,pred))\n",
    "print(mean_squared_error(ytest, pred))\n",
    "print('-----------------')\n",
    "\n",
    "print('================================================')\n",
    "#print(ytest,pred)\n",
    "#print(abs(ytest-pred))\n",
    "#print(ytest_width)\n",
    "relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "#print(relative_width)\n",
    "print(relative_width.mean())\n",
    "print(relative_width.std())\n",
    "print('================================================')\n",
    "\n",
    "print(xtrain.shape, xtrain_fuse.shape, xtrain_pointing.shape, xtrain_eye_gaze.shape,  ytrain.shape, ytrain_fuse.shape, ytrain_pointing.shape, ytrain_eye_gaze.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1, ax1 = plt.subplots(figsize=(15,10))\n",
    "#ax1.set_title('Building Half-width Box Plot', fontsize = 20.0)\n",
    "ax1.boxplot(ytest_width, showfliers=False,showmeans=True, meanline=True)\n",
    "ax1.get_xaxis().set_visible(False)\n",
    "ax1.set_ylabel('Building Half-width in degrees', fontsize = 20.0) # Y label\n",
    "ax1.tick_params(axis='both', which='major', labelsize=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def personalisation_svr_test_train(participant_no,sc_xtrain,sc_xtest,xtrain_fuse,ytrain_fuse,xtrain_pointing,ytrain_pointing,xtrain_eye_gaze,ytrain_eye_gaze,sample_weight_value):\n",
    "\n",
    "    \n",
    "#     xtrain = (dataset.iloc[:,1:5].values.astype(float))\n",
    "#     ytrain = (dataset.iloc[:,-1].values.astype(float))\n",
    "    \n",
    "    print('P',participant_no)\n",
    "    dataset_test_participant = pd.read_csv(Participant_file_name + str(participant_no)+'.csv')\n",
    "\n",
    "\n",
    "    xtest = dataset_test_participant.iloc[:,1:5].values.astype(float)\n",
    "    ytest = dataset_test_participant.iloc[:,6:8].values.astype(float)\n",
    "\n",
    "    #print(xtrain.shape, xtest.shape, ytrain.shape, ytest.shape)\n",
    "    #print('------------------------------')\n",
    "\n",
    "    \n",
    "    from sklearn.model_selection import train_test_split\n",
    "\n",
    "    xtrain_participant,xtest, ytrain_participant_both , ytest_both = train_test_split(xtest, ytest, test_size=0.5, random_state=42)\n",
    "    \n",
    "    \n",
    "    \n",
    "    xtrain_participant = sc_xtrain.fit_transform(xtrain_participant)\n",
    "    xtrain_eye_gaze_participant = xtrain_participant[:,-1].reshape(-1, 1)\n",
    "    xtrain_pointing_participant = xtrain_participant[:,0:3]\n",
    "    ytrain_participant = ytrain_participant_both[:,0]\n",
    "\n",
    "\n",
    "    xtest = sc_xtest.fit_transform(xtest)\n",
    "    xtest_eye_gaze = xtest[:,-1].reshape(-1, 1)\n",
    "    xtest_pointing = xtest[:,0:3]\n",
    "    ytest = ytest_both[:,0]\n",
    "    ytest_width = ytest_both[:,1]\n",
    "\n",
    "\n",
    "#     #############################################################################\n",
    "#     #get before personalization\n",
    "    \n",
    "#     regressor.fit(xtrain_fuse,ytrain_fuse)\n",
    "#     #print('-----------------')\n",
    "#     pred=regressor.predict(xtest)\n",
    "#     print(mean_squared_error(ytest, pred))\n",
    "#     #print('-----------------')\n",
    "\n",
    "#     regressor.fit(xtrain_pointing,ytrain_pointing)\n",
    "#     pred=regressor.predict(xtest_pointing)\n",
    "#     print(mean_squared_error(ytest, pred))\n",
    "#     #print('-----------------')\n",
    "\n",
    "\n",
    "#     regressor.fit(xtrain_eye_gaze,ytrain_eye_gaze)\n",
    "#     pred=regressor.predict(xtest_eye_gaze)\n",
    "#     print(mean_squared_error(ytest, pred))\n",
    "#     #print('-----------------')    \n",
    "#     #############################################################################  \n",
    "\n",
    "    \n",
    "    \n",
    "\n",
    "    #add participants to training\n",
    "    \n",
    "    \n",
    "    xtrain_fuse = np.concatenate((xtrain_fuse, xtrain_participant),axis=0)\n",
    "    ytrain_fuse = np.concatenate((ytrain_fuse, ytrain_participant),axis=0)\n",
    "    \n",
    "    xtrain_pointing = np.concatenate((xtrain_pointing, xtrain_pointing_participant),axis=0)\n",
    "    ytrain_pointing = np.concatenate((ytrain_pointing, ytrain_participant),axis=0)\n",
    "    \n",
    "    xtrain_eye_gaze = np.concatenate((xtrain_eye_gaze, xtrain_eye_gaze_participant),axis=0)\n",
    "    ytrain_eye_gaze = np.concatenate((ytrain_eye_gaze, ytrain_participant),axis=0)\n",
    "\n",
    "    \n",
    "    \n",
    "    #############################################################################\n",
    "    #get after personalization\n",
    "    \n",
    "    \n",
    "\n",
    "    sample_weight_fuse = 1 * np.ones((len(ytrain_fuse)))\n",
    "    sample_weight_fuse[-len(ytrain_participant):] *= sample_weight_value\n",
    "    \n",
    "    sample_weight_point = 1 * np.ones((len(ytrain_pointing)))\n",
    "    sample_weight_point[-len(ytrain_participant):] *= sample_weight_value\n",
    "\n",
    "    sample_weight_gaze = 1 * np.ones((len(ytrain_eye_gaze)))\n",
    "    sample_weight_gaze[-len(ytrain_participant):] *= sample_weight_value\n",
    "    \n",
    "#     print('--------=======---------')\n",
    "#     print(sample_weight_fuse.shape,sample_weight_point.shape,sample_weight_gaze.shape)\n",
    "#     #print(sample_weight_fuse,sample_weight_point,sample_weight_gaze)\n",
    "#     print('--------=======---------')\n",
    "    \n",
    "    \n",
    "    \n",
    "    regressor.fit(xtrain_fuse,ytrain_fuse,sample_weight=sample_weight_fuse)\n",
    "    #print('-----------------')\n",
    "    pred=regressor.predict(xtest)\n",
    "    print(mean_squared_error(ytest, pred))\n",
    "    #print('-----------------')\n",
    "    \n",
    "    print('================================================')\n",
    "    #print(ytest,pred)\n",
    "    #print(abs(ytest-pred))\n",
    "    #print(ytest_width)\n",
    "    relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "    #print(relative_width)\n",
    "    print(relative_width.mean())\n",
    "    print(relative_width.std())\n",
    "    print('================================================')\n",
    "\n",
    "    regressor.fit(xtrain_pointing,ytrain_pointing,sample_weight=sample_weight_point)\n",
    "    pred=regressor.predict(xtest_pointing)\n",
    "    print(mean_squared_error(ytest, pred))\n",
    "    #print('-----------------')\n",
    "\n",
    "    print('================================================')\n",
    "    #print(ytest,pred)\n",
    "    #print(abs(ytest-pred))\n",
    "    #print(ytest_width)\n",
    "    relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "    #print(relative_width)\n",
    "    print(relative_width.mean())\n",
    "    print(relative_width.std())\n",
    "    print('================================================')\n",
    "\n",
    "    regressor.fit(xtrain_eye_gaze,ytrain_eye_gaze,sample_weight=sample_weight_gaze)\n",
    "    pred=regressor.predict(xtest_eye_gaze)\n",
    "    print(mean_squared_error(ytest, pred))\n",
    "    \n",
    "    print('================================================')\n",
    "    #print(ytest,pred)\n",
    "    #print(abs(ytest-pred))\n",
    "    #print(ytest_width)\n",
    "    relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "    #print(relative_width)\n",
    "    print(relative_width.mean())\n",
    "    print(relative_width.std())\n",
    "    print('================================================')\n",
    "    \n",
    "    #print('-----------------')     \n",
    "    #############################################################################\n",
    "    \n",
    "    \n",
    "    #print(xtrain.shape, xtest.shape, xtrain_eye_gaze.shape, xtest_eye_gaze.shape, xtrain_pointing.shape, xtest_pointing.shape, ytrain.shape, ytest.shape)\n",
    "    #print('------------------------------')\n",
    "    \n",
    "    #print('------=====begin inside loop=====------')\n",
    "    \n",
    "    \n",
    "    MSE_fusion = []\n",
    "    MSE_pointing = []\n",
    "    MSE_Gaze = []\n",
    "    \n",
    "    RMDE_fusion = []\n",
    "    RMDE_pointing = []\n",
    "    RMDE_Gaze = []\n",
    "    \n",
    "    for participant_no_inside in sync_confirmed_list_test:\n",
    "    \n",
    "        #print('P',participant_no_inside)\n",
    "        dataset_test_participant_2 = pd.read_csv(Participant_file_name+ str(participant_no_inside)+'.csv')\n",
    "\n",
    "\n",
    "        xtest = dataset_test_participant_2.iloc[:,1:5].values.astype(float)\n",
    "        ytest = dataset_test_participant_2.iloc[:,6:8].values.astype(float)\n",
    "        ssss, xtest, ssss , ytest = train_test_split(xtest, ytest, test_size=0.5, random_state=42)\n",
    "        sc_xtest = StandardScaler()\n",
    "        #sc_xtest = MinMaxScaler()\n",
    "        xtest = sc_xtest.fit_transform(xtest)\n",
    "\n",
    "\n",
    "        xtest_eye_gaze = xtest[:,-1].reshape(-1, 1)\n",
    "        xtest_pointing = xtest[:,0:3]\n",
    "        ytest_width = ytest[:,1]\n",
    "        ytest = ytest[:,0]\n",
    "        \n",
    "\n",
    "\n",
    "        regressor.fit(xtrain_fuse,ytrain_fuse,sample_weight=sample_weight_fuse)\n",
    "        pred=regressor.predict(xtest)\n",
    "        MSE_fusion.append(mean_squared_error(ytest, pred))\n",
    "        relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "        RMDE_fusion.append(relative_width.mean())\n",
    "        \n",
    "        regressor.fit(xtrain_pointing,ytrain_pointing,sample_weight=sample_weight_point)\n",
    "        pred=regressor.predict(xtest_pointing)\n",
    "        MSE_pointing.append(mean_squared_error(ytest, pred))\n",
    "        relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "        RMDE_pointing.append(relative_width.mean())\n",
    "\n",
    "        regressor.fit(xtrain_eye_gaze,ytrain_eye_gaze,sample_weight=sample_weight_gaze)\n",
    "        pred=regressor.predict(xtest_eye_gaze)\n",
    "        MSE_Gaze.append(mean_squared_error(ytest, pred))\n",
    "        relative_width = abs(ytest-pred)/(ytest_width + tolerance_degree)\n",
    "        RMDE_Gaze.append(relative_width.mean())        \n",
    "\n",
    "    appended_MSE_fusion.append(MSE_fusion)\n",
    "    appended_MSE_pointing.append(MSE_pointing)\n",
    "    appended_MSE_Gaze.append(MSE_Gaze)\n",
    "    \n",
    "    appended_RMDE_fusion.append(RMDE_fusion)\n",
    "    appended_RMDE_pointing.append(RMDE_pointing)\n",
    "    appended_RMDE_Gaze.append(RMDE_Gaze)\n",
    "    \n",
    "    #print('------=====end inside loop=====------')\n",
    "    #print('------=====end Participant=====------')\n",
    "    print('------=========================------')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_weight_values = [15]\n",
    "\n",
    "average_fusion_MSE_weights = []\n",
    "average_fusion_MSE_non_weights_total = []\n",
    "\n",
    "average_fusion_RMDE_weights = []\n",
    "average_fusion_RMDE_non_weights_total = []\n",
    "\n",
    "for sample_weight_value in sample_weight_values:\n",
    "\n",
    "    average_fusion_MSE_per_weight = []\n",
    "    average_fusion_RMDE_per_weight = []\n",
    "\n",
    "    average_fusion_MSE_others_total = []\n",
    "    average_fusion_RMDE_others_total = []\n",
    "    \n",
    "    \n",
    "    appended_MSE_fusion = []\n",
    "    appended_MSE_pointing = []\n",
    "    appended_MSE_Gaze = []\n",
    "\n",
    "    appended_RMDE_fusion = []\n",
    "    appended_RMDE_pointing = []\n",
    "    appended_RMDE_Gaze = []\n",
    "\n",
    "    for i in sync_confirmed_list_test:\n",
    "        personalisation_svr_test_train(i,sc_xtrain,sc_xtest,xtrain_fuse,ytrain_fuse,xtrain_pointing,ytrain_pointing,xtrain_eye_gaze,ytrain_eye_gaze,sample_weight_value)\n",
    "\n",
    "    appended_MSE_fusion = np.array(appended_MSE_fusion)\n",
    "    appended_MSE_pointing = np.array(appended_MSE_pointing)\n",
    "    appended_MSE_Gaze = np.array(appended_MSE_Gaze)\n",
    "    \n",
    "    appended_RMDE_fusion = np.array(appended_RMDE_fusion)\n",
    "    appended_RMDE_pointing = np.array(appended_RMDE_pointing)\n",
    "    appended_RMDE_Gaze = np.array(appended_RMDE_Gaze)\n",
    "\n",
    "    for column in range(len(appended_MSE_fusion)):\n",
    "        average_fusion_MSE_others = 0\n",
    "        average_fusion_RMDE_others = 0\n",
    "        for row in range(len(appended_MSE_fusion)):\n",
    "            if row == column:\n",
    "                average_fusion_MSE_per_weight.append(appended_MSE_fusion[row,column])\n",
    "                average_fusion_RMDE_per_weight.append(appended_RMDE_fusion[row,column])\n",
    "            else:\n",
    "                average_fusion_MSE_others += appended_MSE_fusion[row,column]\n",
    "                average_fusion_RMDE_others += appended_RMDE_fusion[row,column]\n",
    "        average_fusion_MSE_others = average_fusion_MSE_others / (len(appended_MSE_fusion)-1)\n",
    "        average_fusion_RMDE_others = average_fusion_RMDE_others / (len(appended_MSE_fusion)-1)    \n",
    "\n",
    "        average_fusion_MSE_others_total.append(average_fusion_MSE_others)\n",
    "        average_fusion_RMDE_others_total.append(average_fusion_RMDE_others)\n",
    "    \n",
    "    \n",
    "#     print(average_fusion_MSE_per_weight)\n",
    "#     print(average_fusion_RMDE_per_weight)\n",
    "\n",
    "#     print(average_fusion_MSE_others_total)\n",
    "#     print(average_fusion_RMDE_others_total)\n",
    "    \n",
    "    average_fusion_MSE_weights.append(np.mean(average_fusion_MSE_per_weight))\n",
    "    average_fusion_RMDE_weights.append(np.mean(average_fusion_RMDE_per_weight))\n",
    "    \n",
    "    average_fusion_MSE_non_weights_total.append(np.mean(average_fusion_MSE_others_total))\n",
    "    average_fusion_RMDE_non_weights_total.append(np.mean(average_fusion_RMDE_others_total))\n",
    "    \n",
    "    \n",
    "    np.savetxt('ML-PersRef_ML_Final_dataset_results/appended_MSE_fusion_first_middle_point_another_sample_sample_weight_'+str(sample_weight_value)+'_support_vectors_only.csv', appended_MSE_fusion, delimiter=',')\n",
    "    np.savetxt('ML-PersRef_ML_Final_dataset_results/appended_MSE_pointing_first_middle_point_another_sample_sample_weight_'+str(sample_weight_value)+'_support_vectors_only.csv', appended_MSE_pointing, delimiter=',')\n",
    "    np.savetxt('ML-PersRef_ML_Final_dataset_results/appended_MSE_Gaze_first_middle_point_another_sample_sample_weight_'+str(sample_weight_value)+'_support_vectors_only.csv', appended_MSE_Gaze, delimiter=',')\n",
    "    \n",
    "    np.savetxt('ML-PersRef_ML_Final_dataset_results/appended_RMDE_fusion_first_middle_point_another_sample_sample_weight_'+str(sample_weight_value)+'_support_vectors_only.csv', appended_RMDE_fusion, delimiter=',')\n",
    "    np.savetxt('ML-PersRef_ML_Final_dataset_results/appended_RMDE_pointing_first_middle_point_another_sample_sample_weight_'+str(sample_weight_value)+'_support_vectors_only.csv', appended_RMDE_pointing, delimiter=',')\n",
    "    np.savetxt('ML-PersRef_ML_Final_dataset_results/appended_RMDE_Gaze_first_middle_point_another_sample_sample_weight_'+str(sample_weight_value)+'_support_vectors_only.csv', appended_RMDE_Gaze, delimiter=',')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}