example_feature_selection_titanic_survivals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "56f0b47e",
   "metadata": {},
   "source": [
    "# Example: Feature Selection -  Predicting Survival of Titanic Passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4c52a895",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import itertools\n",
    "import os\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as colors\n",
    "import networkx as nx\n",
    "\n",
    "import dynex\n",
    "import dimod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbb96a3f",
   "metadata": {},
   "source": [
    "This notebook demonstrates the formulation of an $\\left(\\frac{n}{k}\\right)$ optimization problem to be computed on the Dynex neuromorphic platform. The method used in the example problem of this notebook —feature-selection for machine learning— is applicable to problems from a wide range of domains; for example financial portfolio optimization. This notebook should help you understand both the techniques and Dimod tools used for solving optimization problems on the Dynex computing platform."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58238d5f",
   "metadata": {},
   "source": [
    "## What is Feature Selection? "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b57c429",
   "metadata": {},
   "source": [
    "Statistical and machine-learning models use sets of input variables (\"features\") to predict output variables of interest. Feature selection can be part of the model design process: selecting from a large set of potential features a highly informative subset simplifies the model and reduces dimensionality.\n",
    "\n",
    "For example, to build a model that predicts the ripening of hothouse tomatoes, Farmer MacDonald daily records the date, noontime temperature, daylight hours, degree of cloudiness, rationed water and fertilizer, soil humidity, electric-light hours, etc. These measurements constitute a list of potential features. After a growth cycle or two, her analysis reveals some correlations between these features and crop yields:\n",
    "\n",
    "- fertilizer seems a strong predictor of fruit size\n",
    "- cloudiness and daylight hours seem poor predictors of growth\n",
    "- water rations and soil humidity seem a highly correlated pair of strong predictors of crop rot\n",
    "\n",
    "Farmer MacDonald suspects that her hothouse's use of electric light reduces dependency on seasons and sunlight. She can simplify her model by discarding date, daylight hours, and cloudiness. She can record just water ration or just soil humidity rather than both.\n",
    "\n",
    "For systems with large numbers of potential input information—for example, weather forecasting or image recognition—model complexity and required compute resources can be daunting. Feature selection can help make such models tractable.\n",
    "\n",
    "However, optimal feature selection can itself be a hard problem. This example introduces a powerful method of optimizing feature selection based on a complex probability calculation. This calculation is submitted for solution to a quantum computer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e993bf0b",
   "metadata": {},
   "source": [
    "## Feature Selection by Mutual Information"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0a5688b",
   "metadata": {},
   "source": [
    "There are various methods for feature selection. If you are building a machine-learning model, for example, and have six potential features, you might naively consider training it first on each of the features by itself, then on all 15 combinations of subsets of two features, then 20 combinations of subsets of three features, and so on. However, statistical methods are more efficient.\n",
    "\n",
    "One statistical criterion that can guide this selection is mutual information (MI).The following section explains information and MI based on the Titanic dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04152f71",
   "metadata": {},
   "source": [
    "Mutual information between variables X and Y is defined as"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "106cd7ce",
   "metadata": {},
   "source": [
    "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n",
    "  <mi>I</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mi>X</mi>\n",
    "  <mo>;</mo>\n",
    "  <mi>Y</mi>\n",
    "  <mo stretchy=\"false\">)</mo>\n",
    "  <mo>=</mo>\n",
    "  <munder>\n",
    "    <mo data-mjx-texclass=\"OP\">&#x2211;</mo>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi>y</mi>\n",
    "      <mo>&#x2208;</mo>\n",
    "      <mi>Y</mi>\n",
    "    </mrow>\n",
    "  </munder>\n",
    "  <munder>\n",
    "    <mo data-mjx-texclass=\"OP\">&#x2211;</mo>\n",
    "    <mrow data-mjx-texclass=\"ORD\">\n",
    "      <mi>x</mi>\n",
    "      <mo>&#x2208;</mo>\n",
    "      <mi>X</mi>\n",
    "    </mrow>\n",
    "  </munder>\n",
    "  <mi>p</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mi>x</mi>\n",
    "  <mo>,</mo>\n",
    "  <mi>y</mi>\n",
    "  <mo stretchy=\"false\">)</mo>\n",
    "  <mi>log</mi>\n",
    "  <mo data-mjx-texclass=\"NONE\">&#x2061;</mo>\n",
    "  <mfrac>\n",
    "    <mrow>\n",
    "      <mi>p</mi>\n",
    "      <mo stretchy=\"false\">(</mo>\n",
    "      <mi>x</mi>\n",
    "      <mo>,</mo>\n",
    "      <mi>y</mi>\n",
    "      <mo stretchy=\"false\">)</mo>\n",
    "    </mrow>\n",
    "    <mrow>\n",
    "      <mi>p</mi>\n",
    "      <mo stretchy=\"false\">(</mo>\n",
    "      <mi>x</mi>\n",
    "      <mo stretchy=\"false\">)</mo>\n",
    "      <mi>p</mi>\n",
    "      <mo stretchy=\"false\">(</mo>\n",
    "      <mi>y</mi>\n",
    "      <mo stretchy=\"false\">)</mo>\n",
    "    </mrow>\n",
    "  </mfrac>\n",
    "</math>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b4896c6",
   "metadata": {},
   "source": [
    "where p(x) and p(y)are marginal probabilities of X and Y, and p(y,y) the joint probability. Equivalently,"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb46420",
   "metadata": {},
   "source": [
    "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n",
    "  <mi>I</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mi>X</mi>\n",
    "  <mo>;</mo>\n",
    "  <mi>Y</mi>\n",
    "  <mo stretchy=\"false\">)</mo>\n",
    "  <mo>=</mo>\n",
    "  <mi>H</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mi>Y</mi>\n",
    "  <mo stretchy=\"false\">)</mo>\n",
    "  <mo>&#x2212;</mo>\n",
    "  <mi>H</mi>\n",
    "  <mo stretchy=\"false\">(</mo>\n",
    "  <mi>Y</mi>\n",
    "  <mo data-mjx-texclass=\"ORD\" stretchy=\"false\">|</mo>\n",
    "  <mi>X</mi>\n",
    "  <mo stretchy=\"false\">)</mo>\n",
    "</math>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4273cb32",
   "metadata": {},
   "source": [
    "where H(Y) is the SE of Y and H(Y|X) is the CSE of Y conditional on X."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73d90dcb",
   "metadata": {},
   "source": [
    "Mutual information (MI) quantifies how much one knows about one random variable from observations of another. Intuitively, a model based on just one of a pair of features (e.g., farmer MacDonald's water rations and soil humidity) will better reproduce their combined contribution when MI between them is high."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c02ab970",
   "metadata": {},
   "source": [
    "## Helper Functions (MI and Plotting) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5dd4d5a",
   "metadata": {},
   "source": [
    "The following cells are implementing the MI calculations as well as some functions to plot data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a19daa6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define MI calculations\n",
    "def prob(dataset):\n",
    "    \"\"\"Joint probability distribution P(X) for the given data.\"\"\"\n",
    "\n",
    "    # bin by the number of different values per feature\n",
    "    num_rows, num_columns = dataset.shape\n",
    "    bins = [len(np.unique(dataset[:, ci])) for ci in range(num_columns)]\n",
    "\n",
    "    prob, _ = np.histogramdd(dataset, bins)\n",
    "    return prob / np.sum(prob)\n",
    "\n",
    "\n",
    "def shannon_entropy(p):\n",
    "    \"\"\"Shannon entropy H(X) is the negative sum of P(X)log(P(X)) for probability\n",
    "    distribution P(X).\n",
    "    \"\"\"\n",
    "    p = p.flatten()\n",
    "    return -sum(pi*np.log2(pi) for pi in p if pi)\n",
    "\n",
    "\n",
    "def conditional_shannon_entropy(p, *conditional_indices):\n",
    "    \"\"\"Conditional Shannon entropy H(X|Y) = H(X,Y) - H(Y).\"\"\"\n",
    "\n",
    "    # Sanity check on validity of conditional_indices.  In particular,\n",
    "    # try to trap issues in which dimensions have been removed from\n",
    "    # probability table through marginalization, but\n",
    "    # conditional_indices were not updated accordingly.\n",
    "    assert(all(ci < p.ndim for ci in conditional_indices))\n",
    "\n",
    "    axis = tuple(i for i in np.arange(len(p.shape))\n",
    "                 if i not in conditional_indices)\n",
    "\n",
    "    return shannon_entropy(p) - shannon_entropy(np.sum(p, axis=axis))\n",
    "\n",
    "def mutual_information(prob, j):\n",
    "    \"\"\"Mutual information between variables X and variable Y.\n",
    "\n",
    "    Calculated as I(X; Y) = H(X) - H(X|Y).\"\"\"\n",
    "\n",
    "    return (shannon_entropy(np.sum(prob, axis=j))\n",
    "            - conditional_shannon_entropy(prob, j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0c8c07ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def conditional_mutual_information(p, j, *conditional_indices):\n",
    "    \"\"\"Mutual information between variables X and variable Y conditional on variable Z.\n",
    "\n",
    "    Calculated as I(X;Y|Z) = H(X|Z) - H(X|Y,Z)\"\"\"\n",
    "\n",
    "    # Compute an updated version of the conditional indices for use\n",
    "    # when the probability table is marginalized over dimension j.\n",
    "    # This marginalization removes one dimension, so any conditional\n",
    "    # indices pointing to dimensions after this one must be adjusted\n",
    "    # accordingly.\n",
    "    marginal_conditional_indices = [i-1 if i > j else i for i in conditional_indices]\n",
    "\n",
    "    return (conditional_shannon_entropy(np.sum(p, axis=j), *marginal_conditional_indices)\n",
    "            - conditional_shannon_entropy(p, j, *conditional_indices))\n",
    "\n",
    "\n",
    "def maximum_energy_delta(bqm):\n",
    "    \"\"\"Compute conservative bound on maximum change in energy when flipping a single variable\"\"\"\n",
    "    return max(abs(bqm.get_linear(i))\n",
    "               + sum(abs(bqm.get_quadratic(i,j))\n",
    "                     for j, _ in bqm.iter_neighborhood(i))\n",
    "               for i in bqm.variables)\n",
    "\n",
    "\n",
    "def mutual_information_bqm(dataset, features, target):\n",
    "    \"\"\"Build a BQM that maximizes MI between survival and a subset of features\"\"\"\n",
    "    variables = ((feature, -mutual_information(prob(dataset[[target, feature]].values), 1))\n",
    "                 for feature in features)\n",
    "    interactions = ((f0, f1, -conditional_mutual_information(prob(dataset[[target, f0, f1]].values), 1, 2))\n",
    "                    for f0, f1 in itertools.permutations(features, 2))\n",
    "    return dimod.BinaryQuadraticModel(variables, interactions, 0, dimod.BINARY)\n",
    "\n",
    "\n",
    "def add_combination_penalty(bqm, k, penalty):\n",
    "    \"\"\"Create a new BQM with an additional penalty biased towards k-combinations\"\"\"\n",
    "    kbqm = dimod.generators.combinations(bqm.variables, k, strength=penalty)\n",
    "    kbqm.update(bqm)\n",
    "    return kbqm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "948ec9a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sub_plot(size, small, big, x, subtitles, y, *y2):\n",
    "    gs = GridSpec(big + 1, small)\n",
    "    plt.figure(figsize=size)\n",
    "    for i in range(small):\n",
    "        ax = 'ax_' + str(i)\n",
    "        ax = plt.subplot(gs[0, i])\n",
    "        ax.set_title(subtitles[i])\n",
    "        if y2:\n",
    "            ax.plot(x, y2[0]['out'].values, 'ro')\n",
    "            ax.plot(x, y[y.columns[i]].values, 'bv')\n",
    "            ax.legend([\"out\", \"model\"])\n",
    "        else:\n",
    "            ax.plot(x, y[y.columns[i]].values)\n",
    "\n",
    "    if big:\n",
    "        axy = plt.subplot(gs[1, :])\n",
    "        i += 1\n",
    "        axy.set_title(y.columns[i])\n",
    "        axy.plot(x, y[y.columns[i]].values, 'r')\n",
    "    return plt\n",
    "\n",
    "def plot_toy_signals(df):\n",
    "    sub_plot((10, 8), 3, True, np.linspace(-np.pi, np.pi, len(df)), df.columns, df)\n",
    "    plt.suptitle(\"Toy Problem: System Inputs and Output\", fontsize=15)\n",
    "\n",
    "def plot_two_var_model(df1, df2):\n",
    "    subtitles = [\"Modeling %s and %s\" % f0f1 for f0f1 in df1.columns]\n",
    "    sub_plot((12, 4), 3, 0, np.linspace(-np.pi, np.pi, len(df1)), subtitles, df1, df2)\n",
    "    plt.suptitle(\"Toy Problem: Output Vesus Two-Signal Model\", fontsize=15)\n",
    "\n",
    "def plot_lingress(df, toy):\n",
    "    subtitles = [\"%s correlation coefficient: %.2f\" % var_rval for var_rval in df.columns]\n",
    "    sub_plot((12, 4), 3, 0, np.linspace(-np.pi, np.pi, len(df)), subtitles, df, toy)\n",
    "    plt.suptitle(\"Toy Problem: Linear Regression\", fontsize=15)\n",
    "\n",
    "def plot_se(data):\n",
    "    df = pd.DataFrame(data)\n",
    "    plt.figure(figsize=(5, 4))\n",
    "    plt.plot(df[['Bins']].values, df[['Maximum']].values, 'ro',\n",
    "             df[['Bins']].values, df[['Uniform']].values, 'b',\n",
    "             df[['Bins']].values, df[['Exp']].values, 'g',\n",
    "             df[['Bins']].values, df[['Vals']].values, 'y')\n",
    "    plt.title(\"Shannon Entropy\")\n",
    "    plt.xlabel(\"Bins\")\n",
    "    plt.ylabel(\"Entropy\")\n",
    "    plt.legend(['Maximum', 'Uniform', 'Exp', 'Vals'])\n",
    "\n",
    "def plot_mi(scores):\n",
    "    if len(scores) > 5:\n",
    "        plt.figure(figsize=(8, 5))\n",
    "    else:\n",
    "        plt.figure(figsize=(4, 4))\n",
    "    labels, values = zip(*sorted(scores.items(), key=lambda pair: pair[1], reverse=True))\n",
    "    plt.bar(np.arange(len(labels)), values)\n",
    "    plt.xticks(np.arange(len(labels)), labels, rotation=90)\n",
    "    plt.bar(np.arange(len(labels)), values)\n",
    "    plt.xticks(np.arange(len(labels)), labels, rotation=90)\n",
    "    plt.title(\"Mutual Information\")\n",
    "    plt.ylabel(\"MI with Variable of Interest\")\n",
    "    plt.show\n",
    "\n",
    "def plot_solutions(result):\n",
    "    features = []\n",
    "    energies = []\n",
    "    for sample, energy in result.data(['sample', 'energy']):\n",
    "        energies.append(energy)\n",
    "        features.append([key for (key, value) in sample.items() if value == 1])\n",
    "    plt.figure(figsize=(4, 4))\n",
    "    plt.bar(np.arange(len(features)), energies)\n",
    "    plt.xticks(np.arange(len(features)), features, rotation=90)\n",
    "    plt.title(\"Toy Problem: Unconstrained Solution\")\n",
    "    plt.ylabel(\"Energy\")\n",
    "\n",
    "def plot_features(features, selected_features):\n",
    "    fig = plt.figure(figsize=(6, 6))\n",
    "    ax = fig.add_axes([0.1, 0.3, .9, .7])\n",
    "    ax.set_title(\"Best Feature Selection\")\n",
    "    ax.set_ylabel('Number of Selected Features')\n",
    "    ax.set_xticks(np.arange(len(features)))\n",
    "    ax.set_xticklabels(features, rotation=90)\n",
    "    ax.set_yticks(np.arange(len(features)))\n",
    "    ax.set_yticklabels(np.arange(1, len(features)+1))\n",
    "    # Set a grid on minor ticks\n",
    "    ax.set_xticks(np.arange(-0.5, len(features)), minor=True)\n",
    "    ax.set_yticks(np.arange(-0.5, len(features)), minor=True)\n",
    "    ax.grid(which='minor', color='black')\n",
    "    ax.imshow(selected_features, cmap=colors.ListedColormap(['white', 'red']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "80a0fe56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_bqm(bqm):\n",
    "    \"\"\"Plot binary quadratic model as a labeled graph.\"\"\"\n",
    "    g = nx.Graph()\n",
    "    g.add_nodes_from(bqm.variables)\n",
    "    g.add_edges_from(bqm.quadratic)\n",
    "\n",
    "    plt.figure(figsize=(8, 8))\n",
    "    ax = plt.gca()\n",
    "    ax.set_title(f\"BQM with {len(bqm)} nodes and {len(bqm.quadratic)} edges\")\n",
    "    nx.draw_circular(g, with_labels=True, node_size=3000, node_color=\"y\")\n",
    "    plt.show()\n",
    "\n",
    "def plot_feature_selection(features, selected_features):\n",
    "    fig = plt.figure(figsize=(6, 6))\n",
    "    ax = fig.add_axes([0.1, 0.3, .9, .7])\n",
    "    ax.set_title(\"Best Feature Selection\")\n",
    "    ax.set_ylabel('Number of Selected Features')\n",
    "    ax.set_xticks(np.arange(len(features)))\n",
    "    ax.set_xticklabels(features, rotation=90)\n",
    "    ax.set_yticks(np.arange(len(features)))\n",
    "    ax.set_yticklabels(np.arange(1, len(features)+1))\n",
    "    # Set a grid on minor ticks\n",
    "    ax.set_xticks(np.arange(-0.5, len(features)), minor=True)\n",
    "    ax.set_yticks(np.arange(-0.5, len(features)), minor=True)\n",
    "    ax.grid(which='minor', color='black')\n",
    "    ax.imshow(selected_features, cmap=colors.ListedColormap(['white', 'red']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdacd821",
   "metadata": {},
   "source": [
    "## Feature Selection:  Predicting Survival of Titanic Passengers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45cf66f4",
   "metadata": {},
   "source": [
    "This example illustrates the MIQUBO method by finding an optimal feature set for predicting survival of Titanic passengers. It uses records provided in file formatted_titanic.csv, which is a feature-engineered version of a public database of passenger information recorded by the ship's crew. In addition to a column showing survival for each passenger, its columns record gender, title, class, port of embarkation, etc.\n",
    "\n",
    "The next cell reads the file into a pandas DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d8849047",
   "metadata": {},
   "outputs": [],
   "source": [
    "titanic = pd.read_csv(\"formatted_titanic.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35a65a47",
   "metadata": {},
   "source": [
    "Plot a ranking of MI between each feature and the variable of interest (survival):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b60449e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mi = {}\n",
    "features = list(set(titanic.columns).difference(('survived',)))\n",
    "\n",
    "for feature in features:\n",
    "    mi[feature] = mutual_information(prob(titanic[['survived', feature]].values), 1)\n",
    "\n",
    "plot_mi(mi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc90cf81",
   "metadata": {},
   "source": [
    "The next cell plots the values of MI and CMI for all features and three-variable permutations. Notice the clustering of values in tight ranges of values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d54bd82c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb2247a54c0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(len(features)), [mutual_information(prob(titanic[['survived', feature]].values), 1) for feature in features], 'bo')\n",
    "\n",
    "plt.plot(range(len([x for x in itertools.combinations(features, 2)])), [conditional_mutual_information(prob(titanic[['survived', f0, f1]].values), 1, 2) for f0, f1 in itertools.combinations(features, 2)], 'go')\n",
    "plt.plot(range(len([x for x in itertools.combinations(features, 2)])), [conditional_mutual_information(prob(titanic[['survived', f1, f0]].values), 1, 2) for f0, f1 in itertools.combinations(features, 2)], 'go')\n",
    "\n",
    "plt.title(\"Titanic MI & CMI Values\")\n",
    "plt.ylabel(\"Shannon Entropy\")\n",
    "plt.xlabel(\"Variable\")\n",
    "plt.legend([\"MI\", \"CMI\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71841058",
   "metadata": {},
   "source": [
    "Notice the high number of valid solutions that form a small cluster (the energy difference between the five best solutions in the depicted graph is in the fourth decimal place). Neuromorphic computing's strength is in quickly finding diverse good solutions to hard problems, it is not best employed as a double-precision numerical calculator. Run naively on this dataset, it finds numerous good solutions but is unlikely to find the exact optimal solution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39074d6c",
   "metadata": {},
   "source": [
    "## Building the MI-Based BQM"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2b7a96e",
   "metadata": {},
   "source": [
    "Select 8 features with the top MI ranking found above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6d24e7d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Submitting for 8 features: ['sex', 'cabin', 'miss', 'alone', 'pclass', 'mrs', 'embarked port C', 'mr']\n"
     ]
    }
   ],
   "source": [
    "keep = 8\n",
    "\n",
    "sorted_mi = sorted(mi.items(), key=lambda pair: pair[1], reverse=True)\n",
    "titanic = titanic[[column[0] for column in sorted_mi[0:keep]] + [\"survived\"]]\n",
    "features = list(set(titanic.columns).difference(('survived',)))\n",
    "\n",
    "print(\"Submitting for {} features: {}\".format(keep, features))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2338a08",
   "metadata": {},
   "source": [
    "Calculate a BQM based on the problem's MI and CMI :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "309ab5c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bqm = dimod.BinaryQuadraticModel.empty(dimod.BINARY)\n",
    "\n",
    "# add the features\n",
    "for feature in features:\n",
    "    mi = mutual_information(prob(titanic[['survived', feature]].values), 1)\n",
    "    bqm.add_variable(feature, -mi)\n",
    "\n",
    "for f0, f1 in itertools.combinations(features, 2):\n",
    "    cmi_01 = conditional_mutual_information(prob(titanic[['survived', f0, f1]].values), 1, 2)\n",
    "    cmi_10 = conditional_mutual_information(prob(titanic[['survived', f1, f0]].values), 1, 2)\n",
    "    bqm.add_interaction(f0, f1, -cmi_01)\n",
    "    bqm.add_interaction(f1, f0, -cmi_10)\n",
    "\n",
    "bqm.normalize()  \n",
    "\n",
    "plot_bqm(bqm)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffc1e3e4",
   "metadata": {},
   "source": [
    "##  Setting Up Dynex as a Sampler"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cdeb3bb",
   "metadata": {},
   "source": [
    "Set up a Dynex Annealer as your sampler in the standard way described in the Dynex SDK documentation's Configuring Access to the Dynex Platform."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83d65801",
   "metadata": {},
   "source": [
    "##  Submit the Problem for All k Values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9115c4fa",
   "metadata": {},
   "source": [
    "For all numbers of selected features, k, set a $\\left(\\frac{n}{k}\\right)$ penalty, submit an updated BQM for solution. In this example we will be using 256 reads, which means we are running the sampling problem on 256 individual Dynex Chips with different initial conditions for a period of 1000 integration time steps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e27e614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 0.04s #workers: 1 #chips: 256 #steps: 1000 global falsified softs: 6 global energy: 26768.0\n",
      "FINISHED READ AFTER 0.04 SECONDS\n",
      "SAMPLESET LOADED\n"
     ]
    }
   ],
   "source": [
    "selected_features = np.zeros((len(features), len(features)))\n",
    "for k in range(1, len(features) + 1):\n",
    "    print(\"Submitting for k={}\".format(k))\n",
    "    kbqm = dimod.generators.combinations(features, k, strength=6)\n",
    "    kbqm.update(bqm)\n",
    "    kbqm.normalize()\n",
    "    \n",
    "    # Dynex Sampler:\n",
    "    model = dynex.BQM(kbqm);\n",
    "    sampler = dynex.DynexSampler(model);\n",
    "    \n",
    "    # Map the result to the variables:\n",
    "    sampleset = sampler.sample(num_reads=256, annealing_time = 1000);\n",
    "    sample = {};\n",
    "    i = 0;\n",
    "    for var in sampler.var_mappings:\n",
    "        if float(sampleset[-1]['sample'][i]) < 0:\n",
    "            sample[var] = 0;\n",
    "        else:\n",
    "            sample[var] = 1;\n",
    "        i = i + 1\n",
    "    \n",
    "    for fi, f in enumerate(features):\n",
    "        selected_features[k-1, fi] = sample[f] # best[f]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbf19cc6",
   "metadata": {},
   "source": [
    "Plot the selected features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fdd76730",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_feature_selection(features, selected_features);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}