examples/train_hmc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning MN classifier of label sequences\n",
    "\n",
    "This example shows how to learn a linear Markov Network classifier that outputs a sequence of labels\n",
    "$$\n",
    "   (\\hat{y}_0,\\ldots,\\hat{y}_{l-1})\\in arg\\max_{(y_0,\\ldots,y_{l-1})\\in \\cal{Y}^{l}} \\left( \\sum_{v=0}^{l-1} \\mathbf{x}_v^T\\mathbf{w}_{y_v} + \\sum_{v=1}^{l-1} g(y_{v-1},y_v) \\right )\n",
    "$$\n",
    "where $\\cal{Y}=\\{0,1,\\ldots,n_y-1\\}$ is set of $n_y$ labels, $l$ is length of the sequence, $(\\mathbf{x}_0,\\ldots,\\mathbf{x}_{l-1})\\in\\Re^{n\\times l}$ is a sequence of input feature vectors, $(\\hat{y}_0,\\ldots,\\hat{y}_{l-1})\\in\\cal{Y}^l$ is predicted sequence of labels, $\\mathbf{w}_y\\in\\Re^n$, $y\\in\\cal{Y}$, are weight vectors and $g\\colon\\cal{Y}\\times\\cal{Y}\\rightarrow\\Re$ is a function scoring quality of a pair of consecutive labels. The weight vectors $\\mathbf{w}_y\\in\\Re^n$, $y\\in\\cal{Y},$ and the pair-wise score $g\\colon\\cal{Y}\\times\\cal{Y}\\rightarrow\\Re$ are the parameters to be learned from examples.\n",
    "\n",
    "This example shows how to learn the parameters from completly annotated sequences (standard supervised learning):\n",
    "$$\n",
    "   \\{ ((\\mathbf{x}_0^j,\\ldots,\\mathbf{x}_{l-1}^j), (y_0^j,\\ldots,y_{l-1}^j))\\in \\Re^{n\\times l}\\times \\cal{Y}^l  \\mid j = 1,\\ldots, m \\}\n",
    "$$\n",
    "However, we also show how learn the parameters from partially annoated examples when some labels in the training set are missing:\n",
    "$$\n",
    "   \\{ ((\\mathbf{x}_0^j,\\ldots,\\mathbf{x}_{l-1}^j), (y_0^j,\\ldots,y_{l-1}^j))\\in \\Re^{n\\times l}\\times (\\cal{Y}\\cup \\{?\\})^l  \\mid j = 1,\\ldots, m \\}\n",
    "$$\n",
    "The algorithm implemented in MANET is guaranteed to work under assumption that the labels are missing at random.\n",
    "\n",
    "The objective is to learn MN predictor with minimal expected Hamming loss. Becasue the Hamming loss is hard to optimize as its gradient is zero almost everywhere, the M3N algorithm replaces the target Hamming loss by easier to optimize proxy loss. MANET implements two proxy losses: i) LP Margin-Rescaling loss and ii) MArkov Network Adversarial (MANA) loss.\n",
    "\n",
    "In this example, the input/output sequences are generated from a known Hidden Markov Chain model. Hence, we can estimate the Bayes risk and use it as a reference solution when evaluating the MN predictor learned from data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define data generator\n",
    "\n",
    "We will use synthetic data generated from a Hidden Markov Chain. The observable sequence $(x_0,\\ldots,x_{l-1})\\in \\{0,\\ldots,n_x-1\\}^l$ and the hidden sequence $(y_0,\\ldots,y_{l-1})\\in \\{0,\\ldots,n_y-1\\}^l$ follow the distribution:\n",
    "$$ P(x_0,\\ldots,x_{l-1},y_0,\\ldots,y_{l-1})=P_0(y_0)\\prod_{i=1}^{l-1} P(y_i\\mid y_{i-1}) P(x_i\\mid y_i)$$\n",
    "\n",
    "In this code we set the transition probability to\n",
    "$$P(y_{i+1}\\mid y_i) = \\left \\{ \\begin{array}{lll}\n",
    "   \\alpha & if & y_{i+1} = y_i\\\\\n",
    "   (1-\\alpha)/(n_y-1) & if & y_{i+1} \\neq y_i\n",
    "  \\end{array}\n",
    "  \\right .\n",
    "$$\n",
    "and the emission probability to\n",
    "$$P(x_i\\mid y_i) = \\left \\{ \\begin{array}{lll}\n",
    "   \\beta & if & x_i = y_i\\\\\n",
    "   (1-\\beta)/(n_x-1) & if & x_i \\neq y_i\n",
    "  \\end{array}\n",
    "  \\right .\n",
    "$$\n",
    "\n",
    "The number of observeble symbols $n_x$, hidden symbols $n_y$, the initial state probability $P_0(y_0)$, the numbers $\\alpha\\in(0,1)$, $\\beta\\in(0,1)$ and the sequence length $l$ are hyperparameters that can be defined below. \n",
    "\n",
    "In the following example, the sequence length is kept constant, however note that MANET allows the length of training examples to be different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from manet.hmc import HMC\n",
    "\n",
    "n_x = 30        # number of observable symbols\n",
    "n_y = 10        # number of hidden symbols\n",
    "alpha = 0.7     # hyperparameter of the transition probability\n",
    "beta = 0.7      # hyperparameter of the emission probability\n",
    "seq_length = 10 # sequence length\n",
    "\n",
    "# define transition probability\n",
    "trans = (1-alpha)*np.ones((n_y,n_y)) / (n_y-1)\n",
    "np.fill_diagonal( trans, alpha )\n",
    "\n",
    "# define emission probability\n",
    "emis = (1-beta)*np.ones( (n_y,n_x )) / (n_x - 1)\n",
    "np.fill_diagonal( emis, beta )\n",
    "\n",
    "# define initial state probability\n",
    "p0 = np.ones( n_y ) / n_y\n",
    "\n",
    "# initialize HMC class\n",
    "Hmc = HMC( p0, trans, emis, alphabet=np.int16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estimate Bayes risk\n",
    "\n",
    "Because we know the data distribution, we can construct Bayes optimal rule. We construct the Bayes rule that minimizes the expected Hamming loss \n",
    "$$\n",
    "  \\ell_{Hamming}(y_0,\\ldots,y_{l-1},\\hat{y}_0,\\ldots,\\hat{y}_{l-1}) = \\frac{1}{l}\\sum_{i=1}^{l-1}\\delta(y_i\\neq \\hat{y}_i)\n",
    "$$\n",
    "and the Bayes rule that minimizes the expected 0/1-loss\n",
    "$$\n",
    "  \\ell_{0/1}(y_0,\\ldots,y_{l-1},\\hat{y}_0,\\ldots,\\hat{y}_{l-1}) = \\left \\{\n",
    "    \\begin{array}{ll}\n",
    "      1 & if \\; \\lor_{i=1}^{l-1}\\delta(y_i\\neq \\hat{y}_i)\\\\\n",
    "      0 & otherwise\n",
    "      \\end{array}\n",
    "      \\right .\n",
    "$$\n",
    "In case of Hamming loss, the Bayes rule is a sequence of the most probable states which can be computed by function <code>HMC.decode</code>. In case of 0/1l-loss, the Bayes rule is a sequence maximizing a posteriory probability which can be computed by function <code>HMC.map</code>. Having the Bayes rules, we estimate the Bayes risk (best attainable) to get a reference solution for later comparison with the rule learned from examples by M3N algorithm. The implemented M3N algorithm minimizes only a proxy of the Hamming loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bayes risk for Hamming loss: 0.15619999999999737\n",
      "bayes risk for 0/1-loss: 0.7453\n"
     ]
    }
   ],
   "source": [
    "m = 10000 # number of examples used to estimate the Bayes risk\n",
    "\n",
    "risk_hamming_decode = 0  # Expected Hamming loss of max-marginals (decode) rule\n",
    "risk_01_map = 0          # Expected 0/1-loss of MAP rule\n",
    "for i in range( m ):\n",
    "    X, Y = Hmc.generate( seq_length )\n",
    "\n",
    "    # Maximum aposteriory rule\n",
    "    Ymap, log_map = Hmc.map(X)\n",
    "    risk_01_map += int( np.any( Y != Ymap ) )\n",
    "\n",
    "    # Decode rule i.e. sequnce of the most probable states\n",
    "    P = Hmc.decode( X )\n",
    "    Ydec = np.argmax( P, axis = 0)\n",
    "    risk_hamming_decode += np.count_nonzero( Y-Ydec ) / seq_length\n",
    "    \n",
    "risk_01_map /= m\n",
    "risk_hamming_decode /= m\n",
    "    \n",
    "print(\"Bayes risk for Hamming loss:\", risk_hamming_decode)\n",
    "print(\"bayes risk for 0/1-loss:\", risk_01_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning from completly annotated examples\n",
    "\n",
    "We use the Hidden Markov Chain model to generate set of training sequences and testing sequences. We first consider training from complete label sequences, i.e. there are no missing labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'X': array([ 1,  1, 19, 20,  2,  2,  4,  4,  4,  6], dtype=int16),\n",
       " 'Y': array([1, 1, 4, 2, 2, 2, 4, 4, 4, 6], dtype=int16),\n",
       " 'n_x': 30,\n",
       " 'n_y': 10}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define number of ttraining and test examples\n",
    "n_trn_examples = 500 \n",
    "n_tst_examples = 500\n",
    "def generate_sequences( Hmc, length, n_examples):\n",
    "    examples = []\n",
    "    for i in range( n_examples):\n",
    "        X, Y = Hmc.generate(  length )\n",
    "        examples.append({'X': X, 'Y': Y, 'n_x': Hmc.n_x, 'n_y': Hmc.n_y} )\n",
    "    return examples        \n",
    "\n",
    "trn_sequences = generate_sequences( Hmc, seq_length, n_trn_examples)\n",
    "tst_sequences = generate_sequences( Hmc, seq_length, n_tst_examples)\n",
    "\n",
    "trn_sequences[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We represent each training example as a Markov Network whose input is the observable sequence. The class implementing the Markov Network allows i) to predict the sequence of labels and ii) to evaluate the proxy of the Hamming loss and its gradient which is used when learning parameters of the MN predictor. MANET implements two models which differ in the used proxy: i) the Margin-rescaling loss (class <code>MrMaNetHomo</code>)and ii) MArkov Network Adversarial loss (class <code>AdvMaNetHomo</code>). The models assume the input observations to be real-valued feature vectors, hence, in this example the symbols of the input sequences are one-hot encoded. The models work for arbitrary graph of interactions, however, in this example the edges of the graph are set to be a simple chain.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from manet.m3n import M3N, one_hot\n",
    "from manet.mn_models import MrMaNetHomo, AdvMaNetHomo\n",
    "\n",
    "def create_markov_nets( model, sequences ):\n",
    "    examples = []\n",
    "    for seq in sequences:\n",
    "        length = len( seq['X'])        \n",
    "        chain = np.concatenate(( np.arange(0,length-1).reshape((1,length-1)),\n",
    "                                 np.arange(1,length).reshape((1,length-1)) ),axis=0)\n",
    "        examples.append( model( n_y = seq['n_y'],\\\n",
    "                            X = one_hot(seq['n_x'],seq['X']),\\\n",
    "                            Y = seq['Y'],\\\n",
    "                            E = chain, \\\n",
    "                            graph = 'chain') )\n",
    "    return examples\n",
    "\n",
    "# select which proxy of the Hamming loss is going to be used\n",
    "model = MrMaNetHomo   # use Margin-recaling proxy\n",
    "#model = AdvMaNetHomo # use MANA loss\n",
    "\n",
    "trn_examples = create_markov_nets( model, trn_sequences)\n",
    "tst_examples = create_markov_nets( model, tst_sequences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use stochastic gradient solver to minimize L2-regularized proxy of the Hamming loss (Margin-Rescaling or MANA) on training examples. The strength of L2-regularization is a hyperpameter (<code>lam</code>). The MANET implements a plain Stochastic Gradient Descend (SGD) and ADAM (<code>solver</code>). The algorithm runs for a fixed number of passes through training examples (<code>num_epochs</code>). The learning rate $\\alpha_t$ at epoch $t$ is set to \n",
    "$$\n",
    "   \\alpha_{t} = A(t+1)^B\n",
    "$$\n",
    "where $A$ and $B$ are hyperparameters. The solver returns a vector <code>params</code> which encapsulates parameters $\\mathbf{w}_y\\in\\Re^n$, $y\\in\\cal{Y}$, and $g\\colon\\cal{Y}\\times\\cal{Y}\\rightarrow\\Re$ of the MN predictor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch=0 obj_val=0.9272982448751459\n",
      "epoch=10 obj_val=0.4963930285339164\n",
      "epoch=20 obj_val=0.43220319213721986\n",
      "epoch=30 obj_val=0.41109246162454505\n",
      "epoch=40 obj_val=0.4014600185445441\n",
      "epoch=50 obj_val=0.3946232028035921\n",
      "epoch=60 obj_val=0.39086565445948157\n",
      "epoch=70 obj_val=0.38827788095176313\n",
      "epoch=80 obj_val=0.38680813743013903\n",
      "epoch=90 obj_val=0.3851299513169953\n",
      "epoch=99 obj_val=0.3843592444110392\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'objective')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "config = {'num_epochs': 100,  # number of passes over training examples\n",
    "          'lr_const': 0.01,   # hyperparamter A\n",
    "          'lr_exp': -1,       # hyperparamter B\n",
    "          'eval_obj': 10,     # frequency of evaluation of the objective function \n",
    "          'verb': True,       # display progress\n",
    "          'solver': 'adam'}   # solver \"adam\" or \"sgd\"\n",
    " \n",
    "algo = M3N( config )\n",
    "\n",
    "lam = 0 # regularization parameter\n",
    "params, obj_val = algo.train( trn_examples, lam )\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(obj_val)\n",
    "plt.ylabel(\"objective\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We evaluate training and test error and compare agains the error of Bayes predictor. Recall that M3N aims to minimize a proxy of the Hamming loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[MN predictor]\n",
      "Training error\n",
      "Hamming loss: 0.17120000000000002\n",
      "01-loss: 0.798\n",
      "Test error\n",
      "Hamming loss: 0.184\n",
      "01-loss: 0.818\n",
      "\n",
      "[Test error of Bayes predictor]\n",
      "Hamming loss: 0.15619999999999737\n",
      "01 loss: 0.7453\n"
     ]
    }
   ],
   "source": [
    "trn_hamming_loss, trn_01_loss = algo.eval( params, trn_examples )\n",
    "trn_risk_hamming_m3n = np.mean(trn_hamming_loss)\n",
    "trn_risk_01_m3n = np.mean(trn_01_loss)\n",
    "\n",
    "print(\"[MN predictor]\")\n",
    "print(\"Training error\")\n",
    "print( \"Hamming loss:\",trn_risk_hamming_m3n)\n",
    "print( \"01-loss:\", trn_risk_01_m3n )\n",
    "\n",
    "tst_hamming_loss, tst_01_loss = algo.eval( params, tst_examples )\n",
    "tst_risk_hamming_m3n = np.mean(tst_hamming_loss)\n",
    "tst_risk_01_m3n = np.mean(tst_01_loss)\n",
    "\n",
    "print(\"Test error\")\n",
    "print( \"Hamming loss:\",tst_risk_hamming_m3n)\n",
    "print( \"01-loss:\", tst_risk_01_m3n)\n",
    "\n",
    "print()\n",
    "print(\"[Test error of Bayes predictor]\")\n",
    "print( \"Hamming loss:\", risk_hamming_decode)\n",
    "print( \"01 loss:\", risk_01_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code shows some predictions on test examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example: 0\n",
      "predictor score   : 3.4840696078171978\n",
      "input sequnce     : [28  9  9  3  3  3 23  3  3  3]\n",
      "true sequence     : [9 9 9 3 3 3 3 3 3 3]\n",
      "predicted sequence: [9 9 9 3 3 3 3 3 3 3]\n",
      "example: 1\n",
      "predictor score   : 3.343106245589225\n",
      "input sequnce     : [ 1  4 16  8  1  8  8  8  0  0]\n",
      "true sequence     : [9 9 9 8 8 8 8 8 0 0]\n",
      "predicted sequence: [1 4 4 8 1 8 8 8 0 0]\n",
      "example: 2\n",
      "predictor score   : 3.1801161697904243\n",
      "input sequnce     : [23  2 10  0  0  8  4  2  2  0]\n",
      "true sequence     : [1 1 1 0 0 8 2 2 2 0]\n",
      "predicted sequence: [2 2 2 0 0 8 4 2 2 0]\n",
      "example: 3\n",
      "predictor score   : 3.0993182837087776\n",
      "input sequnce     : [27  9  9 11  1  1 16  9  4  4]\n",
      "true sequence     : [9 9 9 9 1 1 7 4 4 4]\n",
      "predicted sequence: [9 9 9 1 1 1 9 9 4 4]\n",
      "example: 4\n",
      "predictor score   : 3.134699976074608\n",
      "input sequnce     : [ 7  1  1 23  1 23 11  4  4  7]\n",
      "true sequence     : [7 1 1 1 1 1 1 4 4 7]\n",
      "predicted sequence: [7 1 1 1 1 4 4 4 4 7]\n",
      "example: 5\n",
      "predictor score   : 3.49596692692834\n",
      "input sequnce     : [19  2  2  4  2  2  7  0  0  0]\n",
      "true sequence     : [3 2 2 4 2 2 7 0 0 0]\n",
      "predicted sequence: [2 2 2 4 2 2 7 0 0 0]\n",
      "example: 6\n",
      "predictor score   : 3.106444660646231\n",
      "input sequnce     : [ 4  4 21  5  7  6  0 16 15  0]\n",
      "true sequence     : [4 4 5 5 5 8 0 0 0 0]\n",
      "predicted sequence: [4 4 5 5 7 6 0 0 0 0]\n",
      "example: 7\n",
      "predictor score   : 3.2204359441991195\n",
      "input sequnce     : [ 3  5 20  5 29  2  2 16  2  2]\n",
      "true sequence     : [5 5 5 5 2 2 2 2 2 2]\n",
      "predicted sequence: [3 5 5 5 5 2 2 2 2 2]\n",
      "example: 8\n",
      "predictor score   : 3.4413441845685346\n",
      "input sequnce     : [ 6  6 22  6  6  6  4 24  4  0]\n",
      "true sequence     : [6 6 6 6 6 6 4 4 4 0]\n",
      "predicted sequence: [6 6 6 6 6 6 4 4 4 0]\n",
      "example: 9\n",
      "predictor score   : 3.4901917356782333\n",
      "input sequnce     : [ 3  7  7  7 26  0  7  7  2  6]\n",
      "true sequence     : [7 7 7 7 7 7 7 7 6 6]\n",
      "predicted sequence: [3 7 7 7 7 0 7 7 2 6]\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    Y_pred, score = algo.predict( params, tst_examples[i] )\n",
    "\n",
    "    print(\"example:\", i)\n",
    "    print(\"predictor score   :\", score )\n",
    "    print(\"input sequnce     :\", tst_sequences[i]['X'])\n",
    "    print(\"true sequence     :\", tst_sequences[i]['Y'] )\n",
    "    print(\"predicted sequence:\",Y_pred )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning from examples with missing labels\n",
    "\n",
    "We use the Hidden Markov Chain model to generate set of training sequences and testing sequences. A randomly selected portion of labels in the training sequences are changed to be uknown (special label -1). The portion of missing labels is defined by <code>p_missing</code>. Note that the learning algorithm does not need to known the portion of missing labels, however it relies on the assumption that the labels are missing at random."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'X': array([ 3, 18,  3,  3,  3,  6,  6,  6,  0,  7], dtype=int16),\n",
       " 'Y': array([ 3,  3,  3,  3,  6, -1,  6,  6,  6,  7], dtype=int16),\n",
       " 'n_x': 30,\n",
       " 'n_y': 10}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define number of training and test examples\n",
    "n_trn_examples = 500 # number of \n",
    "n_tst_examples = 500\n",
    "\n",
    "# define portion of missing labels\n",
    "p_missing = 0.2\n",
    "\n",
    "def generate_sequences( Hmc, length, n_examples, p_missing):\n",
    "    examples = []\n",
    "    for i in range( n_examples):\n",
    "        X, Y = Hmc.generate(  length )\n",
    "\n",
    "        # randomly selected a subset of labels and change them to unknowns\n",
    "        missing = np.random.choice( 2, length, p=[1-p_missing,p_missing] )\n",
    "        Y[missing==1] = -1\n",
    "\n",
    "        examples.append({'X': X, 'Y': Y, 'n_x': Hmc.n_x, 'n_y': Hmc.n_y} )\n",
    "    return examples        \n",
    "\n",
    "trn_sequences_missing = generate_sequences( Hmc, seq_length, n_trn_examples, p_missing)\n",
    "trn_sequences_missing[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training on from examples with missing labels is the same as in the case of complete annotations. The only difference is that the learning algorithm needs to know type of the process which generated the missing labels. There are two options supported: i) probability of missing label is the same for each object in the sequence (denoted as <code>homo</code>-geneous annotations) or ii) the probability can be different for each object in the sequence (<code>unhomo</code>-geneous annotations). Note that the algorithm does not require to know the probabilities but only whether they are the same or different. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch=0 obj_val=0.9919691402877069\n",
      "epoch=10 obj_val=0.5363907432873647\n",
      "epoch=20 obj_val=0.46282813862131955\n",
      "epoch=30 obj_val=0.43438351614677795\n",
      "epoch=40 obj_val=0.41736179793012346\n",
      "epoch=50 obj_val=0.40675856340841776\n",
      "epoch=60 obj_val=0.3993072741350134\n",
      "epoch=70 obj_val=0.394413796045726\n",
      "epoch=80 obj_val=0.38952141307869154\n",
      "epoch=90 obj_val=0.3859297059481015\n",
      "epoch=99 obj_val=0.3830540911703365\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'objective')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "trn_examples_missing = create_markov_nets( model, trn_sequences_missing)\n",
    "\n",
    "config = {'num_epochs': 100,    # number of passes over training examples\n",
    "          'lr_const': 0.01,     # hyperparamter A\n",
    "          'lr_exp': -1,         # hyperparamter B\n",
    "          'eval_obj': 10,       # frequency of evaluation of the objective function \n",
    "          'verb': True,         # display progress\n",
    "          'solver': 'adam',     # solver \"adam\" or \"sgd\"\n",
    "          'annotation': 'homo'} # type of missingness \"home\"-geneous or \"unhomo\"-geneous\n",
    " \n",
    "algo = M3N( config )\n",
    "\n",
    "lam = 0\n",
    "params_missing, obj_val = algo.train( trn_examples_missing, lam )\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(obj_val)\n",
    "plt.ylabel(\"objective\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finaly, we evaluate performance of the MN predictor trained from examples with missing labels and compare to the one trained from complete annotations and to the Bayes predictor. Note that the training errors of the predictor trained from missing labels is lower because the missing labels do not contribute to the training error as they are unknown. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[MN predictor trained from examples with 20.0% of missing labels]\n",
      "Training errors\n",
      "Hamming loss: 0.11720000000000001\n",
      "01-loss: 0.664\n",
      "Test errors\n",
      "Hamming loss: 0.18760000000000002\n",
      "01-loss: 0.828\n",
      "\n",
      "[MN predictor trained from complete examples]\n",
      "Training errors\n",
      "Hamming loss: 0.17120000000000002\n",
      "01-loss: 0.798\n",
      "Test errors\n",
      "Hamming loss: 0.184\n",
      "01-loss: 0.818\n",
      "\n",
      "[Test error of Bayes predictor]\n",
      "Hamming loss: 0.15619999999999737\n",
      "01 loss: 0.7453\n"
     ]
    }
   ],
   "source": [
    "trn_hamming_loss_mis, trn_01_loss_mis = algo.eval( params_missing, trn_examples_missing )\n",
    "trn_risk_hamming_m3n_mis = np.mean(trn_hamming_loss_mis)\n",
    "trn_risk_01_m3n_mis = np.mean(trn_01_loss_mis)\n",
    "\n",
    "tst_hamming_loss_mis, tst_01_loss_mis = algo.eval( params_missing, tst_examples )\n",
    "tst_risk_hamming_m3n_mis = np.mean(tst_hamming_loss_mis)\n",
    "tst_risk_01_m3n_mis = np.mean(tst_01_loss_mis)\n",
    "\n",
    "\n",
    "print(f\"[MN predictor trained from examples with {p_missing*100}% of missing labels]\")\n",
    "print(\"Training errors\")\n",
    "print(\"Hamming loss:\",trn_risk_hamming_m3n_mis)\n",
    "print(\"01-loss:\", trn_risk_01_m3n_mis )\n",
    "print(\"Test errors\")\n",
    "print(\"Hamming loss:\",tst_risk_hamming_m3n_mis)\n",
    "print(\"01-loss:\", tst_risk_01_m3n_mis )\n",
    "\n",
    "print()\n",
    "print(f\"[MN predictor trained from complete examples]\")\n",
    "print(\"Training errors\")\n",
    "print(\"Hamming loss:\",trn_risk_hamming_m3n)\n",
    "print(\"01-loss:\", trn_risk_01_m3n )\n",
    "print(\"Test errors\")\n",
    "print(\"Hamming loss:\",tst_risk_hamming_m3n)\n",
    "print(\"01-loss:\", tst_risk_01_m3n )\n",
    "\n",
    "print()\n",
    "print(\"[Test error of Bayes predictor]\")\n",
    "print( \"Hamming loss:\", risk_hamming_decode)\n",
    "print( \"01 loss:\", risk_01_map)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.8 ('manet')",
   "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.10.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "34eb675ba1599e41a978d852241fe8b4873ed3c3e59b32810c909d7852b5516c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}