Dermatologist Mini-Project

testing_log = Tee(log_name="inception_test.log", directory_name="~/logs/dermatologist")
with testing_log.path.open() as reader:
    for line in reader:
        print(line.rstrip())

class Predictions:
    """Maps the test data to a predictions file

    Args:
     model_path: path to the stored model parameters
     device: processor to use
     output_path: path to the CSV to output
     test_path: path to the test folder
     inception: object with the model
    """
    def __init__(self, model_path: Path,
                 device: torch.device,
                 output_path: Path,
                 test_path: Path,
                 data_sets: DataSets=None,                 
                 inception: Inception=None) -> None:
        self.model_path = model_path
        self.output_path = output_path
        self.test_path = test_path
        self._device = device
        self._data_sets = data_sets
        self._activation = None
        self.inception = inception
        return

    @property
    def data_sets(self) -> DataSets:
        """the data-sets"""
        if self._data_sets is None:
            self._data_sets = DataSets()
        return self._data_sets

    @property
    def device(self):
        """The processor to use"""
        if self._device is None:
            self._device = torch.device("cuda"
                                        if torch.cuda.is_available()
                                        else "cpu")
        return self._device

    @property
    def inception(self) -> Inception:
        """The Inception Object"""
        if self._inception is None:
            self._inception = Inception(
                classel= self.data_sets.class_count,
                model_path=self.model_path,
                device=self.device)
            self._inception.model.eval()
        return self._inception

    @property
    def activation(self) -> nn.Sigmoid:
        """The non-linear activation"""
        if self._activation is None:
            self._activation = nn.Sigmoid()
        return self._activation

    @inception.setter
    def inception(self, new_inception: Inception) -> None:
        """Sets the inception model to eval only"""
        self._inception = new_inception
        self._inception.model.eval()
        return

    def prediction(self, image_path: Path) -> numpy.ndarray:
        """Calculate predicted class for an image

        Args:
         image_path: path to an inmage file
        Returns:
         array with the probabilities for each disease
        """
        model = self.inception.model        
        image = Image.open(image_path)
        tensor = self.data_sets.transformer.testing(image)
        # add a batch number
        tensor = tensor.unsqueeze_(0)
        tensor = tensor.to(self.inception.device)
        x = torch.autograd.Variable(tensor)
        output = torch.exp(model(x))
        _, top_class = output.topk(1, dim=1)
        return top_class.item()

    def __call__(self) -> None:
        """Creates CSV of predictions"""
        with self.output_path.open("w") as writer:
            writer.write("Id,task_1,task_2\n")
            for category in self.test_path.iterdir():
                for path in category.iterdir():
                    identifier = 'data/' + str(path).split("/dermatologist/")[-1]
                    guess = self.prediction(path)
                    first = 0 if guess else 1
                    second = 1 if guess == 2 else 0
                    writer.write("{},{},{}\n".format(identifier,
                                                     first,
                                                     second))
        return

TIMER = Timer()
test_path = DataPathTwo(folder_key="TEST").folder
csv_output = Path("~/documents/pcloud_drive/outcomes/dermatologist/predictions.csv").expanduser()

predictions = Predictions(model_path=transfer_path,
                          device=inception.device,
                          output_path=csv_output,
                          test_path=test_path,
                          data_sets=data_sets,
                          inception=inception)
with TIMER:
    predictions()