Ridge Regression-Across-All-Voxels.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.io import loadmat\n",
    "from sklearn.model_selection import KFold, RepeatedKFold\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import Ridge, RidgeCV, Lasso\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from scipy.stats import pearsonr\n",
    "from scipy import spatial\n",
    "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pairwise_accuracy(actual, predicted):\n",
    "    true = 0\n",
    "    total = 0\n",
    "    for i in range(0,len(actual)):\n",
    "#         print(i)\n",
    "        for j in range(i+1, len(actual)):\n",
    "            total += 1\n",
    "\n",
    "            s1 = actual[i]\n",
    "            s2 = actual[j]\n",
    "            b1 = predicted[i]\n",
    "            b2 = predicted[j]\n",
    "\n",
    "            result1 = spatial.distance.cosine(s1, b1)\n",
    "            result2 = spatial.distance.cosine(s2, b2)\n",
    "            result3 = spatial.distance.cosine(s1, b2)\n",
    "            result4 = spatial.distance.cosine(s2, b1)\n",
    "\n",
    "            if(result1 + result2 < result3 + result4):\n",
    "                true += 1\n",
    "\n",
    "    return(true/total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pearcorr(actual, predicted):\n",
    "    corr = []\n",
    "    r2 = []\n",
    "    for i in range(0, len(actual)):\n",
    "        corr.append(np.corrcoef(actual[i],predicted[i])[0][1])\n",
    "        r2.append(np.corrcoef(actual[i],predicted[i])[0][1]**2)\n",
    "    return np.mean(corr), np.mean(r2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mse_r2(actual, predicted):\n",
    "    mae = []\n",
    "    r2 = []\n",
    "    for i in range(0, len(actual)):\n",
    "        mae.append(mean_absolute_error(actual[i],predicted[i]))\n",
    "        #r2.append(r2_score(predicted[i], actual[i]))\n",
    "    return np.mean(mae)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "kf = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(vectors, voxels):\n",
    "    \n",
    "    dataset_X = np.array(voxels.copy())\n",
    "    \n",
    "    dataset_Y = np.array(vectors.copy())\n",
    "\n",
    "#     accuracies = []\n",
    "#     accuracies01 = []\n",
    "    \n",
    "    actual = []\n",
    "    predicted = np.empty([0,10732])\n",
    "    pairwise_2v2 = []\n",
    "    final_corr = []\n",
    "    mse = []\n",
    "    r2 = []\n",
    "    #rdm_feat = []\n",
    "\n",
    "    cnt = 0\n",
    "    indices = []\n",
    "    for train_index, test_index in kf.split(dataset_X):\n",
    "\n",
    "        X_train, X_test = dataset_X[train_index], dataset_X[test_index]\n",
    "        y_train, y_test = dataset_Y[train_index], dataset_Y[test_index]\n",
    "           \n",
    "        model = Ridge(alpha=1.0)\n",
    "        #model = MLPRegressor(learning_rate_init=0.1)\n",
    "        #model =Lasso(alpha=0.1)\n",
    "        model.fit(X_train,y_train)\n",
    "        \n",
    "        \n",
    "\n",
    "        y_pred = model.predict(X_test)\n",
    "        predicted = np.concatenate([predicted,y_pred],axis=0)\n",
    "        #print(pairwise_2v2[cnt],final_corr[cnt],rdm_acc[cnt])\n",
    "        cnt += 1\n",
    "        indices.extend(test_index)\n",
    "    return predicted, indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.load('./pieman_data_paraphrase.npy',allow_pickle=True)\n",
    "data = data.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "ROIS = ['eac_L', 'eac_R', 'aac_L', 'aac_R', 'pmc_L', 'pmc_R', 'tpoj_L', 'tpoj_R', 'LAN_L', 'LAN_R']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(82, 259, 808)\n",
      "eac_L\n",
      "\n",
      "(82, 259, 808)\n",
      "(82, 259, 638)\n",
      "eac_R\n",
      "\n",
      "(82, 259, 1446)\n",
      "(82, 259, 1420)\n",
      "aac_L\n",
      "\n",
      "(82, 259, 2866)\n",
      "(82, 259, 1493)\n",
      "aac_R\n",
      "\n",
      "(82, 259, 4359)\n",
      "(82, 259, 1198)\n",
      "pmc_L\n",
      "\n",
      "(82, 259, 5557)\n",
      "(82, 259, 1204)\n",
      "pmc_R\n",
      "\n",
      "(82, 259, 6761)\n",
      "(82, 259, 847)\n",
      "tpoj_L\n",
      "\n",
      "(82, 259, 7608)\n",
      "(82, 259, 1188)\n",
      "tpoj_R\n",
      "\n",
      "(82, 259, 8796)\n",
      "(82, 259, 1061)\n",
      "LAN_L\n",
      "\n",
      "(82, 259, 9857)\n",
      "(82, 259, 875)\n",
      "LAN_R\n",
      "\n",
      "(82, 259, 10732)\n"
     ]
    }
   ],
   "source": [
    "roi_voxels = np.empty([82,259,0])\n",
    "for roi in ROIS:\n",
    "    # data_voxels = loadmat('datafile.mat')\n",
    "    data_voxels = np.load('../../afni-nosmooth/pieman_'+roi+'_avg.npy')\n",
    "    data_voxels = data_voxels[:,data['non_empty_tr_indices'],:]\n",
    "    print(data_voxels.shape)\n",
    "    print(roi)\n",
    "    print()\n",
    "    roi_voxels = np.concatenate([roi_voxels,data_voxels],axis=2)\n",
    "    print(roi_voxels.shape)\n",
    "    \n",
    "    #fn = './'+roi+'_srl_ridge.npy'\n",
    "    #np.save(fn,output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(259, 10732)\n"
     ]
    }
   ],
   "source": [
    "for i in np.arange(82):\n",
    "    roi_fmri = roi_voxels[i]\n",
    "    #scaler = StandardScaler()\n",
    "    #roi_fmri = scaler.fit_transform(roi_fmri)\n",
    "    predicted,indices = train(roi_fmri,data['tr_features'])\n",
    "    break\n",
    "aa = predicted[indices]\n",
    "print(aa.shape)\n",
    "np.save('paraphrase_pred',aa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = ['coreference', 'ner', 'nli', 'sa', 'shallosyntax', 'srl', 'paraphrase', 'summary', 'wsd', 'qa', 'el']\n",
    "ROIS = ['eac_L', 'eac_R', 'aac_L', 'aac_R', 'pmc_L', 'pmc_R', 'tpoj_L', 'tpoj_R', 'LAN_L', 'LAN_R']"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}