gradcam.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow.keras as keras\n",
    "import tensorflow as tf\n",
    "model = keras.models.load_model(\"policy_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "import io\n",
    "import numpy as np\n",
    "import chess.pgn\n",
    "from leela_board import LeelaBoard\n",
    "\n",
    "fens = []\n",
    "with open(os.path.join(\"pgns\", \"century.pgn\")) as f:\n",
    "    game = chess.pgn.read_game(f)\n",
    "\n",
    "\n",
    "all_planes = []\n",
    "indices = [2, 5, 16]\n",
    "board = LeelaBoard()\n",
    "for i, move in enumerate(game.mainline_moves()):\n",
    "    board.pc_board.push(move)\n",
    "    board._lcz_push()\n",
    "    if i in indices:\n",
    "        fen = board.pc_board.fen()\n",
    "        planes = board.lcz_features()\n",
    "        fens.append(fen)\n",
    "        all_planes.append(planes)\n",
    "\n",
    "all_planes = np.array(all_planes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adapted from https://keras.io/examples/vision/grad_cam/\n",
    "\n",
    "def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):\n",
    "    # First, we create a model that maps the input image to the activations\n",
    "    # of the last conv layer as well as the output predictions\n",
    "    grad_model = tf.keras.models.Model(\n",
    "        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]\n",
    "    )\n",
    "\n",
    "    # Then, we compute the gradient of the top predicted class for our input image\n",
    "    # with respect to the activations of the last conv layer\n",
    "    with tf.GradientTape() as tape:\n",
    "        last_conv_layer_output, preds = grad_model(img_array)\n",
    "        if pred_index is not None:\n",
    "            class_channel = preds[:, pred_index]\n",
    "        else:\n",
    "            # over everything\n",
    "            class_channel = preds[:, :]\n",
    "\n",
    "    # This is the gradient of the output neuron (top predicted or chosen)\n",
    "    # with regard to the output feature map of the last conv layer\n",
    "    grads = tape.gradient(class_channel, last_conv_layer_output)\n",
    "\n",
    "    # This is a vector where each entry is the mean intensity of the gradient\n",
    "    # over a specific feature map channel\n",
    "    pooled_grads = tf.reduce_mean(grads, axis=(0, 2, 3))\n",
    "    # We multiply each channel in the feature map array\n",
    "    # by \"how important this channel is\" with regard to the top predicted class\n",
    "    # then sum all the channels to obtain the heatmap class activation\n",
    "    last_conv_layer_output = last_conv_layer_output[0]\n",
    "    heatmap = np.copy(last_conv_layer_output.numpy())\n",
    "    for i in range(32):\n",
    "        heatmap[i] *= pooled_grads[i]\n",
    "    heatmap = heatmap.sum(axis=0)\n",
    "    heatmap = np.squeeze(heatmap)\n",
    "    # For visualization purpose, we will also normalize the heatmap between 0 & 1\n",
    "    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)\n",
    "    return heatmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change i in [0, 1, 2] to get the three results\n",
    "\n",
    "from manim_chess.chess_board import ChessBoard\n",
    "from manim import *\n",
    "class HeatmapGrad(MovingCameraScene):\n",
    "    def construct(self):\n",
    "        i = 3\n",
    "\n",
    "        heatmap = make_gradcam_heatmap(np.expand_dims(all_planes[i], 0), model, \"policy_conv\")\n",
    "        turn = \"w\" in fens[i]\n",
    "        if turn:\n",
    "            heatmap = np.flipud(heatmap)\n",
    "        main_board = ChessBoard(fens[i]).move_to(ORIGIN)\n",
    "        main_board.set_piece_opacities_square(heatmap)\n",
    "\n",
    "        if not turn:\n",
    "            main_board.flip()\n",
    "        self.add(main_board)\n",
    "\n",
    "%manim -qh -v WARNING HeatmapGrad\n"
   ]
  }
 ],
 "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.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}