From 027f8a8881589317882f58e7b66aae3f805f19bb Mon Sep 17 00:00:00 2001 From: vivek-mandal Date: Thu, 30 Mar 2023 23:17:12 +0530 Subject: [PATCH 1/5] Saliency Maps Added to the UDF of eva --- tutorials/saliencyMaps/UDF.py | 76 ++++++++++++++++++++++++ tutorials/saliencyMaps/requirements.txt | 6 ++ tutorials/saliencyMaps/test1.jpeg | Bin 0 -> 3848 bytes tutorials/saliencyMaps/test2.jpeg | Bin 0 -> 8518 bytes 4 files changed, 82 insertions(+) create mode 100644 tutorials/saliencyMaps/UDF.py create mode 100644 tutorials/saliencyMaps/requirements.txt create mode 100644 tutorials/saliencyMaps/test1.jpeg create mode 100644 tutorials/saliencyMaps/test2.jpeg diff --git a/tutorials/saliencyMaps/UDF.py b/tutorials/saliencyMaps/UDF.py new file mode 100644 index 000000000..ae2fc161e --- /dev/null +++ b/tutorials/saliencyMaps/UDF.py @@ -0,0 +1,76 @@ +from typing import List + +import pandas as pd +import numpy as np +import os +import torchvision +import torch +import torch.nn as nn +import torch.nn.functional as F + + +from eva.models.catalog.frame_info import FrameInfo +from eva.models.catalog.properties import ColorSpace +from eva.udfs.abstract.pytorch_abstract_udf import PytorchAbstractClassifierUDF +from torch import Tensor +from torchvision import models +from torchvision.transforms import Compose, ToTensor, Resize +from PIL import Image + + +class MRICNN(PytorchAbstractClassifierUDF): + + @property + def name(self) -> str: + return "MRICNN" + + def setup(self): + # !wget -nc "https://www.dropbox.com/s/cnsgyitrtw40lgs/model.pth?dl=0" + # to get the model from the dropbox + self.model = torchvision.models.resnet18(pretrained=True) + num_features = self.model.fc.in_features + self.model.fc = nn.Linear(num_features, 2) # binary classification (num_of_class == 2) + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + model_state = torch.load("model.pth", map_location=device) + self.model.load_state_dict(model_state) + self.model.eval() + + @property + def input_format(self) -> FrameInfo: + return FrameInfo(-1, -1, 3, ColorSpace.RGB) + + @property + def labels(self) -> List[str]: + return [ + '0', '1' + ] + + def transform(self, images) -> Compose: + composed = Compose([ + Resize((224, 224)), + ToTensor() + ]) + # reverse the channels from opencv + return composed(Image.fromarray(images[:, :, ::-1])).unsqueeze(0) + + def forward(self, frames: Tensor) -> pd.DataFrame: + """ + Performs predictions on input frames + Arguments: + frames (np.ndarray): Frames on which predictions need + to be performed + + Returns: + tuple containing predicted_classes (List[str]) + """ + outcome = pd.DataFrame() + frames.requires_grad_() + outputs = self.model(frames) + score_max_index = outputs.argmax() + score_max = outputs[0,score_max_index] + score_max.backward() + saliency, _ = torch.max(frames.grad.data.abs(),dim=1) + + outcome = outcome.append({"saliency" : saliency}, ignore_index=True) + + return outcome diff --git a/tutorials/saliencyMaps/requirements.txt b/tutorials/saliencyMaps/requirements.txt new file mode 100644 index 000000000..e90e42e81 --- /dev/null +++ b/tutorials/saliencyMaps/requirements.txt @@ -0,0 +1,6 @@ +evadb +pandas +numpy +torch +torchvision +pydicom \ No newline at end of file diff --git a/tutorials/saliencyMaps/test1.jpeg b/tutorials/saliencyMaps/test1.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..d820352f59a309b3715e25936b9b31ca7c28cd5b GIT binary patch literal 3848 zcmb7`c{tSV+s40RjIoZf@0tk_581bgW+MACWGGu9jP+p{yJShFl6_4Lvdv^EGe)EZ zh3r{kNVa5;lBGxH*YiBb`yTK6{`a2u=a1{S?)y6L`>*>rnG?)e0B&JoZUTTn008>E z0Ok~s0&uWF1^D@e1O)hng@r^!MMQ)}MTCS!eoIK`cO@h)Dk`Ob5EYk`5)wkHA>~dg zsi>%k9MjO%P}WgUR#5_Ra&kf-5ZG^ Y{@-H00{Ga09-tNsIu5Y#fxvtqW+xy4 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 literal 0 HcmV?d00001 diff --git a/tutorials/saliencyMaps/test2.jpeg b/tutorials/saliencyMaps/test2.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..b8862ffb96f629715e9cfa596c7e7e9f0d8de96b GIT binary patch literal 8518 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 Date: Fri, 31 Mar 2023 20:40:25 +0530 Subject: [PATCH 2/5] Added Saliency maps notebook --- tutorials/saliencyMaps/EVADB_Notebook.ipynb | 697 ++++++++++++++++++++ 1 file changed, 697 insertions(+) create mode 100644 tutorials/saliencyMaps/EVADB_Notebook.ipynb diff --git a/tutorials/saliencyMaps/EVADB_Notebook.ipynb b/tutorials/saliencyMaps/EVADB_Notebook.ipynb new file mode 100644 index 000000000..2e09a524c --- /dev/null +++ b/tutorials/saliencyMaps/EVADB_Notebook.ipynb @@ -0,0 +1,697 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "DK4AwcI4gNCW", + "outputId": "75eea35b-6f23-4156-82fd-8c3a8d235222" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting evadb\n", + " Downloading evadb-0.1.4-py3-none-any.whl (435 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m435.8/435.8 KB\u001b[0m \u001b[31m11.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 2)) (1.4.4)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 3)) (1.22.4)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 4)) (1.13.1+cu116)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 5)) (0.14.1+cu116)\n", + "Collecting pydicom\n", + " Downloading pydicom-2.3.1-py3-none-any.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m54.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ray>=1.13.0\n", + " Downloading ray-2.3.1-cp39-cp39-manylinux2014_x86_64.whl (58.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.6/58.6 MB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: sqlalchemy<2.0.0,>=1.4.0 in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (1.4.47)\n", + "Collecting easyocr>=1.5.0\n", + " Downloading easyocr-1.6.2-py3-none-any.whl (2.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.9/2.9 MB\u001b[0m \u001b[31m63.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting detoxify\n", + " Downloading detoxify-0.5.1-py3-none-any.whl (12 kB)\n", + "Collecting opencv-python<4.6.0.66,>=4.5.4.60\n", + " Downloading opencv_python-4.5.5.64-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (60.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.5/60.5 MB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting aenum>=2.2.0\n", + " Downloading aenum-3.1.12-py3-none-any.whl (131 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m131.8/131.8 KB\u001b[0m \u001b[31m13.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting yolov5\n", + " Downloading yolov5-7.0.11-py37.py38.py39.py310-none-any.whl (956 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m956.3/956.3 KB\u001b[0m \u001b[31m51.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting faiss-cpu\n", + " Downloading faiss_cpu-1.7.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (17.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m17.0/17.0 MB\u001b[0m \u001b[31m65.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (6.0)\n", + "Requirement already satisfied: Pillow>=8.4.0 in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (8.4.0)\n", + "Collecting sqlalchemy-utils>=0.36.6\n", + " Downloading SQLAlchemy_Utils-0.40.0-py3-none-any.whl (92 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m92.5/92.5 KB\u001b[0m \u001b[31m10.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: ipython in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (7.34.0)\n", + "Collecting importlib-metadata<5.0\n", + " Downloading importlib_metadata-4.13.0-py3-none-any.whl (23 kB)\n", + "Collecting facenet-pytorch>=2.5.2\n", + " Downloading facenet_pytorch-2.5.2-py3-none-any.whl (1.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m62.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting lark>=1.0.0\n", + " Downloading lark-1.1.5-py3-none-any.whl (107 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m108.0/108.0 KB\u001b[0m \u001b[31m10.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from pandas->-r requirements.txt (line 2)) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/dist-packages (from pandas->-r requirements.txt (line 2)) (2022.7.1)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.9/dist-packages (from torch->-r requirements.txt (line 4)) (4.5.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from torchvision->-r requirements.txt (line 5)) (2.27.1)\n", + "Requirement already satisfied: scikit-image in /usr/local/lib/python3.9/dist-packages (from easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (0.19.3)\n", + "Requirement already satisfied: Shapely in /usr/local/lib/python3.9/dist-packages (from easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (2.0.1)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.9/dist-packages (from easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (1.10.1)\n", + "Collecting pyclipper\n", + " Downloading pyclipper-1.3.0.post4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl (608 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m608.2/608.2 KB\u001b[0m \u001b[31m43.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting opencv-python-headless<=4.5.4.60\n", + " Downloading opencv_python_headless-4.5.4.60-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (47.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m47.6/47.6 MB\u001b[0m \u001b[31m15.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting python-bidi\n", + " Downloading python_bidi-0.4.2-py2.py3-none-any.whl (30 kB)\n", + "Collecting ninja\n", + " Downloading ninja-1.11.1-py2.py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (145 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m146.0/146.0 KB\u001b[0m \u001b[31m13.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata<5.0->evadb->-r requirements.txt (line 1)) (3.15.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.8.1->pandas->-r requirements.txt (line 2)) (1.16.0)\n", + "Collecting virtualenv>=20.0.24\n", + " Downloading virtualenv-20.21.0-py3-none-any.whl (8.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.7/8.7 MB\u001b[0m \u001b[31m18.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting frozenlist\n", + " Downloading frozenlist-1.3.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (158 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.8/158.8 KB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (3.10.7)\n", + "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (8.1.3)\n", + "Requirement already satisfied: jsonschema in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (4.3.3)\n", + "Collecting aiosignal\n", + " Downloading aiosignal-1.3.1-py3-none-any.whl (7.6 kB)\n", + "Requirement already satisfied: grpcio>=1.32.0 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (1.53.0)\n", + "Requirement already satisfied: attrs in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (22.2.0)\n", + "Requirement already satisfied: protobuf!=3.19.5,>=3.15.3 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (3.20.3)\n", + "Requirement already satisfied: msgpack<2.0.0,>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (1.0.5)\n", + "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.9/dist-packages (from sqlalchemy<2.0.0,>=1.4.0->evadb->-r requirements.txt (line 1)) (2.0.2)\n", + "Collecting transformers==4.22.1\n", + " Downloading transformers-4.22.1-py3-none-any.whl (4.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.9/4.9 MB\u001b[0m \u001b[31m25.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting sentencepiece>=0.1.94\n", + " Downloading sentencepiece-0.1.97-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m29.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.9/dist-packages (from transformers==4.22.1->detoxify->evadb->-r requirements.txt (line 1)) (2022.10.31)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from transformers==4.22.1->detoxify->evadb->-r requirements.txt (line 1)) (23.0)\n", + "Collecting tokenizers!=0.11.3,<0.13,>=0.11.1\n", + " Downloading tokenizers-0.12.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (6.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.6/6.6 MB\u001b[0m \u001b[31m27.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.9/dist-packages (from transformers==4.22.1->detoxify->evadb->-r requirements.txt (line 1)) (4.65.0)\n", + "Collecting huggingface-hub<1.0,>=0.9.0\n", + " Downloading huggingface_hub-0.13.3-py3-none-any.whl (199 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.8/199.8 KB\u001b[0m \u001b[31m14.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: decorator in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (4.4.2)\n", + "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (5.7.1)\n", + "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (3.0.38)\n", + "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (0.1.6)\n", + "Collecting jedi>=0.16\n", + " Downloading jedi-0.18.2-py2.py3-none-any.whl (1.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m31.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pygments in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (2.14.0)\n", + "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (67.6.1)\n", + "Requirement already satisfied: backcall in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (0.2.0)\n", + "Requirement already satisfied: pickleshare in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (0.7.5)\n", + "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (4.8.0)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (2.0.12)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (2022.12.7)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (1.26.15)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (3.4)\n", + "Collecting fire\n", + " Downloading fire-0.5.0.tar.gz (88 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.3/88.3 KB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting gitpython\n", + " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m14.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting boto3>=1.19.1\n", + " Downloading boto3-1.26.102-py3-none-any.whl (135 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m135.6/135.6 KB\u001b[0m \u001b[31m12.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: psutil in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (5.9.4)\n", + "Collecting sahi>=0.11.10\n", + " Downloading sahi-0.11.13-py3-none-any.whl (100 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.0/101.0 KB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: matplotlib>=3.2.2 in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (3.7.1)\n", + "Collecting roboflow>=0.2.29\n", + " Downloading roboflow-1.0.1-py3-none-any.whl (55 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.7/55.7 KB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tensorboard>=2.4.1 in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (2.12.0)\n", + "Collecting thop>=0.1.1\n", + " Downloading thop-0.1.1.post2209072238-py3-none-any.whl (15 kB)\n", + "Requirement already satisfied: seaborn>=0.11.0 in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (0.12.2)\n", + "Collecting jmespath<2.0.0,>=0.7.1\n", + " Downloading jmespath-1.0.1-py3-none-any.whl (20 kB)\n", + "Collecting s3transfer<0.7.0,>=0.6.0\n", + " Downloading s3transfer-0.6.0-py3-none-any.whl (79 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.6/79.6 KB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting botocore<1.30.0,>=1.29.102\n", + " Downloading botocore-1.29.102-py3-none-any.whl (10.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.6/10.6 MB\u001b[0m \u001b[31m53.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: parso<0.9.0,>=0.8.0 in /usr/local/lib/python3.9/dist-packages (from jedi>=0.16->ipython->evadb->-r requirements.txt (line 1)) (0.8.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (0.11.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (1.0.7)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (3.0.9)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (4.39.3)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (1.4.4)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (5.12.0)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.9/dist-packages (from pexpect>4.3->ipython->evadb->-r requirements.txt (line 1)) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.9/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython->evadb->-r requirements.txt (line 1)) (0.2.6)\n", + "Collecting python-dotenv\n", + " Downloading python_dotenv-1.0.0-py3-none-any.whl (19 kB)\n", + "Collecting wget\n", + " Downloading wget-3.2.zip (10 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting idna<4,>=2.5\n", + " Downloading idna-2.10-py2.py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.8/58.8 KB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: chardet==4.0.0 in /usr/local/lib/python3.9/dist-packages (from roboflow>=0.2.29->yolov5->evadb->-r requirements.txt (line 1)) (4.0.0)\n", + "Collecting requests-toolbelt\n", + " Downloading requests_toolbelt-0.10.1-py2.py3-none-any.whl (54 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.5/54.5 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting pyparsing>=2.3.1\n", + " Downloading pyparsing-2.4.7-py2.py3-none-any.whl (67 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m67.8/67.8 KB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting cycler>=0.10\n", + " Downloading cycler-0.10.0-py2.py3-none-any.whl (6.5 kB)\n", + "Collecting terminaltables\n", + " Downloading terminaltables-3.1.10-py2.py3-none-any.whl (15 kB)\n", + "Collecting pybboxes==0.1.6\n", + " Downloading pybboxes-0.1.6-py3-none-any.whl (24 kB)\n", + "Collecting click>=7.0\n", + " Downloading click-8.0.4-py3-none-any.whl (97 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.5/97.5 KB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (1.4.0)\n", + "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (1.8.1)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (2.2.3)\n", + "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.4.6)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (2.17.0)\n", + "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.40.0)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.7.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (3.4.3)\n", + "Collecting distlib<1,>=0.3.6\n", + " Downloading distlib-0.3.6-py2.py3-none-any.whl (468 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m468.5/468.5 KB\u001b[0m \u001b[31m31.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: platformdirs<4,>=2.4 in /usr/local/lib/python3.9/dist-packages (from virtualenv>=20.0.24->ray>=1.13.0->evadb->-r requirements.txt (line 1)) (3.2.0)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.9/dist-packages (from fire->yolov5->evadb->-r requirements.txt (line 1)) (2.2.0)\n", + "Collecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.9/dist-packages (from jsonschema->ray>=1.13.0->evadb->-r requirements.txt (line 1)) (0.19.3)\n", + "Requirement already satisfied: PyWavelets>=1.1.1 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (1.4.1)\n", + "Requirement already satisfied: tifffile>=2019.7.26 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (2023.3.21)\n", + "Requirement already satisfied: networkx>=2.2 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (3.0)\n", + "Requirement already satisfied: imageio>=2.4.1 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (2.25.1)\n", + "Collecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (5.3.0)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.2.8)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (4.9)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.9/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (1.3.1)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.9/dist-packages (from werkzeug>=1.0.1->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (2.1.2)\n", + "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.9/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.4.8)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.9/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (3.2.2)\n", + "Building wheels for collected packages: fire, wget\n", + " Building wheel for fire (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for fire: filename=fire-0.5.0-py2.py3-none-any.whl size=116952 sha256=eb5dfa686699b199e7cca080b76d67baa9f47f34485603c8bfc3d253ec2611db\n", + " Stored in directory: /root/.cache/pip/wheels/f7/f1/89/b9ea2bf8f80ec027a88fef1d354b3816b4d3d29530988972f6\n", + " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9676 sha256=1b81a63c6b01489b7d99c71a0cad2f5fdbff17e9d94de3304ae27e5ae53ec303\n", + " Stored in directory: /root/.cache/pip/wheels/04/5f/3e/46cc37c5d698415694d83f607f833f83f0149e49b3af9d0f38\n", + "Successfully built fire wget\n", + "Installing collected packages: wget, tokenizers, sentencepiece, pyclipper, ninja, lark, faiss-cpu, distlib, aenum, virtualenv, terminaltables, smmap, python-dotenv, python-bidi, pyparsing, pydicom, pybboxes, opencv-python-headless, opencv-python, jmespath, jedi, importlib-metadata, idna, frozenlist, fire, cycler, click, thop, sqlalchemy-utils, gitdb, botocore, aiosignal, sahi, s3transfer, requests-toolbelt, ray, huggingface-hub, gitpython, transformers, roboflow, facenet-pytorch, easyocr, boto3, detoxify, yolov5, evadb\n", + " Attempting uninstall: pyparsing\n", + " Found existing installation: pyparsing 3.0.9\n", + " Uninstalling pyparsing-3.0.9:\n", + " Successfully uninstalled pyparsing-3.0.9\n", + " Attempting uninstall: opencv-python-headless\n", + " Found existing installation: opencv-python-headless 4.7.0.72\n", + " Uninstalling opencv-python-headless-4.7.0.72:\n", + " Successfully uninstalled opencv-python-headless-4.7.0.72\n", + " Attempting uninstall: opencv-python\n", + " Found existing installation: opencv-python 4.7.0.72\n", + " Uninstalling opencv-python-4.7.0.72:\n", + " Successfully uninstalled opencv-python-4.7.0.72\n", + " Attempting uninstall: importlib-metadata\n", + " Found existing installation: importlib-metadata 6.1.0\n", + " Uninstalling importlib-metadata-6.1.0:\n", + " Successfully uninstalled importlib-metadata-6.1.0\n", + " Attempting uninstall: idna\n", + " Found existing installation: idna 3.4\n", + " Uninstalling idna-3.4:\n", + " Successfully uninstalled idna-3.4\n", + " Attempting uninstall: cycler\n", + " Found existing installation: cycler 0.11.0\n", + " Uninstalling cycler-0.11.0:\n", + " Successfully uninstalled cycler-0.11.0\n", + " Attempting uninstall: click\n", + " Found existing installation: click 8.1.3\n", + " Uninstalling click-8.1.3:\n", + " Successfully uninstalled click-8.1.3\n", + "Successfully installed aenum-3.1.12 aiosignal-1.3.1 boto3-1.26.102 botocore-1.29.102 click-8.0.4 cycler-0.10.0 detoxify-0.5.1 distlib-0.3.6 easyocr-1.6.2 evadb-0.1.4 facenet-pytorch-2.5.2 faiss-cpu-1.7.3 fire-0.5.0 frozenlist-1.3.3 gitdb-4.0.10 gitpython-3.1.31 huggingface-hub-0.13.3 idna-2.10 importlib-metadata-4.13.0 jedi-0.18.2 jmespath-1.0.1 lark-1.1.5 ninja-1.11.1 opencv-python-4.5.5.64 opencv-python-headless-4.5.4.60 pybboxes-0.1.6 pyclipper-1.3.0.post4 pydicom-2.3.1 pyparsing-2.4.7 python-bidi-0.4.2 python-dotenv-1.0.0 ray-2.3.1 requests-toolbelt-0.10.1 roboflow-1.0.1 s3transfer-0.6.0 sahi-0.11.13 sentencepiece-0.1.97 smmap-5.0.0 sqlalchemy-utils-0.40.0 terminaltables-3.1.10 thop-0.1.1.post2209072238 tokenizers-0.12.1 transformers-4.22.1 virtualenv-20.21.0 wget-3.2 yolov5-7.0.11\n" + ] + }, + { + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "cycler", + "pyparsing" + ] + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# !pip install -r requirements.txt" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xaqSm-DUgN3c", + "outputId": "0b8fb001-bea9-4070-9bb2-59388c0648cb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-03-30 17:14:14-- https://raw.githubusercontent.com/georgia-tech-db/eva/master/tutorials/00-start-eva-server.ipynb\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.111.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3971 (3.9K) [text/plain]\n", + "Saving to: ‘00-start-eva-server.ipynb’\n", + "\n", + "00-start-eva-server 100%[===================>] 3.88K --.-KB/s in 0s \n", + "\n", + "2023-03-30 17:14:14 (47.3 MB/s) - ‘00-start-eva-server.ipynb’ saved [3971/3971]\n", + "\n", + "nohup eva_server >> eva.log 2>&1 &\n" + ] + } + ], + "source": [ + "!wget -nc \"https://raw.githubusercontent.com/georgia-tech-db/eva/master/tutorials/00-start-eva-server.ipynb\"\n", + "!wget -nc \"https://www.dropbox.com/s/cnsgyitrtw40lgs/model.pth?dl=0\"\n", + "%run 00-start-eva-server.ipynb\n", + "cursor = connect_to_server()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tL9hLo2ug52e", + "outputId": "9e01f4be-e5cc-429b-e016-814da5cca05d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@status: ResponseStatus.SUCCESS\n", + "@batch: \n", + " 0\n", + "0 Table Successfully dropped: MRI\n", + "@query_time: 0.07096198499993989\n", + "@status: ResponseStatus.SUCCESS\n", + "@batch: \n", + " 0\n", + "0 Number of loaded IMAGE: 1\n", + "@query_time: 0.15114561900008994\n", + "@status: ResponseStatus.SUCCESS\n", + "@batch: \n", + " 0\n", + "0 Number of loaded IMAGE: 1\n", + "@query_time: 0.027401803999964613\n" + ] + } + ], + "source": [ + "cursor.execute(\"DROP TABLE MRI;\")\n", + "response = cursor.fetch_all()\n", + "print(response)\n", + "cursor.execute(\"LOAD IMAGE 'test2.jpeg' INTO MRI;\")\n", + "response = cursor.fetch_all()\n", + "print(response)\n", + "cursor.execute(\"LOAD IMAGE 'test1.jpeg' INTO MRI;\")\n", + "response = cursor.fetch_all()\n", + "print(response)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nn02z2PXhLZs", + "outputId": "eb43ae3c-18c4-43ba-98d5-ffe8843239e6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@status: ResponseStatus.SUCCESS\n", + "@batch: \n", + " 0\n", + "0 UDF MRICNN successfully dropped\n", + "@query_time: 0.027917190000152914\n", + "@status: ResponseStatus.SUCCESS\n", + "@batch: \n", + " 0\n", + "0 UDF MRICNN successfully added to the database.\n", + "@query_time: 0.5369972539997434\n" + ] + } + ], + "source": [ + "cursor.execute(\"\"\"DROP UDF MRICNN;\"\"\")\n", + "response = cursor.fetch_all()\n", + "print(response)\n", + "\n", + "cursor.execute(\"\"\"CREATE UDF IF NOT EXISTS \n", + " MRICNN\n", + " INPUT (data NDARRAY UINT8(3, 224, 224)) \n", + " OUTPUT (saliency ANYTYPE) \n", + " TYPE Classification \n", + " IMPL 'UDF.py';\n", + " \"\"\")\n", + "response = cursor.fetch_all()\n", + "print(response)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VfWK6vlXhPzd", + "outputId": "c0d781a4-7613-4015-c615-7c38dc9fe408" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mri.data \\\n", + "0 [[[13 31 30]\\n [16 34 33]\\n [20 34 33]\\n [28 42 41]\\n [17 29 29]\\n [20 32 32]\\n [12 22 22]\\n [25... \n", + "1 [[[0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0... \n", + "\n", + " mricnn.saliency \n", + "0 [tensor([[0.0005, 0.0003, 0.0004, ..., 0.0035, 0.0042, 0.0036],\\n [0.0013, 0.0011, 0.002... \n", + "1 [tensor([[0.0020, 0.0017, 0.0008, ..., 0.0002, 0.0000, 0.0000],\\n [0.0036, 0.0035, 0.001... \n" + ] + } + ], + "source": [ + "cursor.execute(\"\"\"SELECT data, MRICNN(data)\n", + " FROM MRI\n", + " \"\"\")\n", + "response = cursor.fetch_all()\n", + "print(response.batch)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 112 + }, + "id": "J4JHTIW7hTpA", + "outputId": "6964739c-0fc5-4f28-c974-77888c73a074" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mri.datamricnn.saliency
0[[[13, 31, 30], [16, 34, 33], [20, 34, 33], [2...[[[tensor(0.0005), tensor(0.0003), tensor(0.00...
1[[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], ...[[[tensor(0.0020), tensor(0.0017), tensor(0.00...
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + " mri.data \\\n", + "0 [[[13, 31, 30], [16, 34, 33], [20, 34, 33], [2... \n", + "1 [[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], ... \n", + "\n", + " mricnn.saliency \n", + "0 [[[tensor(0.0005), tensor(0.0003), tensor(0.00... \n", + "1 [[[tensor(0.0020), tensor(0.0017), tensor(0.00... " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = response.batch.frames\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Bb-fkO86haib", + "outputId": "eb2e5db8-3494-4447-bab1-329984f4a838" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[0.0005, 0.0003, 0.0004, ..., 0.0035, 0.0042, 0.0036],\n", + " [0.0013, 0.0011, 0.0022, ..., 0.0066, 0.0100, 0.0091],\n", + " [0.0006, 0.0020, 0.0040, ..., 0.0175, 0.0233, 0.0203],\n", + " ...,\n", + " [0.0005, 0.0004, 0.0010, ..., 0.0035, 0.0008, 0.0015],\n", + " [0.0002, 0.0002, 0.0005, ..., 0.0023, 0.0007, 0.0008],\n", + " [0.0001, 0.0005, 0.0001, ..., 0.0022, 0.0003, 0.0006]]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[\"mricnn.saliency\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 422 + }, + "id": "AStT5LRGhuFb", + "outputId": "18f5f76d-4a13-48b3-d650-228fd6df901c" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch \n", + "df = response.batch.frames\n", + "fig, ax = plt.subplots(nrows=2, ncols=len(df), figsize=[15,18])\n", + "\n", + "for i in range(len(df)):\n", + " img = df['mri.data'].iloc[i]\n", + " ax[0,i].imshow(img)\n", + " ax[1,i].imshow(df[\"mricnn.saliency\"][i][0],cmap=plt.cm.hot)\n", + " ax[0,i].axis('off')\n", + " ax[1,i].axis('off')\n", + "plt.gcf().set_size_inches(5, 5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jRmVDb1oiMI6" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.9 (v3.10.9:1dd9be6584, Dec 6 2022, 14:37:36) [Clang 13.0.0 (clang-1300.0.29.30)]" + }, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 483ea5007b22add5e788b7dbc9580252dc9004ab Mon Sep 17 00:00:00 2001 From: vivek-mandal Date: Sat, 17 Jun 2023 16:12:39 +0530 Subject: [PATCH 3/5] Added Streamlit App for youtube Q and A --- apps/youtube_qa/README_StreamliteApp.md | 26 +++ apps/youtube_qa/requirements.txt | 3 +- apps/youtube_qa/youtube_streamlit_app.py | 276 +++++++++++++++++++++++ setup.py | 1 + 4 files changed, 305 insertions(+), 1 deletion(-) create mode 100644 apps/youtube_qa/README_StreamliteApp.md create mode 100644 apps/youtube_qa/youtube_streamlit_app.py diff --git a/apps/youtube_qa/README_StreamliteApp.md b/apps/youtube_qa/README_StreamliteApp.md new file mode 100644 index 000000000..63110d099 --- /dev/null +++ b/apps/youtube_qa/README_StreamliteApp.md @@ -0,0 +1,26 @@ +# YouTube Question Answering + +## Overview +This app lets you ask questions about any YouTube video. You will only need to supply a Youtube URL and an OpenAI API key. + +This app is powered by EvaDB's Python API and ChatGPT UDF. + +## Setup +Ensure that the local Python version is >= 3.8. Install the required libraries: + +```bat +pip install -r requirements.txt +``` + +## Enter Your OpenAPI Key +```bat +Please set your OpenAI API key in evadb.yml file (third_party, open_api_key) or environment variable (OPENAI_KEY) +``` + +## Usage +Run script: +```bat +streamlit run youtube_streamlit_app.py +``` + +## Example diff --git a/apps/youtube_qa/requirements.txt b/apps/youtube_qa/requirements.txt index ee4c79a90..fb6088a26 100644 --- a/apps/youtube_qa/requirements.txt +++ b/apps/youtube_qa/requirements.txt @@ -1,3 +1,4 @@ evadb[document] pytube -youtube_transcript_api \ No newline at end of file +youtube_transcript_api +streamlit \ No newline at end of file diff --git a/apps/youtube_qa/youtube_streamlit_app.py b/apps/youtube_qa/youtube_streamlit_app.py new file mode 100644 index 000000000..ac775950f --- /dev/null +++ b/apps/youtube_qa/youtube_streamlit_app.py @@ -0,0 +1,276 @@ +# from evadb.configuration.configuration_manager import ConfigurationManager +import streamlit as st + +import os +import shutil +import time + +import pandas as pd +from evadb.configuration.configuration_manager import ConfigurationManager + +import evadb + + +def try_to_import_pytube(): + try: + import pytube # noqa: F401 + except ImportError: + raise ValueError( + """Could not import pytube python package. + Please install it with `pip install -r requirements.txt`.""" + ) + + +try_to_import_pytube() + +from pytube import YouTube, extract # noqa: E402 +from youtube_transcript_api import YouTubeTranscriptApi # noqa: E402 + +MAX_CHUNK_SIZE = 5000 +DEFAULT_VIDEO_LINK = "https://www.youtube.com/watch?v=TvS1lHEQoKk" + + + +os.environ['OPENAI_API_KEY'] = ConfigurationManager().get_value("third_party", "OPENAI_KEY") + + + +def try_to_import_pytube(): + try: + import pytube # noqa: F401 + except ImportError: + raise ValueError( + """Could not import pytube python package. + Please install it with `pip install -r requirements.txt`.""" + ) + + +try_to_import_pytube() + +from pytube import YouTube, extract # noqa: E402 +from youtube_transcript_api import YouTubeTranscriptApi # noqa: E402 + +MAX_CHUNK_SIZE = 5000 +DEFAULT_VIDEO_LINK = "https://www.youtube.com/watch?v=TvS1lHEQoKk" + + +def partition_transcript(raw_transcript: str): + """Group video transcript elements when they are too large. + + Args: + transcript (str): downloaded video transcript as a raw string. + + Returns: + List: a list of partitioned transcript + """ + if len(raw_transcript) <= MAX_CHUNK_SIZE: + return [{"text": raw_transcript}] + + k = 2 + while True: + if (len(raw_transcript) / k) <= MAX_CHUNK_SIZE: + break + else: + k += 1 + chunk_size = int(len(raw_transcript) / k) + + partitioned_transcript = [ + {"text": raw_transcript[i : i + chunk_size]} + for i in range(0, len(raw_transcript), chunk_size) + ] + if len(partitioned_transcript[-1]["text"]) < 30: + partitioned_transcript.pop() + return partitioned_transcript + + +def group_transcript(transcript: dict): + """Group video transcript elements when they are too short. + + Args: + transcript (dict): downloaded video transcript as a dictionary. + + Returns: + List: a list of partitioned transcript + """ + grouped_transcript = [] + new_line = "" + for line in transcript: + if len(new_line) <= MAX_CHUNK_SIZE: + new_line += line["text"] + else: + grouped_transcript.append({"text": new_line}) + new_line = "" + + if grouped_transcript == []: + return [{"text": new_line}] + return grouped_transcript + + +def download_youtube_video_transcript(video_link: str): + """Downloads a YouTube video's transcript. + + Args: + video_link (str): url of the target YouTube video. + """ + start = time.time() + video_id = extract.video_id(video_link) + print("Transcript download in progress...") + transcript = YouTubeTranscriptApi.get_transcript(video_id) + print(f"Video transcript downloaded successfully in {time.time() - start} seconds") + return transcript + + +def download_youtube_video_from_link(video_link: str): + """Downloads a YouTube video from url. + + Args: + video_link (str): url of the target YouTube video. + """ + start = time.time() + yt = ( + YouTube(video_link) + .streams.filter(file_extension="mp4", progressive="True") + .first() + ) + try: + print("Video download in progress...") + yt.download(filename="online_video.mp4") + except Exception as e: + print(f"Video download failed with error: \n{e}") + print(f"Video downloaded successfully in {time.time() - start} seconds") + + +def generate_online_video_transcript(cursor) -> str: + """Extracts speech from video for llm processing. + + Args: + cursor (EVADBCursor): evadb api cursor. + + Returns: + str: video transcript text. + """ + print("Analyzing video. This may take a while...") + start = time.time() + + # bootstrap speech analyzer udf and chatgpt udf for analysis + args = {"task": "automatic-speech-recognition", "model": "openai/whisper-base"} + speech_analyzer_udf_rel = cursor.create_udf( + "SpeechRecognizer", type="HuggingFace", **args + ) + speech_analyzer_udf_rel.execute() + + # load youtube video into an evadb table + cursor.query("""DROP TABLE IF EXISTS youtube_video;""").execute() + cursor.load("online_video.mp4", "youtube_video", "video").execute() + + # extract speech texts from videos + cursor.query( + "CREATE TABLE IF NOT EXISTS youtube_video_text AS SELECT SpeechRecognizer(audio) FROM youtube_video;" + ).execute() + print(f"Video transcript generated in {time.time() - start} seconds.") + + raw_transcript_string = ( + cursor.table("youtube_video_text") + .select("text") + .df()["youtube_video_text.text"][0] + ) + return raw_transcript_string + + +def cleanup(): + """Removes any temporary file / directory created by EvaDB.""" + if os.path.exists("online_video.mp4"): + os.remove("online_video.mp4") + if os.path.exists("transcript.csv"): + os.remove("transcript.csv") + if os.path.exists("evadb_data"): + shutil.rmtree("evadb_data") + + + +# App Framework +if __name__ == "__main__": + + st.title('Enter Youtube Video Link Here') + video_link = st.text_input('Plug in your video link here ') + + + # Display if there's a prompt + if video_link: + # title = title_chain.run(prompt) + # wiki_research = wiki.run(prompt) + # script = script_chain.run(title=title, wikipedia_research=wiki_research) + + # st.write(title) + # st.write(script) + + transcript = None + try: + transcript = download_youtube_video_transcript(video_link) + print(transcript) + except Exception as e: + print(e) + print( + "Failed to download video transcript. Downloading video and generate transcript from video instead..." + ) + + try: + # establish evadb api cursor + cursor = evadb.connect().cursor() + if transcript is not None: + grouped_transcript = group_transcript(transcript) + df = pd.DataFrame(grouped_transcript) + df.to_csv("transcript.csv") + else: + # download youtube video online if the video disabled transcript + download_youtube_video_from_link(video_link) + + # generate video transcript + raw_transcript_string = generate_online_video_transcript(cursor) + partitioned_transcript = partition_transcript(raw_transcript_string) + df = pd.DataFrame(partitioned_transcript) + df.to_csv("transcript.csv") + + # load chunked transcript into table + cursor.query("""DROP TABLE IF EXISTS Transcript;""").execute() + cursor.query( + """CREATE TABLE IF NOT EXISTS Transcript (text TEXT(50));""" + ).execute() + cursor.load("transcript.csv", "Transcript", "csv").execute() + print("===========================================") + print("Ask anything about the video!") + ready = True + # while ready: + # question = str(input("Question (enter 'exit' to exit): ")) + st.title('Ask Anything About the Video') + question = st.text_input("Question (enter 'exit' to exit):") + if question.lower() == "exit": + ready = False + else: + # Generate response with chatgpt udf + print("Generating response...") + generate_chatgpt_response_rel = cursor.table("Transcript").select( + f"ChatGPT('{question} in 50 words', text)" + ) + start = time.time() + responses = generate_chatgpt_response_rel.df()["chatgpt.response"] + + response = "" + for r in responses: + response += f"{r} \n" + print(f"Answer (generated in {time.time() - start} seconds):") + print(response, "\n") + st.write("Answer ::") + st.write("{}\n".format(response)) + question = st.empty() + + cleanup() + print("Session ended.") + print("===========================================") + except Exception as e: + cleanup() + print("Session ended with an error.") + print(e) + print("===========================================") + + diff --git a/setup.py b/setup.py index 8a309869a..dc4eba725 100644 --- a/setup.py +++ b/setup.py @@ -49,6 +49,7 @@ def read(path, encoding="utf-8"): "aenum>=2.2.0", "diskcache>=5.4.0", "retry>=0.9.2", + "streamlit", ] vision_libs = [ From 6cd51f2905943453a56899b4f414e5a9f0aebe46 Mon Sep 17 00:00:00 2001 From: Vivek Mandal Date: Sat, 17 Jun 2023 16:14:46 +0530 Subject: [PATCH 4/5] Update README_StreamliteApp.md --- apps/youtube_qa/README_StreamliteApp.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/apps/youtube_qa/README_StreamliteApp.md b/apps/youtube_qa/README_StreamliteApp.md index 63110d099..fc39794be 100644 --- a/apps/youtube_qa/README_StreamliteApp.md +++ b/apps/youtube_qa/README_StreamliteApp.md @@ -24,3 +24,6 @@ streamlit run youtube_streamlit_app.py ``` ## Example + +YoutubeApp + From 0307d87d7e93d105db816b476ad882dc4d53d622 Mon Sep 17 00:00:00 2001 From: vivek-mandal Date: Sat, 17 Jun 2023 16:21:06 +0530 Subject: [PATCH 5/5] Removed non relavant commits --- tutorials/saliencyMaps/EVADB_Notebook.ipynb | 697 -------------------- tutorials/saliencyMaps/UDF.py | 76 --- tutorials/saliencyMaps/requirements.txt | 6 - tutorials/saliencyMaps/test1.jpeg | Bin 3848 -> 0 bytes tutorials/saliencyMaps/test2.jpeg | Bin 8518 -> 0 bytes 5 files changed, 779 deletions(-) delete mode 100644 tutorials/saliencyMaps/EVADB_Notebook.ipynb delete mode 100644 tutorials/saliencyMaps/UDF.py delete mode 100644 tutorials/saliencyMaps/requirements.txt delete mode 100644 tutorials/saliencyMaps/test1.jpeg delete mode 100644 tutorials/saliencyMaps/test2.jpeg diff --git a/tutorials/saliencyMaps/EVADB_Notebook.ipynb b/tutorials/saliencyMaps/EVADB_Notebook.ipynb deleted file mode 100644 index 2e09a524c..000000000 --- a/tutorials/saliencyMaps/EVADB_Notebook.ipynb +++ /dev/null @@ -1,697 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "DK4AwcI4gNCW", - "outputId": "75eea35b-6f23-4156-82fd-8c3a8d235222" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting evadb\n", - " Downloading evadb-0.1.4-py3-none-any.whl (435 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m435.8/435.8 KB\u001b[0m \u001b[31m11.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 2)) (1.4.4)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 3)) (1.22.4)\n", - "Requirement already satisfied: torch in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 4)) (1.13.1+cu116)\n", - "Requirement already satisfied: torchvision in /usr/local/lib/python3.9/dist-packages (from -r requirements.txt (line 5)) (0.14.1+cu116)\n", - "Collecting pydicom\n", - " Downloading pydicom-2.3.1-py3-none-any.whl (2.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m54.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting ray>=1.13.0\n", - " Downloading ray-2.3.1-cp39-cp39-manylinux2014_x86_64.whl (58.6 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.6/58.6 MB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: sqlalchemy<2.0.0,>=1.4.0 in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (1.4.47)\n", - "Collecting easyocr>=1.5.0\n", - " Downloading easyocr-1.6.2-py3-none-any.whl (2.9 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.9/2.9 MB\u001b[0m \u001b[31m63.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting detoxify\n", - " Downloading detoxify-0.5.1-py3-none-any.whl (12 kB)\n", - "Collecting opencv-python<4.6.0.66,>=4.5.4.60\n", - " Downloading opencv_python-4.5.5.64-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (60.5 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m60.5/60.5 MB\u001b[0m \u001b[31m10.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting aenum>=2.2.0\n", - " Downloading aenum-3.1.12-py3-none-any.whl (131 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m131.8/131.8 KB\u001b[0m \u001b[31m13.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting yolov5\n", - " Downloading yolov5-7.0.11-py37.py38.py39.py310-none-any.whl (956 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m956.3/956.3 KB\u001b[0m \u001b[31m51.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting faiss-cpu\n", - " Downloading faiss_cpu-1.7.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (17.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m17.0/17.0 MB\u001b[0m \u001b[31m65.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (6.0)\n", - "Requirement already satisfied: Pillow>=8.4.0 in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (8.4.0)\n", - "Collecting sqlalchemy-utils>=0.36.6\n", - " Downloading SQLAlchemy_Utils-0.40.0-py3-none-any.whl (92 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m92.5/92.5 KB\u001b[0m \u001b[31m10.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: ipython in /usr/local/lib/python3.9/dist-packages (from evadb->-r requirements.txt (line 1)) (7.34.0)\n", - "Collecting importlib-metadata<5.0\n", - " Downloading importlib_metadata-4.13.0-py3-none-any.whl (23 kB)\n", - "Collecting facenet-pytorch>=2.5.2\n", - " Downloading facenet_pytorch-2.5.2-py3-none-any.whl (1.9 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m62.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting lark>=1.0.0\n", - " Downloading lark-1.1.5-py3-none-any.whl (107 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m108.0/108.0 KB\u001b[0m \u001b[31m10.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from pandas->-r requirements.txt (line 2)) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/dist-packages (from pandas->-r requirements.txt (line 2)) (2022.7.1)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.9/dist-packages (from torch->-r requirements.txt (line 4)) (4.5.0)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.9/dist-packages (from torchvision->-r requirements.txt (line 5)) (2.27.1)\n", - "Requirement already satisfied: scikit-image in /usr/local/lib/python3.9/dist-packages (from easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (0.19.3)\n", - "Requirement already satisfied: Shapely in /usr/local/lib/python3.9/dist-packages (from easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (2.0.1)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.9/dist-packages (from easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (1.10.1)\n", - "Collecting pyclipper\n", - " Downloading pyclipper-1.3.0.post4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl (608 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m608.2/608.2 KB\u001b[0m \u001b[31m43.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting opencv-python-headless<=4.5.4.60\n", - " Downloading opencv_python_headless-4.5.4.60-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (47.6 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m47.6/47.6 MB\u001b[0m \u001b[31m15.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting python-bidi\n", - " Downloading python_bidi-0.4.2-py2.py3-none-any.whl (30 kB)\n", - "Collecting ninja\n", - " Downloading ninja-1.11.1-py2.py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (145 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m146.0/146.0 KB\u001b[0m \u001b[31m13.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata<5.0->evadb->-r requirements.txt (line 1)) (3.15.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.8.1->pandas->-r requirements.txt (line 2)) (1.16.0)\n", - "Collecting virtualenv>=20.0.24\n", - " Downloading virtualenv-20.21.0-py3-none-any.whl (8.7 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.7/8.7 MB\u001b[0m \u001b[31m18.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting frozenlist\n", - " Downloading frozenlist-1.3.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (158 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m158.8/158.8 KB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (3.10.7)\n", - "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (8.1.3)\n", - "Requirement already satisfied: jsonschema in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (4.3.3)\n", - "Collecting aiosignal\n", - " Downloading aiosignal-1.3.1-py3-none-any.whl (7.6 kB)\n", - "Requirement already satisfied: grpcio>=1.32.0 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (1.53.0)\n", - "Requirement already satisfied: attrs in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (22.2.0)\n", - "Requirement already satisfied: protobuf!=3.19.5,>=3.15.3 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (3.20.3)\n", - "Requirement already satisfied: msgpack<2.0.0,>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from ray>=1.13.0->evadb->-r requirements.txt (line 1)) (1.0.5)\n", - "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.9/dist-packages (from sqlalchemy<2.0.0,>=1.4.0->evadb->-r requirements.txt (line 1)) (2.0.2)\n", - "Collecting transformers==4.22.1\n", - " Downloading transformers-4.22.1-py3-none-any.whl (4.9 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.9/4.9 MB\u001b[0m \u001b[31m25.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting sentencepiece>=0.1.94\n", - " Downloading sentencepiece-0.1.97-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m29.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.9/dist-packages (from transformers==4.22.1->detoxify->evadb->-r requirements.txt (line 1)) (2022.10.31)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.9/dist-packages (from transformers==4.22.1->detoxify->evadb->-r requirements.txt (line 1)) (23.0)\n", - "Collecting tokenizers!=0.11.3,<0.13,>=0.11.1\n", - " Downloading tokenizers-0.12.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (6.6 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.6/6.6 MB\u001b[0m \u001b[31m27.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.9/dist-packages (from transformers==4.22.1->detoxify->evadb->-r requirements.txt (line 1)) (4.65.0)\n", - "Collecting huggingface-hub<1.0,>=0.9.0\n", - " Downloading huggingface_hub-0.13.3-py3-none-any.whl (199 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m199.8/199.8 KB\u001b[0m \u001b[31m14.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: decorator in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (4.4.2)\n", - "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (5.7.1)\n", - "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (3.0.38)\n", - "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (0.1.6)\n", - "Collecting jedi>=0.16\n", - " Downloading jedi-0.18.2-py2.py3-none-any.whl (1.6 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m31.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pygments in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (2.14.0)\n", - "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (67.6.1)\n", - "Requirement already satisfied: backcall in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (0.2.0)\n", - "Requirement already satisfied: pickleshare in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (0.7.5)\n", - "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.9/dist-packages (from ipython->evadb->-r requirements.txt (line 1)) (4.8.0)\n", - "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (2.0.12)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (2022.12.7)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (1.26.15)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests->torchvision->-r requirements.txt (line 5)) (3.4)\n", - "Collecting fire\n", - " Downloading fire-0.5.0.tar.gz (88 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.3/88.3 KB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "Collecting gitpython\n", - " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m14.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting boto3>=1.19.1\n", - " Downloading boto3-1.26.102-py3-none-any.whl (135 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m135.6/135.6 KB\u001b[0m \u001b[31m12.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: psutil in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (5.9.4)\n", - "Collecting sahi>=0.11.10\n", - " Downloading sahi-0.11.13-py3-none-any.whl (100 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.0/101.0 KB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: matplotlib>=3.2.2 in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (3.7.1)\n", - "Collecting roboflow>=0.2.29\n", - " Downloading roboflow-1.0.1-py3-none-any.whl (55 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.7/55.7 KB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: tensorboard>=2.4.1 in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (2.12.0)\n", - "Collecting thop>=0.1.1\n", - " Downloading thop-0.1.1.post2209072238-py3-none-any.whl (15 kB)\n", - "Requirement already satisfied: seaborn>=0.11.0 in /usr/local/lib/python3.9/dist-packages (from yolov5->evadb->-r requirements.txt (line 1)) (0.12.2)\n", - "Collecting jmespath<2.0.0,>=0.7.1\n", - " Downloading jmespath-1.0.1-py3-none-any.whl (20 kB)\n", - "Collecting s3transfer<0.7.0,>=0.6.0\n", - " Downloading s3transfer-0.6.0-py3-none-any.whl (79 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.6/79.6 KB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting botocore<1.30.0,>=1.29.102\n", - " Downloading botocore-1.29.102-py3-none-any.whl (10.6 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.6/10.6 MB\u001b[0m \u001b[31m53.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: parso<0.9.0,>=0.8.0 in /usr/local/lib/python3.9/dist-packages (from jedi>=0.16->ipython->evadb->-r requirements.txt (line 1)) (0.8.3)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (0.11.0)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (1.0.7)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (3.0.9)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (4.39.3)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (1.4.4)\n", - "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib>=3.2.2->yolov5->evadb->-r requirements.txt (line 1)) (5.12.0)\n", - "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.9/dist-packages (from pexpect>4.3->ipython->evadb->-r requirements.txt (line 1)) (0.7.0)\n", - "Requirement already satisfied: wcwidth in /usr/local/lib/python3.9/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython->evadb->-r requirements.txt (line 1)) (0.2.6)\n", - "Collecting python-dotenv\n", - " Downloading python_dotenv-1.0.0-py3-none-any.whl (19 kB)\n", - "Collecting wget\n", - " Downloading wget-3.2.zip (10 kB)\n", - " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "Collecting idna<4,>=2.5\n", - " Downloading idna-2.10-py2.py3-none-any.whl (58 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.8/58.8 KB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: chardet==4.0.0 in /usr/local/lib/python3.9/dist-packages (from roboflow>=0.2.29->yolov5->evadb->-r requirements.txt (line 1)) (4.0.0)\n", - "Collecting requests-toolbelt\n", - " Downloading requests_toolbelt-0.10.1-py2.py3-none-any.whl (54 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.5/54.5 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting pyparsing>=2.3.1\n", - " Downloading pyparsing-2.4.7-py2.py3-none-any.whl (67 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m67.8/67.8 KB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting cycler>=0.10\n", - " Downloading cycler-0.10.0-py2.py3-none-any.whl (6.5 kB)\n", - "Collecting terminaltables\n", - " Downloading terminaltables-3.1.10-py2.py3-none-any.whl (15 kB)\n", - "Collecting pybboxes==0.1.6\n", - " Downloading pybboxes-0.1.6-py3-none-any.whl (24 kB)\n", - "Collecting click>=7.0\n", - " Downloading click-8.0.4-py3-none-any.whl (97 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.5/97.5 KB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (1.4.0)\n", - "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (1.8.1)\n", - "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (2.2.3)\n", - "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.4.6)\n", - "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (2.17.0)\n", - "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.40.0)\n", - "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.7.0)\n", - "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.9/dist-packages (from tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (3.4.3)\n", - "Collecting distlib<1,>=0.3.6\n", - " Downloading distlib-0.3.6-py2.py3-none-any.whl (468 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m468.5/468.5 KB\u001b[0m \u001b[31m31.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: platformdirs<4,>=2.4 in /usr/local/lib/python3.9/dist-packages (from virtualenv>=20.0.24->ray>=1.13.0->evadb->-r requirements.txt (line 1)) (3.2.0)\n", - "Requirement already satisfied: termcolor in /usr/local/lib/python3.9/dist-packages (from fire->yolov5->evadb->-r requirements.txt (line 1)) (2.2.0)\n", - "Collecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.9/dist-packages (from jsonschema->ray>=1.13.0->evadb->-r requirements.txt (line 1)) (0.19.3)\n", - "Requirement already satisfied: PyWavelets>=1.1.1 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (1.4.1)\n", - "Requirement already satisfied: tifffile>=2019.7.26 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (2023.3.21)\n", - "Requirement already satisfied: networkx>=2.2 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (3.0)\n", - "Requirement already satisfied: imageio>=2.4.1 in /usr/local/lib/python3.9/dist-packages (from scikit-image->easyocr>=1.5.0->evadb->-r requirements.txt (line 1)) (2.25.1)\n", - "Collecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (5.3.0)\n", - "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.2.8)\n", - "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (4.9)\n", - "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.9/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (1.3.1)\n", - "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.9/dist-packages (from werkzeug>=1.0.1->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (2.1.2)\n", - "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.9/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (0.4.8)\n", - "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.9/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.4.1->yolov5->evadb->-r requirements.txt (line 1)) (3.2.2)\n", - "Building wheels for collected packages: fire, wget\n", - " Building wheel for fire (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for fire: filename=fire-0.5.0-py2.py3-none-any.whl size=116952 sha256=eb5dfa686699b199e7cca080b76d67baa9f47f34485603c8bfc3d253ec2611db\n", - " Stored in directory: /root/.cache/pip/wheels/f7/f1/89/b9ea2bf8f80ec027a88fef1d354b3816b4d3d29530988972f6\n", - " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9676 sha256=1b81a63c6b01489b7d99c71a0cad2f5fdbff17e9d94de3304ae27e5ae53ec303\n", - " Stored in directory: /root/.cache/pip/wheels/04/5f/3e/46cc37c5d698415694d83f607f833f83f0149e49b3af9d0f38\n", - "Successfully built fire wget\n", - "Installing collected packages: wget, tokenizers, sentencepiece, pyclipper, ninja, lark, faiss-cpu, distlib, aenum, virtualenv, terminaltables, smmap, python-dotenv, python-bidi, pyparsing, pydicom, pybboxes, opencv-python-headless, opencv-python, jmespath, jedi, importlib-metadata, idna, frozenlist, fire, cycler, click, thop, sqlalchemy-utils, gitdb, botocore, aiosignal, sahi, s3transfer, requests-toolbelt, ray, huggingface-hub, gitpython, transformers, roboflow, facenet-pytorch, easyocr, boto3, detoxify, yolov5, evadb\n", - " Attempting uninstall: pyparsing\n", - " Found existing installation: pyparsing 3.0.9\n", - " Uninstalling pyparsing-3.0.9:\n", - " Successfully uninstalled pyparsing-3.0.9\n", - " Attempting uninstall: opencv-python-headless\n", - " Found existing installation: opencv-python-headless 4.7.0.72\n", - " Uninstalling opencv-python-headless-4.7.0.72:\n", - " Successfully uninstalled opencv-python-headless-4.7.0.72\n", - " Attempting uninstall: opencv-python\n", - " Found existing installation: opencv-python 4.7.0.72\n", - " Uninstalling opencv-python-4.7.0.72:\n", - " Successfully uninstalled opencv-python-4.7.0.72\n", - " Attempting uninstall: importlib-metadata\n", - " Found existing installation: importlib-metadata 6.1.0\n", - " Uninstalling importlib-metadata-6.1.0:\n", - " Successfully uninstalled importlib-metadata-6.1.0\n", - " Attempting uninstall: idna\n", - " Found existing installation: idna 3.4\n", - " Uninstalling idna-3.4:\n", - " Successfully uninstalled idna-3.4\n", - " Attempting uninstall: cycler\n", - " Found existing installation: cycler 0.11.0\n", - " Uninstalling cycler-0.11.0:\n", - " Successfully uninstalled cycler-0.11.0\n", - " Attempting uninstall: click\n", - " Found existing installation: click 8.1.3\n", - " Uninstalling click-8.1.3:\n", - " Successfully uninstalled click-8.1.3\n", - "Successfully installed aenum-3.1.12 aiosignal-1.3.1 boto3-1.26.102 botocore-1.29.102 click-8.0.4 cycler-0.10.0 detoxify-0.5.1 distlib-0.3.6 easyocr-1.6.2 evadb-0.1.4 facenet-pytorch-2.5.2 faiss-cpu-1.7.3 fire-0.5.0 frozenlist-1.3.3 gitdb-4.0.10 gitpython-3.1.31 huggingface-hub-0.13.3 idna-2.10 importlib-metadata-4.13.0 jedi-0.18.2 jmespath-1.0.1 lark-1.1.5 ninja-1.11.1 opencv-python-4.5.5.64 opencv-python-headless-4.5.4.60 pybboxes-0.1.6 pyclipper-1.3.0.post4 pydicom-2.3.1 pyparsing-2.4.7 python-bidi-0.4.2 python-dotenv-1.0.0 ray-2.3.1 requests-toolbelt-0.10.1 roboflow-1.0.1 s3transfer-0.6.0 sahi-0.11.13 sentencepiece-0.1.97 smmap-5.0.0 sqlalchemy-utils-0.40.0 terminaltables-3.1.10 thop-0.1.1.post2209072238 tokenizers-0.12.1 transformers-4.22.1 virtualenv-20.21.0 wget-3.2 yolov5-7.0.11\n" - ] - }, - { - "data": { - "application/vnd.colab-display-data+json": { - "pip_warning": { - "packages": [ - "cycler", - "pyparsing" - ] - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# !pip install -r requirements.txt" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "xaqSm-DUgN3c", - "outputId": "0b8fb001-bea9-4070-9bb2-59388c0648cb" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2023-03-30 17:14:14-- https://raw.githubusercontent.com/georgia-tech-db/eva/master/tutorials/00-start-eva-server.ipynb\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.109.133, 185.199.111.133, 185.199.110.133, ...\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.109.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 3971 (3.9K) [text/plain]\n", - "Saving to: ‘00-start-eva-server.ipynb’\n", - "\n", - "00-start-eva-server 100%[===================>] 3.88K --.-KB/s in 0s \n", - "\n", - "2023-03-30 17:14:14 (47.3 MB/s) - ‘00-start-eva-server.ipynb’ saved [3971/3971]\n", - "\n", - "nohup eva_server >> eva.log 2>&1 &\n" - ] - } - ], - "source": [ - "!wget -nc \"https://raw.githubusercontent.com/georgia-tech-db/eva/master/tutorials/00-start-eva-server.ipynb\"\n", - "!wget -nc \"https://www.dropbox.com/s/cnsgyitrtw40lgs/model.pth?dl=0\"\n", - "%run 00-start-eva-server.ipynb\n", - "cursor = connect_to_server()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "tL9hLo2ug52e", - "outputId": "9e01f4be-e5cc-429b-e016-814da5cca05d" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "@status: ResponseStatus.SUCCESS\n", - "@batch: \n", - " 0\n", - "0 Table Successfully dropped: MRI\n", - "@query_time: 0.07096198499993989\n", - "@status: ResponseStatus.SUCCESS\n", - "@batch: \n", - " 0\n", - "0 Number of loaded IMAGE: 1\n", - "@query_time: 0.15114561900008994\n", - "@status: ResponseStatus.SUCCESS\n", - "@batch: \n", - " 0\n", - "0 Number of loaded IMAGE: 1\n", - "@query_time: 0.027401803999964613\n" - ] - } - ], - "source": [ - "cursor.execute(\"DROP TABLE MRI;\")\n", - "response = cursor.fetch_all()\n", - "print(response)\n", - "cursor.execute(\"LOAD IMAGE 'test2.jpeg' INTO MRI;\")\n", - "response = cursor.fetch_all()\n", - "print(response)\n", - "cursor.execute(\"LOAD IMAGE 'test1.jpeg' INTO MRI;\")\n", - "response = cursor.fetch_all()\n", - "print(response)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "nn02z2PXhLZs", - "outputId": "eb43ae3c-18c4-43ba-98d5-ffe8843239e6" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "@status: ResponseStatus.SUCCESS\n", - "@batch: \n", - " 0\n", - "0 UDF MRICNN successfully dropped\n", - "@query_time: 0.027917190000152914\n", - "@status: ResponseStatus.SUCCESS\n", - "@batch: \n", - " 0\n", - "0 UDF MRICNN successfully added to the database.\n", - "@query_time: 0.5369972539997434\n" - ] - } - ], - "source": [ - "cursor.execute(\"\"\"DROP UDF MRICNN;\"\"\")\n", - "response = cursor.fetch_all()\n", - "print(response)\n", - "\n", - "cursor.execute(\"\"\"CREATE UDF IF NOT EXISTS \n", - " MRICNN\n", - " INPUT (data NDARRAY UINT8(3, 224, 224)) \n", - " OUTPUT (saliency ANYTYPE) \n", - " TYPE Classification \n", - " IMPL 'UDF.py';\n", - " \"\"\")\n", - "response = cursor.fetch_all()\n", - "print(response)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "VfWK6vlXhPzd", - "outputId": "c0d781a4-7613-4015-c615-7c38dc9fe408" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " mri.data \\\n", - "0 [[[13 31 30]\\n [16 34 33]\\n [20 34 33]\\n [28 42 41]\\n [17 29 29]\\n [20 32 32]\\n [12 22 22]\\n [25... \n", - "1 [[[0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0 0]\\n [0 0... \n", - "\n", - " mricnn.saliency \n", - "0 [tensor([[0.0005, 0.0003, 0.0004, ..., 0.0035, 0.0042, 0.0036],\\n [0.0013, 0.0011, 0.002... \n", - "1 [tensor([[0.0020, 0.0017, 0.0008, ..., 0.0002, 0.0000, 0.0000],\\n [0.0036, 0.0035, 0.001... \n" - ] - } - ], - "source": [ - "cursor.execute(\"\"\"SELECT data, MRICNN(data)\n", - " FROM MRI\n", - " \"\"\")\n", - "response = cursor.fetch_all()\n", - "print(response.batch)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 112 - }, - "id": "J4JHTIW7hTpA", - "outputId": "6964739c-0fc5-4f28-c974-77888c73a074" - }, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
mri.datamricnn.saliency
0[[[13, 31, 30], [16, 34, 33], [20, 34, 33], [2...[[[tensor(0.0005), tensor(0.0003), tensor(0.00...
1[[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], ...[[[tensor(0.0020), tensor(0.0017), tensor(0.00...
\n", - "
\n", - " \n", - " \n", - " \n", - "\n", - " \n", - "
\n", - "
\n", - " " - ], - "text/plain": [ - " mri.data \\\n", - "0 [[[13, 31, 30], [16, 34, 33], [20, 34, 33], [2... \n", - "1 [[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], ... \n", - "\n", - " mricnn.saliency \n", - "0 [[[tensor(0.0005), tensor(0.0003), tensor(0.00... \n", - "1 [[[tensor(0.0020), tensor(0.0017), tensor(0.00... " - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = response.batch.frames\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Bb-fkO86haib", - "outputId": "eb2e5db8-3494-4447-bab1-329984f4a838" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[[0.0005, 0.0003, 0.0004, ..., 0.0035, 0.0042, 0.0036],\n", - " [0.0013, 0.0011, 0.0022, ..., 0.0066, 0.0100, 0.0091],\n", - " [0.0006, 0.0020, 0.0040, ..., 0.0175, 0.0233, 0.0203],\n", - " ...,\n", - " [0.0005, 0.0004, 0.0010, ..., 0.0035, 0.0008, 0.0015],\n", - " [0.0002, 0.0002, 0.0005, ..., 0.0023, 0.0007, 0.0008],\n", - " [0.0001, 0.0005, 0.0001, ..., 0.0022, 0.0003, 0.0006]]])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df[\"mricnn.saliency\"][0]" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 422 - }, - "id": "AStT5LRGhuFb", - "outputId": "18f5f76d-4a13-48b3-d650-228fd6df901c" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import torch \n", - "df = response.batch.frames\n", - "fig, ax = plt.subplots(nrows=2, ncols=len(df), figsize=[15,18])\n", - "\n", - "for i in range(len(df)):\n", - " img = df['mri.data'].iloc[i]\n", - " ax[0,i].imshow(img)\n", - " ax[1,i].imshow(df[\"mricnn.saliency\"][i][0],cmap=plt.cm.hot)\n", - " ax[0,i].axis('off')\n", - " ax[1,i].axis('off')\n", - "plt.gcf().set_size_inches(5, 5)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "jRmVDb1oiMI6" - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "name": "python", - "version": "3.10.9 (v3.10.9:1dd9be6584, Dec 6 2022, 14:37:36) [Clang 13.0.0 (clang-1300.0.29.30)]" - }, - "vscode": { - "interpreter": { - "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" - } - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/tutorials/saliencyMaps/UDF.py b/tutorials/saliencyMaps/UDF.py deleted file mode 100644 index ae2fc161e..000000000 --- a/tutorials/saliencyMaps/UDF.py +++ /dev/null @@ -1,76 +0,0 @@ -from typing import List - -import pandas as pd -import numpy as np -import os -import torchvision -import torch -import torch.nn as nn -import torch.nn.functional as F - - -from eva.models.catalog.frame_info import FrameInfo -from eva.models.catalog.properties import ColorSpace -from eva.udfs.abstract.pytorch_abstract_udf import PytorchAbstractClassifierUDF -from torch import Tensor -from torchvision import models -from torchvision.transforms import Compose, ToTensor, Resize -from PIL import Image - - -class MRICNN(PytorchAbstractClassifierUDF): - - @property - def name(self) -> str: - return "MRICNN" - - def setup(self): - # !wget -nc "https://www.dropbox.com/s/cnsgyitrtw40lgs/model.pth?dl=0" - # to get the model from the dropbox - self.model = torchvision.models.resnet18(pretrained=True) - num_features = self.model.fc.in_features - self.model.fc = nn.Linear(num_features, 2) # binary classification (num_of_class == 2) - device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - model_state = torch.load("model.pth", map_location=device) - self.model.load_state_dict(model_state) - self.model.eval() - - @property - def input_format(self) -> FrameInfo: - return FrameInfo(-1, -1, 3, ColorSpace.RGB) - - @property - def labels(self) -> List[str]: - return [ - '0', '1' - ] - - def transform(self, images) -> Compose: - composed = Compose([ - Resize((224, 224)), - ToTensor() - ]) - # reverse the channels from opencv - return composed(Image.fromarray(images[:, :, ::-1])).unsqueeze(0) - - def forward(self, frames: Tensor) -> pd.DataFrame: - """ - Performs predictions on input frames - Arguments: - frames (np.ndarray): Frames on which predictions need - to be performed - - Returns: - tuple containing predicted_classes (List[str]) - """ - outcome = pd.DataFrame() - frames.requires_grad_() - outputs = self.model(frames) - score_max_index = outputs.argmax() - score_max = outputs[0,score_max_index] - score_max.backward() - saliency, _ = torch.max(frames.grad.data.abs(),dim=1) - - outcome = outcome.append({"saliency" : saliency}, ignore_index=True) - - return outcome diff --git a/tutorials/saliencyMaps/requirements.txt b/tutorials/saliencyMaps/requirements.txt deleted file mode 100644 index e90e42e81..000000000 --- a/tutorials/saliencyMaps/requirements.txt +++ /dev/null @@ -1,6 +0,0 @@ -evadb -pandas -numpy -torch -torchvision -pydicom \ No newline at end of file diff --git a/tutorials/saliencyMaps/test1.jpeg b/tutorials/saliencyMaps/test1.jpeg deleted file mode 100644 index d820352f59a309b3715e25936b9b31ca7c28cd5b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3848 zcmb7`c{tSV+s40RjIoZf@0tk_581bgW+MACWGGu9jP+p{yJShFl6_4Lvdv^EGe)EZ zh3r{kNVa5;lBGxH*YiBb`yTK6{`a2u=a1{S?)y6L`>*>rnG?)e0B&JoZUTTn008>E z0Ok~s0&uWF1^D@e1O)hng@r^!MMQ)}MTCS!eoIK`cO@h)Dk`Ob5EYk`5)wkHA>~dg zsi>%k9MjO%P}WgUR#5_Ra&kf-5ZG^ Y{@-H00{Ga09-tNsIu5Y#fxvtqW+xy4 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 diff --git a/tutorials/saliencyMaps/test2.jpeg b/tutorials/saliencyMaps/test2.jpeg deleted file mode 100644 index b8862ffb96f629715e9cfa596c7e7e9f0d8de96b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8518 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