[Demo Gradio] Add to Huggingface Space

AUTHORS.rst

@@ -0,0 +1,13 @@
+=======
+Credits
+=======
+
+Development Lead
+----------------
+
+* Full name of the author <Email of the author>
+
+Contributors
+------------
+
+None yet. Why not be the first?

README.md

@@ -1,12 +1,3 @@
----
-title: Table Extraction
-emoji: 🔥
-colorFrom: purple
-colorTo: purple
-sdk: gradio
-sdk_version: 3.28.1
-app_file: app.py
-pinned: false
----
+# huggingface-space
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Base structure for Deep learning project

app.py

@@ -0,0 +1,9 @@
+import gradio as gr
+
+
+def greet(name):
+    return "Hello " + name + "!!"
+
+
+iface = gr.Interface(fn=greet, inputs="text", outputs="text")
+iface.launch()

components/callbacks.py

@@ -0,0 +1,4 @@
+# Define callbacks here
+from pytorch_lightning.callbacks import EarlyStopping
+
+early_stopping = EarlyStopping(monitor="loss", min_delta=0, patience=3)

components/data_module.py

@@ -0,0 +1,81 @@
+from typing import Callable, List, Optional, Union
+
+import torch
+from pytorch_lightning import LightningDataModule
+from torch.utils.data import DataLoader, Dataset
+
+
+class SampleDataset(Dataset):
+
+    def __init__(self,
+                 x: Union[List, torch.Tensor],
+                 y: Union[List, torch.Tensor],
+                 transforms: Optional[Callable] = None) -> None:
+        super(SampleDataset, self).__init__()
+        self.x = x
+        self.y = y
+
+        if transforms is None:
+            # Replace None with some default transforms
+            # If image, could be an Resize and ToTensor
+            self.transforms = lambda x: x
+        else:
+            self.transforms = transforms
+
+    def __len__(self):
+        return len(self.x)
+
+    def __getitem__(self, index: int):
+        x = self.x[index]
+        y = self.y[index]
+
+        x = self.transforms(x)
+        return x, y
+
+
+class SampleDataModule(LightningDataModule):
+
+    def __init__(self,
+                 x: Union[List, torch.Tensor],
+                 y: Union[List, torch.Tensor],
+                 transforms: Optional[Callable] = None,
+                 val_ratio: float = 0,
+                 batch_size: int = 32) -> None:
+        super(SampleDataModule, self).__init__()
+        assert 0 <= val_ratio < 1
+        assert isinstance(batch_size, int)
+        self.x = x
+        self.y = y
+
+        self.transforms = transforms
+        self.val_ratio = val_ratio
+        self.batch_size = batch_size
+
+        self.setup()
+        self.prepare_data()
+
+    def setup(self, stage: Optional[str] = None) -> None:
+        pass
+
+    def prepare_data(self) -> None:
+        n_samples: int = len(self.x)
+        train_size: int = n_samples - int(n_samples * self.val_ratio)
+
+        self.train_dataset = SampleDataset(x=self.x[:train_size],
+                                           y=self.y[:train_size],
+                                           transforms=self.transforms)
+        if train_size < n_samples:
+            self.val_dataset = SampleDataset(x=self.x[train_size:],
+                                             y=self.y[train_size:],
+                                             transforms=self.transforms)
+        else:
+            self.val_dataset = SampleDataset(x=self.x[-self.batch_size:],
+                                             y=self.y[-self.batch_size:],
+                                             transforms=self.transforms)
+
+    def train_dataloader(self) -> DataLoader:
+        return DataLoader(dataset=self.train_dataset,
+                          batch_size=self.batch_size)
+
+    def val_dataloader(self) -> DataLoader:
+        return DataLoader(dataset=self.val_dataset, batch_size=self.batch_size)

config.py

@@ -0,0 +1,3 @@
+from dynaconf import Dynaconf
+
+CFG = Dynaconf(envvar_prefix="DYNACONF", settings_files=["config/config.yaml"])

docker-compose.yml

