demo.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QWb55fWU5vUc"
      },
      "outputs": [],
      "source": [
        "!pip install fastapi\n",
        "!pip install uvicorn\n",
        "!pip install pickle5\n",
        "!pip install pydantic\n",
        "!pip install scikit-learn\n",
        "!pip install requests\n",
        "!pip install pypi-json\n",
        "!pip install pyngrok==4.1.1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "02Rb8RjyL7EV"
      },
      "outputs": [],
      "source": [
        "!pip install python-multipart\n",
        "!pip install nest-asyncio\n",
        "!pip install aiofiles\n",
        "!pip install ar-corrector"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "ftpA2wttIeGK"
      },
      "outputs": [],
      "source": [
        "from fastapi import FastAPI\n",
        "from pydantic import BaseModel\n",
        "import pickle\n",
        "import json\n",
        "import uvicorn\n",
        "from  pyngrok import ngrok\n",
        "from fastapi.middleware.cors import CORSMiddleware\n",
        "import nest_asyncio\n",
        "import os\n",
        "import sys\n",
        "from fastapi import FastAPI, File, UploadFile\n",
        "from tempfile import NamedTemporaryFile\n",
        "from fastapi.responses import HTMLResponse, StreamingResponse"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "vMjL99ldqhps"
      },
      "outputs": [],
      "source": [
        "sys.path.insert(0, '/content/folder')\n",
        "from preprocessing import preprocess_sample\n",
        "from config import args\n",
        "from models.visual_frontend import VisualFrontend\n",
        "from spell_sentence import Spell\n",
        "import torch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "nKexpmUt5vX1"
      },
      "outputs": [],
      "source": [
        "app = FastAPI()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "VVPqCCZdLYVK"
      },
      "outputs": [],
      "source": [
        "gpuAvailable = torch.cuda.is_available()\n",
        "device = torch.device(\"cuda\" if gpuAvailable else \"cpu\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "_rv6keMhqt21"
      },
      "source": [
        "# RUN DEMO\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "wQoV9fjDqx6P"
      },
      "outputs": [],
      "source": [
        "from config import args\n",
        "from models.video_net import VideoNet\n",
        "from models.visual_frontend import VisualFrontend\n",
        "from models.lrs2_char_lm import LRS2CharLM\n",
        "from utils import prepare_main_input, collate_fn\n",
        "from preprocessing import preprocess_sample\n",
        "from decoders import ctc_greedy_decode, ctc_search_decode\n",
        "from demo import demo_test"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "wJvNlc4Pq15_"
      },
      "source": [
        "# RUN preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6Ywd0ADrLNaJ"
      },
      "outputs": [],
      "source": [
        "vf = VisualFrontend()\n",
        "vf.load_state_dict(torch.load(args[\"TRAINED_FRONTEND_FILE\"], map_location=device))\n",
        "vf.to(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OM_Io8djKU7m"
      },
      "outputs": [],
      "source": [
        "params = {\"roiSize\":args[\"ROI_SIZE\"], \"normMean\":args[\"NORMALIZATION_MEAN\"], \"normStd\":args[\"NORMALIZATION_STD\"], \"vf\":vf}"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "9bZ1bb3Lq9J8"
      },
      "source": [
        "# RUN app"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "p3I6olGArA3T"
      },
      "outputs": [],
      "source": [
        "import shutil\n",
        "from fastapi.concurrency import run_in_threadpool\n",
        "import aiofiles\n",
        "import asyncio\n",
        "import os\n",
        "import binascii"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "HZMweA-F3vDJ"
      },
      "outputs": [],
      "source": [
        "from typing_extensions import Annotated\n",
        "from starlette.requests import Request"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "GrqkVAxz5zEz"
      },
      "outputs": [],
      "source": [
        "from moviepy.editor import VideoFileClip\n",
        "from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip\n",
        "import math\n",
        "def cut_video(video_path):\n",
        "  all_paths=[]\n",
        "  clip = VideoFileClip(\"/content/folder/output.mp4\")\n",
        "  #print((clip.duration))\n",
        "  duration       = (clip.duration)\n",
        "  fps            = clip.fps\n",
        "  #print((duration))\n",
        "  i=0\n",
        "  while(i<=int(duration) and i != int(duration)):\n",
        "    videos = str(i+1)+\".mp4\"\n",
        "    all_paths.append(\"/content/\"+videos)\n",
        "    #print(i)\n",
        "    #print(i+2)\n",
        "    ffmpeg_extract_subclip(\"/content/folder/output.mp4\", i,i+2,targetname=videos)\n",
        "    i=i+2\n",
        "  return all_paths"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "rPHR2hm7J0Gq"
      },
      "outputs": [],
      "source": [
        "@app.post(\"/uploadfiles/\")\n",
        "async def create_upload_file(request: Request):\n",
        "    rs = \"\"\n",
        "    data: bytes = await request.body()\n",
        "    output = data\n",
        "    print(output)\n",
        "    #video_path = binascii.unhexlify(output)\n",
        "    #print(video_path)\n",
        "    f = open(\"/content/folder/output.mp4\", 'wb')\n",
        "    f.write(output)\n",
        "    f.close()\n",
        "    cutting_video=cut_video(\"/content/folder/output.mp4\")\n",
        "    for video in cutting_video:\n",
        "      try:\n",
        "        rs = rs+demo_test(video)+\" \"\n",
        "      finally:\n",
        "        os.unlink(video)\n",
        "    grid=\"/content/folder/words75.txt\"\n",
        "    Sp = Spell(grid)\n",
        "    pred=Sp.sentence(rs.strip())  \n",
        "    return pred"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UMsEqG1MjiPb",
        "outputId": "f2d7a79e-5450-4373-d1f3-fb0e4ab9f769"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "auth_token = \"2OKzCE2QibAxS9SV8WQ6cjmTRxk_2nP26rKamD6rFb8yx1Ufq\" #@param {type:\"string\"}\n",
        "# Since we can't access Colab notebooks IP directly we'll use\n",
        "# ngrok to create a public URL for the server via a tunnel\n",
        "\n",
        "# Authenticate ngrok\n",
        "# https://dashboard.ngrok.com/signup\n",
        "# Then go to the \"Your Authtoken\" tab in the sidebar and copy the API key\n",
        "import os\n",
        "os.system(f\"ngrok authtoken {auth_token}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "tZC60sWiJ0J2"
      },
      "outputs": [],
      "source": [
        "# Create tunnel\n",
        "public_url = ngrok.connect( port='8000')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C18G_5ACkJwp",
        "outputId": "6c56c14f-d333-41e9-f863-da8669779494"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "root       36852 26.0  0.1 726760 24700 ?        Sl   12:51   0:00 /usr/local/lib/python3.10/dist-packages/pyngrok/bin/ngrok start --none --log=stdout\n",
            "root       36866  0.0  0.0   6904  3292 ?        S    12:51   0:00 /bin/bash -c ps aux | grep ngrok\n",
            "root       36868  0.0  0.0   6444   720 ?        S    12:51   0:00 grep ngrok\n"
          ]
        }
      ],
      "source": [
        "# Check if it exists\n",
        "!ps aux | grep ngrok"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x4_h74Zzv1y-"
      },
      "outputs": [],
      "source": [
        "import nest_asyncio\n",
        "\n",
        "# Allow for asyncio to work within the Jupyter notebook cell\n",
        "nest_asyncio.apply()\n",
        "\n",
        "import uvicorn\n",
        "\n",
        "# Run the FastAPI app using uvicorn\n",
        "print(public_url)\n",
        "uvicorn.run(app)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n-0hn0tKUfOJ"
      },
      "outputs": [],
      "source": [
        "# Kill tunnel\n",
        "ngrok.disconnect(public_url=public_url)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LW6pAiO-AC_P"
      },
      "outputs": [],
      "source": [
        "!zip -r /content/drive/MyDrive/final/End_Api2.zip /content/folder"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}