1_MLIntro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 1\n",
    "\n",
    "Concepts for learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def to_01(arr):\n",
    "    return ''.join(['{0:08b}'.format(x) for x in arr.astype(np.uint8)])\n",
    "\n",
    "def from_01(binary_str):\n",
    "    n = 8\n",
    "    return np.array([int(binary_str[i:i+n], 2) for i in range(0, len(binary_str), n)], dtype=np.uint8)\n",
    "\n",
    "# a = np.array([3, 5])\n",
    "# s = to_01(a)\n",
    "# print(s, from_01(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00000110000100110\n",
      "00011100000011101\n",
      "00001010000001111\n",
      "00011100000101001\n",
      "00000110000110010\n",
      "00010010000101100\n",
      "00001010000010101\n",
      "00010111000101001\n",
      "00000011000001110\n",
      "00010111000000101\n",
      "00010101000101001\n",
      "00000001000101110\n",
      "00001011000111010\n",
      "00000101000000011\n",
      "00011111000110111\n",
      "00010100000000001\n",
      "00001011000110010\n",
      "00010101000111000\n",
      "00001011000110000\n",
      "00010000000110100\n",
      "00011010000111100\n",
      "00001001000111110\n",
      "00011011000110111\n",
      "00001111000011101\n",
      "00011101000111011\n",
      "00001110000111010\n",
      "00010010000010111\n",
      "00010110000100111\n",
      "00011111000110001\n",
      "00000010000001000\n",
      "00010010000001101\n",
      "00010100000010001\n",
      "00000110000100010\n",
      "00000011000110000\n",
      "00011011000011011\n",
      "00010001000110010\n",
      "00001000000110010\n",
      "00010100000000011\n",
      "00010011000110110\n",
      "00001110000110110\n",
      "00000110000010110\n",
      "00011100000001111\n",
      "00001110000000101\n",
      "00001101000100000\n",
      "00000011000100010\n",
      "00000111000000111\n",
      "00000001000111010\n",
      "00000101000101010\n",
      "00001001000000111\n",
      "00010101000111000\n"
     ]
    }
   ],
   "source": [
    "rng = np.random.RandomState(42)\n",
    "n = 50\n",
    "samples = []\n",
    "samples_b = []\n",
    "for i in range(n):\n",
    "    a0 = rng.randint(32)\n",
    "    a1 = rng.randint(32)\n",
    "    samples.append([a0, a1])\n",
    "for a0, a1 in samples:\n",
    "    ge = '0' if a0 < a1 else '1'\n",
    "    a = np.array([a0, a1])\n",
    "    s = to_01(a)\n",
    "    samples_b.append(s)\n",
    "    print(s+ge)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   6   19 0\n",
      "  28   14 1\n",
      "  10    7 1\n",
      "  28   20 1\n",
      "   6   25 0\n",
      "  18   22 0\n",
      "  10   10 1\n",
      "  23   20 1\n",
      "   3    7 0\n",
      "  23    2 1\n",
      "  21   20 1\n",
      "   1   23 0\n",
      "  11   29 0\n",
      "   5    1 1\n",
      "  31   27 1\n",
      "  20    0 1\n",
      "  11   25 0\n",
      "  21   28 0\n",
      "  11   24 0\n",
      "  16   26 0\n",
      "  26   30 0\n",
      "   9   31 0\n",
      "  27   27 1\n",
      "  15   14 1\n",
      "  29   29 1\n",
      "  14   29 0\n",
      "  18   11 1\n",
      "  22   19 1\n",
      "  31   24 1\n",
      "   2    4 0\n",
      "  18    6 1\n",
      "  20    8 1\n",
      "   6   17 0\n",
      "   3   24 0\n",
      "  27   13 1\n",
      "  17   25 0\n",
      "   8   25 0\n",
      "  20    1 1\n",
      "  19   27 0\n",
      "  14   27 0\n",
      "   6   11 0\n",
      "  28    7 1\n",
      "  14    2 1\n",
      "  13   16 0\n",
      "   3   17 0\n",
      "   7    3 1\n",
      "   1   29 0\n",
      "   5   21 0\n",
      "   9    3 1\n",
      "  21   28 0\n"
     ]
    }
   ],
   "source": [
    "for s in samples_b:\n",
    "    a0, a1 = from_01(s)\n",
    "    ge = '0' if a0 < a1 else '1'\n",
    "    print(f\"{a0:4d} {a1:4d}\", ge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "samp_arr = np.array(samples)\n",
    "fig, ax = plt.subplots(1, 1, figsize=(6, 6))\n",
    "ax.scatter(samp_arr[:, 0], samp_arr[:, 1], c=samp_arr[:, 0]>=samp_arr[:, 1])\n",
    "ax.grid('on')\n",
    "ax.set_xticks(np.arange(0, 32, 2))\n",
    "ax.set_yticks(np.arange(0, 32, 2))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us do a model manually\n",
    "\n",
    "$w1 * x1 + w2 * x2 + ... > 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check samples_b contains binary string\n",
    "# samples contains the numbers\n",
    "samples_b[0], samples[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bitstr_to_bits(s):\n",
    "    return np.array([int(c) for c in s]).astype(np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights [ 128   64   32   16    8    4    2    1 -128  -64  -32  -16   -8   -4\n",
      "   -2   -1]\n",
      "Weights working on the first 10 samples\n",
      "0 <W,Bits> -13.0 >= 0? False a0(6)>=a1(19)? False\n",
      "1 <W,Bits> 14.0 >= 0? True a0(28)>=a1(14)? True\n",
      "2 <W,Bits> 3.0 >= 0? True a0(10)>=a1(7)? True\n",
      "3 <W,Bits> 8.0 >= 0? True a0(28)>=a1(20)? True\n",
      "4 <W,Bits> -19.0 >= 0? False a0(6)>=a1(25)? False\n",
      "5 <W,Bits> -4.0 >= 0? False a0(18)>=a1(22)? False\n",
      "6 <W,Bits> 0.0 >= 0? True a0(10)>=a1(10)? True\n",
      "7 <W,Bits> 3.0 >= 0? True a0(23)>=a1(20)? True\n",
      "8 <W,Bits> -4.0 >= 0? False a0(3)>=a1(7)? False\n",
      "9 <W,Bits> 21.0 >= 0? True a0(23)>=a1(2)? True\n"
     ]
    }
   ],
   "source": [
    "w_tmp = np.power(2, np.arange(7, -1, -1))\n",
    "w = np.concatenate([w_tmp, -w_tmp])\n",
    "print(\"Weights\", w)\n",
    "print(\"Weights working on the first 10 samples\")\n",
    "for i in range(10):\n",
    "    xbits = bitstr_to_bits(samples_b[i])\n",
    "    a0, a1 = samples[i]\n",
    "    print(i, f\"<W,Bits> {(w*xbits).sum()} >= 0?\", (w*xbits).sum()>=0, f\"a0({a0})>=a1({a1})?\", a0>=a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 3\n",
    "\n",
    "Let us try to guess the $w$ parameters automatically.\n",
    "\n",
    "Basically, we give a \"reckless enough W\" that \"fights with\" a data sample a high energy. \n",
    "\n",
    "Then we let the system \"relax\" -- by having it \"lazily go to low energy status\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00000110000100110\n",
      "00011100000011101\n",
      "00001010000001111\n",
      "00011100000101001\n",
      "00000110000110010\n",
      "00010010000101100\n",
      "00001010000010101\n",
      "00010111000101001\n",
      "00000011000001110\n",
      "00010111000000101\n",
      "00010101000101001\n",
      "00000001000101110\n",
      "00001011000111010\n",
      "00000101000000011\n",
      "00011111000110111\n",
      "00010100000000001\n",
      "00001011000110010\n",
      "00010101000111000\n",
      "00001011000110000\n",
      "00010000000110100\n",
      "00011010000111100\n",
      "00001001000111110\n",
      "00011011000110111\n",
      "00001111000011101\n",
      "00011101000111011\n",
      "00001110000111010\n",
      "00010010000010111\n",
      "00010110000100111\n",
      "00011111000110001\n",
      "00000010000001000\n",
      "00010010000001101\n",
      "00010100000010001\n",
      "00000110000100010\n",
      "00000011000110000\n",
      "00011011000011011\n",
      "00010001000110010\n",
      "00001000000110010\n",
      "00010100000000011\n",
      "00010011000110110\n",
      "00001110000110110\n",
      "00000110000010110\n",
      "00011100000001111\n",
      "00001110000000101\n",
      "00001101000100000\n",
      "00000011000100010\n",
      "00000111000000111\n",
      "00000001000111010\n",
      "00000101000101010\n",
      "00001001000000111\n",
      "00010101000111000\n",
      "00011110000100011\n",
      "00011001000010111\n",
      "00000001000010010\n",
      "00011101000000111\n",
      "00001101000111100\n",
      "00001111000011101\n",
      "00000111000011010\n",
      "00010110000110110\n",
      "00011000000111010\n",
      "00000111000101000\n",
      "00001111000011001\n",
      "00010001000011101\n",
      "00010100000101110\n",
      "00011001000110001\n",
      "00011011000110111\n",
      "00011011000011001\n",
      "00001000000111000\n",
      "00001110000011001\n",
      "00000000000110000\n",
      "00000110000010000\n",
      "00010111000000001\n",
      "00001011000001111\n",
      "00010111000111100\n",
      "00001010000100100\n",
      "00010000000001111\n",
      "00000010000000101\n",
      "00000000000110100\n",
      "00000100000010010\n",
      "00000110000110010\n",
      "00001000000110110\n",
      "00000110000010000\n",
      "00000111000010110\n",
      "00000001000000001\n",
      "00001111000101100\n",
      "00010110000111010\n",
      "00010111000001001\n",
      "00000010000010110\n",
      "00000111000101010\n",
      "00011010000000101\n",
      "00000000000000100\n",
      "00000100000011100\n",
      "00001101000000101\n",
      "00000000000001000\n",
      "00011001000101101\n",
      "00011110000011011\n",
      "00000110000110100\n",
      "00001000000011100\n",
      "00001110000110010\n",
      "00001001000110110\n",
      "00001100000100100\n"
     ]
    }
   ],
   "source": [
    "rng = np.random.RandomState(42)\n",
    "n = 100\n",
    "samples = []\n",
    "samples_b = []\n",
    "for i in range(n):\n",
    "    a0 = rng.randint(32)\n",
    "    a1 = rng.randint(32)\n",
    "    samples.append([a0, a1])\n",
    "for a0, a1 in samples:\n",
    "    ge = '0' if a0 < a1 else '1'\n",
    "    a = np.array([a0, a1])\n",
    "    s = to_01(a)\n",
    "    samples_b.append(s)\n",
    "    print(s+ge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define an \"energy\" term:\n",
    "\n",
    "If $y$ and $\\langle x, w \\rangle$ do not agree, then\n",
    "\n",
    "$E(x;w) = |\\langle x, w \\rangle| $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 37.97085952962537\n",
      "19 32.15001871872728\n",
      "31 24.904474501572942\n",
      "72 21.114046996105156\n",
      "33 15.381911857424695\n",
      "16 10.063202381480549\n",
      "67 7.491021525438362\n",
      "27 5.2267377019047165\n",
      "3 3.6463226950769605\n",
      "52 2.019659248888888\n",
      "32 1.1569888468598513\n",
      "6 0.4429345815492141\n",
      "54 0.13290866601081314\n",
      "81 0.0006166117486262612\n",
      "16 0.0\n",
      "25 0.0\n",
      "35 0.013862431892223692\n",
      "91 0.0\n",
      "16 0.0\n",
      "10 0.0\n"
     ]
    }
   ],
   "source": [
    "# compute the energy \n",
    "def mod_eng_persample(sample, w):\n",
    "    x, y = sample\n",
    "\n",
    "    if ((x * w).sum() >= 0 and y == 0) or ((x*w).sum() < 0 and y == 1):\n",
    "        return abs((x*w).sum())\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "# compute the energy per sample\n",
    "def mod_eng(w):\n",
    "    e = 0\n",
    "    for i in range(len(samples)):\n",
    "        xbits = bitstr_to_bits(samples_b[i])\n",
    "        a0, a1 = samples[i]\n",
    "        y = 1 if a0>=a1 else 0\n",
    "        e += mod_eng_persample((xbits, y), w)\n",
    "    return e\n",
    "\n",
    "    \n",
    "\n",
    "rng = np.random.RandomState(42)\n",
    "w0 = rng.randn(16)\n",
    "\n",
    "dt = 0.1\n",
    "beta = 0.1\n",
    "w = w0\n",
    "for t in range(20):\n",
    "    dw = rng.randn(100, len(w)) * dt\n",
    "    w_candi = dw + w\n",
    "\n",
    "    # compute the energies for each new proposal\n",
    "    energies = np.array([mod_eng(w_) for w_ in w_candi])\n",
    "\n",
    "    j = np.argmin(energies) # this == \\beta = \\infity (99999)\n",
    "    w = w_candi[j]\n",
    "    print(j, energies[j])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.bar(np.arange(len(w)), w)\n",
    "plt.grid('on')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 100\n",
    "samples_test = []\n",
    "samples_b_test = []\n",
    "for i in range(n):\n",
    "    a0 = rng.randint(32)\n",
    "    a1 = rng.randint(32)\n",
    "    samples_test.append([a0, a1])\n",
    "for a0, a1 in samples_test:\n",
    "    ge = '0' if a0 < a1 else '1'\n",
    "    a = np.array([a0, a1])\n",
    "    s = to_01(a)\n",
    "    samples_b_test.append(s)\n",
    "\n",
    "print(\"Check model on new samples\")\n",
    "corr_test = 0\n",
    "for i in range(len(samples_test)):\n",
    "    xbits = bitstr_to_bits(samples_b_test[i])\n",
    "    a0, a1 = samples_test[i]\n",
    "    corr = ((w*xbits).sum() >= 0) == (a0 >= a1)\n",
    "    corr_test += int(corr)\n",
    "    if i<10:\n",
    "        print(i, f\"<W,Bits> {(w*xbits).sum()}\", a0, a1)\n",
    "        print(f\"\\t Is the model getting the concept correctly? {corr}\")\n",
    "print(corr_test, f\"samples are correctly compared in {n} test samples\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 4\n",
    "\n",
    "Hmm..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To prepare the data in slides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "# Define the directories\n",
    "duck_dir = 'Data/DuckImages/Ducks'\n",
    "cow_dir = 'Data/DuckImages/Cows'\n",
    "\n",
    "# Function to load and preprocess images\n",
    "def load_and_preprocess_images(directory, label):\n",
    "    images = []\n",
    "    for filename in os.listdir(directory):\n",
    "        if filename.endswith('.webp'):\n",
    "            image_path = os.path.join(directory, filename)\n",
    "            image = Image.open(image_path).convert('RGB')\n",
    "            image = image.resize((16, 16))\n",
    "            image = np.array(image).astype(np.uint8)\n",
    "            images.append(image)\n",
    "    return np.array(images)\n",
    "\n",
    "# Load and preprocess images\n",
    "cow_images = load_and_preprocess_images(cow_dir, 0)\n",
    "duck_images = load_and_preprocess_images(duck_dir, 0)\n",
    "imc = cow_images[5]\n",
    "im0 = duck_images[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(im0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output to 01 strings\n",
    "with open('tmp01.txt', 'w') as f:\n",
    "    for r in range(16):\n",
    "        f.write(to_01(im0[r].flatten()))\n",
    "        f.write('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To reveal what is in the slides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[113 180 208]\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'plt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/ht/ryk_q36173dg_qtcy535zzy40000gp/T/ipykernel_9876/2753139475.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcb0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mcb0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcb0\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcb0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined"
     ]
    }
   ],
   "source": [
    "cb0 = from_01('011100011011010011010000')\n",
    "print(cb0)\n",
    "cb0 = cb0.reshape((1, 1, 3))\n",
    "plt.imshow(cb0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cb1 = from_01('011000011011010111100000011101011011111011000111110111001100000100110000')\n",
    "print(cb1)\n",
    "cb1 = cb1.reshape((1, 3, 3))\n",
    "plt.imshow(cb1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cb2 = from_01('011100011011010111010100011110101011111011010000111000111110011001011000111110001110000100100001011100001011011011011000101111111101111110101010111111001111000001100000111011011101101101000101011110101011111011010110111001011110101101100100111101001110001000110110111001101100111100100101')\n",
    "cb2 = cb2.reshape((3, 4, 3))\n",
    "plt.imshow(cb2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cb4 = from_01('011100011011010011010000011011111010111111001101011010111010110011001011011001111010100111001001010111011010010011001010011011101011000110110100100000011011011010011001010111001010001010110100010011001001100111000001010011011001010010111000010010001000111110110011010001011000101110101111010000011000100010101100001111101000010010101010001110101000001010100111001101100111111110100110011100111011010111010000011100011011000011001100011011001010110111001010011000111010100011001101100011001100011010101100111000111101111000110000101110111001100000001011101100111001110000100010011000111001100110100100010011011001100010111110010011011001001010110100010010011000111010110010010001011000101110101110010000011000011110101011001111111000010110101001001110111000001110101000011101001011011011010001011100011011000111001101011010101010111011001110011000001010111011010110110011111101000001111001111100011101000100011010110010101010101100001010101010110111111100000000100000010111111001011010010100001001110111000101010011101001010110110111010011001001000110110100010010011000111110110001010001011000101110101110010000101000100010101100001111101000010110101010011101001011011011010010011011111011001011010000011110001011010111000101101101001011001101101001110101001000000100000110101101100110100100000010101101111000011000001000100000000101000000000000100000000110100000111000010110111010000111000100010011101001100010111011010011101001010010110110010011001001001010110011010010001000111010110001010001011000101110101110010000001000100010101100011101011011011111010011011011111011011011010110100101001010110110010111101010101001001101010111011101111001100010011100101110111001000000110000101111111000011100000100101000000110111100000000100100110111010000111111010101001010010011001111010100001001110011000000010100001001100010111001010011011001010110110110010010111001000110110010010010011000111010101111010000111000101110101111011101101011100111010100011101011011011011010010011011101011010111010101011000011011010111100000011101011011111011000111110111001100000100110000111001001100011100001000110000111010011100001010101010011000110000111100011100111010010110101010010110001010000011000000010011011001101111000100010011111001100010111010010011011001010110110110010010101001001010110100010001101000111010110010011110011011101111010101011101101011011111010011011100011011010111010100011110101011111011010000111000111110011001011000111110001110000100100001111010001101011000100100110100101011110000010011110100101011001100000110111000001100000000001000110101001100010000101001100100001011000010001111010100001001111111000101010011111001100110111011010011011001010110110111010010011001000110110100011110101011110111010111011110001011100111010011011100001011011011011000101111111101111110101010111111001111000001100000111011011101101101000101111000001100101100100011110001101010110100001101110010011010010100001001111010101101000000001111110100101011001000000000101101101001001100010011100011001010001110010111010100011010000011000110010100001001101010111101010010111001011010111001011111001011111011011001011110011011101111010110011110101011111011010110111001011110101101100100111101001110001000110110111001101100111100100101110100011011011100010100101101101001011000001011101100011000011000001000110101101011100100001100101000111000001100000101011110110101111000000000100110101000010001010000011111001010111010111110010011111010000111000010010011111001110111000001011111111100001011011011011111001011111011011001011111101100000111010110111001101110010100101110111011001101010100010000110110001011111000010010101111111010000100001111100111110111110100001100100001010101111000000110100111100111100000000011100000000110010100000011010111110100110000000000011101110110110000111010101100101011001010001001101000001011011101111110010011111010001011001011100001001100010111011110100000011100001011011011011110111100000111100011110010011101011001001111111000011100011000000001110000011010010000001101101000111000001000001100100000100110001000001001011000110100100100000100011000010100001000000010011000100100011100000001010101000100100000000000011001000101111100011011100110101001001101110010100001101010100110100100010101011010101011010010100010101100100011100001100001111100011011011111100001011100011011100110100100111100100110111001110001101011010000010000101001001000001000000100100001010110010000001001011100010100101100000101011010010100000100000011011010010011110000000011011000010011110100000010010101000100100000000000010111110101100100001010011101101001101010001010011010011010110011000101011001101010011010110100100101101100111111100111101000011101000011100110101011001101001111101000100100011100110011101100100100011100000010101001100101111000001100011111100011110101001100000000100101010100100000000001101000110100001000000001101000000100000000000010011011000011111100000001010001010100110000010101011001111001000010000000011110111100001011100110011000111010110010111100010110001001101010010011101001001101010011101001100111111100110111100000100101111100011011010000100101011100111011101011100101011100111111110101100100011100101111100100101001001001110101111100101100110110111100100101100100100110010100100011011110110011111000010000010010110100000100100101010001100111001101101101010111101001011010011010011001101010000010100010010101111001100110000101001111000111011101010110101000101101000011010110100011101100010011000011011101111011011010100011101001001101011011010101100110011101001010011111100100111101000101101011101100101011101001001001100011001001000000100000010001110111011100010100100010100101001100010000010000100100110000001111000111010101100100001011000111100110000000001001001011010110100000001110001111110111001100010111001000010101110000011000100011001100001010110000011101011011101101110110011011011011110000111001011100111100011000101011011101101011111000001101101011001011000000000111100100011010100000001101011110011010011100010101101010111001101000001101100011001001010100010010001111011001010000011010001100111000110000011000001011111000000000010111001100110111111000010101001101110111011100010101001010110110111100010001')\n",
    "cb4 = cb4.reshape((16, 16, 3))\n",
    "plt.imshow(cb4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(imc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}