@@ -0,0 +1,23 @@
+version: "3.7"
+
+services:
+  model_name:
+    build:
+      context: .
+      dockerfile: .docker/Dockerfile
+    container_name: model_name
+    ports:
+      - "8996:8996"
+    env_file:
+      - ./.env
+    volumes:
+      - ./data:/home/working/data:ro
+
+    # This part is used to enable GPU support
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [ gpu ]

models/base_model/classification.py

@@ -0,0 +1,63 @@
+from abc import abstractmethod
+from typing import Any, Dict, List
+
+import torch
+from pytorch_lightning import LightningModule
+from torch import Tensor
+
+
+class LightningClassification(LightningModule):
+
+    @abstractmethod
+    def __init__(self, *args, **kwargs) -> None:
+        super(LightningClassification, self).__init__(*args, **kwargs)
+        self.train_batch_output: List[Dict] = []
+        self.validation_batch_output: List[Dict] = []
+        self.log_value_list: List[str] = ['loss', 'f1', 'precision', 'recall']
+
+    @abstractmethod
+    def forward(self, *args, **kwargs) -> Any:
+        pass
+
+    @abstractmethod
+    def configure_optimizers(self):
+        pass
+
+    @abstractmethod
+    def loss(self, input: Tensor, target: Tensor, **kwargs) -> Tensor:
+        pass
+
+    @abstractmethod
+    def training_step(self, batch, batch_idx):
+        pass
+
+    def __average(self, key: str, outputs: List[Dict]) -> Tensor:
+        target_arr = torch.Tensor([val[key] for val in outputs]).float()
+        return target_arr.mean()
+
+    @torch.no_grad()
+    def on_train_epoch_start(self) -> None:
+        self.train_batch_output = []
+
+    @torch.no_grad()
+    def on_train_epoch_end(self) -> None:
+        for key in self.log_value_list:
+            val = self.__average(key=key, outputs=self.train_batch_output)
+            log_name = f"training/{key}"
+            self.log(name=log_name, value=val)
+
+    @abstractmethod
+    @torch.no_grad()
+    def validation_step(self, batch, batch_idx):
+        pass
+
+    @torch.no_grad()
+    def on_validation_epoch_start(self) -> None:
+        self.validation_batch_output = []
+
+    @torch.no_grad()
+    def on_validation_epoch_end(self) -> None:
+        for key in self.log_value_list:
+            val = self.__average(key=key, outputs=self.validation_batch_output)
+            log_name = f"val/{key}"
+            self.log(name=log_name, value=val)

models/base_model/regression.py

@@ -0,0 +1,55 @@
+from abc import abstractmethod
+from typing import Any, Dict, List
+
+import torch
+from pytorch_lightning import LightningModule
+from torch import Tensor
+
+
+class LightningRegression(LightningModule):
+
+    @abstractmethod
+    def __init__(self, *args, **kwargs) -> None:
+        super(LightningRegression, self).__init__(*args, **kwargs)
+        self.train_step_output: List[Dict] = []
+        self.validation_step_output: List[Dict] = []
+        self.log_value_list: List[str] = ['loss', 'mse', 'mape']
+
+    @abstractmethod
+    def forward(self, *args, **kwargs) -> Any:
+        pass
+
+    @abstractmethod
+    def configure_optimizers(self):
+        pass
+
+    @abstractmethod
+    def loss(self, input: Tensor, output: Tensor, **kwargs):
+        return 0
+
+    @abstractmethod
+    def training_step(self, batch, batch_idx):
+        pass
+
+    def __average(self, key: str, outputs: List[Dict]) -> Tensor:
+        target_arr = torch.Tensor([val[key] for val in outputs]).float()
+        return target_arr.mean()
+
+    @torch.no_grad()
+    def on_train_epoch_end(self) -> None:
+        for key in self.log_value_list:
+            val = self.__average(key=key, outputs=self.train_step_output)
+            log_name = f"training/{key}"
+            self.log(name=log_name, value=val)
+
+    @torch.no_grad()
+    @abstractmethod
+    def validation_step(self, batch, batch_idx):
+        pass
+
+    @torch.no_grad()
+    def validation_epoch_end(self, outputs):
+        for key in self.log_value_list:
+            val = self.__average(key=key, outputs=self.validation_step_output)
+            log_name = f"training/{key}"
+            self.log(name=log_name, value=val)

