plato-learn 1.1__py3-none-any.whl

plato/datasources/texas.py

@@ -0,0 +1,94 @@
+"""
+The Texas100 dataset.
+"""
+
+import os
+import logging
+import urllib
+import tarfile
+import torch
+import numpy as np
+from torch.utils import data
+from plato.config import Config
+from plato.datasources import base
+
+
+class DataSource(base.DataSource):
+    """The Texas100 dataset."""
+
+    def __init__(self):
+        super().__init__()
+        root_path = Config().params["data_path"]
+        feat_path = os.path.join(root_path, "texas/100/feats")
+        label_path = os.path.join(root_path, "texas/100/labels")
+        if not os.path.isdir(root_path):
+            os.mkdir(root_path)
+        if not os.path.isfile(feat_path):
+            self.download_dataset(root_path, feat_path, label_path)
+
+        self.trainset, self.testset = self.extract_data(root_path)
+
+    def download_dataset(self, root_path, feat_path, label_path):
+        """Download the Texas100 dataset."""
+        logging.info("Downloading the Texas100 dataset...")
+        filename = "https://www.comp.nus.edu.sg/~reza/files/dataset_texas.tgz"
+        urllib.request.urlretrieve(filename, os.path.join(root_path, "tmp_texas.tgz"))
+        logging.info("Dataset downloaded.")
+        tar = tarfile.open(os.path.join(root_path, "tmp_texas.tgz"))
+        tar.extractall(path=root_path)
+
+        logging.info("Processing the dataset...")
+        data_set_feats = np.genfromtxt(feat_path, delimiter=",")
+        data_set_labels = np.genfromtxt(label_path, delimiter=",")
+        logging.info("Finish processing the dataset.")
+
+        X = data_set_feats.astype(np.float64)
+        Y = data_set_labels.astype(np.int32) - 1
+        np.savez(os.path.join(root_path, "texas_numpy.npz"), X=X, Y=Y)
+
+    def extract_data(self, root_path):
+        """Extract data."""
+        data = np.load(os.path.join(root_path, "texas_numpy.npz"))
+
+        ## randomly shuffle the data
+        X, Y = data["X"], data["Y"]
+        np.random.seed(0)
+        indices = np.arange(len(X))
+        np.random.shuffle(indices)
+        X, Y = X[indices], Y[indices]
+
+        ## extract 20000 data samplers for training and testing respectively
+        num_train = 20000
+        train_data = X[:num_train]
+        test_data = X[num_train : num_train * 2]
+        train_label = Y[:num_train]
+        test_label = Y[num_train : num_train * 2]
+
+        ## create datasets
+        train_dataset = VectorDataset(train_data, train_label)
+        test_dataset = VectorDataset(test_data, test_label)
+
+        return train_dataset, test_dataset
+
+    def num_train_examples(self):
+        return 20000
+
+    def num_test_examples(self):
+        return 20000
+
+
+class VectorDataset(data.Dataset):
+    """
+    Create a Texas100 dataset based on features and labels
+    """
+
+    def __init__(self, features, labels):
+        self.data = torch.stack([torch.FloatTensor(i) for i in features])
+        self.targets = torch.stack([torch.LongTensor([i]) for i in labels])[:, 0]
+        self.classes = [f"Procedure #{i}" for i in range(100)]
+
+    def __getitem__(self, index):
+        return self.data[index], self.targets[index]
+
+    def __len__(self):
+        return self.data.size(0)

plato/datasources/tiny_imagenet.py

