RockPaperScissors.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RockPaperScissors",
      "provenance": [],
      "authorship_tag": "ABX9TyPMx4CPtI0MyBl1Ih3aGf1L",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ArnavPalkhiwala/MachineLearningRockPaperScissors/blob/master/RockPaperScissors.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0rVfXG2nqeMI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from IPython.display import display, Javascript\n",
        "from google.colab.output import eval_js\n",
        "from base64 import b64decode\n",
        "\n",
        "def take_photo(filename='photo.jpg', quality=0.8):\n",
        "  js = Javascript('''\n",
        "    async function takePhoto(quality) {\n",
        "      const div = document.createElement('div');\n",
        "      const capture = document.createElement('button');\n",
        "      capture.textContent = 'Capture';\n",
        "      div.appendChild(capture);\n",
        "\n",
        "      const video = document.createElement('video');\n",
        "      video.style.display = 'block';\n",
        "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
        "\n",
        "      document.body.appendChild(div);\n",
        "      div.appendChild(video);\n",
        "      video.srcObject = stream;\n",
        "      await video.play();\n",
        "\n",
        "      // Resize the output to fit the video element.\n",
        "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
        "\n",
        "      // Wait for Capture to be clicked.\n",
        "      await new Promise((resolve) => capture.onclick = resolve);\n",
        "\n",
        "      const canvas = document.createElement('canvas');\n",
        "      canvas.width = video.videoWidth;\n",
        "      canvas.height = video.videoHeight;\n",
        "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
        "      stream.getVideoTracks()[0].stop();\n",
        "      div.remove();\n",
        "      return canvas.toDataURL('image/jpeg', quality);\n",
        "    }\n",
        "    ''')\n",
        "  display(js)\n",
        "  data = eval_js('takePhoto({})'.format(quality))\n",
        "  binary = b64decode(data.split(',')[1])\n",
        "  with open(filename, 'wb') as f:\n",
        "    f.write(binary)\n",
        "  return filename"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "McRtqWFZqd7q",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 514
        },
        "outputId": "ef182fa6-8315-4002-ef93-60228b975b55"
      },
      "source": [
        "from IPython.display import Image\n",
        "try:\n",
        "  filename = take_photo()\n",
        "  print('Saved to {}'.format(filename))\n",
        "  \n",
        "  # Show the image which was just taken.\n",
        "  display(Image(filename))\n",
        "except Exception as err:\n",
        "  # Errors will be thrown if the user does not have a webcam or if they do not\n",
        "  # grant the page permission to access it.\n",
        "  print(str(err))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function takePhoto(quality) {\n",
              "      const div = document.createElement('div');\n",
              "      const capture = document.createElement('button');\n",
              "      capture.textContent = 'Capture';\n",
              "      div.appendChild(capture);\n",
              "\n",
              "      const video = document.createElement('video');\n",
              "      video.style.display = 'block';\n",
              "      const stream = await navigator.mediaDevices.getUserMedia({video: true});\n",
              "\n",
              "      document.body.appendChild(div);\n",
              "      div.appendChild(video);\n",
              "      video.srcObject = stream;\n",
              "      await video.play();\n",
              "\n",
              "      // Resize the output to fit the video element.\n",
              "      google.colab.output.setIframeHeight(document.documentElement.scrollHeight, true);\n",
              "\n",
              "      // Wait for Capture to be clicked.\n",
              "      await new Promise((resolve) => capture.onclick = resolve);\n",
              "\n",
              "      const canvas = document.createElement('canvas');\n",
              "      canvas.width = video.videoWidth;\n",
              "      canvas.height = video.videoHeight;\n",
              "      canvas.getContext('2d').drawImage(video, 0, 0);\n",
              "      stream.getVideoTracks()[0].stop();\n",
              "      div.remove();\n",
              "      return canvas.toDataURL('image/jpeg', quality);\n",
              "    }\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saved to photo.jpg\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/jpeg": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aNgF_1RXgyPo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "outputId": "7516b6f2-b125-4218-ab29-600b42ee12fa"
      },
      "source": [
        "import tensorflow.keras\n",
        "from PIL import Image, ImageOps\n",
        "import numpy as np\n",
        "import random\n",
        "\n",
        "# Disable scientific notation for clarity\n",
        "np.set_printoptions(suppress=True)\n",
        "\n",
        "# Load the model\n",
        "model = tensorflow.keras.models.load_model('keras_model.h5')\n",
        "labels = [line for line in open(\"labels.txt\")]\n",
        "\n",
        "# Create the array of the right shape to feed into the keras model\n",
        "# The 'length' or number of images you can put into the array is\n",
        "# determined by the first position in the shape tuple, in this case 1.\n",
        "data = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32)\n",
        "\n",
        "# Replace this with the path to your image\n",
        "image = Image.open('photo.jpg')\n",
        "\n",
        "#resize the image to a 224x224 with the same strategy as in TM2:\n",
        "#resizing the image to be at least 224x224 and then cropping from the center\n",
        "size = (224, 224)\n",
        "image = ImageOps.fit(image, size, Image.ANTIALIAS)\n",
        "\n",
        "#turn the image into a numpy array\n",
        "image_array = np.asarray(image)\n",
        "\n",
        "# display the resized image\n",
        "image.show()\n",
        "\n",
        "# Normalize the image\n",
        "normalized_image_array = (image_array.astype(np.float32) / 127.0) - 1\n",
        "\n",
        "# Load the image into the array\n",
        "data[0] = normalized_image_array\n",
        "\n",
        "# run the inference\n",
        "prediction = model.predict(data)\n",
        "print(\"\\nModel prediction stats: \")\n",
        "print(prediction)\n",
        "choice = labels[np.argmax(prediction)]\n",
        "if str(0) in choice:\n",
        "  print(\"\\nYou picked\" + (choice.replace(str(0), \"\")).lower())\n",
        "elif str(1) in choice:\n",
        "  print(\"\\nYou picked\" + (choice.replace(str(1), \"\")).lower())\n",
        "else:\n",
        "  print(\"\\nYou picked\" + (choice.replace(str(2), \"\")).lower())\n",
        "\n",
        "print(\"VS\")\n",
        "rand = random.randint(0, 2)\n",
        "\n",
        "if rand == 0:\n",
        "  print(\"\\nI picked rock\")\n",
        "  if str(0) in choice:\n",
        "    print(\"\\nWe tied!\")\n",
        "  elif str(1) in choice:\n",
        "    print(\"\\nGood job, you won!\")\n",
        "  else:\n",
        "    print(\"\\nLet's go, I won!\")\n",
        "\n",
        "elif rand == 1:\n",
        "  print(\"\\nI picked paper\")\n",
        "  if str(0) in choice:\n",
        "    print(\"\\nLet's go, I won!\")\n",
        "  elif str(1) in choice:\n",
        "    print(\"\\nWe tied!\")\n",
        "  else:\n",
        "    print(\"\\nGood job, you won!\")\n",
        "\n",
        "else:\n",
        "  print(\"\\nI picked scissors\")\n",
        "  if str(0) in choice:\n",
        "    print(\"\\nGood job, you won!\")\n",
        "  elif str(1) in choice:\n",
        "    print(\"\\nLet's go, I won!\")\n",
        "  else:\n",
        "    print(\"\\nWe tied!\")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n",
            "\n",
            "Model prediction stats: \n",
            "[[0. 1. 0.]]\n",
            "\n",
            "You picked paper\n",
            "\n",
            "VS\n",
            "\n",
            "I picked rock\n",
            "\n",
            "Good job, you won!\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}