models/metrics/classification.py

@@ -0,0 +1,44 @@
+from typing import Dict
+
+import torch
+from torchmetrics import functional as FM
+
+
+def classification_metrics(
+        preds: torch.Tensor,
+        target: torch.Tensor,
+        num_classes: int,
+        average: str = 'macro',
+        task: str = 'multiclass') -> Dict[str, torch.Tensor]:
+    """
+    get_classification_metrics
+    Return some metrics evaluation the classification task
+
+    Parameters
+    ----------
+    preds : torch.Tensor
+        logits, probs
+    target : torch.Tensor
+        targets label
+
+    Returns
+    -------
+    Dict[str, torch.Tensor]
+        _description_
+    """
+    f1 = FM.f1_score(preds=preds,
+                     target=target,
+                     num_classes=num_classes,
+                     task=task,
+                     average=average)
+    recall = FM.recall(preds=preds,
+                       target=target,
+                       num_classes=num_classes,
+                       task=task,
+                       average=average)
+    precision = FM.precision(preds=preds,
+                             target=target,
+                             num_classes=num_classes,
+                             task=task,
+                             average=average)
+    return dict(f1=f1, precision=precision, recall=recall)

models/metrics/regression.py

@@ -0,0 +1,28 @@
+from typing import Dict
+
+import torch
+from torchmetrics import functional as FM
+
+
+def regression_metrics(preds: torch.Tensor,
+                       target: torch.Tensor) -> Dict[str, torch.Tensor]:
+    """
+    get_classification_metrics
+    Return some metrics evaluation the classification task
+
+    Parameters
+    ----------
+    preds : torch.Tensor
+        logits, probs
+    target : torch.Tensor
+        targets label
+
+    Returns
+    -------
+    Dict[str, torch.Tensor]
+        _description_
+    """
+    mse: torch.Tensor = FM.mean_squared_error(preds=preds, target=target)
+    mape: torch.Tensor = FM.mean_absolute_percentage_error(preds=preds,
+                                                           target=target)
+    return dict(mse=mse, mape=mape)

models/model_lit.py

@@ -0,0 +1,50 @@
+from torch import Tensor, nn, optim
+from torch.nn import functional as F
+
+from .base_model.classification import LightningClassification
+from .metrics.classification import classification_metrics
+from .modules.sample_torch_module import UselessLayer
+
+
+class UselessClassification(LightningClassification):
+
+    def __init__(self, n_classes: int, lr: float, **kwargs) -> None:
+        super(UselessClassification).__init__()
+        self.save_hyperparameters()
+        self.n_classes = n_classes
+        self.lr = lr
+        self.main = nn.Sequential(UselessLayer(), nn.GELU())
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.main(x)
+
+    def loss(self, input: Tensor, target: Tensor) -> Tensor:
+        return F.mse_loss(input=input, target=target)
+
+    def configure_optimizers(self):
+        optimizer = optim.Adam(params=self.parameters(), lr=self.lr)
+        return optimizer
+
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+
+        logits = self.forward(x)
+        loss = self.loss(input=x, target=y)
+        metrics = classification_metrics(preds=logits,
+                                         target=y,
+                                         num_classes=self.n_classes)
+
+        self.train_batch_output.append({'loss': loss, **metrics})
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+
+        logits = self.forward(x)
+        loss = self.loss(input=x, target=y)
+        metrics = classification_metrics(preds=logits,
+                                         target=y,
+                                         num_classes=self.n_classes)
+
+        self.validation_batch_output.append({'loss': loss, **metrics})
+        return loss

models/modules/sample_torch_module.py

@@ -0,0 +1,12 @@
+from torch import Tensor, nn
+
+
+class UselessLayer(nn.Module):
+
+    def __init__(self) -> None:
+        super(UselessLayer, self).__init__()
+        self.seq = nn.Identity()
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.seq(x)
+        return x

requirements.txt

@@ -0,0 +1,2 @@
+dynaconf==3.1.12
+pytorch-lightning==2.0.0

tests/test_resource.py

@@ -0,0 +1,4 @@
+def test_cuda():
+    from torch.cuda import is_available
+    assert is_available()
+