Bayesian_Inference_and_Kinect_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Bayesian Inference: *An application to Kinect data*\n",
    "\n",
    "*by Javier Rico Reche (jvirico@gmail.com)*\n",
    "\n",
    "[*Online version*](https://www.notion.so/ABM-Assignment-II-1bf730df6f9944f2bc9ecb3804712551)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Introduction\n",
    "\n",
    "During this work we perform the classification of sequences of body positions of skeletal body movements recorded from a kinect device.\n",
    "\n",
    "First we train two Bayesian models, Naïve Bayes and Linear Gaussian Model, the later considering dependencies between the positions of different parts of the skeleton.\n",
    "\n",
    "Second, we classify a set of new instances using both methods, and finally we evaluate the results giving an Accuracy estimate using Stratified K-Fold Cross-Validation."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Data\n",
    "\n",
    "We use a fraction of the [Kinect Gesture Dataset](https://www.microsoft.com/en-us/download/details.aspx?id=52283&from=http%3A%2F%2Fresearch.microsoft.com%2Fen-us%2Fum%2Fcambridge%2Fprojects%2Fmsrc12%2F) from Microsoft Research Cambridge, that consists of sequences of human movements, represented as body-part locations, and the associated gesture to be recognized by a system. Although the original dataset contains more than 6h of recordings of 30 people, our subset has 2045 instances of body positions for 4 classes, 'arms lifted', 'right arm extended to one side', 'crouched' and 'right arm extended to the front'.\n",
    "\n",
    "The data is provided in a .mat Matlab file and loaded in python using *scipy.io.loadmat* function.\n",
    "\n",
    "It is organized in three data structures:\n",
    "\n",
    "1. **data**: a matrix (20x3x2045) with information of joints and their corresponding 3D coordinates of 2045 instances.\n",
    "2. **labels**: a vector (2045x1) with the class label for each instance.\n",
    "3. **individuals:** a vector (2045x1) with the identification of each individual."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    " ## Source Code"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Libraries"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "import numpy as np \n",
    "import math\n",
    "import random\n",
    "import scipy.io\n",
    "from copy import copy, deepcopy\n",
    "from scipy.stats import lognorm\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import StratifiedKFold"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Data structures and classes"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "# Skeleton definition\n",
    "NUI_SKELETON_POSITION_COUNT = 20\n",
    "\n",
    "NONE = -1\n",
    "HIP_CENTER = 0\n",
    "SPINE = 1\n",
    "SHOULDER_CENTER = 2\n",
    "HEAD = 3\n",
    "SHOULDER_LEFT = 4\n",
    "ELBOW_LEFT = 5\n",
    "WRIST_LEFT = 6\n",
    "HAND_LEFT = 7\n",
    "SHOULDER_RIGHT = 8\n",
    "ELBOW_RIGHT = 9\n",
    "WRIST_RIGHT = 10\n",
    "HAND_RIGHT = 11\n",
    "HIP_LEFT = 12\n",
    "KNEE_LEFT = 13\n",
    "ANKLE_LEFT = 14\n",
    "FOOT_LEFT = 15\n",
    "HIP_RIGHT = 16\n",
    "KNEE_RIGHT = 17\n",
    "ANKLE_RIGHT = 18\n",
    "FOOT_RIGHT = 19\n",
    "\n",
    "nui_skeleton_names = ( \\\n",
    "    'HIP_CENTER', 'SPINE', 'SHOULDER_CENTER', 'HEAD', \\\n",
    "    'SHOULDER_LEFT', 'ELBOW_LEFT', 'WRIST_LEFT', 'HAND_LEFT', \\\n",
    "    'SHOULDER_RIGHT', 'ELBOW_RIGHT', 'WRIST_RIGHT', 'HAND_RIGHT', \\\n",
    "    'HIP_LEFT', 'KNEE_LEFT', 'ANKLE_LEFT', 'FOOT_LEFT', \\\n",
    "    'HIP_RIGHT', 'KNEE_RIGHT', 'ANKLE_RIGHT', 'FOOT_RIGHT' )\n",
    "\n",
    "nui_skeleton_conn = ( \\\n",
    "    NONE, \\\n",
    "    HIP_CENTER, \\\n",
    "    SPINE, \\\n",
    "    SHOULDER_CENTER, \\\n",
    "    # Left arm \n",
    "    SHOULDER_CENTER, \\\n",
    "    SHOULDER_LEFT,  \\\n",
    "    ELBOW_LEFT,  \\\n",
    "    WRIST_LEFT,  \\\n",
    "    # Right arm \n",
    "    SHOULDER_CENTER,  \\\n",
    "    SHOULDER_RIGHT,  \\\n",
    "    ELBOW_RIGHT,  \\\n",
    "    WRIST_RIGHT,  \\\n",
    "    # Left leg \n",
    "    HIP_CENTER,  \\\n",
    "    HIP_LEFT,  \\\n",
    "    KNEE_LEFT,  \\\n",
    "    ANKLE_LEFT,  \\\n",
    "    # Right leg \n",
    "    HIP_CENTER,  \\\n",
    "    HIP_RIGHT,  \\\n",
    "    KNEE_RIGHT,  \\\n",
    "    ANKLE_RIGHT,  \\\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "## Saving the Skeleton definition\n",
    "G = []\n",
    "G.append(nui_skeleton_names)\n",
    "G.append(nui_skeleton_conn)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "## Accessing Skeleton info\n",
    "print(G[0][1])       #Joint 1 name\n",
    "print(G[1][1])       #Joint 1 parent\n",
    "print(G[0][G[1][1]]) #Joint 1 parent name"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "SPINE\n",
      "0\n",
      "HIP_CENTER\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Model Object\n",
    "\n",
    "The parameters are stored in an object of class *model* as the one below."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "# Classes used to build the model structure\n",
    "class model:\n",
    "    def __init__(self, G=None):\n",
    "        self.connectivity = G\n",
    "        self.class_priors = []\n",
    "        self.jointparts   = []\n",
    "\n",
    "class NBJoint:\n",
    "    def __init__(self):\n",
    "        self.means  = []\n",
    "        self.sigmas = []\n",
    "        \n",
    "class LGMJoint:\n",
    "    def __init__(slf):\n",
    "        slf.HC_means  = []\n",
    "        slf.HC_sigmas = []\n",
    "        slf.betas     = []\n",
    "        slf.sigmas    = []"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Auxiliary Functions"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "def load_dataset(file=None):\n",
    "    \"\"\"\n",
    "      Returns the data, the labels and the person id for each action\n",
    "    \"\"\"\n",
    "    import scipy.io\n",
    "    \n",
    "    if file is None:\n",
    "        ex = scipy.io.loadmat('data/data.mat')\n",
    "    else:\n",
    "        ex = scipy.io.loadmat(file)\n",
    "        \n",
    "    return ex['data'],ex['labels'],ex['individuals']"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "def normpdf(x, mu, sigma):\n",
    "    \"\"\"\n",
    "        Computes Normal PDF\n",
    "    \n",
    "    \"\"\"\n",
    "    p = (1/(sigma*np.sqrt(2*np.pi)))*math.exp(-( ( (x-mu)/sigma )**2 )/2)\n",
    "    \n",
    "    return p"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "def my_normalizator(probs):\n",
    "    total = 0\n",
    "    for i in range(0, len(probs)):\n",
    "        total = total + probs[i]\n",
    "        \n",
    "    return (np.divide(probs,total))\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "print(my_normalizator([2,3,3,4]))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[0.16666667 0.25       0.25       0.33333333]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions for Bayesian Models"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "def my_cov(x,y,w):\n",
    "    \"\"\"\n",
    "      Useful function for fit_linear_gaussian\n",
    "    \"\"\"\n",
    "    return np.sum(w*x*y)/np.sum(w)-np.sum(w*x)*np.sum(w*y)/np.sum(w)/np.sum(w)\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Out Naïve Bayes Model will use a Normal Distribution.\n",
    "\n",
    "$$P(X|C) = Normal(X;\\mu, \\sigma^2)$$\n",
    "\n",
    "See fit_gaussian below:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "def fit_gaussian(X, W=None):\n",
    "    \"\"\"\n",
    "      Compute the mean and variance of X, \n",
    "      You can ignore W for the moment\n",
    "    \"\"\"\n",
    "    mean = np.mean(X)\n",
    "    sigma = np.std(X)\n",
    "    #var = std**2\n",
    "    \n",
    "    return (mean, sigma)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Out Linear Gaussian Model will use the following distribution.\n",
    "\n",
    "$$P(Y|X) = Normal(Y;\\beta_{0}+\\beta_{1}x_{1}+\\beta_{2}x_{2}+...+\\beta_{k}x_{k}; \\sigma^2)$$\n",
    "\n",
    "See fit_linear_gaussian below:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "def fit_linear_gaussian(Y,X,W = None):\n",
    "    \"\"\"\n",
    "    Input:\n",
    "      Y: vector of size D with the observations for the variable\n",
    "      X: matrix DxV with the observations for the parent variables\n",
    "                 of X. V is the number of parent variables\n",
    "      W: vector of size D with the weights of the instances (ignore for the moment)\n",
    "      \n",
    "    Outout:\n",
    "       The betas and sigma\n",
    "    \"\"\"\n",
    "    \n",
    "    #Betas\n",
    "    D = len(X)\n",
    "    V = len(X[0])\n",
    "    b = []\n",
    "    b.append(np.sum(Y)/D)\n",
    "\n",
    "    for i in range(0, V):\n",
    "        b.append(np.sum((Y@X[:,i]))/D)\n",
    "    \n",
    "    A = np.zeros((V+1, V+1))\n",
    "    A[0,0] = 1\n",
    "\n",
    "    for i in range(0, V):\n",
    "        A[0,i+1] = np.sum(X[:,i])/D\n",
    "\n",
    "    for i in range(0, V):\n",
    "        A[i+1,0] = np.sum(X[:,i])/D\n",
    "\n",
    "    for i in range(0, V):\n",
    "        for j in range(0, V):\n",
    "            A[i+1,j+1] = np.sum((X[:,i]*X[:,j]))/D\n",
    "    \n",
    "    betas = np.linalg.solve(A,b)\n",
    "    \n",
    "    \n",
    "    #Sigma\n",
    "    if (W == None):\n",
    "        W = np.ones(D)\n",
    "\n",
    "    s1 = my_cov(Y,Y,W)\n",
    "    s2 = 0\n",
    "    N = X.shape[1]\n",
    "\n",
    "    for i in range(1, N+1):\n",
    "        for j in range(1, N+1):\n",
    "            s2 = s2 + betas[i]*betas[j]*my_cov(X[:,i-1],X[:,j-1],W)\n",
    "    \n",
    "    sigma = np.sqrt(abs(s1 - s2))\n",
    "    \n",
    "    return (betas,sigma)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "def learn_model(dataset, labels, G=None):\n",
    "    \"\"\"\n",
    "    Input:\n",
    "     dataset: The data as it is loaded from load_data\n",
    "     labels:  The labels as loaded from load_data\n",
    "     Graph:   (optional) If None, this def should compute the naive \n",
    "           bayes model. If it contains a skel description (pe \n",
    "           nui_skeleton_conn, as obtained from skel_model) then it should\n",
    "           compute the model using the Linear Gausian Model\n",
    "\n",
    "    Output: the model\n",
    "     a (tentative) structure for the output model is:\n",
    "       model.connectivity: the input Graph variable should be stored here \n",
    "                           for later use.\n",
    "       model.class_priors: containing a vector with the prior estimations\n",
    "                           for each class\n",
    "       model.jointparts[i] contains the estimated parameters for the i-th joint\n",
    "\n",
    "          For joints that only depend on the class model.jointparts(i) has:\n",
    "            model.jointparts(i).means: a matrix of 3 x #classes with the\n",
    "                   estimated means for each of the x,y,z variables of the \n",
    "                   i-th joint and for each class.\n",
    "            model.jointparts(i).sigma: a matrix of 3 x #classes with the\n",
    "                   estimated stadar deviations for each of the x,y,z \n",
    "                   variables of the i-th joint and for each class.\n",
    "\n",
    "          For joints that follow a gausian linear model model.jointparts(i) has:\n",
    "            model.jointparts(i).betas: a matrix of 12 x #classes with the\n",
    "                   estimated betas for each x,y,z variables (12 in total) \n",
    "                   of the i-th joint and for each class label.\n",
    "            model.jointparts(i).sigma: as above\n",
    "\n",
    "    \"\"\"\n",
    "    numClasses = 4\n",
    "    numJoints = 20\n",
    "    numCoords = 3\n",
    "    \n",
    "    M = model(G)\n",
    "    \n",
    "    #Priors\n",
    "    M.class_priors = [1/numClasses,1/numClasses,1/numClasses,1/numClasses]\n",
    "    \n",
    "    #Estimated parameters of Joints\n",
    "    if(G == None):\n",
    "          ###############\n",
    "         # Naïve Bayes #\n",
    "        ###############\n",
    "        \n",
    "        #Single variable\n",
    "        joint = NBJoint()\n",
    "        j_m = np.zeros((numCoords,numClasses))\n",
    "        j_s = np.zeros((numCoords,numClasses))\n",
    "        \n",
    "        # Joints loop\n",
    "        for i in range(0,numJoints):\n",
    "            # Coordinates loop\n",
    "            for j in range(0,numCoords):\n",
    "                # Classes loop\n",
    "                for k in range(0,numClasses):\n",
    "                    \n",
    "                    if(k == 3):\n",
    "                        clase = 8\n",
    "                    else:        \n",
    "                        clase = k+1\n",
    "                    \n",
    "                    m,s = fit_gaussian(getInstancesValues(dataset,labels,i,j,clase))\n",
    "                    j_m[j,k] = m\n",
    "                    j_s[j,k] = s\n",
    "            \n",
    "            joint.means.append(deepcopy(j_m))\n",
    "            joint.sigmas.append(deepcopy(j_s))\n",
    "            M.jointparts.append(deepcopy(joint))\n",
    "            \n",
    "            j_m = np.zeros((numCoords,numClasses))\n",
    "            j_s = np.zeros((numCoords,numClasses))\n",
    "            joint.means  = []\n",
    "            joint.sigmas = []\n",
    "        \n",
    "    else:\n",
    "          #########################\n",
    "         # Linear Gaussian Model #\n",
    "        #########################\n",
    "\n",
    "        # Single variable\n",
    "        joint = LGMJoint()\n",
    "        j_m = np.zeros((numCoords,numClasses))\n",
    "        j_b = np.zeros((numCoords,numClasses,4))\n",
    "        j_s = np.zeros((numCoords,numClasses))\n",
    "        \n",
    "        # Joints loop\n",
    "        for i in range(0,numJoints):\n",
    "            # Coordinates loop\n",
    "            for j in range(0,numCoords):\n",
    "                # Classes loop\n",
    "                for k in range(0,numClasses):\n",
    "                    \n",
    "                    if(k == 3):\n",
    "                        clase = 8\n",
    "                    else:        \n",
    "                        clase = k+1\n",
    "                    \n",
    "                    Y,X = getInstancesAndParentValues(dataset,labels,i,j,clase,G)\n",
    "                    \n",
    "                    if(i == 0):\n",
    "                        #Special case of HIP_CENTER wich has no parents, we use Mean and Variance\n",
    "                        m,s = fit_gaussian(Y)\n",
    "                        \n",
    "                        j_m[j,k] = m\n",
    "                        j_s[j,k] = s\n",
    "                    else:\n",
    "                        b,s = fit_linear_gaussian(Y,X)\n",
    "                        \n",
    "                        j_b[j,k] = np.array(b)\n",
    "                        j_s[j,k] = s\n",
    "            \n",
    "            if(i == 0):\n",
    "                joint.HC_means.append(deepcopy(j_m))\n",
    "                joint.HC_sigmas.append(deepcopy(j_s))\n",
    "            else:\n",
    "                joint.betas.append(deepcopy(j_b))\n",
    "                joint.sigmas.append(deepcopy(j_s))\n",
    "                \n",
    "            M.jointparts.append(deepcopy(joint))\n",
    "            \n",
    "            j_b = np.zeros((numCoords,numClasses,4))\n",
    "            j_s = np.zeros((numCoords,numClasses))\n",
    "            joint.betas  = []\n",
    "            joint.sigmas = []\n",
    "\n",
    "    return M"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "def getInstancesValues(data, labels, joint,coordinate,clase):\n",
    "    \"\"\"\n",
    "        Input:\n",
    "            data: dataset\n",
    "            labels: labesls dataset\n",
    "            joint: joint number\n",
    "            coordinat: x, y or z (0,1 or 2)\n",
    "            clase: class value (1, 2, 3 or 8)\n",
    "        Output:\n",
    "            retorno: Vector with values of a specific\n",
    "                coordinate (x,y or z) given joint and class.\n",
    "    \"\"\"\n",
    "    retorno = []\n",
    "    \n",
    "    for l in range(0,len(labels)):\n",
    "        if(labels[l]==clase):\n",
    "            retorno.append(data[joint,coordinate,l])\n",
    "\n",
    "    return (retorno)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "def getInstancesAndParentValues(data, labels, joint, coordinate, clase, G):\n",
    "    \"\"\"\n",
    "        Input:\n",
    "            data: dataset\n",
    "            labels: labesls dataset\n",
    "            joint: joint number\n",
    "            coordinat: x, y or z (0,1 or 2)\n",
    "            clase: class value (1, 2, 3 or 8)\n",
    "            G: skeleton structure\n",
    "        Output:\n",
    "            retornoY: Vector with values of a specific\n",
    "            coordinate (x,y or z) given joint and class.\n",
    "            retornoX: Vector with values form parent joint.\n",
    "    \"\"\"\n",
    "    retornoY = []\n",
    "    retornoX = []\n",
    "    \n",
    "    N = len(labels)\n",
    "    PJoint = G[1][joint]\n",
    "    \n",
    "    for l in range(0,N):\n",
    "        if(labels[l]==clase):\n",
    "            retornoY.append(data[joint,coordinate,l])\n",
    "            if(PJoint == -1):\n",
    "                #print(\"HIP_CENTER\")\n",
    "                retornoX.append(data[joint,coordinate,l])\n",
    "            else:\n",
    "                retornoX.append(data[PJoint,:,l])           \n",
    "    \n",
    "    return (np.array(retornoY),np.array(retornoX))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "def classify_instances(instances, model):\n",
    "    \"\"\"    \n",
    "        Input\n",
    "           instance: a 20x3x#instances matrix defining body positions of\n",
    "                     instances\n",
    "           model: as the output of learn_model\n",
    "\n",
    "        Output\n",
    "           probs: a matrix of #instances x #classes with the probability of each\n",
    "                  instance of belonging to each of the classes\n",
    "\n",
    "        Important: to avoid underflow numerical issues this computations should\n",
    "                   be performed in log space\n",
    "    \"\"\"\n",
    "\n",
    "    N = instances.shape[2]\n",
    "    Nclasses = len(model.class_priors)\n",
    "    probs = []\n",
    "    \n",
    "    # We iterate throught instances\n",
    "    for i in range(0,N):\n",
    "        # We calculate the probability of instance ith beloging to each class\n",
    "        probs.append(compute_logprobs(instances[:,:,i],model))\n",
    "    \n",
    "    return np.array(probs)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "source": [
    "def GetMu(instance,joint, coord, clase, model):\n",
    "    \"\"\"\n",
    "       Input\n",
    "           instance: single instance\n",
    "           joint: joint number\n",
    "           coord: coordinate index (0, 1 or 2)\n",
    "           clase: class index\n",
    "           model: as given by learn_model\n",
    "\n",
    "       Output\n",
    "           prbs: calculated mean value\n",
    "    \"\"\"\n",
    "    \n",
    "    if(joint == 0):\n",
    "        mu = model.jointparts[0].HC_means[0][coord,clase]\n",
    "    else:\n",
    "\n",
    "        parentJoint = model.connectivity[1][joint]\n",
    "\n",
    "        Xp = instance[parentJoint,0]\n",
    "        Yp = instance[parentJoint,1]\n",
    "        Zp = instance[parentJoint,2]\n",
    "\n",
    "        B0 = model.jointparts[joint].betas[0][coord,clase,0]\n",
    "        B1 = model.jointparts[joint].betas[0][coord,clase,1]\n",
    "        B2 = model.jointparts[joint].betas[0][coord,clase,2]\n",
    "        B3 = model.jointparts[joint].betas[0][coord,clase,3]\n",
    "\n",
    "        mu = B0 + B1*Xp + B2*Yp + B3*Zp\n",
    "\n",
    "    return mu"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "def generate_random_lgm_samples(n, betas, sigma):\n",
    "    \"\"\"Function to generate random samples for a \n",
    "       Linear Gaussian Model\n",
    "       Input:\n",
    "           n: Number of samples\n",
    "           betas: vector with the values the the betas from 0 to k\n",
    "           sigma: standard deviation\n",
    "    \"\"\"\n",
    "    X = np.random.randn(n,betas.shape[0]-1)\n",
    "    Y = np.random.randn(n)*sigma + np.sum(X*betas[1:],axis=1)+betas[0]\n",
    "    return X,Y"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions to compute in Log Space\n",
    "\n",
    "To avoid underflow numerical issues caused by repeated product operations of small numbers we perform the Posterior's computation in Log Space.\n",
    "\n",
    "To implement this we use the following functions:\n",
    "\n",
    "1. ***log_normpdf***: Computes the natural logarithm of the normal probability.\n",
    "2. ***compute_logprobs***: Computes the log probabilities of an instance.\n",
    "3. ***normalize_logprobs***: Normalizes log probabilities."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "def log_normpdf(x, mean, sigma):\n",
    "    \"\"\"\n",
    "      Computes the natural logarithm of the normal probability density function\n",
    "      \n",
    "    \"\"\"\n",
    "    prob = -np.log(sigma)-(1/2)*(np.log(2*np.pi))-(1/2)*(((x-mean)/sigma)**2)\n",
    "    \n",
    "    return prob\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "def compute_logprobs(example, model):\n",
    "    \"\"\"\n",
    "       Input\n",
    "           example: a 20x3 matrix defining body positions of one instance\n",
    "           model: as given by learn_model\n",
    "\n",
    "       Output\n",
    "           prbs: a vector of len #classes containing the loglikelihood of the \n",
    "              instance\n",
    "    \"\"\"\n",
    "    \n",
    "    Nclasses = len(M.class_priors)\n",
    "    Ncoords = 3\n",
    "    Njoints = 20\n",
    "    prbs = []\n",
    "    prb = []\n",
    "\n",
    "    if(model.connectivity == None):\n",
    "        \n",
    "        # We go through the classes\n",
    "        for c in range(0,Nclasses):\n",
    "            # Class prior prob\n",
    "            prb = np.log(M.class_priors[c])\n",
    "            \n",
    "            # We multiply by the likelihood of each joint given parent and class.\n",
    "            # In Log space we add log probabilities\n",
    "            for j in range(0,Njoints):\n",
    "                for i in range(0,Ncoords):\n",
    "\n",
    "                    x = example[j,i]\n",
    "\n",
    "                    mu  = model.jointparts[j].means[0][i,c]\n",
    "                    sig = model.jointparts[j].sigmas[0][i,c]\n",
    "                    \n",
    "                    prb = prb + log_normpdf(x, mu, sig)\n",
    "                    \n",
    "            prbs.append(prb)  \n",
    "\n",
    "    else:\n",
    "    \n",
    "        # We go through the classes\n",
    "        for c in range(0,Nclasses):\n",
    "            # Class prior prob\n",
    "            prb = np.log(M.class_priors[c])\n",
    "\n",
    "            # We multiply by the likelihood of each joint given parent and class\n",
    "            # In Log space we add log probabilities\n",
    "            for j in range(0,Njoints):\n",
    "                for i in range(0,Ncoords):\n",
    "\n",
    "                    x = example[j,i]\n",
    "\n",
    "                    if(j == 0):\n",
    "                        mu  = model.jointparts[0].HC_means[0][i,c]\n",
    "                        sig = model.jointparts[0].HC_sigmas[0][i,c]\n",
    "                    else:\n",
    "                        mu = GetMu(example,j, i, c, model)\n",
    "                        sig = model.jointparts[j].sigmas[0][i,c]\n",
    "\n",
    "                    prb = prb + log_normpdf(x, mu, sig)\n",
    "        \n",
    "            prbs.append(prb)\n",
    "\n",
    "    return np.array(np.exp(normalize_logprobs(prbs)))\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "def normalize_logprobs(log_probs):\n",
    "    \"\"\"\n",
    "       Returns the log prob normalizes so that when exponenciated\n",
    "       it adds up to 1 (Useful to normalizes logprobs)\n",
    "    \"\"\"\n",
    "    mm = np.max(log_probs)\n",
    "    return log_probs - mm - np.log(np.sum(np.exp(log_probs - mm)))\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions to evaluate estimator performance\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "We use the measurement ***Accuracy*** to compare the methods and the models.\n",
    "![image.png](attachment:image.png)\n",
    "We can see its implementation below:"
   ],
   "metadata": {},
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "def Accuracy(predictions, groundTruth):\n",
    "    \"\"\"\n",
    "       Input\n",
    "           predictions: vector with predicted classes for each instance\n",
    "           groundTruth: vector with real classes for each instance\n",
    "\n",
    "       Output\n",
    "           accuracy: accuracy of prediction\n",
    "    \"\"\"\n",
    "    N = len(predictions)\n",
    "    y_pred = []\n",
    "    y_true = groundTruth\n",
    "    \n",
    "    for i in range(0,N):\n",
    "        \n",
    "        c = np.where(predictions[i] == np.amax(predictions[i]))\n",
    "        \n",
    "        if (c[0][0] == 3):\n",
    "            c = 8\n",
    "        else:\n",
    "            c = c[0][0] + 1\n",
    "        \n",
    "        y_pred.append(c)\n",
    " \n",
    "    return (accuracy_score(y_true, y_pred,True))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "source": [
    "def RandomVect(N, min,max):\n",
    "    \"\"\"\n",
    "       Input\n",
    "           N: size of vector to generate\n",
    "           min: minimum value of vector\n",
    "           max: maximum value of vector\n",
    "\n",
    "       Output\n",
    "           retorno: vector with N random (unique) numbers inside range min-max\n",
    "    \"\"\"\n",
    "    \n",
    "    retorno = []\n",
    "    finished = False\n",
    "    ran = 0\n",
    "    i = 0\n",
    "    \n",
    "    while(not finished):\n",
    "        ran = random.randrange(min, max+1)\n",
    "        \n",
    "        if not(ran in retorno):\n",
    "            retorno.append(ran)\n",
    "            i = i + 1\n",
    "            \n",
    "        if(i == N): finished = True\n",
    "        \n",
    "    return retorno"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "source": [
    "print(RandomVect(10,1,100))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[47, 88, 43, 7, 21, 14, 79, 23, 61, 18]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "source": [
    "\"\"\"\n",
    "Stratified k-Fold CrossValidation\n",
    "\"\"\"\n",
    "def GetPerformance(X, y, n_folds = 4, G = None):\n",
    "    \"\"\"\n",
    "       Input\n",
    "           X: data\n",
    "           y: labels\n",
    "           n_folds: number of folds for K-Fold Cross-Validation\n",
    "           G: skeleton info\n",
    "\n",
    "       Output\n",
    "           model: model object eith model with better accuracy\n",
    "           measure: better accuracy, corresponds to model returned\n",
    "           measures: vector with accuracies of all Folds performed,\n",
    "               it has lenght #n_folds.\n",
    "    \"\"\"\n",
    "    \n",
    "    skf = StratifiedKFold(n_folds)\n",
    "    models, measures = [], []\n",
    "    \n",
    "    X_ = np.zeros(len(y))\n",
    "    \n",
    "    for train_index, test_index in skf.split(X_,y):\n",
    "        \n",
    "        ## Extract Kfold\n",
    "        X_train, X_test = X[:,:,train_index], X[:,:,test_index]\n",
    "        y_train, y_test = y[train_index], y[test_index]\n",
    "                \n",
    "        ## Fit models\n",
    "        M = learn_model(X_train,y_train, G)\n",
    "        models.append(learn_model(X_train,y_train, G))\n",
    "        ## Compute measure\n",
    "        proba_m = classify_instances(X_test, M)\n",
    "        Accuracy(probs, labels_test)\n",
    "        measures.append(Accuracy(proba_m, y_test))\n",
    "\n",
    "    i = np.argmax(measures)\n",
    "    model, measure = models[i], measures[i]\n",
    "    return model, measure, measures"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## End of definitions - Code executions"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Testing learned model functionality"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "source": [
    " # Testing GetMu #\n",
    "#################\n",
    "data,labels,individuals = load_dataset()\n",
    "data_train = data[:,:,0:int(2045*0.8)]   #1636 of instances (80%) to train model\n",
    "data_test = data[:,:,int(2045*0.8):2045] #409 of instances (20%) to evaluate model\n",
    "labels_train = labels[0:int(2045*0.8)]\n",
    "labels_test = labels[int(2045*0.8):2045]\n",
    "\n",
    "M = learn_model(data_train,labels_train,G)\n",
    "\n",
    "mu = GetMu(data[:,:,0],2, 0, 1, M)\n",
    "mu"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.10568026257482874"
      ]
     },
     "metadata": {},
     "execution_count": 26
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "source": [
    " # Printing Naïve Bayes model #\n",
    "##############################\n",
    "data,labels,individuals = load_dataset()\n",
    "m = learn_model(data,labels)\n",
    "\n",
    "for i in range(0, 20):\n",
    "    print(i)\n",
    "#    for j in range(0, 3):\n",
    "    print('Means:')\n",
    "    print(m.jointparts[i].means[0])\n",
    "    print('Sigmas:')\n",
    "    print(m.jointparts[i].sigmas[0])"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0\n",
      "Means:\n",
      "[[ 0.01112212 -0.01737053 -0.03560072 -0.1022157 ]\n",
      " [ 0.18124251 -0.43052049  0.13204696  0.13630162]\n",
      " [ 2.85197619  2.85893658  2.83214059  2.63312742]]\n",
      "Sigmas:\n",
      "[[0.11684439 0.13480722 0.12590237 0.149213  ]\n",
      " [0.09502697 0.10523837 0.08837552 0.0926438 ]\n",
      " [0.18857258 0.21078747 0.24108265 0.28238917]]\n",
      "1\n",
      "Means:\n",
      "[[ 0.01083158 -0.01739497 -0.03400122 -0.09851582]\n",
      " [ 0.24235283 -0.38530225  0.19924413  0.20401199]\n",
      " [ 2.8864795   2.83167166  2.86767057  2.65532527]]\n",
      "Sigmas:\n",
      "[[0.11943067 0.13416078 0.12819645 0.14952076]\n",
      " [0.0969737  0.10677718 0.09008805 0.0950633 ]\n",
      " [0.18145818 0.20940876 0.23704666 0.28819055]]\n",
      "2\n",
      "Means:\n",
      "[[ 0.01374415 -0.01706751 -0.02952214 -0.1313279 ]\n",
      " [ 0.5740649  -0.16192242  0.55733611  0.55160436]\n",
      " [ 2.87825109  2.70663207  2.85304254  2.62372971]]\n",
      "Sigmas:\n",
      "[[0.12154389 0.13433178 0.13316234 0.15133611]\n",
      " [0.10389168 0.12209005 0.09798363 0.1128473 ]\n",
      " [0.17965779 0.21224576 0.23622663 0.30221824]]\n",
      "3\n",
      "Means:\n",
      "[[ 0.01617589 -0.01180968 -0.02698633 -0.16865735]\n",
      " [ 0.74267254  0.00901981  0.73504375  0.71543807]\n",
      " [ 2.85054275  2.61412852  2.81432166  2.60538104]]\n",
      "Sigmas:\n",
      "[[0.11687802 0.12628902 0.12857776 0.1540254 ]\n",
      " [0.10719216 0.12613684 0.09932484 0.11377846]\n",
      " [0.17870818 0.21789758 0.23360901 0.29721382]]\n",
      "4\n",
      "Means:\n",
      "[[-0.14967607 -0.17301904 -0.19575962 -0.27031533]\n",
      " [ 0.51550559 -0.21523615  0.4443765   0.42236433]\n",
      " [ 2.87710193  2.71716311  2.85506356  2.65957694]]\n",
      "Sigmas:\n",
      "[[0.11911822 0.12915158 0.13143535 0.15359978]\n",
      " [0.10478839 0.1136214  0.09658991 0.10888713]\n",
      " [0.18198678 0.21038455 0.23893606 0.30246375]]\n",
      "5\n",
      "Means:\n",
      "[[-0.30091319 -0.24341837 -0.26876171 -0.30682637]\n",
      " [ 0.67361136 -0.40015202  0.21111867  0.19959236]\n",
      " [ 2.79295167  2.70844166  2.85160251  2.69423934]]\n",
      "Sigmas:\n",
      "[[0.13633954 0.1407115  0.1307063  0.15915055]\n",
      " [0.11766319 0.11160973 0.10272748 0.13387879]\n",
      " [0.19618766 0.21639394 0.23983838 0.32188071]]\n",
      "6\n",
      "Means:\n",
      "[[-3.82619831e-01 -1.65492648e-01 -2.92808860e-01 -3.17898555e-01]\n",
      " [ 8.68820555e-01 -5.18747216e-01  1.62949195e-02 -5.87994175e-04]\n",
      " [ 2.71742967e+00  2.59278055e+00  2.78512230e+00  2.64973526e+00]]\n",
      "Sigmas:\n",
      "[[0.17301053 0.1733113  0.15550349 0.16358529]\n",
      " [0.14359351 0.14010525 0.13055446 0.16809058]\n",
      " [0.21007846 0.22328894 0.24482453 0.31800955]]\n",
      "7\n",
      "Means:\n",
      "[[-0.40390818 -0.14016127 -0.29307873 -0.31757104]\n",
      " [ 0.93387792 -0.55963989 -0.05570707 -0.07061215]\n",
      " [ 2.7025071   2.56721904  2.76615025  2.63315677]]\n",
      "Sigmas:\n",
      "[[0.18705656 0.18829216 0.17111632 0.16860874]\n",
      " [0.15583031 0.15525214 0.14778209 0.18405282]\n",
      " [0.216535   0.23239437 0.2489823  0.3196296 ]]\n",
      "8\n",
      "Means:\n",
      "[[ 0.17990058  0.14299644  0.13093183 -0.00767857]\n",
      " [ 0.51194072 -0.21415411  0.44661746  0.45278782]\n",
      " [ 2.88498997  2.73845243  2.84673808  2.57078725]]\n",
      "Sigmas:\n",
      "[[0.12265246 0.13295219 0.13302757 0.14758673]\n",
      " [0.10640819 0.11294383 0.0958853  0.10630185]\n",
      " [0.18998322 0.2159962  0.24576417 0.29813152]]\n",
      "9\n",
      "Means:\n",
      "[[ 0.34058479  0.20905185  0.30382232  0.03050674]\n",
      " [ 0.66445383 -0.4005482   0.332115    0.53481485]\n",
      " [ 2.81303485  2.72399393  2.79039616  2.33747796]]\n",
      "Sigmas:\n",
      "[[0.1318329  0.13682889 0.13683435 0.15010778]\n",
      " [0.12455631 0.11161234 0.12890609 0.13902523]\n",
      " [0.21069952 0.22344772 0.24489817 0.28297075]]\n",
      "10\n",
      "Means:\n",
      "[[ 0.4300465   0.12594525  0.45926917  0.00463112]\n",
      " [ 0.86354495 -0.52222032  0.2501721   0.6135753 ]\n",
      " [ 2.75548808  2.60879483  2.6961175   2.12820339]]\n",
      "Sigmas:\n",
      "[[0.16648754 0.13237184 0.16301782 0.1582822 ]\n",
      " [0.15106957 0.13645714 0.16994772 0.19091446]\n",
      " [0.23377784 0.23760304 0.26384719 0.2796971 ]]\n",
      "11\n",
      "Means:\n",
      "[[ 0.45282774  0.10141821  0.51619971 -0.00458963]\n",
      " [ 0.93080543 -0.56168058  0.22683247  0.64006985]\n",
      " [ 2.7441518   2.58121435  2.66260451  2.05520483]]\n",
      "Sigmas:\n",
      "[[0.18410738 0.14228641 0.17900992 0.16511025]\n",
      " [0.16238732 0.15640247 0.18880838 0.21261636]\n",
      " [0.24303131 0.24649246 0.27615368 0.28340105]]\n",
      "12\n",
      "Means:\n",
      "[[-0.06243419 -0.09610842 -0.11007617 -0.15992385]\n",
      " [ 0.10834492 -0.49368803  0.05942384  0.06831221]\n",
      " [ 2.84053987  2.88588784  2.82545406  2.64829435]]\n",
      "Sigmas:\n",
      "[[0.11565509 0.13424023 0.12496666 0.15220191]\n",
      " [0.09176499 0.10567002 0.08539121 0.0899885 ]\n",
      " [0.1886328  0.21007939 0.24070102 0.28227313]]\n",
      "13\n",
      "Means:\n",
      "[[-0.09486201 -0.19268565 -0.14878563 -0.18918934]\n",
      " [-0.41204043 -0.60064749 -0.42102863 -0.42431115]\n",
      " [ 2.91145871  2.62054852  2.89457349  2.68010248]]\n",
      "Sigmas:\n",
      "[[0.11972627 0.1413239  0.12858521 0.15548806]\n",
      " [0.0710576  0.10479167 0.06048578 0.0561025 ]\n",
      " [0.19358271 0.24851408 0.24515752 0.31221083]]\n",
      "14\n",
      "Means:\n",
      "[[-0.10896065 -0.17166262 -0.16772993 -0.20301799]\n",
      " [-0.79179006 -0.83167493 -0.78945061 -0.79530364]\n",
      " [ 2.96456383  2.85152519  2.94483693  2.70756736]]\n",
      "Sigmas:\n",
      "[[0.1222     0.14083112 0.1305679  0.15538536]\n",
      " [0.0752383  0.07935355 0.06319461 0.06014247]\n",
      " [0.19838567 0.22036401 0.25172069 0.33377173]]\n",
      "15\n",
      "Means:\n",
      "[[-0.12906635 -0.18793655 -0.19441283 -0.20989173]\n",
      " [-0.85794438 -0.87760838 -0.85470363 -0.85505689]\n",
      " [ 2.91805241  2.8323671   2.89900733  2.65937084]]\n",
      "Sigmas:\n",
      "[[0.12556837 0.14601586 0.13835946 0.16169569]\n",
      " [0.07778588 0.07765839 0.06585713 0.06470113]\n",
      " [0.19201985 0.2254878  0.25118864 0.3329784 ]]\n",
      "16\n",
      "Means:\n",
      "[[ 0.08356727  0.06197449  0.03667595 -0.03664889]\n",
      " [ 0.10578288 -0.49355204  0.05787068  0.07734206]\n",
      " [ 2.8488346   2.89642419  2.82681992  2.61672576]]\n",
      "Sigmas:\n",
      "[[0.11684861 0.13893913 0.12504453 0.14898719]\n",
      " [0.09173166 0.10483828 0.08519006 0.09091828]\n",
      " [0.19216987 0.21578841 0.24362293 0.28048509]]\n",
      "17\n",
      "Means:\n",
      "[[ 0.10035271  0.14027371  0.06369924  0.01747584]\n",
      " [-0.41809406 -0.61649828 -0.42388353 -0.41011153]\n",
      " [ 2.91903965  2.62933414  2.89769795  2.7517804 ]]\n",
      "Sigmas:\n",
      "[[0.12308121 0.15567391 0.12957238 0.1585109 ]\n",
      " [0.06917225 0.1182931  0.05818857 0.06010008]\n",
      " [0.19572537 0.24263418 0.25138738 0.26467254]]\n",
      "18\n",
      "Means:\n",
      "[[ 0.10143451  0.10876364  0.07083294  0.027485  ]\n",
      " [-0.79719492 -0.83276923 -0.78970081 -0.77630555]\n",
      " [ 2.96326712  2.85311499  2.94042201  2.87994175]]\n",
      "Sigmas:\n",
      "[[0.12740891 0.15671017 0.13716236 0.16483138]\n",
      " [0.07266853 0.08298766 0.06299601 0.06483109]\n",
      " [0.19788448 0.2332874  0.25753437 0.24931021]]\n",
      "19\n",
      "Means:\n",
      "[[ 0.11313215  0.12626051  0.08720845  0.03102705]\n",
      " [-0.86168554 -0.87911671 -0.85317957 -0.83367055]\n",
      " [ 2.91628159  2.83069128  2.89668825  2.83559507]]\n",
      "Sigmas:\n",
      "[[0.12742016 0.15770608 0.13317667 0.16424823]\n",
      " [0.0761083  0.08138086 0.06685319 0.07025631]\n",
      " [0.19730763 0.23529434 0.25852945 0.25145287]]\n"
     ]
    }
   ],
   "metadata": {
    "scrolled": true
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "source": [
    " # Testing learn_model #\n",
    "#######################\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "m = learn_model(data,labels,G)\n",
    "\n",
    "print('Special case of HIP_CENTER')\n",
    "print('Means')\n",
    "print(m.jointparts[0].HC_means[0][0,0]) #jointparts[ <<joint>> ].HC_means[0][<<x,y,z>>,<<class(0-3)>>]\n",
    "print('Sigmas')\n",
    "print(m.jointparts[0].HC_sigmas[0][0,0])\n",
    "print()\n",
    "\n",
    "print('Betas')\n",
    "print(m.jointparts[1].betas[0]) #jointparts[ <<joint>> ].betas[0][<<x,y,z>>,<<class(0-3)>>,<<beta(0-3)>>]\n",
    "print('Sigmas')\n",
    "print(m.jointparts[1].sigmas[0])"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Special case of HIP_CENTER\n",
      "Means\n",
      "0.011122120078740158\n",
      "Sigmas\n",
      "0.11684439406137646\n",
      "\n",
      "Betas\n",
      "[[[ 6.86024005e-03  1.01999064e+00 -1.84209844e-03 -2.46819986e-03]\n",
      "  [ 1.39553237e-03  9.95810413e-01  6.81524334e-03  5.04159543e-04]\n",
      "  [ 9.57077564e-03  1.01803251e+00  1.33723213e-02 -3.21137723e-03]\n",
      "  [-3.50960597e-02  1.01270875e+00 -8.89966734e-03  1.56878144e-02]]\n",
      "\n",
      " [[ 4.45088373e-02 -4.93703006e-04  1.01592983e+00  4.81063439e-03]\n",
      "  [ 4.07484899e-02  6.11734789e-03  1.01222576e+00  3.44164473e-03]\n",
      "  [ 6.43680057e-02  5.74098790e-05  1.01862114e+00  1.31471332e-04]\n",
      "  [ 5.85507308e-02 -8.80639312e-04  1.02135510e+00  2.33900063e-03]]\n",
      "\n",
      " [[ 1.69426531e-01 -3.79209328e-02 -1.41988073e-02  9.53741536e-01]\n",
      "  [-1.07805527e-02  1.41194281e-02  3.03523612e-03  9.94776950e-01]\n",
      "  [ 1.20631066e-01 -6.39881040e-02 -3.71791121e-02  9.70880783e-01]\n",
      "  [-1.84796978e-02 -7.28869531e-03 -5.05545544e-03  1.01542713e+00]]]\n",
      "Sigmas\n",
      "[[0.00380429 0.00563751 0.00404109 0.01128487]\n",
      " [0.00477928 0.00776929 0.0034189  0.00583828]\n",
      " [0.01498314 0.01139866 0.01771913 0.02443616]]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "source": [
    " # Testing fit_linear_gaussian 1 #\n",
    "#################################\n",
    "\n",
    "betas = np.array([1,2,10,4,5,6])\n",
    "sigma = 0.1\n",
    "n=100\n",
    "X,Y=generate_random_lgm_samples(n,betas,sigma)\n",
    "\n",
    "# This following call should output  betas and sigma close to the above ones\n",
    "b, s = fit_linear_gaussian(Y,X)\n",
    "\n",
    "print( 'GT_Betas: ' + str(betas))\n",
    "print ('My_Betas: ' + str(b))\n",
    "print('GT_Sigma: ' + str(sigma))\n",
    "print ('My_Sigma: ' + str(s))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "GT_Betas: [ 1  2 10  4  5  6]\n",
      "My_Betas: [0.99926501 1.98761131 9.98851481 3.99070043 5.00334655 6.0006243 ]\n",
      "GT_Sigma: 0.1\n",
      "My_Sigma: 0.10500603063835766\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "source": [
    " # Testing fit_linear_gaussian 2 #\n",
    "#################################\n",
    "\n",
    "import scipy.io\n",
    "\n",
    "dd = scipy.io.loadmat('data/ejemplolineargaussian.mat')\n",
    "dd = dd['ejemplo'][0]\n",
    "# The inputs are\n",
    "X = dd['inputX']\n",
    "Y = dd['inputY']\n",
    "X = X[0]\n",
    "Y = Y[0][:,0]\n",
    "# The expected outputs are\n",
    "betas = dd['outputBetas']\n",
    "sigma = dd['outputSigma']\n",
    "\n",
    "### Mine\n",
    "data,labels,individuals = load_dataset()\n",
    "#Y_,X_ = getInstancesAndParentValues(data,labels,1,1,1,G)\n",
    "\n",
    "b,s = fit_linear_gaussian(Y,X)\n",
    "print('GT_Betas:' + str(betas[0][:,0]))\n",
    "print('My_Betas:' + str(b))\n",
    "\n",
    "print('GT_Sigma: ' + str(sigma[0][:,0]))\n",
    "print('My_Sigma: ' + str(s))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "GT_Betas:[ 1.00264759e+00 -2.29891432e-03  5.80448903e-02 -4.56929038e+00]\n",
      "My_Betas:[-4.56929038e+00  1.00264759e+00 -2.29891432e-03  5.80448903e-02]\n",
      "GT_Sigma: [1.52449884]\n",
      "My_Sigma: 1.5244988379202242\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "source": [
    " # Testing fit_gaussian #\n",
    "#######################\n",
    "\n",
    "V = np.array([1,2,10,4,5,6])\n",
    "\n",
    "mean, var = fit_gaussian(V)\n",
    "\n",
    "print(mean)\n",
    "print(var)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4.666666666666667\n",
      "2.9249881291307074\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "source": [
    " # NB Model data validation #\n",
    "############################\n",
    "\n",
    "dd = scipy.io.loadmat('data/validation_data.mat')\n",
    "data = dd['data_small'] # Input data\n",
    "labels = dd['labels_small'] # Input labels\n",
    "individuals = dd['individuals_small'] # Input individual indexes\n",
    "dd['train_indexes'] # Instances used for training\n",
    "dd['test_indexes']  # Instances used for test\n",
    "dd['model_nb']      # NB model\n",
    "dd['model_lg']      # LG model\n",
    "dd['accur_nb']      # Accuracy of NB model on test instances\n",
    "dd['accur_lg']      # Accuracy of LG model on test instances\n",
    "\n",
    "### Mine\n",
    "data_ori,labels_ori,individuals_ori = load_dataset()\n",
    "m = learn_model(data,labels)\n",
    "with np.printoptions(precision=3, suppress=True):\n",
    "    for i in range(0,20):\n",
    "        print('## Joint '+ str(i) + ' ##')\n",
    "        print('My_Means:')\n",
    "        print(m.jointparts[i].means[0])\n",
    "        print('GT_Means: ')\n",
    "        print(str(dd['model_nb'][0,0][0][0][i][0]))\n",
    "        print()\n",
    "\n",
    "        print('My_Sigmas_:')\n",
    "        print(m.jointparts[i].sigmas[0])\n",
    "        print('GT_Sigmas: ')\n",
    "        print(str(dd['model_nb'][0,0][0][0][i][1]))\n",
    "\n",
    "        print()\n",
    "        print()\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "## Joint 0 ##\n",
      "My_Means:\n",
      "[[ 0.002 -0.036 -0.052 -0.095]\n",
      " [ 0.181 -0.418  0.125  0.135]\n",
      " [ 2.839  2.879  2.84   2.662]]\n",
      "GT_Means: \n",
      "[[ 0.017 -0.023 -0.025 -0.086]\n",
      " [ 0.184 -0.425  0.127  0.14 ]\n",
      " [ 2.837  2.866  2.84   2.649]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.117 0.127 0.123 0.142]\n",
      " [0.092 0.101 0.087 0.087]\n",
      " [0.19  0.202 0.242 0.275]]\n",
      "GT_Sigmas: \n",
      "[[0.114 0.122 0.113 0.127]\n",
      " [0.1   0.119 0.095 0.099]\n",
      " [0.162 0.189 0.212 0.198]]\n",
      "\n",
      "\n",
      "## Joint 1 ##\n",
      "My_Means:\n",
      "[[ 0.002 -0.034 -0.05  -0.09 ]\n",
      " [ 0.243 -0.374  0.193  0.203]\n",
      " [ 2.876  2.848  2.875  2.687]]\n",
      "GT_Means: \n",
      "[[ 0.017 -0.021 -0.022 -0.081]\n",
      " [ 0.246 -0.38   0.196  0.208]\n",
      " [ 2.873  2.836  2.872  2.673]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.119 0.126 0.125 0.143]\n",
      " [0.094 0.102 0.089 0.089]\n",
      " [0.184 0.198 0.238 0.275]]\n",
      "GT_Sigmas: \n",
      "[[0.115 0.119 0.116 0.127]\n",
      " [0.102 0.12  0.097 0.1  ]\n",
      " [0.155 0.186 0.208 0.205]]\n",
      "\n",
      "\n",
      "## Joint 2 ##\n",
      "My_Means:\n",
      "[[ 0.004 -0.026 -0.046 -0.124]\n",
      " [ 0.575 -0.156  0.554  0.558]\n",
      " [ 2.867  2.705  2.86   2.664]]\n",
      "GT_Means: \n",
      "[[ 0.019 -0.01  -0.015 -0.122]\n",
      " [ 0.583 -0.159  0.56   0.563]\n",
      " [ 2.865  2.696  2.856  2.648]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.122 0.121 0.128 0.158]\n",
      " [0.101 0.109 0.095 0.098]\n",
      " [0.184 0.191 0.237 0.277]]\n",
      "GT_Sigmas: \n",
      "[[0.116 0.11  0.116 0.135]\n",
      " [0.11  0.125 0.102 0.108]\n",
      " [0.157 0.182 0.206 0.221]]\n",
      "\n",
      "\n",
      "## Joint 3 ##\n",
      "My_Means:\n",
      "[[ 0.002 -0.02  -0.043 -0.162]\n",
      " [ 0.743  0.016  0.73   0.721]\n",
      " [ 2.84   2.609  2.82   2.646]]\n",
      "GT_Means: \n",
      "[[ 0.017 -0.003 -0.014 -0.167]\n",
      " [ 0.754  0.01   0.737  0.729]\n",
      " [ 2.843  2.602  2.819  2.634]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.118 0.119 0.122 0.168]\n",
      " [0.104 0.106 0.097 0.098]\n",
      " [0.181 0.195 0.232 0.274]]\n",
      "GT_Sigmas: \n",
      "[[0.112 0.107 0.109 0.138]\n",
      " [0.113 0.121 0.104 0.107]\n",
      " [0.158 0.193 0.206 0.225]]\n",
      "\n",
      "\n",
      "## Joint 4 ##\n",
      "My_Means:\n",
      "[[-0.164 -0.185 -0.21  -0.257]\n",
      " [ 0.515 -0.205  0.44   0.428]\n",
      " [ 2.869  2.713  2.862  2.7  ]]\n",
      "GT_Means: \n",
      "[[-0.152 -0.169 -0.181 -0.26 ]\n",
      " [ 0.521 -0.209  0.446  0.432]\n",
      " [ 2.867  2.7    2.861  2.694]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.119 0.122 0.125 0.155]\n",
      " [0.105 0.104 0.096 0.099]\n",
      " [0.183 0.19  0.237 0.288]]\n",
      "GT_Sigmas: \n",
      "[[0.113 0.113 0.114 0.13 ]\n",
      " [0.113 0.12  0.103 0.107]\n",
      " [0.16  0.18  0.208 0.224]]\n",
      "\n",
      "\n",
      "## Joint 5 ##\n",
      "My_Means:\n",
      "[[-0.333 -0.259 -0.29  -0.291]\n",
      " [ 0.675 -0.39   0.206  0.207]\n",
      " [ 2.804  2.699  2.868  2.72 ]]\n",
      "GT_Means: \n",
      "[[-0.32  -0.242 -0.261 -0.288]\n",
      " [ 0.682 -0.394  0.208  0.205]\n",
      " [ 2.799  2.683  2.865  2.716]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.123 0.134 0.129 0.156]\n",
      " [0.116 0.1   0.103 0.131]\n",
      " [0.192 0.19  0.241 0.334]]\n",
      "GT_Sigmas: \n",
      "[[0.112 0.125 0.125 0.134]\n",
      " [0.128 0.118 0.113 0.132]\n",
      " [0.182 0.189 0.208 0.251]]\n",
      "\n",
      "\n",
      "## Joint 6 ##\n",
      "My_Means:\n",
      "[[-0.441 -0.162 -0.323 -0.285]\n",
      " [ 0.877 -0.487  0.002  0.013]\n",
      " [ 2.749  2.574  2.809  2.686]]\n",
      "GT_Means: \n",
      "[[-0.422 -0.122 -0.291 -0.275]\n",
      " [ 0.882 -0.467  0.     0.003]\n",
      " [ 2.741  2.552  2.804  2.67 ]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.144 0.142 0.159 0.171]\n",
      " [0.116 0.16  0.125 0.182]\n",
      " [0.204 0.201 0.251 0.324]]\n",
      "GT_Sigmas: \n",
      "[[0.131 0.115 0.156 0.148]\n",
      " [0.12  0.189 0.14  0.153]\n",
      " [0.192 0.198 0.214 0.251]]\n",
      "\n",
      "\n",
      "## Joint 7 ##\n",
      "My_Means:\n",
      "[[-0.471 -0.135 -0.329 -0.286]\n",
      " [ 0.946 -0.525 -0.069 -0.057]\n",
      " [ 2.738  2.548  2.795  2.676]]\n",
      "GT_Means: \n",
      "[[-0.451 -0.088 -0.298 -0.276]\n",
      " [ 0.953 -0.498 -0.074 -0.069]\n",
      " [ 2.733  2.528  2.792  2.653]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.153 0.162 0.176 0.181]\n",
      " [0.125 0.189 0.138 0.199]\n",
      " [0.203 0.199 0.257 0.324]]\n",
      "GT_Sigmas: \n",
      "[[0.143 0.132 0.173 0.164]\n",
      " [0.126 0.222 0.148 0.153]\n",
      " [0.198 0.198 0.222 0.255]]\n",
      "\n",
      "\n",
      "## Joint 8 ##\n",
      "My_Means:\n",
      "[[ 0.173  0.132  0.114 -0.005]\n",
      " [ 0.515 -0.206  0.442  0.451]\n",
      " [ 2.874  2.744  2.856  2.61 ]]\n",
      "GT_Means: \n",
      "[[ 0.189  0.149  0.145 -0.004]\n",
      " [ 0.518 -0.21   0.445  0.46 ]\n",
      " [ 2.866  2.736  2.849  2.59 ]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.123 0.125 0.129 0.155]\n",
      " [0.104 0.1   0.093 0.093]\n",
      " [0.192 0.195 0.247 0.27 ]]\n",
      "GT_Sigmas: \n",
      "[[0.118 0.11  0.115 0.133]\n",
      " [0.112 0.115 0.098 0.103]\n",
      " [0.162 0.188 0.218 0.216]]\n",
      "\n",
      "\n",
      "## Joint 9 ##\n",
      "My_Means:\n",
      "[[ 0.346  0.204  0.287  0.037]\n",
      " [ 0.675 -0.392  0.321  0.524]\n",
      " [ 2.823  2.731  2.816  2.371]]\n",
      "GT_Means: \n",
      "[[ 0.357  0.22   0.319  0.032]\n",
      " [ 0.671 -0.397  0.318  0.549]\n",
      " [ 2.807  2.719  2.809  2.344]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.128 0.122 0.135 0.155]\n",
      " [0.12  0.096 0.123 0.111]\n",
      " [0.209 0.19  0.253 0.249]]\n",
      "GT_Sigmas: \n",
      "[[0.13  0.116 0.131 0.13 ]\n",
      " [0.134 0.111 0.121 0.107]\n",
      " [0.189 0.181 0.225 0.22 ]]\n",
      "\n",
      "\n",
      "## Joint 10 ##\n",
      "My_Means:\n",
      "[[ 0.454  0.1    0.447  0.009]\n",
      " [ 0.886 -0.493  0.233  0.595]\n",
      " [ 2.78   2.592  2.734  2.163]]\n",
      "GT_Means: \n",
      "[[ 0.463  0.115  0.487 -0.003]\n",
      " [ 0.884 -0.481  0.227  0.628]\n",
      " [ 2.751  2.582  2.727  2.122]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.139 0.133 0.155 0.171]\n",
      " [0.127 0.145 0.16  0.159]\n",
      " [0.234 0.191 0.278 0.254]]\n",
      "GT_Sigmas: \n",
      "[[0.146 0.131 0.156 0.13 ]\n",
      " [0.135 0.174 0.157 0.129]\n",
      " [0.213 0.181 0.244 0.219]]\n",
      "\n",
      "\n",
      "## Joint 11 ##\n",
      "My_Means:\n",
      "[[ 0.48   0.071  0.506 -0.002]\n",
      " [ 0.958 -0.521  0.205  0.619]\n",
      " [ 2.774  2.562  2.701  2.091]]\n",
      "GT_Means: \n",
      "[[ 0.486  0.085  0.55  -0.016]\n",
      " [ 0.955 -0.501  0.198  0.654]\n",
      " [ 2.744  2.549  2.693  2.043]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.149 0.15  0.171 0.178]\n",
      " [0.132 0.172 0.174 0.18 ]\n",
      " [0.238 0.2   0.281 0.263]]\n",
      "GT_Sigmas: \n",
      "[[0.157 0.145 0.17  0.136]\n",
      " [0.137 0.205 0.167 0.142]\n",
      " [0.225 0.194 0.247 0.225]]\n",
      "\n",
      "\n",
      "## Joint 12 ##\n",
      "My_Means:\n",
      "[[-0.072 -0.116 -0.126 -0.15 ]\n",
      " [ 0.107 -0.479  0.053  0.069]\n",
      " [ 2.827  2.906  2.833  2.678]]\n",
      "GT_Means: \n",
      "[[-0.059 -0.106 -0.1   -0.141]\n",
      " [ 0.108 -0.485  0.055  0.072]\n",
      " [ 2.826  2.893  2.835  2.667]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.116 0.127 0.121 0.142]\n",
      " [0.089 0.103 0.085 0.085]\n",
      " [0.19  0.206 0.242 0.28 ]]\n",
      "GT_Sigmas: \n",
      "[[0.113 0.126 0.113 0.128]\n",
      " [0.098 0.123 0.093 0.098]\n",
      " [0.162 0.193 0.213 0.196]]\n",
      "\n",
      "\n",
      "## Joint 13 ##\n",
      "My_Means:\n",
      "[[-0.099 -0.226 -0.161 -0.183]\n",
      " [-0.411 -0.576 -0.418 -0.424]\n",
      " [ 2.901  2.616  2.905  2.714]]\n",
      "GT_Means: \n",
      "[[-0.084 -0.205 -0.133 -0.169]\n",
      " [-0.412 -0.582 -0.422 -0.434]\n",
      " [ 2.893  2.618  2.9    2.695]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.122 0.158 0.126 0.146]\n",
      " [0.065 0.094 0.063 0.06 ]\n",
      " [0.196 0.257 0.247 0.303]]\n",
      "GT_Sigmas: \n",
      "[[0.118 0.172 0.12  0.135]\n",
      " [0.073 0.109 0.073 0.066]\n",
      " [0.159 0.262 0.214 0.206]]\n",
      "\n",
      "\n",
      "## Joint 14 ##\n",
      "My_Means:\n",
      "[[-0.111 -0.187 -0.179 -0.199]\n",
      " [-0.789 -0.811 -0.788 -0.796]\n",
      " [ 2.959  2.867  2.955  2.75 ]]\n",
      "GT_Means: \n",
      "[[-0.093 -0.169 -0.149 -0.179]\n",
      " [-0.791 -0.815 -0.795 -0.808]\n",
      " [ 2.957  2.859  2.954  2.725]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.125 0.142 0.128 0.143]\n",
      " [0.067 0.079 0.066 0.065]\n",
      " [0.2   0.218 0.253 0.32 ]]\n",
      "GT_Sigmas: \n",
      "[[0.119 0.141 0.121 0.13 ]\n",
      " [0.077 0.091 0.078 0.073]\n",
      " [0.157 0.231 0.215 0.224]]\n",
      "\n",
      "\n",
      "## Joint 15 ##\n",
      "My_Means:\n",
      "[[-0.131 -0.207 -0.205 -0.208]\n",
      " [-0.854 -0.864 -0.854 -0.855]\n",
      " [ 2.914  2.851  2.911  2.697]]\n",
      "GT_Means: \n",
      "[[-0.113 -0.19  -0.176 -0.185]\n",
      " [-0.859 -0.867 -0.862 -0.868]\n",
      " [ 2.917  2.836  2.912  2.675]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.129 0.144 0.133 0.152]\n",
      " [0.071 0.08  0.068 0.064]\n",
      " [0.195 0.224 0.251 0.321]]\n",
      "GT_Sigmas: \n",
      "[[0.13  0.149 0.129 0.139]\n",
      " [0.081 0.09  0.079 0.07 ]\n",
      " [0.156 0.239 0.212 0.223]]\n",
      "\n",
      "\n",
      "## Joint 16 ##\n",
      "My_Means:\n",
      "[[ 0.076  0.042  0.021 -0.032]\n",
      " [ 0.105 -0.48   0.051  0.078]\n",
      " [ 2.834  2.923  2.834  2.642]]\n",
      "GT_Means: \n",
      "[[ 0.091  0.055  0.047 -0.021]\n",
      " [ 0.106 -0.487  0.052  0.085]\n",
      " [ 2.833  2.91   2.835  2.629]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.118 0.132 0.123 0.143]\n",
      " [0.089 0.099 0.084 0.085]\n",
      " [0.194 0.201 0.245 0.273]]\n",
      "GT_Sigmas: \n",
      "[[0.115 0.127 0.112 0.13 ]\n",
      " [0.098 0.118 0.092 0.096]\n",
      " [0.164 0.188 0.216 0.197]]\n",
      "\n",
      "\n",
      "## Joint 17 ##\n",
      "My_Means:\n",
      "[[ 0.091  0.129  0.048  0.03 ]\n",
      " [-0.414 -0.596 -0.424 -0.411]\n",
      " [ 2.903  2.63   2.907  2.765]]\n",
      "GT_Means: \n",
      "[[ 0.109  0.143  0.073  0.051]\n",
      " [-0.417 -0.584 -0.428 -0.413]\n",
      " [ 2.892  2.617  2.901  2.762]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.123 0.131 0.128 0.146]\n",
      " [0.062 0.132 0.062 0.062]\n",
      " [0.201 0.235 0.253 0.279]]\n",
      "GT_Sigmas: \n",
      "[[0.12  0.129 0.124 0.133]\n",
      " [0.071 0.148 0.073 0.071]\n",
      " [0.164 0.247 0.22  0.175]]\n",
      "\n",
      "\n",
      "## Joint 18 ##\n",
      "My_Means:\n",
      "[[ 0.092  0.09   0.058  0.046]\n",
      " [-0.792 -0.829 -0.788 -0.781]\n",
      " [ 2.954  2.861  2.954  2.877]]\n",
      "GT_Means: \n",
      "[[ 0.11   0.103  0.083  0.075]\n",
      " [-0.798 -0.829 -0.796 -0.783]\n",
      " [ 2.949  2.85   2.95   2.892]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.129 0.147 0.135 0.148]\n",
      " [0.067 0.085 0.068 0.066]\n",
      " [0.203 0.223 0.264 0.287]]\n",
      "GT_Sigmas: \n",
      "[[0.129 0.14  0.137 0.132]\n",
      " [0.076 0.103 0.08  0.079]\n",
      " [0.161 0.224 0.23  0.177]]\n",
      "\n",
      "\n",
      "## Joint 19 ##\n",
      "My_Means:\n",
      "[[ 0.103  0.109  0.075  0.054]\n",
      " [-0.856 -0.882 -0.852 -0.842]\n",
      " [ 2.909  2.844  2.911  2.836]]\n",
      "GT_Means: \n",
      "[[ 0.119  0.124  0.098  0.081]\n",
      " [-0.865 -0.878 -0.86  -0.845]\n",
      " [ 2.909  2.835  2.907  2.858]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.127 0.146 0.13  0.154]\n",
      " [0.074 0.084 0.072 0.071]\n",
      " [0.201 0.208 0.269 0.297]]\n",
      "GT_Sigmas: \n",
      "[[0.127 0.135 0.131 0.141]\n",
      " [0.081 0.101 0.084 0.083]\n",
      " [0.16  0.211 0.23  0.192]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "source": [
    " # LGM Model data validation #\n",
    "#############################\n",
    "\n",
    "dd = scipy.io.loadmat('data/validation_data.mat')\n",
    "data = dd['data_small'] # Input data\n",
    "labels = dd['labels_small'] # Input labels\n",
    "individuals = dd['individuals_small'] # Input individual indexes\n",
    "dd['train_indexes'] # Instances used for training\n",
    "dd['test_indexes']  # Instances used for test\n",
    "dd['model_nb']      # NB model\n",
    "dd['model_lg']      # LG model\n",
    "dd['accur_nb']      # Accuracy of NB model on test instances\n",
    "dd['accur_lg']      # Accuracy of LG model on test instances\n",
    "\n",
    "### Mine\n",
    "data_ori,labels_ori,individuals_ori = load_dataset()\n",
    "m = learn_model(data,labels,G)\n",
    "with np.printoptions(precision=3, suppress=True):\n",
    "        \n",
    "    print('## Joint '+ str(0) + ' ##')\n",
    "    print('My_HCMeans:')\n",
    "    print(m.jointparts[0].HC_means[0])\n",
    "    print('GT_HCMeans: ')\n",
    "    print(str(dd['model_lg'][0,0][0][0][0][0]))\n",
    "    print()\n",
    "\n",
    "    print('My_HCSigmas:')\n",
    "    print(m.jointparts[0].HC_sigmas[0])\n",
    "    print('GT_HCSigmas: ')\n",
    "    print(str(dd['model_lg'][0,0][0][0][0][1]))\n",
    "\n",
    "    print()\n",
    "    print()   \n",
    "    \n",
    "    for i in range(1,20):\n",
    "        print('## Joint '+ str(i) + ' ##')\n",
    "        print('My_Betas:')\n",
    "        print(m.jointparts[i].betas[0])\n",
    "        print('GT_Betas: ')\n",
    "        print(str(dd['model_lg'][0,0][0][0][i][0]))\n",
    "        print()\n",
    "\n",
    "        print('My_Sigmas_:')\n",
    "        print(m.jointparts[i].sigmas[0])\n",
    "        print('GT_Sigmas: ')\n",
    "        print(str(dd['model_lg'][0,0][0][0][i][1]))\n",
    "\n",
    "        print()\n",
    "        print()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "## Joint 0 ##\n",
      "My_HCMeans:\n",
      "[[ 0.002 -0.036 -0.052 -0.095]\n",
      " [ 0.181 -0.418  0.125  0.135]\n",
      " [ 2.839  2.879  2.84   2.662]]\n",
      "GT_HCMeans: \n",
      "[[ 0.017 -0.023 -0.025 -0.086]\n",
      " [ 0.184 -0.425  0.127  0.14 ]\n",
      " [ 2.837  2.866  2.84   2.649]]\n",
      "\n",
      "My_HCSigmas:\n",
      "[[0.117 0.127 0.123 0.142]\n",
      " [0.092 0.101 0.087 0.087]\n",
      " [0.19  0.202 0.242 0.275]]\n",
      "GT_HCSigmas: \n",
      "[[0.114 0.122 0.113 0.127]\n",
      " [0.1   0.119 0.095 0.099]\n",
      " [0.162 0.189 0.212 0.198]]\n",
      "\n",
      "\n",
      "## Joint 1 ##\n",
      "My_Betas:\n",
      "[[[ 0.009  1.018  0.008 -0.004]\n",
      "  [ 0.01   0.993  0.013 -0.001]\n",
      "  [ 0.007  1.022  0.008 -0.002]\n",
      "  [-0.033  1.015 -0.016  0.015]]\n",
      "\n",
      " [[ 0.038  0.006  1.021  0.007]\n",
      "  [ 0.042  0.006  1.007  0.002]\n",
      "  [ 0.065  0.001  1.02   0.   ]\n",
      "  [ 0.046  0.005  1.014  0.008]]\n",
      "\n",
      " [[ 0.172 -0.05  -0.015  0.953]\n",
      "  [ 0.019  0.007  0.006  0.984]\n",
      "  [ 0.117 -0.062 -0.082  0.973]\n",
      "  [ 0.051 -0.016 -0.099  0.995]]]\n",
      "GT_Betas: \n",
      "[[ 0.003  0.002  0.002 -0.02 ]\n",
      " [ 1.013  0.983  1.027  0.993]\n",
      " [ 0.005  0.012  0.015 -0.012]\n",
      " [-0.002  0.002 -0.     0.01 ]\n",
      " [ 0.044  0.037  0.071  0.06 ]\n",
      " [ 0.005  0.001 -0.005  0.   ]\n",
      " [ 1.019  1.003  1.015  1.009]\n",
      " [ 0.005  0.003 -0.001  0.003]\n",
      " [ 0.177  0.012  0.151 -0.021]\n",
      " [-0.046  0.003 -0.071 -0.047]\n",
      " [-0.009 -0.007 -0.097 -0.114]\n",
      " [ 0.951  0.984  0.961  1.021]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.003 0.005 0.003 0.014]\n",
      " [0.003 0.006 0.004 0.005]\n",
      " [0.013 0.009 0.017 0.024]]\n",
      "GT_Sigmas: \n",
      "[[0.013 0.015 0.014 0.024]\n",
      " [0.014 0.017 0.014 0.016]\n",
      " [0.025 0.019 0.029 0.035]]\n",
      "\n",
      "\n",
      "## Joint 2 ##\n",
      "My_Betas:\n",
      "[[[ 0.021  1.009 -0.01  -0.006]\n",
      "  [ 0.057  0.961  0.072 -0.008]\n",
      "  [ 0.005  1.019  0.03  -0.002]\n",
      "  [-0.019  1.031 -0.131  0.005]]\n",
      "\n",
      " [[ 0.347 -0.017  1.043 -0.009]\n",
      "  [ 0.194  0.028  1.028  0.012]\n",
      "  [ 0.411 -0.038  1.041 -0.021]\n",
      "  [ 0.276 -0.013  1.003  0.029]]\n",
      "\n",
      " [[ 0.005 -0.008 -0.063  1.001]\n",
      "  [ 0.054  0.04   0.039  0.937]\n",
      "  [ 0.004 -0.009 -0.006  0.994]\n",
      "  [-0.004 -0.01  -0.167  1.005]]]\n",
      "GT_Betas: \n",
      "[[-0.022  0.043 -0.016 -0.091]\n",
      " [ 0.998  0.932  1.001  0.97 ]\n",
      " [-0.01   0.079  0.042 -0.167]\n",
      " [ 0.009 -0.001  0.005  0.03 ]\n",
      " [ 0.358  0.155  0.458  0.242]\n",
      " [-0.029 -0.02  -0.074 -0.106]\n",
      " [ 1.043  0.992  1.011  0.952]\n",
      " [-0.011  0.022 -0.034  0.043]\n",
      " [-0.022  0.006  0.012 -0.121]\n",
      " [-0.022  0.009  0.    -0.055]\n",
      " [-0.062 -0.036 -0.003 -0.205]\n",
      " [ 1.01   0.944  0.991  1.05 ]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.01  0.024 0.014 0.043]\n",
      " [0.021 0.034 0.016 0.036]\n",
      " [0.008 0.046 0.007 0.034]]\n",
      "GT_Sigmas: \n",
      "[[0.021 0.037 0.026 0.046]\n",
      " [0.033 0.045 0.027 0.046]\n",
      " [0.019 0.056 0.017 0.047]]\n",
      "\n",
      "\n",
      "## Joint 3 ##\n",
      "My_Betas:\n",
      "[[[ 0.013  0.958  0.004 -0.006]\n",
      "  [-0.021  0.966  0.073  0.014]\n",
      "  [-0.013  0.948 -0.     0.005]\n",
      "  [ 0.049  1.02  -0.059 -0.019]]\n",
      "\n",
      " [[ 0.088  0.039  1.03   0.022]\n",
      "  [ 0.178  0.01   0.977 -0.004]\n",
      "  [ 0.15   0.03   1.023  0.005]\n",
      "  [ 0.116  0.045  1.003  0.019]]\n",
      "\n",
      " [[ 0.006  0.037 -0.002  0.989]\n",
      "  [-0.146  0.017 -0.005  1.019]\n",
      "  [ 0.056 -0.033 -0.05   0.976]\n",
      "  [ 0.001  0.047 -0.014  0.998]]]\n",
      "GT_Betas: \n",
      "[[-0.002 -0.094 -0.07  -0.003]\n",
      " [ 0.954  0.918  0.93   0.967]\n",
      " [ 0.004  0.081  0.011 -0.104]\n",
      " [-0.     0.042  0.022  0.005]\n",
      " [ 0.024  0.204  0.163  0.118]\n",
      " [ 0.014  0.041  0.009  0.055]\n",
      " [ 1.031  0.981  1.006  1.006]\n",
      " [ 0.045 -0.014  0.004  0.02 ]\n",
      " [ 0.004 -0.21   0.026 -0.031]\n",
      " [ 0.007  0.041 -0.076  0.029]\n",
      " [-0.005  0.02  -0.05  -0.013]\n",
      " [ 0.992  1.044  0.987  1.011]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.014 0.034 0.019 0.031]\n",
      " [0.014 0.01  0.013 0.018]\n",
      " [0.023 0.026 0.014 0.025]]\n",
      "GT_Sigmas: \n",
      "[[0.026 0.048 0.031 0.034]\n",
      " [0.025 0.02  0.024 0.029]\n",
      " [0.032 0.034 0.023 0.036]]\n",
      "\n",
      "\n",
      "## Joint 4 ##\n",
      "My_Betas:\n",
      "[[[-0.09   0.941 -0.092 -0.009]\n",
      "  [-0.206  0.982 -0.034  0.015]\n",
      "  [-0.1    0.946 -0.075 -0.009]\n",
      "  [ 0.012  0.913 -0.039 -0.051]]\n",
      "\n",
      " [[-0.     0.002  1.018 -0.025]\n",
      "  [-0.054 -0.026  0.933 -0.002]\n",
      "  [-0.19   0.061  1.011  0.025]\n",
      "  [ 0.022 -0.064  0.947 -0.049]]\n",
      "\n",
      " [[-0.068  0.111  0.051  1.014]\n",
      "  [ 0.045 -0.022 -0.061  0.983]\n",
      "  [-0.089  0.123  0.087  1.017]\n",
      "  [-0.063 -0.041  0.185  0.996]]]\n",
      "GT_Betas: \n",
      "[[-0.107 -0.3   -0.159  0.034]\n",
      " [ 0.955  0.958  0.97   0.917]\n",
      " [-0.063 -0.014 -0.053 -0.038]\n",
      " [-0.009  0.051  0.008 -0.06 ]\n",
      " [-0.006 -0.009 -0.245  0.103]\n",
      " [-0.005  0.     0.068 -0.043]\n",
      " [ 0.995  0.955  1.031  0.915]\n",
      " [-0.018 -0.018  0.04  -0.072]\n",
      " [-0.046  0.058 -0.119 -0.045]\n",
      " [ 0.122 -0.006  0.165 -0.011]\n",
      " [ 0.031 -0.084  0.111  0.24 ]\n",
      " [ 1.01   0.975  1.023  0.983]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.016 0.028 0.012 0.028]\n",
      " [0.026 0.016 0.013 0.028]\n",
      " [0.02  0.028 0.023 0.05 ]]\n",
      "GT_Sigmas: \n",
      "[[0.023 0.042 0.02  0.035]\n",
      " [0.035 0.026 0.024 0.04 ]\n",
      " [0.031 0.037 0.037 0.051]]\n",
      "\n",
      "\n",
      "## Joint 5 ##\n",
      "My_Betas:\n",
      "[[[ 0.035  0.973  0.096 -0.09 ]\n",
      "  [-0.154  1.051  0.036  0.035]\n",
      "  [-0.057  0.9   -0.111  0.002]\n",
      "  [ 0.009  0.967  0.005 -0.02 ]]\n",
      "\n",
      " [[ 0.251  0.047  1.069 -0.041]\n",
      "  [-0.117 -0.033  0.9   -0.035]\n",
      "  [-0.12   0.04   0.972 -0.033]\n",
      "  [ 0.014  0.031  1.188 -0.114]]\n",
      "\n",
      " [[-0.217  0.165 -0.023  1.067]\n",
      "  [ 0.079 -0.019 -0.069  0.959]\n",
      "  [-0.053  0.016  0.078  1.01 ]\n",
      "  [-0.292 -0.066  0.135  1.088]]]\n",
      "GT_Betas: \n",
      "[[-0.034 -0.172 -0.192  0.047]\n",
      " [ 0.972  1.011  0.953  0.997]\n",
      " [ 0.129 -0.002 -0.114  0.021]\n",
      " [-0.072  0.037  0.054 -0.032]\n",
      " [ 0.275 -0.098  0.073 -0.297]\n",
      " [ 0.079  0.014  0.028 -0.114]\n",
      " [ 1.08   0.945  0.955  1.054]\n",
      " [-0.05  -0.036 -0.1    0.007]\n",
      " [-0.346 -0.102 -0.043 -0.224]\n",
      " [ 0.12  -0.114  0.061  0.085]\n",
      " [-0.056 -0.153  0.103  0.374]\n",
      " [ 1.113  1.012  1.004  1.04 ]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.028 0.044 0.059 0.03 ]\n",
      " [0.036 0.033 0.049 0.064]\n",
      " [0.038 0.055 0.018 0.089]]\n",
      "GT_Sigmas: \n",
      "[[0.042 0.055 0.065 0.04 ]\n",
      " [0.05  0.04  0.059 0.063]\n",
      " [0.031 0.063 0.023 0.098]]\n",
      "\n",
      "\n",
      "## Joint 6 ##\n",
      "My_Betas:\n",
      "[[[ 0.011  1.073  0.115 -0.061]\n",
      "  [ 0.366  0.892  0.096 -0.096]\n",
      "  [-0.085  1.105 -0.2    0.043]\n",
      "  [ 0.244  0.916 -0.099 -0.089]]\n",
      "\n",
      " [[ 0.134 -0.003  0.967  0.032]\n",
      "  [ 0.318  0.154  1.355 -0.087]\n",
      "  [ 0.001 -0.072  1.079 -0.084]\n",
      "  [ 0.047  0.062  1.238 -0.1  ]]\n",
      "\n",
      " [[-0.18   0.069 -0.035  1.061]\n",
      "  [-0.218 -0.071 -0.103  1.012]\n",
      "  [-0.137 -0.089 -0.045  1.022]\n",
      "  [ 0.086 -0.086  0.332  0.922]]]\n",
      "GT_Betas: \n",
      "[[ 0.086  0.265 -0.154  0.247]\n",
      " [ 1.074  0.781  1.086  0.852]\n",
      " [ 0.058  0.108 -0.177 -0.246]\n",
      " [-0.073 -0.058  0.064 -0.083]\n",
      " [ 0.238  0.441  0.083 -0.268]\n",
      " [ 0.043  0.144 -0.048  0.042]\n",
      " [ 0.911  1.395  1.051  1.098]\n",
      " [ 0.013 -0.121 -0.11   0.022]\n",
      " [-0.086 -0.167 -0.129  0.208]\n",
      " [ 0.054  0.061 -0.069 -0.079]\n",
      " [-0.069 -0.086 -0.047  0.451]\n",
      " [ 1.033  1.006  1.021  0.864]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.044 0.075 0.054 0.048]\n",
      " [0.031 0.088 0.051 0.062]\n",
      " [0.034 0.049 0.023 0.085]]\n",
      "GT_Sigmas: \n",
      "[[0.056 0.078 0.06  0.057]\n",
      " [0.036 0.101 0.063 0.062]\n",
      " [0.032 0.048 0.032 0.099]]\n",
      "\n",
      "\n",
      "## Joint 7 ##\n",
      "My_Betas:\n",
      "[[[-0.006  1.056 -0.003  0.001]\n",
      "  [ 0.108  1.093  0.069 -0.013]\n",
      "  [-0.019  1.062 -0.084  0.012]\n",
      "  [ 0.068  1.025 -0.012 -0.023]]\n",
      "\n",
      " [[ 0.003  0.036  1.06   0.01 ]\n",
      "  [ 0.056  0.086  1.157 -0.002]\n",
      "  [-0.062 -0.062  1.04  -0.01 ]\n",
      "  [ 0.005  0.053  1.075 -0.023]]\n",
      "\n",
      " [[ 0.028  0.018 -0.035  1.   ]\n",
      "  [ 0.048 -0.025  0.     0.97 ]\n",
      "  [-0.079 -0.019 -0.051  1.021]\n",
      "  [-0.039  0.034  0.039  1.014]]]\n",
      "GT_Betas: \n",
      "[[ 0.114  0.147 -0.01   0.096]\n",
      " [ 1.085  1.103  1.06   1.07 ]\n",
      " [-0.048  0.046 -0.077 -0.016]\n",
      " [-0.023 -0.031  0.007 -0.029]\n",
      " [ 0.004 -0.022 -0.082 -0.051]\n",
      " [ 0.03   0.083 -0.063  0.048]\n",
      " [ 1.042  1.172  1.004  1.016]\n",
      " [ 0.016  0.032 -0.004 -0.003]\n",
      " [-0.028 -0.021 -0.084 -0.019]\n",
      " [-0.015 -0.078 -0.021 -0.029]\n",
      " [-0.039  0.031 -0.055  0.006]\n",
      " [ 1.018  1.001  1.023  0.998]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.02  0.037 0.02  0.018]\n",
      " [0.015 0.028 0.022 0.022]\n",
      " [0.016 0.034 0.01  0.031]]\n",
      "GT_Sigmas: \n",
      "[[0.03  0.044 0.03  0.023]\n",
      " [0.025 0.034 0.028 0.027]\n",
      " [0.023 0.044 0.02  0.038]]\n",
      "\n",
      "\n",
      "## Joint 8 ##\n",
      "My_Betas:\n",
      "[[[ 0.175  1.005  0.057 -0.013]\n",
      "  [ 0.161  1.009 -0.017 -0.002]\n",
      "  [ 0.088  1.026  0.076  0.011]\n",
      "  [ 0.199  0.952  0.019 -0.036]]\n",
      "\n",
      " [[-0.077 -0.005  1.007  0.004]\n",
      "  [ 0.008 -0.101  0.876 -0.029]\n",
      "  [-0.156 -0.017  0.956  0.024]\n",
      "  [-0.016 -0.056  0.852 -0.006]]\n",
      "\n",
      " [[-0.069 -0.032  0.008  1.025]\n",
      "  [ 0.089 -0.079  0.135  0.989]\n",
      "  [-0.124 -0.021  0.081  1.026]\n",
      "  [ 0.108 -0.072 -0.085  0.954]]]\n",
      "GT_Betas: \n",
      "[[ 0.194  0.094  0.087  0.16 ]\n",
      " [ 1.011  0.935  0.999  0.976]\n",
      " [ 0.046 -0.056  0.058  0.005]\n",
      " [-0.018  0.021  0.014 -0.018]\n",
      " [-0.066  0.037 -0.174  0.004]\n",
      " [ 0.028 -0.077  0.014  0.051]\n",
      " [ 1.007  0.878  0.967  0.941]\n",
      " [-0.001 -0.04   0.027 -0.025]\n",
      " [-0.071  0.    -0.201  0.103]\n",
      " [ 0.002 -0.119 -0.041 -0.062]\n",
      " [ 0.014  0.132  0.102 -0.129]\n",
      " [ 1.022  1.022  1.048  0.964]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.018 0.026 0.015 0.021]\n",
      " [0.024 0.017 0.009 0.032]\n",
      " [0.025 0.029 0.029 0.032]]\n",
      "GT_Sigmas: \n",
      "[[0.03  0.037 0.025 0.029]\n",
      " [0.032 0.027 0.019 0.042]\n",
      " [0.034 0.04  0.041 0.039]]\n",
      "\n",
      "\n",
      "## Joint 9 ##\n",
      "My_Betas:\n",
      "[[[ 0.062  1.034 -0.089  0.053]\n",
      "  [ 0.143  0.883 -0.022 -0.022]\n",
      "  [ 0.057  1.004  0.032  0.036]\n",
      "  [-0.022  0.992 -0.04   0.031]]\n",
      "\n",
      " [[ 0.31  -0.021  1.102 -0.069]\n",
      "  [-0.15  -0.063  0.894 -0.018]\n",
      "  [-0.298 -0.105  1.081  0.053]\n",
      "  [ 0.023 -0.003  0.888  0.039]]\n",
      "\n",
      " [[-0.297  0.064 -0.088  1.097]\n",
      "  [ 0.127  0.018  0.066  0.953]\n",
      "  [-0.068 -0.006 -0.047  1.017]\n",
      "  [-0.039  0.081 -0.047  0.932]]]\n",
      "GT_Betas: \n",
      "[[ 0.091  0.211 -0.091 -0.072]\n",
      " [ 1.055  1.024  1.095  0.927]\n",
      " [-0.095  0.096  0.062 -0.076]\n",
      " [ 0.04  -0.045  0.079  0.055]\n",
      " [ 0.28  -0.159 -0.406  0.015]\n",
      " [ 0.     0.002 -0.004  0.2  ]\n",
      " [ 1.113  0.949  1.071  1.05 ]\n",
      " [-0.064 -0.014  0.087  0.02 ]\n",
      " [-0.411  0.157 -0.099 -0.292]\n",
      " [ 0.028  0.028 -0.015  0.081]\n",
      " [-0.081  0.031  0.021  0.019]\n",
      " [ 1.135  0.938  1.018  1.015]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.026 0.046 0.047 0.034]\n",
      " [0.037 0.025 0.058 0.07 ]\n",
      " [0.04  0.039 0.038 0.049]]\n",
      "GT_Sigmas: \n",
      "[[0.039 0.055 0.057 0.041]\n",
      " [0.051 0.031 0.066 0.044]\n",
      " [0.041 0.047 0.044 0.041]]\n",
      "\n",
      "\n",
      "## Joint 10 ##\n",
      "My_Betas:\n",
      "[[[ 0.003  1.    -0.023  0.043]\n",
      "  [-0.019  0.989  0.2   -0.001]\n",
      "  [-0.065  1.119  0.221  0.043]\n",
      "  [ 0.065  1.038 -0.022 -0.035]]\n",
      "\n",
      " [[ 0.153 -0.023  1.028  0.017]\n",
      "  [-0.218  0.134  1.249  0.069]\n",
      "  [-0.234  0.074  1.248  0.016]\n",
      "  [-0.148  0.038  1.327  0.019]]\n",
      "\n",
      " [[-0.283  0.017 -0.095  1.106]\n",
      "  [-0.133  0.015 -0.227  0.964]\n",
      "  [-0.336  0.018 -0.047  1.094]\n",
      "  [-0.19   0.126 -0.157  1.025]]]\n",
      "GT_Betas: \n",
      "[[ 0.05   0.056 -0.186 -0.11 ]\n",
      " [ 1.014  1.021  1.12   0.994]\n",
      " [-0.01   0.166  0.216  0.095]\n",
      " [ 0.02  -0.037  0.088  0.01 ]\n",
      " [ 0.203 -0.393 -0.464 -0.078]\n",
      " [-0.016 -0.045  0.123  0.02 ]\n",
      " [ 0.994  1.301  1.223  1.084]\n",
      " [ 0.007  0.161  0.093  0.047]\n",
      " [-0.278 -0.099 -0.317 -0.19 ]\n",
      " [-0.011  0.098  0.049  0.121]\n",
      " [-0.087 -0.216  0.02   0.014]\n",
      " [ 1.102  0.947  1.076  0.981]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.056 0.066 0.052 0.039]\n",
      " [0.028 0.085 0.045 0.065]\n",
      " [0.039 0.059 0.043 0.063]]\n",
      "GT_Sigmas: \n",
      "[[0.071 0.072 0.058 0.035]\n",
      " [0.031 0.096 0.049 0.065]\n",
      " [0.04  0.059 0.044 0.036]]\n",
      "\n",
      "\n",
      "## Joint 11 ##\n",
      "My_Betas:\n",
      "[[[-0.068  1.08   0.025  0.012]\n",
      "  [-0.013  1.091 -0.034 -0.016]\n",
      "  [ 0.017  1.074  0.089 -0.005]\n",
      "  [-0.005  1.039  0.006 -0.004]]\n",
      "\n",
      " [[-0.038  0.016  1.039  0.025]\n",
      "  [ 0.127 -0.013  1.168 -0.027]\n",
      "  [-0.033  0.039  1.082 -0.012]\n",
      "  [-0.086  0.033  1.135  0.014]]\n",
      "\n",
      " [[ 0.003 -0.001 -0.057  1.015]\n",
      "  [-0.13  -0.048 -0.068  1.027]\n",
      "  [-0.087  0.041 -0.078  1.02 ]\n",
      "  [-0.134  0.055 -0.03   1.037]]]\n",
      "GT_Betas: \n",
      "[[-0.042 -0.071 -0.033 -0.036]\n",
      " [ 1.071  1.073  1.046  1.038]\n",
      " [ 0.022 -0.017  0.081  0.044]\n",
      " [ 0.005  0.009  0.02  -0.002]\n",
      " [-0.024  0.211 -0.058 -0.077]\n",
      " [ 0.018  0.042  0.073  0.019]\n",
      " [ 1.024  1.166  1.038  1.09 ]\n",
      " [ 0.024 -0.061 -0.006  0.022]\n",
      " [-0.069 -0.233 -0.069 -0.116]\n",
      " [-0.032 -0.064  0.04   0.045]\n",
      " [-0.055 -0.077 -0.07   0.039]\n",
      " [ 1.046  1.066  1.012  1.006]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.017 0.031 0.023 0.019]\n",
      " [0.013 0.032 0.02  0.017]\n",
      " [0.016 0.029 0.032 0.035]]\n",
      "GT_Sigmas: \n",
      "[[0.028 0.042 0.032 0.027]\n",
      " [0.024 0.044 0.027 0.027]\n",
      " [0.019 0.039 0.04  0.045]]\n",
      "\n",
      "\n",
      "## Joint 12 ##\n",
      "My_Betas:\n",
      "[[[-0.077  0.979 -0.04   0.003]\n",
      "  [-0.125  1.011  0.02   0.018]\n",
      "  [-0.063  0.977 -0.041 -0.003]\n",
      "  [-0.06   0.995  0.002  0.001]]\n",
      "\n",
      " [[-0.056 -0.016  0.959 -0.004]\n",
      "  [-0.139 -0.014  1.005  0.028]\n",
      "  [-0.059 -0.01   0.972 -0.004]\n",
      "  [-0.035 -0.013  0.971 -0.01 ]]\n",
      "\n",
      " [[-0.034  0.045  0.016  1.007]\n",
      "  [-0.03   0.018 -0.008  1.019]\n",
      "  [-0.016  0.04  -0.001  1.004]\n",
      "  [-0.048  0.032  0.045  1.023]]]\n",
      "GT_Betas: \n",
      "[[-0.066 -0.091 -0.068 -0.029]\n",
      " [ 0.986  1.05   0.992  1.001]\n",
      " [-0.029  0.049 -0.033  0.021]\n",
      " [-0.001  0.011 -0.001 -0.011]\n",
      " [-0.072 -0.168 -0.077 -0.017]\n",
      " [-0.018 -0.03  -0.004 -0.003]\n",
      " [ 0.969  1.015  0.983  0.982]\n",
      " [ 0.001  0.04   0.002 -0.018]\n",
      " [-0.023 -0.008 -0.021  0.041]\n",
      " [ 0.045  0.029  0.068  0.007]\n",
      " [ 0.012  0.005  0.012  0.061]\n",
      " [ 1.003  1.013  1.006  0.988]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.007 0.012 0.005 0.012]\n",
      " [0.007 0.012 0.005 0.011]\n",
      " [0.004 0.015 0.01  0.019]]\n",
      "GT_Sigmas: \n",
      "[[0.016 0.02  0.014 0.021]\n",
      " [0.016 0.021 0.015 0.02 ]\n",
      " [0.015 0.027 0.02  0.022]]\n",
      "\n",
      "\n",
      "## Joint 13 ##\n",
      "My_Betas:\n",
      "[[[ 0.016  0.997 -0.112 -0.011]\n",
      "  [-0.193  0.866  0.084  0.037]\n",
      "  [-0.12   1.011 -0.149  0.033]\n",
      "  [ 0.005  0.969 -0.108 -0.013]]\n",
      "\n",
      " [[-0.564 -0.011  0.569  0.032]\n",
      "  [ 0.074 -0.036  0.396 -0.16 ]\n",
      "  [-0.448 -0.005  0.635 -0.001]\n",
      "  [-0.331 -0.04   0.468 -0.049]]\n",
      "\n",
      " [[ 0.072 -0.081  0.002  0.999]\n",
      "  [-0.691  0.02   0.108  1.157]\n",
      "  [ 0.06  -0.101 -0.083  1.001]\n",
      "  [-0.101 -0.049  0.009  1.048]]]\n",
      "GT_Betas: \n",
      "[[-0.034 -0.25  -0.157  0.17 ]\n",
      " [ 0.989  0.782  1.005  0.985]\n",
      " [-0.086  0.078 -0.154 -0.111]\n",
      " [ 0.006  0.057  0.047 -0.072]\n",
      " [-0.617  0.611 -0.503 -0.369]\n",
      " [-0.052  0.13   0.015 -0.017]\n",
      " [ 0.584  0.506  0.677  0.462]\n",
      " [ 0.049 -0.323  0.016 -0.038]\n",
      " [ 0.15  -1.084  0.093 -0.015]\n",
      " [-0.    -0.159 -0.042 -0.004]\n",
      " [ 0.027  0.025 -0.043  0.069]\n",
      " [ 0.969  1.278  0.989  1.014]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.026 0.118 0.022 0.028]\n",
      " [0.039 0.078 0.032 0.044]\n",
      " [0.028 0.096 0.028 0.058]]\n",
      "GT_Sigmas: \n",
      "[[0.041 0.148 0.034 0.035]\n",
      " [0.053 0.084 0.046 0.055]\n",
      " [0.037 0.103 0.04  0.061]]\n",
      "\n",
      "\n",
      "## Joint 14 ##\n",
      "My_Betas:\n",
      "[[[ 0.073  0.994  0.012 -0.028]\n",
      "  [ 0.025  0.589 -0.398 -0.118]\n",
      "  [-0.132  0.994 -0.122  0.021]\n",
      "  [-0.101  0.962 -0.156  0.004]]\n",
      "\n",
      " [[-0.482  0.03   0.954  0.03 ]\n",
      "  [-0.706 -0.024  0.638  0.098]\n",
      "  [-0.371  0.007  0.953 -0.006]\n",
      "  [-0.369  0.058  1.063  0.013]]\n",
      "\n",
      " [[ 0.049 -0.038  0.004  1.002]\n",
      "  [ 0.711 -0.204 -0.484  0.7  ]\n",
      "  [ 0.013 -0.024  0.02   1.014]\n",
      "  [-0.128 -0.061 -0.241  1.019]]]\n",
      "GT_Betas: \n",
      "[[ 0.095 -0.249 -0.14  -0.013]\n",
      " [ 0.993  0.45   0.976  0.929]\n",
      " [ 0.009 -0.306 -0.131 -0.098]\n",
      " [-0.035 -0.002  0.023 -0.019]\n",
      " [-0.521 -0.672 -0.378 -0.26 ]\n",
      " [ 0.019  0.035  0.059  0.047]\n",
      " [ 0.988  0.724  1.013  1.087]\n",
      " [ 0.048  0.109  0.006 -0.025]\n",
      " [ 0.17   0.61   0.055 -0.197]\n",
      " [-0.012 -0.218 -0.051 -0.006]\n",
      " [ 0.011 -0.528  0.009 -0.176]\n",
      " [ 0.964  0.725  0.998  1.056]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.019 0.096 0.018 0.021]\n",
      " [0.023 0.056 0.029 0.02 ]\n",
      " [0.031 0.079 0.027 0.049]]\n",
      "GT_Sigmas: \n",
      "[[0.031 0.116 0.028 0.024]\n",
      " [0.036 0.068 0.039 0.026]\n",
      " [0.04  0.082 0.035 0.05 ]]\n",
      "\n",
      "\n",
      "## Joint 15 ##\n",
      "My_Betas:\n",
      "[[[-0.227  1.069  0.013  0.076]\n",
      "  [ 0.009  1.     0.029 -0.002]\n",
      "  [-0.102  1.043 -0.012  0.025]\n",
      "  [ 0.135  0.975 -0.006 -0.056]]\n",
      "\n",
      " [[ 0.013  0.008  1.06  -0.01 ]\n",
      "  [-0.164 -0.017  0.931  0.018]\n",
      "  [-0.     0.016  1.03  -0.013]\n",
      "  [-0.071 -0.051  0.923 -0.021]]\n",
      "\n",
      " [[-0.007  0.074 -0.007  0.988]\n",
      "  [-0.046 -0.04  -0.016  1.003]\n",
      "  [-0.016  0.008  0.003  0.992]\n",
      "  [-0.078  0.083  0.027  1.023]]]\n",
      "GT_Betas: \n",
      "[[-0.256  0.121 -0.126  0.207]\n",
      " [ 1.071  1.067  1.049  0.996]\n",
      " [ 0.035  0.032  0.006 -0.044]\n",
      " [ 0.092 -0.036  0.038 -0.091]\n",
      " [-0.012 -0.13  -0.042 -0.089]\n",
      " [ 0.012  0.019  0.026 -0.038]\n",
      " [ 1.048  0.952  1.017  0.917]\n",
      " [-0.006  0.015 -0.003 -0.017]\n",
      " [ 0.006 -0.095  0.014  0.   ]\n",
      " [ 0.056 -0.053  0.009  0.097]\n",
      " [ 0.     0.032 -0.003  0.1  ]\n",
      " [ 0.986  1.031  0.981  1.018]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.022 0.029 0.02  0.024]\n",
      " [0.012 0.03  0.013 0.01 ]\n",
      " [0.021 0.044 0.021 0.019]]\n",
      "GT_Sigmas: \n",
      "[[0.033 0.037 0.031 0.034]\n",
      " [0.022 0.041 0.02  0.02 ]\n",
      " [0.032 0.051 0.03  0.026]]\n",
      "\n",
      "\n",
      "## Joint 16 ##\n",
      "My_Betas:\n",
      "[[[ 0.064  1.011  0.036  0.001]\n",
      "  [ 0.097  1.011 -0.061 -0.015]\n",
      "  [ 0.055  1.011  0.031  0.005]\n",
      "  [ 0.052  1.014  0.027  0.003]]\n",
      "\n",
      " [[-0.068 -0.018  0.961 -0.   ]\n",
      "  [-0.084 -0.01   0.971  0.003]\n",
      "  [-0.057 -0.026  0.954 -0.005]\n",
      "  [-0.042 -0.038  0.947 -0.004]]\n",
      "\n",
      " [[-0.038 -0.024  0.002  1.012]\n",
      "  [ 0.067 -0.023  0.004  0.992]\n",
      "  [-0.026 -0.02   0.023  1.006]\n",
      "  [ 0.023 -0.022  0.01   0.983]]]\n",
      "GT_Betas: \n",
      "[[ 0.073  0.09   0.068  0.047]\n",
      " [ 1.011  1.002  1.     1.028]\n",
      " [ 0.027 -0.085  0.017  0.018]\n",
      " [-0.001 -0.017  0.001  0.007]\n",
      " [-0.061 -0.041 -0.057  0.005]\n",
      " [-0.014  0.024 -0.005 -0.029]\n",
      " [ 0.971  0.998  0.965  0.96 ]\n",
      " [-0.004 -0.007 -0.005 -0.022]\n",
      " [-0.041  0.064 -0.036  0.008]\n",
      " [-0.022 -0.033 -0.047  0.024]\n",
      " [ 0.003  0.008  0.016  0.006]\n",
      " [ 1.013  0.994  1.01   0.99 ]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.007 0.013 0.006 0.01 ]\n",
      " [0.007 0.01  0.005 0.01 ]\n",
      " [0.004 0.014 0.01  0.021]]\n",
      "GT_Sigmas: \n",
      "[[0.017 0.022 0.016 0.019]\n",
      " [0.017 0.018 0.014 0.018]\n",
      " [0.015 0.022 0.021 0.031]]\n",
      "\n",
      "\n",
      "## Joint 17 ##\n",
      "My_Betas:\n",
      "[[[ 0.042  1.039  0.208 -0.018]\n",
      "  [ 0.462  0.778  0.151 -0.1  ]\n",
      "  [ 0.069  1.025  0.08  -0.016]\n",
      "  [ 0.094  0.992  0.194 -0.018]]\n",
      "\n",
      " [[-0.459 -0.04   0.522 -0.002]\n",
      "  [-0.212 -0.001  0.759 -0.007]\n",
      "  [-0.425 -0.042  0.59  -0.01 ]\n",
      "  [-0.243 -0.102  0.518 -0.08 ]]\n",
      "\n",
      " [[ 0.032 -0.044 -0.042  1.016]\n",
      "  [-0.127 -0.23   0.149  0.971]\n",
      "  [ 0.018 -0.031 -0.     1.02 ]\n",
      "  [ 0.123  0.091  0.414  0.989]]]\n",
      "GT_Betas: \n",
      "[[ 0.123  0.458  0.037  0.28 ]\n",
      " [ 1.03   0.763  1.096  0.96 ]\n",
      " [ 0.166  0.102  0.098  0.123]\n",
      " [-0.044 -0.106 -0.007 -0.084]\n",
      " [-0.572  0.376 -0.51  -0.242]\n",
      " [-0.065  0.085 -0.035 -0.083]\n",
      " [ 0.564  0.881  0.645  0.53 ]\n",
      " [ 0.035 -0.184  0.018 -0.083]\n",
      " [ 0.119 -0.68   0.005  0.539]\n",
      " [ 0.048 -0.37   0.063  0.162]\n",
      " [-0.037  0.164  0.042  0.454]\n",
      " [ 0.979  1.168  1.019  0.832]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.022 0.08  0.023 0.043]\n",
      " [0.039 0.108 0.035 0.037]\n",
      " [0.033 0.111 0.029 0.065]]\n",
      "GT_Sigmas: \n",
      "[[0.034 0.099 0.035 0.055]\n",
      " [0.053 0.113 0.051 0.05 ]\n",
      " [0.042 0.115 0.04  0.067]]\n",
      "\n",
      "\n",
      "## Joint 18 ##\n",
      "My_Betas:\n",
      "[[[ 0.024  1.052  0.097  0.005]\n",
      "  [ 0.008  0.94  -0.007 -0.016]\n",
      "  [-0.02   1.049 -0.007  0.009]\n",
      "  [ 0.041  0.932 -0.05  -0.016]]\n",
      "\n",
      " [[-0.422 -0.037  1.008  0.017]\n",
      "  [-0.728 -0.088  0.406  0.058]\n",
      "  [-0.31  -0.018  1.021 -0.015]\n",
      "  [-0.404  0.019  0.965  0.007]]\n",
      "\n",
      " [[ 0.085 -0.088 -0.065  0.982]\n",
      "  [ 0.681 -0.002 -0.001  0.829]\n",
      "  [-0.07  -0.025 -0.035  1.035]\n",
      "  [ 0.173  0.022  0.216  1.01 ]]]\n",
      "GT_Betas: \n",
      "[[ 0.045 -0.11  -0.044  0.264]\n",
      " [ 1.068  0.905  1.103  0.861]\n",
      " [ 0.117 -0.027  0.025 -0.066]\n",
      " [-0.001  0.026  0.02  -0.094]\n",
      " [-0.431 -0.809 -0.364 -0.205]\n",
      " [-0.045 -0.185  0.013  0.029]\n",
      " [ 1.002  0.514  1.036  1.004]\n",
      " [ 0.019  0.117  0.004 -0.059]\n",
      " [ 0.139  0.689 -0.058  0.392]\n",
      " [-0.075 -0.02  -0.018 -0.054]\n",
      " [-0.057 -0.193 -0.021  0.244]\n",
      " [ 0.966  0.784  1.034  0.942]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.019 0.076 0.017 0.049]\n",
      " [0.02  0.063 0.025 0.031]\n",
      " [0.028 0.108 0.026 0.061]]\n",
      "GT_Sigmas: \n",
      "[[0.027 0.087 0.023 0.063]\n",
      " [0.032 0.073 0.036 0.042]\n",
      " [0.034 0.105 0.036 0.068]]\n",
      "\n",
      "\n",
      "## Joint 19 ##\n",
      "My_Betas:\n",
      "[[[ 0.059  0.946 -0.004 -0.016]\n",
      "  [-0.008  0.987  0.016  0.015]\n",
      "  [-0.003  0.939 -0.051 -0.006]\n",
      "  [-0.025  1.042  0.044  0.023]]\n",
      "\n",
      " [[-0.048  0.043  1.079  0.014]\n",
      "  [-0.149  0.013  0.959  0.021]\n",
      "  [ 0.013 -0.025  1.028 -0.018]\n",
      "  [ 0.005 -0.036  1.033 -0.013]]\n",
      "\n",
      " [[-0.029 -0.1   -0.125  0.964]\n",
      "  [ 0.39  -0.041  0.129  0.896]\n",
      "  [-0.087 -0.025 -0.025  1.009]\n",
      "  [-0.168  0.108  0.042  1.054]]]\n",
      "GT_Betas: \n",
      "[[ 0.173 -0.072  0.029 -0.199]\n",
      " [ 0.948  0.946  0.932  1.078]\n",
      " [-0.044 -0.036 -0.053  0.032]\n",
      " [-0.066  0.024 -0.017  0.078]\n",
      " [-0.128 -0.215 -0.011  0.034]\n",
      " [ 0.03  -0.003 -0.007 -0.046]\n",
      " [ 1.053  0.934  1.025  1.01 ]\n",
      " [ 0.034  0.039 -0.011 -0.03 ]\n",
      " [-0.031  0.391 -0.036 -0.256]\n",
      " [-0.105 -0.071 -0.015  0.09 ]\n",
      " [-0.096  0.133 -0.019  0.071]\n",
      " [ 0.975  0.899  0.993  1.094]]\n",
      "\n",
      "My_Sigmas_:\n",
      "[[0.026 0.027 0.021 0.031]\n",
      " [0.016 0.021 0.014 0.015]\n",
      " [0.016 0.04  0.026 0.03 ]]\n",
      "GT_Sigmas: \n",
      "[[0.037 0.035 0.033 0.04 ]\n",
      " [0.025 0.031 0.023 0.024]\n",
      " [0.025 0.055 0.036 0.042]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Evaluation"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "An evaluation of both, Naïve Bayes and Linear Gaussian Model have been performed using the following methods:\n",
    "\n",
    "1. **Sequential Holdout** 80/20 split.\n",
    "2. **Random Holdout** 80/20 split.\n",
    "3. **Stratified 4-Fold Cross-validation**."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Sequential Holdout\n",
    "\n",
    "We use a split of 80% instances to build the training dataset and 20% for the testing dataset. The separation is done sequentially, therefore it does not consider that the instances of the original dataset have a specific order, and that instances of a specific class are mostly grouped together.\n",
    "\n",
    "Since the method does not split in train and test datasets with data representing equally all classes, this method is the weakest one as we will see in the Results section."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "source": [
    "##\n",
    "## Naïve Bayes Model\n",
    "##\n",
    "## Sequential Holdout 80/20 split\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "\n",
    "data_train = data[:,:,0:int(2045*0.8)]   #1636 of instances (80%) to train model\n",
    "data_test = data[:,:,int(2045*0.8):2045] #409 of instances (20%) to evaluate model\n",
    "\n",
    "labels_train = labels[0:int(2045*0.8)]\n",
    "labels_test = labels[int(2045*0.8):2045]\n",
    "\n",
    "M = learn_model(data_train,labels_train)\n",
    "probs = classify_instances(data_test, M)\n",
    "\n",
    "A = Accuracy(probs, labels_test)\n",
    "A"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.7579462102689487"
      ]
     },
     "metadata": {},
     "execution_count": 34
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "source": [
    "##\n",
    "## Linear Gaussian Model\n",
    "##\n",
    "## Sequential Holdout 80/20 split\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "\n",
    "data_train = data[:,:,0:int(2045*0.8)]   #1636 of instances (80%) to train model\n",
    "data_test = data[:,:,int(2045*0.8):2045] #409 of instances (20%) to evaluate model\n",
    "\n",
    "labels_train = labels[0:int(2045*0.8)]\n",
    "labels_test = labels[int(2045*0.8):2045]\n",
    "\n",
    "M = learn_model(data_train,labels_train,G)\n",
    "probs = classify_instances(data_test, M)\n",
    "\n",
    "\n",
    "A = Accuracy(probs, labels_test)\n",
    "A"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.7970660146699267"
      ]
     },
     "metadata": {},
     "execution_count": 35
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Random Holdout\n",
    "\n",
    "For the generation of Random index vectors without repetitions we use the function ***RandomVect:***\n",
    "\n",
    "We use again a split of 80% instances to build the training dataset and 20% for the testing dataset. \n",
    "\n",
    "This time the separation of instances is done randomly using ***RandomVect***, therefore we minimize the previous problem of not representing all clases in the train and test datasets equally.\n",
    "\n",
    "No repetitions of instances is used in the process of splitting into train and test datasets."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "source": [
    "##\n",
    "## Naïve Bayes Model\n",
    "##\n",
    "## Random Holdout 80/20 split\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "\n",
    "shuffledIndex = RandomVect(2045,0,2044)\n",
    "\n",
    "data_train = data[:,:,shuffledIndex[0:int(2045*0.8)]]   #1636 of instances (80%) to train model\n",
    "data_test = data[:,:,shuffledIndex[int(2045*0.8):2045]] #409 of instances (20%) to evaluate model\n",
    "\n",
    "labels_train = labels[shuffledIndex[0:int(2045*0.8)]]\n",
    "labels_test = labels[shuffledIndex[int(2045*0.8):2045]]\n",
    "\n",
    "M = learn_model(data_train,labels_train)\n",
    "probs = classify_instances(data_test, M)\n",
    "\n",
    "\n",
    "A = Accuracy(probs, labels_test)\n",
    "A"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.9437652811735942"
      ]
     },
     "metadata": {},
     "execution_count": 36
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "source": [
    "##\n",
    "## Linear Gaussian Model\n",
    "##\n",
    "## Random Holdout 80/20 split\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "\n",
    "shuffledIndex = RandomVect(2045,0,2044)\n",
    "\n",
    "data_train = data[:,:,shuffledIndex[0:int(2045*0.8)]]   #1636 of instances (80%) to train model\n",
    "data_test = data[:,:,shuffledIndex[int(2045*0.8):2045]] #409 of instances (20%) to evaluate model\n",
    "\n",
    "labels_train = labels[shuffledIndex[0:int(2045*0.8)]]\n",
    "labels_test = labels[shuffledIndex[int(2045*0.8):2045]]\n",
    "\n",
    "M = learn_model(data_train,labels_train, G)\n",
    "\n",
    "probs = classify_instances(data_test, M)\n",
    "\n",
    "A = Accuracy(probs, labels_test)\n",
    "A"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "0.9853300733496333"
      ]
     },
     "metadata": {},
     "execution_count": 37
    }
   ],
   "metadata": {
    "scrolled": true
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Stratified 4-Fold Cross-validation\n",
    "\n",
    "To solve the problem of not representing all clases equally for train and test datasets we introduce Stratification, and a 4 Fold Cross-validation, assuring that the folds preserve the percentage of samples for each class.\n",
    "\n",
    "To control the Cross-validation iterations we use the function ***GetPerformance***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "source": [
    "##\n",
    "## Naïve Bayes Model\n",
    "##\n",
    "## Stratified Crossvalidation 4Fold\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "[M, A, measures] = GetPerformance(data, np.concatenate(labels), 4)\n",
    "\n",
    "print(\"Accuracies       = \" + str(measures))\n",
    "print(\"Best Accuracy    = \" + str(A))\n",
    "print(\"Average Accuracy = \" + str(np.average(measures)))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Accuracies       = [0.9765625, 0.9197651663405088, 0.9804305283757339, 0.9021526418786693]\n",
      "Best Accuracy    = 0.9804305283757339\n",
      "Average Accuracy = 0.9447277091487281\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "source": [
    "##\n",
    "## Linear Gaussian Model\n",
    "##\n",
    "## Stratified Crossvalidation 4Fold\n",
    "\n",
    "data,labels,individuals = load_dataset()\n",
    "[M, A, measures] = GetPerformance(data, np.concatenate(labels), 4, G)\n",
    "\n",
    "print(\"Accuracies       = \" + str(measures))\n",
    "print(\"Best Accuracy    = \" + str(A))\n",
    "print(\"Average Accuracy = \" + str(np.average(measures)))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Accuracies       = [1.0, 0.9569471624266145, 0.9784735812133072, 0.9452054794520548]\n",
      "Best Accuracy    = 1.0\n",
      "Average Accuracy = 0.9701565557729941\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Results"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "As we can observe in the table '*Accuracy Table*' below, **Linear Gaussian Model outperforms Naïve Bayes** **Model** with all evaluation methods used. Being the former a Discriminative model that considers conditional probabilities (parent joints), and the later a Generative model with a more simplistic view of the data (strong variables independence), the results are congruent.\n",
    "\n",
    "Regarding the method of validation, **Stratified Cross-validation** is clearly the **more robust** method we have used and therefore more reliable than Random Holdout. Although the results are similar on both methods, Cross-validation is usually the preferred because it gives the model the opportunity to train on multiple train-test splits.\n",
    "\n",
    "This gives us a better indication of how well the model will perform on unseen data. Hold-out, on the other hand, is dependent on just one train-test split.\n",
    "\n",
    "Regarding Sequential or Random Holdout, as we have mentioned before, splitting the data randomly produces a more 'fair' model than a sequential split, specially considering that the instances in the original dataset are grouped by classes. We can see, comparing Sequential Holdout and Random Holdout, that the results clearly support this. \n",
    "\n",
    "Finally, **Stratification** ensures even greater 'fairness' regarding to equal representation of classes in all datasets and folds."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "![image.png](attachment:image.png)"
   ],
   "metadata": {},
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Conclusions"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Regardless the naïve aspect of Naïve Bayes, and having into account that strong conditional independence assumptions rarely hold true, we observe good performance for this model, achieving a good balance between accuracy and simplicity of implementation.\n",
    "\n",
    "Nevertheless, introducing dependencies between the positions of different parts of the skeleton makes Linear Gaussian Model outperform the Naïve Bayes approach.\n",
    "\n",
    "Notice the importance to perform the calculation of the posteriors in Log Space to avoid floating point underflows, and ending up dealing with numbers of smaller absolute value than the computer can actually represent."
   ],
   "metadata": {}
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}