Beispiel #1
0
class DatasetAll(TensorDataset):
    def __init__(self,
                 X,
                 y,
                 perturbations,
                 k=20,
                 return_index=False,
                 joint_transform=None):
        if perturbations.size(0) < k:
            raise ValueError
        perturbations = perturbations[:, :, :, :, :k]
        perturbations = perturbations.permute(0, 4, 1, 2,
                                              3).reshape(-1,
                                                         *X.size()[1:])
        super(DatasetAll, self).__init__(perturbations)
        self.Xy = TensorDataset(X, y)
        self.k = k
        self.return_index = return_index
        self.joint_transform = joint_transform

    def __getitem__(self, index):
        t3, = super(DatasetAll, self).__getitem__(index)
        # print(index, self.k, index//self.k)
        t1, t2 = self.Xy.__getitem__(int(index // self.k))
        if self.joint_transform is not None:
            t1, t3 = self.joint_transform(t1, t3)
        if self.return_index:
            return t1, t2, t3, index
        else:
            return t1, t2, t3
class RawBinaryDataset(Dataset):
    """Binary features dataset."""
    def __init__(self, json_file):
        """
        Args:
            json_file (string): Path to the json file the 1 Kb samples.
        """
        with open(json_file, "r") as f:
            data = f.read()
            self.data_frame = json.loads(data)

        data_frame_X, data_frame_Y = self._from_json_to_tensor(self.data_frame)
        self.dataset = TensorDataset(data_frame_X, data_frame_Y)

    def _from_json_to_tensor(self, json_data: dict):
        x = []
        y = []
        for key, value in json_data.items():
            y.extend([ARCHITECTURES.index(key)] * len(value))
            x.extend(value)

        return torch.Tensor(x), torch.Tensor(y)

    def __len__(self):
        return len(self.dataset)

    def __getitem__(self, idx):
        return self.dataset.__getitem__(idx)
Beispiel #3
0
 def predict(self, image_url):
     inp = self.process_raw(image_url)
     test_img = TensorDataset(torch.from_numpy(inp).float())
     output = self.convnet(test_img.__getitem__())
     print(output)
     _, predicted = torch.max(output.data, 1)
     return self.labels[predicted.item()]
class FeatureDataset(Dataset):
    """Binary features dataset."""
    def __init__(self, csv_file):
        """
        Args:
            csv_file (string): Path to the csv file with annotations.
        """
        self.data_frame = np.genfromtxt(csv_file,
                                        delimiter=',',
                                        skip_header=True,
                                        filling_values=0)
        self.data_frame = torch.from_numpy(self.data_frame)
        data_frame_X = self.data_frame[:, 0:-1]
        data_frame_Y = self.data_frame[:, -1]
        self.dataset = TensorDataset(data_frame_X, data_frame_Y)

    def __len__(self):
        return len(self.data_frame)

    def __getitem__(self, idx):
        return self.dataset.__getitem__(idx)