notebooks/30_sudoku_dashboard.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Summary\n",
    "\n",
    "In this notebook we load a network trained to solve Sudoku puzzles and use this network to solve a single Sudoku.\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hide": true,
    "id": "eoBMUoW2Hvhp",
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TbKxMUZWHvhq"
   },
   "outputs": [],
   "source": [
    "import functools\n",
    "import io\n",
    "import os\n",
    "import sys\n",
    "import tempfile\n",
    "import time\n",
    "from collections import deque\n",
    "from pathlib import Path\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tqdm\n",
    "from IPython.display import HTML, display\n",
    "from ipywidgets import fixed, interact, interact_manual, interactive\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import pyarrow\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from matplotlib import cm\n",
    "from torch_geometric.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 334
    },
    "colab_type": "code",
    "id": "rczy7pPiHvhs",
    "outputId": "8e4673d7-4cc7-4f8e-ffc4-de94302e5fab"
   },
   "outputs": [],
   "source": [
    "import proteinsolver\n",
    "import proteinsolver.datasets\n",
    "from proteinsolver.utils import gen_sudoku_graph_featured"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib agg\n",
    "\n",
    "try:\n",
    "    inline_rc\n",
    "except NameError:\n",
    "    inline_rc = mpl.rcParams.copy()\n",
    "    \n",
    "mpl.rcParams.update({\"font.size\": 12})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "hide": true,
    "hide_input": true,
    "id": "dsEY3dtLHvhy",
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "UNIQUE_ID = \"c8de7e56\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Load model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run sudoku_train/{UNIQUE_ID}/model.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "state_files = sorted(\n",
    "    Path(\"sudoku_train\").joinpath(UNIQUE_ID).glob(\"*.state\"),\n",
    "    key=lambda s: (int(s.stem.split(\"-\")[3].strip(\"amv\")), int(s.stem.split(\"-\")[2].strip(\"d\"))),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "state_file = state_files[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = Net(\n",
    "    x_input_size=13, adj_input_size=3, hidden_size=162, output_size=9, batch_size=8\n",
    ").to(device)\n",
    "\n",
    "net.load_state_dict(torch.load(state_file, map_location=device))\n",
    "net = net.eval()\n",
    "net = net.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Define widgets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "### Sudoku grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sudoku_widget_lookup = [[None for _ in range(9)] for _ in range(9)]\n",
    "\n",
    "row_widgets = []\n",
    "for row in range(3):\n",
    "    col_widgets = []\n",
    "    for col in range(3):\n",
    "        subrow_widgets = []\n",
    "        for subrow in range(3):\n",
    "            subcol_widgets = []\n",
    "            for subcol in range(3):\n",
    "                i = row * 3 + subrow\n",
    "                j = col * 3 + subcol\n",
    "                subcol_widget = (\n",
    "                    widgets.BoundedIntText(\n",
    "                        value=0,\n",
    "                        min=0,\n",
    "                        max=9,\n",
    "                        step=1,\n",
    "                        description='',\n",
    "                        disabled=False,\n",
    "                        allow_none=True,\n",
    "                        layout={\"width\": \"42px\"}\n",
    "                    )\n",
    "                )\n",
    "                subcol_widgets.append(subcol_widget)\n",
    "                sudoku_widget_lookup[i][j] = subcol_widget\n",
    "            subrow_widget = widgets.HBox(subcol_widgets)\n",
    "            subrow_widgets.append(subrow_widget)\n",
    "        col_widget = widgets.VBox(subrow_widgets, layout={\"padding\": \"5px\"})\n",
    "        col_widgets.append(col_widget)\n",
    "    row_widget = widgets.HBox(col_widgets)    \n",
    "    row_widgets.append(row_widget)\n",
    "\n",
    "sudoku_widget = widgets.VBox(row_widgets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "### Puzzle selector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "puzzle_0 = torch.zeros(9, 9, dtype=torch.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "puzzle_1 = torch.tensor(\n",
    "    [\n",
    "        [0, 8, 0, 0, 3, 2, 0, 0, 1],\n",
    "        [7, 0, 3, 0, 8, 0, 0, 0, 2],\n",
    "        [5, 0, 0, 0, 0, 7, 0, 3, 0],\n",
    "        [0, 5, 0, 0, 0, 1, 9, 7, 0],\n",
    "        [6, 0, 0, 7, 0, 9, 0, 0, 8],\n",
    "        [0, 4, 7, 2, 0, 0, 0, 5, 0],\n",
    "        [0, 2, 0, 6, 0, 0, 0, 0, 9],\n",
    "        [8, 0, 0, 0, 9, 0, 3, 0, 5],\n",
    "        [3, 0, 0, 8, 2, 0, 0, 1, 0],\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "buf = io.StringIO()\n",
    "buf.write(\"\"\"\\\n",
    "\t\t6\t3\t4\t8\t9\t1\t\n",
    "\t\t\t\t6\t\t4\t\t8\n",
    "\t\t\t\t\t\t\t\t\n",
    "\t\t\t6\t\t\t7\t\t9\n",
    "\t6\t\t8\t9\t1\t2\t4\t5\n",
    "\t9\t\t2\t7\t\t1\t\t3\n",
    "\t\t1\t4\t5\t\t\t9\t\n",
    "\t\t2\t9\t\t6\t\t3\t\n",
    "9\t\t5\t\t\t\t6\t\t\n",
    "\"\"\")\n",
    "buf.seek(0)\n",
    "df = pd.read_csv(buf, sep=\"\\t\", names=list(range(9))).fillna(0).astype(int)\n",
    "puzzle_2 = torch.from_numpy(df.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "buf = io.StringIO()\n",
    "buf.write(\"\"\"\\\n",
    ",,,,7,,,2,\n",
    ",,,,4,,7,,\n",
    ",,9,,3,6,1,4,\n",
    "1,,3,4,5,,8,9,\n",
    "4,,7,6,,,2,,\n",
    ",,8,,1,,,,\n",
    "3,,2,5,6,,,,8\n",
    "8,,,,,3,,6,4\n",
    "9,6,,,,4,,1,\n",
    "\"\"\")\n",
    "buf.seek(0)\n",
    "df = pd.read_csv(buf, names=list(range(9))).fillna(0).astype(int)\n",
    "puzzle_3 = torch.from_numpy(df.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def empty_out_puzzle(b, puzzle_matrix):\n",
    "    for i in range(9):\n",
    "        for j in range(9):\n",
    "            sudoku_widget_lookup[i][j].value = puzzle_matrix[i][j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_puzzle_button = widgets.Button(\n",
    "    description=\"Empty\",\n",
    "    disabled=False,\n",
    "    button_style=\"\",  # 'success', 'info', 'warning', 'danger' or ''\n",
    "    tooltip=\"Click me to set Sudoku grid to empty.\",\n",
    "    #     icon='puzzle-piece'\n",
    ")\n",
    "empty_puzzle_button.on_click(functools.partial(empty_out_puzzle, puzzle_matrix=puzzle_0))\n",
    "\n",
    "\n",
    "test_puzzle_1_button = widgets.Button(\n",
    "    description=\"Puzzle 1\",\n",
    "    disabled=False,\n",
    "    button_style=\"\",  # 'success', 'info', 'warning', 'danger' or ''\n",
    "    tooltip=\"Click me to set Sudoku grid to puzzle 1\",\n",
    "    icon=\"puzzle-piece\",\n",
    ")\n",
    "test_puzzle_1_button.on_click(functools.partial(empty_out_puzzle, puzzle_matrix=puzzle_1))\n",
    "\n",
    "\n",
    "test_puzzle_2_button = widgets.Button(\n",
    "    description=\"Puzzle 2\",\n",
    "    disabled=False,\n",
    "    button_style=\"\",  # 'success', 'info', 'warning', 'danger' or ''\n",
    "    tooltip=\"Click me to set Sudoku grid to puzzle 2\",\n",
    "    icon=\"puzzle-piece\",\n",
    ")\n",
    "test_puzzle_2_button.on_click(functools.partial(empty_out_puzzle, puzzle_matrix=puzzle_2))\n",
    "\n",
    "\n",
    "test_puzzle_3_button = widgets.Button(\n",
    "    description=\"Puzzle 3\",\n",
    "    disabled=False,\n",
    "    button_style=\"\",  # 'success', 'info', 'warning', 'danger' or ''\n",
    "    tooltip=\"Click me to set Sudoku grid to puzzle 3\",\n",
    "    icon=\"puzzle-piece\",\n",
    "    #     layout={\"margin\": \"10px\"}\n",
    ")\n",
    "test_puzzle_3_button.on_click(functools.partial(empty_out_puzzle, puzzle_matrix=puzzle_3))\n",
    "\n",
    "\n",
    "puzzle_selector_widget = widgets.HBox(\n",
    "    [empty_puzzle_button, test_puzzle_1_button, test_puzzle_2_button, test_puzzle_3_button]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_out_puzzle(None, puzzle_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "### Puzzle solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_puzzle(puzzle):\n",
    "    puzzle = puzzle - 1\n",
    "    puzzle = torch.where(puzzle >= 0, puzzle, torch.tensor(9))\n",
    "    return puzzle\n",
    "\n",
    "\n",
    "def decode_puzzle(puzzle):\n",
    "    puzzle = (puzzle + 1) % 10\n",
    "    return puzzle\n",
    "\n",
    "\n",
    "puzzle = torch.tensor([1, 1, 1])\n",
    "assert torch.equal(decode_puzzle(encode_puzzle(puzzle)), puzzle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_sudoku(net, puzzle):\n",
    "    sudoku_graph = torch.from_numpy(gen_sudoku_graph_featured()).to_sparse(2)\n",
    "    edge_index = sudoku_graph.indices()\n",
    "    edge_attr = sudoku_graph.values()\n",
    "\n",
    "    output = net(\n",
    "        encode_puzzle(puzzle).view(-1).to(device), edge_index.clone().to(device), edge_attr.clone().to(device)\n",
    "    ).to(\"cpu\")\n",
    "    output = torch.softmax(output, dim=1)\n",
    "    _, predicted = output.max(dim=1)\n",
    "\n",
    "    return decode_puzzle(predicted).reshape(9, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_sudoku(puzzle, solved=None, pred=None, title=\"\", color=\"black\", ax=None):\n",
    "    # Simple plotting statement that ingests a 9x9 array (n), and plots a sudoku-style grid around it.\n",
    "    \n",
    "    if ax is None:\n",
    "        fg, ax = plt.subplots(figsize=(4.8, 4.8))\n",
    "\n",
    "    for y in range(10):\n",
    "        ax.plot([-0.05, 9.05], [y, y], color=\"black\", linewidth=1)\n",
    "\n",
    "    for y in range(0, 10, 3):\n",
    "        ax.plot([-0.05, 9.05], [y, y], color=\"black\", linewidth=3)\n",
    "\n",
    "    for x in range(10):\n",
    "        ax.plot([x, x], [-0.05, 9.05], color=\"black\", linewidth=1)\n",
    "\n",
    "    for x in range(0, 10, 3):\n",
    "        ax.plot([x, x], [-0.05, 9.05], color=\"black\", linewidth=3)\n",
    "\n",
    "    ax.axis(\"image\")\n",
    "    ax.axis(\"off\")  # drop the axes, they're not important here\n",
    "\n",
    "#     if title is not None:\n",
    "    ax.set_title(title, fontsize=20)\n",
    "\n",
    "    for x in range(9):\n",
    "        for y in range(9):\n",
    "            puzzle_element = puzzle[8 - y][x]  # need to reverse the y-direction for plotting\n",
    "            if puzzle_element > 0:  # ignore the zeros\n",
    "                T = f\"{puzzle_element}\"\n",
    "                ax.text(x + 0.25, y + 0.22, T, fontsize=20, color=color)\n",
    "            elif solved is not None and pred is not None:\n",
    "                solved_element = solved[8 - y][x]\n",
    "                pred_element = pred[8 - y][x]\n",
    "                if solved_element == pred_element:\n",
    "                    T = f\"{solved_element}\"\n",
    "                    ax.text(x + 0.25, y + 0.22, T, fontsize=20, color=\"C0\")\n",
    "                else:\n",
    "                    ax.text(x + 0.1, y + 0.3, f\"{pred_element}\", fontsize=13, color=\"C3\")\n",
    "                    ax.text(x + 0.55, y + 0.3, f\"{solved_element}\", fontsize=13, color=\"C2\")\n",
    "\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_no_conflicts(title=\"\", ax=None):\n",
    "    if ax is None:\n",
    "        fg, ax = plt.subplots(figsize=(4.8, 4.8))\n",
    "    ax.axis(\"image\")\n",
    "    ax.axis(\"off\")  # drop the axes, they're not important here\n",
    "    ax.text(\n",
    "        0.5,\n",
    "        0.5,\n",
    "        \"No conflicts!\",\n",
    "        fontsize=20,\n",
    "        fontdict={\"horizontalalignment\": \"center\", \"color\": \"C2\"},\n",
    "        transform=ax.transAxes,\n",
    "    )\n",
    "    ax.set_title(title, fontsize=20)\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "plot_no_conflicts(title=\"Conflict\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "show_sudoku(puzzle_1, title=\"Input\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "show_sudoku(puzzle_1, puzzle_1, puzzle_1, title=\"Solution\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_conflict(puzzle):\n",
    "    for row_idx in range(9):\n",
    "        for value in range(1, 10):\n",
    "            mask = puzzle[row_idx, :] == value\n",
    "            if mask.sum() > 1:\n",
    "                ref = puzzle[row_idx, mask]\n",
    "                puzzle = torch.zeros_like(puzzle)\n",
    "                puzzle[row_idx, mask] = ref\n",
    "                return puzzle\n",
    "\n",
    "    for col_idx in range(9):\n",
    "        for value in range(1, 10):\n",
    "            mask = puzzle[:, col_idx] == value\n",
    "            if mask.sum() > 1:\n",
    "                ref = puzzle[mask, col_idx]\n",
    "                puzzle = torch.zeros_like(puzzle)\n",
    "                puzzle[mask, col_idx] = ref\n",
    "                return puzzle\n",
    "\n",
    "    for row_start_idx in range(0, 9, 3):\n",
    "        for col_start_idx in range(0, 9, 3):\n",
    "            for value in range(1, 10):\n",
    "                mask = puzzle[row_start_idx : row_start_idx + 3, col_start_idx : col_start_idx + 3] == value\n",
    "                if mask.sum() > 1:\n",
    "                    ref = puzzle[row_start_idx : row_start_idx + 3, col_start_idx : col_start_idx + 3][mask]\n",
    "                    puzzle = torch.zeros_like(puzzle)\n",
    "                    puzzle[row_start_idx : row_start_idx + 3, col_start_idx : col_start_idx + 3][mask] = ref\n",
    "                    return puzzle\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "puzzle = puzzle_1.clone()\n",
    "puzzle[0, 0] = 7\n",
    "find_conflict(puzzle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "puzzle = puzzle_1.clone()\n",
    "puzzle[0, 2] = 8\n",
    "find_conflict(puzzle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "puzzle = puzzle_1.clone()\n",
    "puzzle[6, 2] = 8\n",
    "find_conflict(puzzle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_solution(puzzle, solution):\n",
    "    fg, axs = plt.subplots(1, 2, figsize=(9.8, 5))\n",
    "    show_sudoku(puzzle, solution, solution, title=\"Solution\", ax=axs[0])\n",
    "    puzzle_conflict = find_conflict(solution)\n",
    "    if puzzle_conflict is not None:\n",
    "        show_sudoku(puzzle_conflict, title=\"Conflict\", color=\"C3\", ax=axs[1])\n",
    "    else:\n",
    "        plot_no_conflicts(title=\"Conflicts\", ax=axs[1])\n",
    "    return fg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "_ = plot_solution(puzzle_0, puzzle_0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solution_output_widget = widgets.Output(layout={'border': '1px solid black', \"width\": \"600px\"})\n",
    "\n",
    "def solve_sudoku_from_widget(b):\n",
    "    puzzle = torch.zeros(9, 9, dtype=torch.int64)\n",
    "    for i in range(9):\n",
    "        for j in range(9):\n",
    "            puzzle[i][j] = sudoku_widget_lookup[i][j].value\n",
    "    solution = solve_sudoku(net, puzzle)\n",
    "    with solution_output_widget:\n",
    "        solution_output_widget.clear_output()\n",
    "        fg = plot_solution(puzzle, solution)\n",
    "        display(fg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "solve_button_widget = widgets.Button(\n",
    "    description='Solve!',\n",
    "    disabled=False,\n",
    "    button_style='', # 'success', 'info', 'warning', 'danger' or ''\n",
    "    tooltip='Click to solve the Sudoku puzzle',\n",
    "    icon='check'\n",
    ")\n",
    "solve_button_widget.on_click(solve_sudoku_from_widget)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "solution = torch.tensor(\n",
    "    [\n",
    "        [4, 8, 9, 5, 3, 2, 7, 6, 1],\n",
    "        [7, 1, 3, 4, 8, 6, 5, 9, 2],\n",
    "        [5, 6, 2, 9, 1, 7, 8, 3, 4],\n",
    "        [2, 5, 8, 3, 4, 1, 9, 7, 6],\n",
    "        [6, 3, 1, 7, 5, 9, 2, 4, 8],\n",
    "        [9, 4, 7, 2, 6, 8, 1, 5, 3],\n",
    "        [1, 2, 5, 6, 7, 3, 4, 8, 9],\n",
    "        [8, 7, 6, 1, 9, 4, 3, 2, 5],\n",
    "        [3, 9, 4, 8, 2, 5, 6, 1, 7],\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "outputs": [],
   "source": [
    "assert proteinsolver.utils.sudoku.sudoku_is_solved(solution.to(\"cpu\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide"
    ]
   },
   "source": [
    "## Dashboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solve a custom Sudoku puzzle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(puzzle_selector_widget)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(sudoku_widget)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(solve_button_widget)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(solution_output_widget)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(HTML(\"\"\"\\\n",
    "<hr>\n",
    "<p>Running into issues? Please send an email to <a href=\"help@proteinsolver.org\">help@proteinsolver.org</a>.\n",
    "<br>\n",
    "<em>This website works best using the latest versions of Firefox or Chrome web browsers.</em>\n",
    "</p>\n",
    "\"\"\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "celltoolbar": "Tags",
  "colab": {
   "collapsed_sections": [
    "1fXJz1l9HvhW",
    "u9q4iTifHvhl"
   ],
   "name": "Copy of 2019-03-30-sudoku-4xEdgeConv-09862+.ipynb",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-showcode": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}