@@ -0,0 +1,64 @@
+"""
+The Tiny ImageNet 200 Classification dataset.
+
+Tiny ImageNet contains 100000 images of 200 classes (500 for each class)
+downsized to 64×64 colored images.
+Each class has 500 training images, 50 validation images and 50 test images.
+"""
+
+import logging
+import os
+
+from torchvision import datasets, transforms
+
+from plato.config import Config
+from plato.datasources import base
+
+
+class DataSource(base.DataSource):
+    """The Tiny ImageNet 200 dataset."""
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        _path = Config().params["data_path"]
+
+        if not os.path.exists(_path):
+            logging.info(
+                "Downloading the Tiny ImageNet 200 dataset. This may take a while."
+            )
+            url = (
+                Config().data.download_url
+                if hasattr(Config().data, "download_url")
+                else "http://cs231n.stanford.edu/tiny-imagenet-200.zip"
+            )
+            DataSource.download(url, _path)
+
+        train_transform = (
+            kwargs["train_transform"]
+            if "train_transform" in kwargs
+            else (
+                transforms.Compose(
+                    [
+                        transforms.RandomResizedCrop(299),
+                        transforms.CenterCrop(299),
+                        transforms.ToTensor(),
+                        transforms.Normalize(
+                            [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
+                        ),
+                    ]
+                )
+            )
+        )
+        test_transform = train_transform
+        self.trainset = datasets.ImageFolder(
+            root=os.path.join(_path, "train"), transform=train_transform
+        )
+        self.testset = datasets.ImageFolder(
+            root=os.path.join(_path, "test"), transform=test_transform
+        )
+
+    def num_train_examples(self):
+        return 100000
+
+    def num_test_examples(self):
+        return 10000

plato/datasources/yolov8.py

@@ -0,0 +1,85 @@
+"""
+The COCO dataset or other datasets for the YOLOv8 model.
+
+For more information about COCO 128, which contains the first 128 images of the
+COCO 2017 dataset, refer to https://www.kaggle.com/ultralytics/coco128.
+
+For more information about the COCO 2017 dataset, refer to http://cocodataset.org.
+"""
+
+from ultralytics.data.dataset import YOLODataset
+from ultralytics.cfg import DEFAULT_CFG
+from ultralytics.data.utils import check_det_dataset
+from plato.config import Config
+from plato.datasources import base
+
+
+class DataSource(base.DataSource):
+    """The YOLO dataset."""
+
+    # pylint: disable=unused-argument
+    def __init__(self, **kwargs):
+        super().__init__()
+
+        self.grid_size = Config().parameters.grid_size
+        self.data = check_det_dataset(Config().data.data_params)
+        self.train_set = None
+        self.test_set = None
+
+    def get_train_set(self):
+        single_class = Config().parameters.model.num_classes == 1
+
+        if self.train_set is None:
+            self.train_set = YOLODataset(
+                img_path=self.data["train"],
+                imgsz=Config().data.image_size,
+                batch_size=Config().trainer.batch_size,
+                augment=False,
+                hyp=DEFAULT_CFG,
+                rect=False,
+                cache=False,
+                single_cls=single_class,
+                stride=int(self.grid_size),
+                pad=0.0,
+                prefix="",
+                use_segments=False,
+                use_keypoints=False,
+                classes=Config().data.classes,
+                data=self.data,
+            )
+
+        return self.train_set
+
+    def get_test_set(self):
+        single_class = Config().parameters.model.num_classes == 1
+
+        if self.test_set is None:
+            self.test_set = YOLODataset(
+                img_path=self.data["val"],
+                imgsz=Config().data.image_size,
+                batch_size=Config().trainer.batch_size,
+                augment=True,
+                hyp=DEFAULT_CFG,
+                rect=False,
+                cache=False,
+                single_cls=single_class,
+                stride=int(self.grid_size),
+                pad=0.0,
+                prefix="",
+                use_segments=False,
+                use_keypoints=False,
+                classes=Config().data.classes,
+                data=self.data,
+            )
+
+        return self.test_set
+
+    def num_train_examples(self):
+        return Config().data.num_train_examples
+
+    def num_test_examples(self):
+        return Config().data.num_test_examples
+
+    def classes(self):
+        """Obtains a list of class names in the dataset."""
+        return Config().data.classes

plato/models/cnn_encoder.py

@@ -0,0 +1,103 @@
+"""
+A factory that generates fully convolutional neural network encoder.
+
+The fully convolutional neural network used as the encoder in this implementation
+is the backbone part of a model.
+
+This encoder is solely capable of extracting features from the input sample.
+Generally, in the context of classification tasks, this encoder has to cooperate
+with the classification head to make the prediction.
+
+Besides, the 'AdaptiveAvgPool2d' layer is included to support extracting
+features with fixed dimensions.
+
+"""
+
+from typing import Optional, Dict
+
+from torch import nn
+import torchvision
+
+from plato.models.lenet5 import Model as lenet5_model
+from plato.models.vgg import Model as vgg_model
+
+from plato.config import Config
+
+
+class TruncatedLeNetModel(nn.Module):
+    """The truncated LeNet-5 model."""
+
+    def __init__(self, defined_lenet5_model):
+        super().__init__()
+        self.model = defined_lenet5_model
+        self.model.fc4 = nn.Identity()
+        self.model.relu4 = nn.Identity()
+        self.model.fc5 = nn.Identity()
+
+    def forward(self, samples):
+        """Forward to specific layer (cut)_layer) of LeNet5."""
+        self.model.cut_layer = "flatten"
+        return self.model.forward_to(samples)
+
+
+class Model:
+    """The encoder obtained by removing the final
+    fully-connected blocks of the required model.
+    """
+
+    # pylint:disable=too-few-public-methods
+    @staticmethod
+    def get(model_name: Optional[str] = None, **kwargs: Dict[str, str]):  # pylint: disable=unused-argument
+        """Returns an encoder that is a fully CNN block."""
+
+        # as the final fully-connected layer will be removed
+        # the number of classes can be the randomly value
+        # thus, set it to be constant value 10.
+        num_classes = 10
+
+        if model_name == "lenet5":
+            model = lenet5_model(num_classes=num_classes)
+            # get encoding dimensions
+            #   i.e., the output dim of the encoder
+            encode_output_dim = model.fc4.in_features
+            encoder = TruncatedLeNetModel(model)
+
+        if "vgg" in model_name:
+            encoder = vgg_model.get(model_name=model_name, num_classes=num_classes)
+            # get encoding dimensions
+            #   i.e., the output dim of the encoder
+            encode_output_dim = encoder.fc.in_features
+            encoder.fc = nn.Identity()
+
+        if "resnet" in model_name:
+            resnets = {
+                "resnet_18": torchvision.models.resnet18,
+                "resnet_50": torchvision.models.resnet50,
+            }
+
+            encoder = resnets[model_name](num_classes=num_classes)
+
+            datasource = (
+                kwargs["datasource"]
+                if "datasource" in kwargs
+                else Config().data.datasource
+            )
+            if "CIFAR" in datasource:
+                # The structure specifically for CIFAR-based dataset.
+                # Replace conv 7x7 with conv 3x3,
+                # and remove first max pooling.
+                # For example,
+                #   see Section B.9 of SimCLR paper.
+                encoder.conv1 = nn.Conv2d(
+                    3, 64, kernel_size=3, stride=1, padding=2, bias=False
+                )
+                encoder.maxpool = nn.Identity()
+
+            # get encoding dimensions
+            #   i.e., the output dim of the encoder
+            encode_output_dim = encoder.fc.in_features
+            encoder.fc = nn.Identity()
+
+        encoder.encoding_dim = encode_output_dim
+
+        return encoder

plato/models/dcgan.py

@@ -0,0 +1,116 @@
+"""
+The DCGAN model.
+
+Reference:
+https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html
+"""
+
+from torch import nn
+
+nz = 100
+nc = 3
+ngf = 64
+ndf = 64
+
+
+class Generator(nn.Module):
+    """Generator network of DCGAN"""
+
+    def __init__(self):
+        super().__init__()
+
+        self.main = nn.Sequential(
+            # input is Z, going into a convolution
+            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
+            nn.BatchNorm2d(ngf * 8),
+            nn.ReLU(True),
+            # state size. (ngf*8) x 4 x 4
+            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf * 4),
+            nn.ReLU(True),
+            # state size. (ngf*4) x 8 x 8
+            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf * 2),
+            nn.ReLU(True),
+            # state size. (ngf*2) x 16 x 16
+            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ngf),
+            nn.ReLU(True),
+            # state size. (ngf) x 32 x 32
+            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
+            nn.Tanh(),
+            # state size. (nc) x 64 x 64
+        )
+
+    def forward(self, input_data):
+        """Forward pass."""
+        return self.main(input_data)
+
+
+class Discriminator(nn.Module):
+    """Discriminator network of DCGAN."""
+
+    def __init__(self):
+        super().__init__()
+
+        self.main = nn.Sequential(
+            # input is (nc) x 64 x 64
+            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf) x 32 x 32
+            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ndf * 2),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf*2) x 16 x 16
+            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ndf * 4),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf*4) x 8 x 8
+            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
+            nn.BatchNorm2d(ndf * 8),
+            nn.LeakyReLU(0.2, inplace=True),
+            # state size. (ndf*8) x 4 x 4
+            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
+            nn.Sigmoid(),
+        )
+
+    def forward(self, input_data):
+        return self.main(input_data)
+
+
+class Model:
+    """A wrapper class to hold the Generator and Discriminator models of DCGAN."""
+
+    def __init__(self) -> None:
+        self.generator = Generator()
+        self.discriminator = Discriminator()
+        self.loss_criterion = nn.BCELoss()
+
+        self.nz = nz
+        self.nc = nc
+        self.ngf = ngf
+        self.ndf = ndf
+
+    def weights_init(self, model):
+        classname = model.__class__.__name__
+        if classname.find("Conv") != -1:
+            nn.init.normal_(model.weight.data, 0.0, 0.02)
+        elif classname.find("BatchNorm") != -1:
+            nn.init.normal_(model.weight.data, 1.0, 0.02)
+            nn.init.constant_(model.bias.data, 0)
+
+    def cpu(self):
+        self.generator.cpu()
+        self.discriminator.cpu()
+
+    def to(self, device):
+        self.generator.to(device)
+        self.discriminator.to(device)
+
+    def train(self):
+        self.generator.train()
+        self.discriminator.train()
+
+    def eval(self):
+        self.generator.eval()
+        self.discriminator.eval()