Added aix sources

src/aix/__init__.py

@@ -0,0 +1,350 @@
+import sys
+import os
+from pathlib import Path
+import json
+import os
+import dataclasses
+from dataclasses import dataclass
+
+from typing import Any, Optional
+import math
+
+import logging
+from logging import NullHandler, StreamHandler
+
+import numpy as np
+import cv2
+import tensorflow as tf
+
+__import__('pkg_resources').declare_namespace(__name__)
+
+# Set default logging handler to avoid "No handler found" warnings.
+
+logger = logging.getLogger(__name__)
+if not logger.hasHandlers():
+    logger.addHandler(NullHandler())
+    logger.addHandler(StreamHandler(sys.stdout))
+    logger.setLevel('INFO')
+
+# environment variables:
+# DATAPATH: PATH of the data files
+
+DATA_FOLDER = "/data/eurova/cumulus_database/"
+if "DATAPATH" in os.environ:
+    DATA_FOLDER = os.environ["DATAPATH"]
+
+if "AIX_DATA" in os.environ:
+    AIX_DATA = Path(os.environ["AIX_DATA"])
+else:
+    AIX_DATA = Path("data")
+
+if "AIX_MODELS" in os.environ:
+    AIX_MODELS = Path(os.environ["AIX_MODELS"])
+else:
+    AIX_MODELS = Path("models")
+if "AIX_EVALS" in os.environ:
+    AIX_EVALS = Path(os.environ["AIX_EVALS"])
+else:
+    AIX_EVALS = Path("eval")
+
+AIX_DATASETS = AIX_DATA / "datasets"
+
+MATURE = "mature"
+IMMATURE = "immature"
+
+def init_path(output_path:Path, stages=[IMMATURE, MATURE]):
+    output_path.mkdir(parents=True, exist_ok=True)
+    for stage in stages:
+        (output_path/stage).mkdir(exist_ok=True)
+
+# An item is a generalization which includes as particular cases an oocyte image, an oocyte mask, and patches of those.
+@dataclass
+class Item:
+    dataset: Any
+    mask: bool
+    index: str
+    stage: str = ""
+    extension: str = ".png"
+
+    def filename(self):
+        if self.mask:
+            bp = Path(self.dataset.rooted_annotations_path)
+        else:
+            bp = Path(self.dataset.rooted_images_path)
+        if self.stage != "":
+            bp = (bp / self.stage)
+        f_name = str(bp / (self.index + self.extension))
+        #print(f_name)
+        return f_name
+
+    def raw_image(self, opts=cv2.IMREAD_UNCHANGED, remove_alpha=True):
+        img = cv2.imread(self.filename(), opts)
+        if len(img.shape) == 3 and img.shape[2] == 4:
+            print(self.filename() + " is in RGBA format. We remove the A")
+            # print(np.unique(img[:,:,3]))
+            # print(np.unique(img[:,:,0]-img[:,:,1]))
+            img = img[:, :, :3]
+        return img
+
+    def float_image(self, opts=cv2.IMREAD_UNCHANGED):
+        return self.raw_image(opts).astype(np.float32)
+
+    def norm_image(self, opts=cv2.IMREAD_UNCHANGED):
+        return self.float_image(opts) / 255.
+
+    def uint_norm_image(self, opts=cv2.IMREAD_UNCHANGED):
+        return self.raw_image(opts) / 255.
+
+    def tensor(self, shape):
+        img = self.raw_image(cv2.IMREAD_GRAYSCALE)
+        if len(img.shape) == 2:
+            img.shape = (img.shape[0], img.shape[1], 1)
+        t = tf.convert_to_tensor(img)
+        t = tf.image.resize(t, shape[:2])
+        t = tf.cast(t, tf.float32)
+        return t
+
+    def norm_tensor(self, shape):
+        return self.tensor(shape)/255.
+
+    def write(self, img):
+        assert img.dtype == np.uint8
+        print("Writing image ", self.filename())
+        cv2.imwrite(self.filename(), img)
+
+    def copy(self):
+        return dataclasses.replace(self)
+
+class Dataset:
+    def __init__(self, name, oocytes, images_path:str, annotations_path:Optional[str]=None, image_extension=".png",
+                 stages=[IMMATURE, MATURE], create_folders=False):
+        self.name = name
+        self.oocytes = oocytes
+        self.stages = stages
+        print("Number of oocytes for dataset ", name, ":", len(self.oocytes))
+        # root path with subfolders immature / mature
+
+        if os.path.isabs(images_path):
+            rooted_images_path = Path(images_path)
+        else:
+            rooted_images_path = AIX_DATA / images_path
+
+        if annotations_path is not None:
+            if os.path.isabs(annotations_path):
+                rooted_annotations_path = Path(annotations_path)
+            else:
+                #    !="" and not os.path.isabs(annotations_path) and annotations_path[:2]!="./"):
+                rooted_annotations_path = AIX_DATA / annotations_path
+        else:
+            rooted_annotations_path = None
+        # Check
+        if create_folders:
+            init_path(rooted_images_path, stages)
+            if rooted_annotations_path is not None:
+                init_path(rooted_annotations_path, stages)
+        else:
+            for subfold in stages:
+                if not (rooted_images_path / subfold).is_dir():
+                    raise Exception("Path "+ str(rooted_images_path) +" not found.")
+                if rooted_annotations_path is not None and not (rooted_annotations_path / subfold).is_dir():
+                    raise Exception("Path "+ str(rooted_annotations_path) +" not found.")
+
+        self.images_path = images_path
+        self.annotations_path = annotations_path
+        self.rooted_images_path = rooted_images_path
+        self.rooted_annotations_path = rooted_annotations_path
+        self.extension = image_extension
+
+    @staticmethod
+    def from_folder(name, folder_name, images_path, annotations_path, image_extension=".png"):
+        if not Path(folder_name).is_dir():
+            raise Exception("Path "+folder_name+" not found.")
+
+        oocytes = sorted(f.stem for f in Path(folder_name).iterdir() if f.suffix == image_extension)
+
+        return Dataset(name, oocytes, images_path, annotations_path, image_extension)
+
+    @staticmethod
+    def from_file(file_name: Path):
+        if not Path(file_name).is_file():
+            raise Exception("File "+str(file_name)+" not found")
+        json_data = open(file_name).read()
+        data = json.loads(json_data)
+        if "image_extension" not in data:
+            data['image_extension'] = ".png"
+        dataset = Dataset(data["name"], data["oocytes"], data["images"], data["annotations"], data["image_extension"])
+        return dataset
+
+    @staticmethod
+    def create(name, images_path:str, annotations_path:str,
+               image_extension=".png", stages=[IMMATURE, MATURE]):
+        #init_path(AIX_DATA / images_path, stages)
+        #if annotations_path!="":
+        #    init_path(AIX_DATA / annotations_path, stages)
+        return Dataset(name, [], images_path, annotations_path, image_extension, create_folders=True)
+
+    def num_images(self):
+        return len(self.stages)*len(self.oocytes)
+
+    def save(self, file_name):
+        d = {"name": self.name, "oocytes" : self.oocytes,
+             "image_extension": self.extension,
+             "images": str(self.images_path),
+             "annotations": str(self.annotations_path)}
+        with open(file_name, "w") as f:
+            f.write(json.dumps(d))
+
+    def has_annotations(self):
+        return self.annotations_path is not None
+
+    def new_item(self, mask=False, stage="", index=""):
+        return Item(self, mask, index=index, stage=stage, extension=self.extension)
+
+    def cv_item_iterator(self, k=10, seed=42, maturity=None):
+        random_arr = np.arange(len(self.oocytes))
+        np.random.seed(seed)
+        np.random.shuffle(random_arr)
+        oocyte_items = []
+        mask_items = []
+        for i in random_arr:
+            oocyte_index = self.oocytes[i]
+            if maturity is None or maturity == IMMATURE:
+                oocyte_items.append(self.new_item(mask=False, stage=IMMATURE, index=oocyte_index))
+                mask_items.append(self.new_item(mask=True, stage=IMMATURE, index=oocyte_index))
+            if maturity is None or maturity == MATURE:
+                oocyte_items.append(self.new_item(mask=False, stage=MATURE, index=oocyte_index))
+                mask_items.append(self.new_item(mask=True, stage=MATURE, index=oocyte_index))
+
+        fold_sizes = np.repeat(len(self.oocytes)// k, k)
+        # Adjust sizes when len no multiple of k
+        fold_sizes[:len(self.oocytes) % k] += 1
+        if maturity is None:
+            fold_sizes *= 2
+        num_fold = np.repeat(np.arange(k), fold_sizes)
+        oocyte_items = np.array(oocyte_items)
+        mask_items = np.array(mask_items)
+
+        for fold in range(k):
+            x_train = oocyte_items[num_fold != fold]
+            y_train = mask_items[num_fold != fold]
+            x_test = oocyte_items[num_fold == fold]
+            y_test = mask_items[num_fold == fold]
+            yield x_train, x_test, y_train, y_test
+
+    @classmethod
+    def tf_dataset_from_items(cls, x, y, image_shape, mask_shape):
+        def f():
+            for x_item, y_item in zip(x, y):
+                yield x_item.tensor(image_shape), y_item.norm_tensor(mask_shape)
+
+        return tf.data.Dataset.from_generator(f,
+                                       output_signature=(tf.TensorSpec(shape=image_shape, dtype=tf.float32),
+                                                         tf.TensorSpec(shape=mask_shape, dtype=tf.float32)))
+
+    def cv_tf_dataset_iterator(self, image_shape, mask_shape, k=10, seed=42, maturity=None):
+        for x_train, x_test, y_train, y_test in self.cv_item_iterator(k=k, seed=seed, maturity=maturity):
+            train = self.tf_dataset_from_items(x_train, y_train, image_shape, mask_shape)
+            test = self.tf_dataset_from_items(x_test, y_test, image_shape, mask_shape)
+            yield (x_train, y_train), train, (x_test, y_test), test
+
+
+    def train_test_iterator(self, k=10, seed=42):
+        random_arr = np.arange(len(self.oocytes))
+        np.random.seed(seed)
+        np.random.shuffle(random_arr)
+
+        image_files = []
+        mask_files = []
+        for idx in random_arr:
+
+            for stage in self.stages:
+                image_files.append((Path(self.rooted_images_path) / stage / (self.oocytes[idx])).as_posix())
+                mask_files.append((Path(self.rooted_annotations_path) / stage / (self.oocytes[idx])).as_posix())
+
+        fold_sizes = np.repeat(len(self.oocytes)// k, k)
+        # Adjust sizes when len no multiple of k
+        fold_sizes[:len(self.oocytes) % k] += 1
+
+        num_fold = np.repeat(np.arange(10), fold_sizes * 2)
+        image_files = np.array(image_files)
+        mask_files = np.array(mask_files)
+
+        for fold in range(k):
+            x_train = image_files[num_fold!=fold]
+            y_train = mask_files[num_fold!=fold]
+            x_test = image_files[num_fold==fold]
+            y_test = mask_files[num_fold==fold]
+            yield x_train, x_test, y_train, y_test
+
+    def train_test_split(self, percent=90, seed=42):
+        random_arr = np.arange(len(self.oocytes))
+        np.random.seed(seed)
+        np.random.shuffle(random_arr)
+        first_test = math.floor(percent * len(self.oocytes)/100.)
+        oocytes_a = np.array(self.oocytes)
+        train_oocytes = list(oocytes_a[:first_test])
+        test_oocytes = list(oocytes_a[first_test:])
+        train_ds = Dataset(self.name+"train", train_oocytes, self.images_path, self.annotations_path)
+        test_ds = Dataset(self.name+"test", test_oocytes, self.images_path, self.annotations_path)
+        return train_ds, test_ds
+
+    def tfDataset(self):
+        idx = self.oocytes[0]
+        image_shape = self.new_item(mask=False, stage=IMMATURE, index=idx).tensor().shape
+        mask_shape = self.new_item(mask=True, stage=IMMATURE, index=idx).tensor().shape
+        return tf.data.Dataset.from_generator(self.iterate_pairs,
+                output_signature=(tf.TensorSpec(shape=image_shape, dtype=tf.float32),
+                    tf.TensorSpec(shape=mask_shape, dtype=tf.float32)))
+
+    def tfDataset_fixed_shape(self, image_shape, mask_shape):
+        def f():
+            for x_item, y_item in self.iterate_pairs(tensor=False):
+                yield x_item.tensor(image_shape), y_item.norm_tensor(mask_shape)
+
+        return tf.data.Dataset.from_generator(f,
+                output_signature=(tf.TensorSpec(shape=image_shape, dtype=tf.float32),
+                tf.TensorSpec(shape=mask_shape, dtype=tf.float32)))
+
+    def iterate_pairs(self, tensor=True):
+        for idx in self.oocytes:
+            for stage in self.stages:
+                x = self.new_item(mask=False, stage=stage, index=idx)
+                y = self.new_item(mask=True, stage=stage, index=idx)
+                if tensor:
+                    x = x.tensor()
+                    y = y.tensor()
+                yield x, y
+
+    def iterate_items(self):
+        for idx in self.oocytes:
+            for stage in self.stages:
+                yield self.new_item(mask=False, stage=stage, index=idx)
+                yield self.new_item(mask=True, stage=stage, index=idx)
+
+    def iterate_oocyte_items(self, tensor=True):
+        for idx in self.oocytes:
+            for stage in self.stages:
+                x = self.new_item(mask=False, stage=stage, index=idx)
+                if tensor:
+                    x = x.tensor()
+                yield x
+
+    def iterate_mask_items(self):
+        for idx in self.oocytes:
+            for stage in self.stages:
+                yield self.new_item(mask=True, stage=stage, index=idx)
+
+    def iterate_oocyte_masks(self):
+        for idx in self.oocytes:
+            masks = []
+            for stage in self.stages:
+                x = self.new_item(mask=True, stage=stage, index=idx)
+                masks.append(x)
+            yield masks
+
+    def __repr__(self):
+        return "<Dataset: {}>".format(self.name)
+
+    def add_oocyte(self, index):
+        if index not in self.oocytes:
+            self.oocytes.append(index)

src/aix/augmentation.py

@@ -0,0 +1,56 @@
+
+import tensorflow as tf
+
+class Augment(tf.keras.layers.Layer):
+    def __init__(self, seed=42):
+        super().__init__()
+        # both use the same seed, so they'll make the same random changes.
+        self.augment_inputs = tf.keras.layers.RandomRotation(factor=(-0.9, 0.9), fill_mode="constant",
+                                                             interpolation="bilinear", seed=seed, fill_value=0.0)
+        self.augment_labels = tf.keras.layers.RandomRotation(factor=(-0.9, 0.9), fill_mode="constant",
+                                                             interpolation="bilinear", seed=seed, fill_value=0.0)
+        self.augment_inputs = tf.keras.layers.RandomFlip(mode="horizontal_and_vertical", seed=seed)
+        self.augment_labels = tf.keras.layers.RandomFlip(mode="horizontal_and_vertical", seed=seed)
+
+    def call(self, inputs, labels):
+        inputs = self.augment_inputs(inputs)
+        labels = self.augment_labels(labels)
+        return inputs, labels
+
+
+def augment_flip(image, label, axis=0):
+    if axis == 0:
+
+        image = tf.image.random_flip_left_right(image, seed=42)
+        label = tf.image.random_flip_left_right(label, seed=42)
+
+    else:
+
+        image = tf.image.random_flip_up_down(image, seed=42)
+        label = tf.image.random_flip_up_down(label, seed=42)
+
+    return image, label
+
+
+def augment_rot(image, label, kappa=1):
+    image = tf.image.rot90(image, k=kappa)
+    label = tf.image.rot90(label, k=kappa)
+
+    return image, label
+
+
+def augment(images, labels, seed=42):
+    print(type(images))
+    print(tf.shape(images))
+
+    images = tf.image.random_flip_left_right(images, seed=seed)
+    labels = tf.image.random_flip_left_right(labels, seed=seed)
+    images = tf.image.random_flip_up_down(images, seed=seed)
+    labels = tf.image.random_flip_up_down(labels, seed=seed)
+    images = tf.image.rot90(images, k=2)
+    labels = tf.image.rot90(labels, k=2)
+    # images = tf.image.random_crop(images, size = [1, IMG_SIZE[0], IMG_SIZE[1], 1], seed = seed)
+    # labels = tf.image.random_crop(labels, size = [1, IMG_SIZE[0], IMG_SIZE[1], 1], seed = seed)
+
+    return images, labels
+

src/aix/consensus.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+
+def mean(input_masks):
+    zeros = np.zeros_like(input_masks[0]).astype(np.float64)
+    float_mask = sum(input_masks, zeros) / len(input_masks)
+    return float_mask.astype(np.uint8)
+
+
+def intersection(input_masks):
+    m = np.copy(input_masks[0])
+    mmean = mean(input_masks)
+    m[mmean < 255.] = 0.
+    m[mmean == 255.] = 255.
+    return m
+
+
+def majority(input_masks):
+    m = np.copy(input_masks[0])
+    mmean = mean(input_masks)
+    m[mmean < 127] = 0
+    m[mmean > 127] = 255
+    return m
+
+
+
+MEAN = "mean"
+INTERSECTION = "intersection"
+MAJORITY = "majority"
+
+consensus_methods = {}
+consensus_methods[MEAN] = mean
+consensus_methods[INTERSECTION] = intersection
+consensus_methods[MAJORITY] = majority
+
+
+def get_consensus(consensus_name):
+    return consensus_methods[consensus_name]

src/aix/constants.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+SEED = 42
+
+INIT_WIDTH = 1944
+INIT_HEIGHT = 2592
+
+IMG_WIDTH = 192
+IMG_HEIGHT = 240
+IMG_CHANNELS = 1
+
+VIEW = False
+
+epsilon = .0001
+
+# model parameters
+
+OPTIMIZER = 'adam'
+MODEL_LOSS = 'binary_crossentropy'
+
+patience = 500
+
+val_split = 0.1
+batch_size = 16
+
+TEST_SIZE = 20
+
+MATURE = "mature"
+IMMATURE = "immature"
+BASE_DATA_DIR = Path("/data/eurova/cumulus_database/")
+BASE_MASKS_DIR = BASE_DATA_DIR/"masks"
+

src/aix/entropy.py

@@ -0,0 +1,73 @@
+import numpy as np
+import cv2
+import skimage.morphology
+import skimage.filters.rank
+
+
+# Aux functions (originally from suzie.images)
+
+def local_entropy(im, kernel_size=5, normalize=True):
+    kernel = skimage.morphology.disk(kernel_size)
+    if len(im.shape)>2:
+        kkernel = np.zeros((kernel.shape[0], kernel.shape[1],im.shape[2]))
+        for i in range(im.shape[2]):
+            kkernel[:,:,i]=kernel
+        kernel = kkernel
+    entr_img = skimage.filters.rank.entropy(im, kernel)
+    if normalize:
+        max_img = np.max(entr_img)
+        entr_img = (entr_img * 255 / max_img).astype(np.uint8)
+    return entr_img
+
+
+def calc_dim(contour):
+    c_0 = [point[0][0] for point in contour]
+    c_1 = [point[0][1] for point in contour]
+    return (min(c_0), max(c_0), min(c_1), max(c_1))
+
+
+def calc_size(dim):
+    return (dim[1] - dim[0]) * (dim[3] - dim[2])
+
+
+def calc_dist(dim1, dim2):
+    return None
+
+
+# -- Main function
+
+def extract_mask(img, filled=True, threshold=135, kernel_size=5):
+    entr_img = local_entropy(img, kernel_size=kernel_size)
+    _, mask = cv2.threshold(entr_img, threshold, 255, cv2.THRESH_BINARY)
+    while(len(np.unique(mask))==1):
+        threshold -= 5
+        print("Reducing threshold to ",threshold)
+        _, mask = cv2.threshold(entr_img, threshold, 255, cv2.THRESH_BINARY)
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+
+    contours_d = [calc_dim(c) for c in contours]
+    contours_sizes = [calc_size(c) for c in contours_d]
+    contour_indices = np.argsort(contours_sizes)[::-1]
+
+    # remove artifacts
+    fratio = 0
+    sratio = 5
+    idx = -1
+    while fratio < 0.3 or sratio > 5:
+        idx += 1
+        biggest = contour_indices[idx]
+        filled_mask = np.zeros(img.shape, dtype=np.uint8)
+        filled_mask = cv2.fillPoly(filled_mask, [contours[biggest]], 255)
+        fratio = filled_mask.sum() / 255 / contours_sizes[biggest]
+        cdim = contours_d[biggest]
+        sratio = (cdim[3] - cdim[2]) / (cdim[1] - cdim[0])
+        if sratio < 1: sratio = 1 / sratio
+  
+    # generating the mask
+    filled_mask = np.zeros(img.shape, dtype=np.uint8)
+    if filled:
+        filled_mask = cv2.fillPoly(filled_mask, [contours[biggest]], 255)
+    else:
+        filled_mask = cv2.polylines(filled_mask, [contours[biggest]], 30, 255)
+
+    return filled_mask

src/aix/evaluation.py

@@ -0,0 +1,141 @@
+from tqdm import tqdm
+
+import aix
+from aix import AIX_DATASETS, AIX_EVALS, MATURE, IMMATURE
+from aix.np_metrics import hard_dice, dice, rel_size_diff
+import cv2
+import pandas as pd
+import json
+
+all_measures = {
+        "dice": dice,
+        "hard_dice": hard_dice,
+        "rel_size_diff": rel_size_diff
+    }
+
+OOCYTE = "oocyte"
+REFERENCE = "reference"
+COMPARED = "compared"
+
+
+def load_csv(filename):
+    csv_file_path = AIX_EVALS / filename
+    if csv_file_path.is_file():
+        print("Loaded")
+        return pd.read_csv(csv_file_path, dtype={OOCYTE: str})
+    else:
+        print("NOT FOUND!!!")
+        print(csv_file_path)
+    return None
+
+
+def compare_masks(reference: str, alternatives: str, measures=all_measures,
+                  in_csv_metrics="eval.csv", out_csv_metrics="out.csv"):
+    df_old = load_csv(in_csv_metrics)
+    print(df_old)
+    reference_dataset = aix.Dataset.from_file(AIX_DATASETS / reference)
+    alt_datasets = {}
+    for alt in alternatives:
+        alt_datasets[alt] = aix.Dataset.from_file(AIX_DATASETS / alt)
+    l = []
+    for item_mask in tqdm(reference_dataset.iterate_mask_items()):
+        ref_mask_img = item_mask.norm_image(cv2.IMREAD_GRAYSCALE)
+        for alt, alt_d in alt_datasets.items():
+            if item_mask.index in alt_d.oocytes:
+                alt_mask = aix.Item(alt_d, mask=item_mask.mask, stage=item_mask.stage, index=item_mask.index)
+                alt_mask_img = alt_mask.norm_image(cv2.IMREAD_GRAYSCALE)
+                d = {OOCYTE: item_mask.index,
+                     MATURE: item_mask.stage,
+                     REFERENCE: reference_dataset.name,
+                     COMPARED: alt_d.name}
+                for measure_name, measure in measures.items():
+                    m = measure(ref_mask_img, alt_mask_img)
+                    d[measure_name] = m
+                l.append(d)
+            else:
+                print("Ignoring oocyte " + str(item_mask.index) + " for dataset " + alt_d.name)
+        #break
+    df = pd.DataFrame(l)
+    if df_old is not None:
+        index_fields = [OOCYTE, MATURE, REFERENCE, COMPARED]
+        df = df_old.merge(df, how='outer', on=index_fields, suffixes=("_x", None))
+        print("After merge")
+        print(df[COMPARED].unique())
+        for measure_name in measures:
+            index_fields.append(measure_name)
+            df[measure_name].fillna(df[measure_name + "_x"], inplace=True)
+        df = df[index_fields]
+    out_csv_file_path = AIX_EVALS / out_csv_metrics
+    out_csv_file_path.parent.mkdir(parents=True, exist_ok=True)
+    print(out_csv_file_path)
+    df.to_csv(out_csv_file_path, index=False)
+
+    return df
+
+
+def make_dict(df: pd.DataFrame):
+    d = {}
+
+    metrics = df.columns
+    for index, row in df.iterrows():
+        name = "-".join(index)
+        for i, val in enumerate(row):
+            namem = name + "-" + metrics[i]
+            d[namem] = val
+    return d
+
+def summarize_comparison(df:pd.DataFrame, metrics_file="eval.json"):
+    print(df)
+    gb = df.drop([MATURE,OOCYTE], axis=1).groupby([REFERENCE, COMPARED])
+    print(gb)
+    means = make_dict(gb.mean())
+    medians = make_dict(gb.median())
+    d = {"MEANS": means, "MEDIANS": medians}
+    filepath = AIX_EVALS/metrics_file
+    with filepath.open("w") as f:
+        json.dump(d, f)
+    # df.groupby([REFERENCE, COMPARED, MATURE])
+    # df.mean()
+    # df.median()
+    #
+    # measures = df.columns[4:]
+    # labelings = np.unique(df[])
+    # for alt in alternatives:
+    #     print("==", alt)
+    #
+    #     for measure_name in measures:
+    #         condition = (df["reference"] == reference_dataset.name) & (df["compared"] == alt_datasets[alt].name)
+    #         measure_slice = df[condition][measure_name].to_numpy()
+    #         print("   Mean " + measure_name + ": %4.4f" % np.mean(measure_slice))
+    #         print("   Median " + measure_name + ": %4.4f" % np.median(measure_slice))
+    #         for mature in [False,True]:
+    #             condition_mature = condition & (df[MATURE]==mature)
+    #             measure_slice = df[condition_mature][measure_name].to_numpy()
+    #             mature_txt = MATURE if mature else IMMATURE
+    #             print("   Mean " + measure_name + " " + mature_txt + ": %4.4f" % np.mean(measure_slice))
+    #             print("   Median " + measure_name + " " + mature_txt + ": %4.4f" % np.median(measure_slice))
+
+            
+            
+def evaluate_scale_loss(reference: str, dim, interpolation=cv2.INTER_AREA, extrapolation=cv2.INTER_CUBIC, measures=all_measures):
+    reference_dataset = aix.Dataset.from_file(reference)
+    measure_vals = {}
+    for measure_name in measures:
+        measure_vals[measure_name] = []
+    for item_mask in tqdm(reference_dataset.iterate_mask_items()):
+        ref_mask_img = item_mask.uint_norm_image()
+        
+        resized = cv2.resize(ref_mask_img, dim, interpolation=interpolation)
+        back_area = cv2.resize(resized, (ref_mask_img.shape[1], ref_mask_img.shape[0]), interpolation=extrapolation)
+        back_area[back_area<0.]=0.
+        back_area[back_area>1.]=1.
+        for measure_name, measure in measures.items():
+            measure_vals[measure_name].append(measure(ref_mask_img, back_area))
+         
+    print("\nReference: " + reference + "\n")
+    
+    first_measure_name = next(iter(measures))
+    n_masks = len(measure_vals[first_measure_name])
+    print("   N.Images : %4d" % n_masks)
+    for measure_name in measures:
+        print("   " + measure_name + ": %4.2f" % (sum(measure_vals[measure_name]) / n_masks))

src/aix/load_dataset.py

@@ -0,0 +1,72 @@
+from aix import Dataset
+import aix.constants as C
+import os
+import numpy as np
+import cv2
+
+def load_image(path):
+
+    img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+    array = np.reshape(img, (img.shape[0], img.shape[1], -1)) / 255
+
+    return array
+
+def temp_numpy_masks(training_fold):
+
+    image_rows = C.IMG_WIDTH
+    image_cols = C.IMG_HEIGHT
+
+    X_train = np.ndarray((len(training_fold[0]), image_rows, image_cols, 1), dtype = np.float64)
+    y_train = np.ndarray((len(training_fold[1]), image_rows, image_cols, 1), dtype = np.float64)
+    X_test = np.ndarray((len(training_fold[2]), image_rows, image_cols, 1), dtype = np.float64)
+    y_test = np.ndarray((len(training_fold[3]), image_rows, image_cols, 1), dtype = np.float64)
+
+    for i, obj in enumerate(training_fold[0]):
+
+        img = load_image(obj)
+        img = cv2.resize(img, (image_cols, image_rows), interpolation = cv2.INTER_AREA)
+        img = np.expand_dims(img, axis = 2)
+        X_train[i] = img
+
+    for i, obj in enumerate(training_fold[1]):
+
+        mask = load_image(obj)
+        mask = cv2.resize(mask, (image_cols, image_rows), interpolation = cv2.INTER_AREA)
+        mask = np.expand_dims(mask, axis = 2)
+        y_train[i] = mask
+
+    for i, obj in enumerate(training_fold[2]):
+
+        img = load_image(obj)
+        img = cv2.resize(img, (image_cols, image_rows), interpolation = cv2.INTER_AREA)
+        img = np.expand_dims(img, axis = 2)
+        X_test[i] = img
+
+    for i, obj in enumerate(training_fold[3]):
+
+        mask = load_image(obj)
+        mask = cv2.resize(mask, (image_cols, image_rows), interpolation = cv2.INTER_AREA)
+        mask = np.expand_dims(mask, axis = 2)
+        y_test[i] = mask
+
+    return X_train, y_train, X_test, y_test
+
+def load_training_batch(name = 'average_model', oocytes_list = [], images_path = '', annotations_path = ''):
+
+    dataset = Dataset(name, oocytes_list, images_path, annotations_path)
+
+    gen = dataset.train_test_iterator()
+
+    j = 0
+    folds = []
+    for x_train, x_test, y_train, y_test in gen:
+
+        j += 1
+        print(j)
+        folds.append(temp_numpy_masks([x_train, y_train, x_test, y_test]))
+
+        # save temporary numpies??
+
+        # DO MODEL stuff in here
+
+    return folds

src/aix/losses.py

@@ -0,0 +1,134 @@
+
+import numpy as np
+
+import tensorflow as tf
+from tensorflow.keras import backend as K
+from keras.layers import *
+from keras.losses import binary_crossentropy
+import keras
+
+from aix import logger
+import aix.constants as C
+
+epsilon = 1e-5
+smooth = 1
+
+
+def dice_coef(y_true, y_pred):
+
+    y_true_f = K.flatten(y_true)
+    y_pred_f = K.flatten(y_pred)
+    intersection = K.sum(y_true_f * y_pred_f)
+
+    return (2. * intersection + K.epsilon()) / (K.sum(y_true_f) + K.sum(y_pred_f) + K.epsilon())
+
+alpha = 0.25
+gamma = 2
+
+def focal_loss_with_logits(logits, targets, alpha, gamma, y_pred):
+
+    weight_a = alpha * (1 - y_pred) ** gamma * targets
+    weight_b = (1 - alpha) * y_pred ** gamma * (1 - targets)
+
+    return (tf.math.log1p(tf.exp(-tf.abs(logits))) + tf.nn.relu(-logits)) * (weight_a + weight_b) + logits * weight_b
+
+def focal_loss(y_true, y_pred):
+
+    y_pred = tf.clip_by_value(y_pred, tf.keras.backend.epsilon(), 1 - tf.keras.backend.epsilon())
+    logits = tf.math.log(y_pred / (1 - y_pred))
+
+    loss = focal_loss_with_logits(logits=logits, targets=y_true, alpha=alpha, gamma=gamma, y_pred=y_pred)
+
+    return tf.reduce_mean(loss)
+
+@keras.saving.register_keras_serializable(package="aix.losses")
+def dsc(y_true, y_pred):
+
+    smooth = 1.
+    y_true_f = K.flatten(y_true)
+    y_pred_f = K.flatten(y_pred)
+    intersection = K.sum(y_true_f * y_pred_f)
+    score = (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
+
+    return score
+
+
+@keras.saving.register_keras_serializable(package="aix.losses")
+def dice_loss(y_true, y_pred):
+
+    loss = 1 - dsc(y_true, y_pred)
+
+    return loss
+
+
+def bce_dice_loss(y_true, y_pred):
+
+    loss = binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred)
+
+    return loss
+
+def confusion(y_true, y_pred):
+
+    smooth = 1
+    y_pred_pos = K.clip(y_pred, 0, 1)
+    y_pred_neg = 1 - y_pred_pos
+    y_pos = K.clip(y_true, 0, 1)
+    y_neg = 1 - y_pos
+    tp = K.sum(y_pos * y_pred_pos)
+    fp = K.sum(y_neg * y_pred_pos)
+    fn = K.sum(y_pos * y_pred_neg)
+    prec = (tp + smooth) / (tp + fp + smooth)
+    recall = (tp + smooth) / (tp + fn + smooth)
+
+    return prec, recall
+
+def tp(y_true, y_pred):
+
+    smooth = 1
+    y_pred_pos = K.round(K.clip(y_pred, 0, 1))
+    y_pos = K.round(K.clip(y_true, 0, 1))
+    tp = (K.sum(y_pos * y_pred_pos) + smooth) / (K.sum(y_pos) + smooth)
+
+    return tp
+
+def tn(y_true, y_pred):
+    smooth = 1
+    y_pred_pos = K.round(K.clip(y_pred, 0, 1))
+    y_pred_neg = 1 - y_pred_pos
+    y_pos = K.round(K.clip(y_true, 0, 1))
+    y_neg = 1 - y_pos
+    tn = (K.sum(y_neg * y_pred_neg) + smooth) / (K.sum(y_neg) + smooth )
+
+    return tn
+
+def tversky(y_true, y_pred):
+
+    y_true_pos = K.flatten(y_true)
+    y_pred_pos = K.flatten(y_pred)
+    true_pos = K.sum(y_true_pos * y_pred_pos)
+    false_neg = K.sum(y_true_pos * (1 - y_pred_pos))
+    false_pos = K.sum((1 - y_true_pos) * y_pred_pos)
+    alpha = 0.7
+
+    return (true_pos + smooth) / (true_pos + alpha * false_neg + (1 - alpha) * false_pos + smooth)
+
+def tversky_loss(y_true, y_pred):
+
+    return 1 - tversky(y_true, y_pred)
+
+def focal_tversky(y_true,y_pred):
+
+    pt_1 = tversky(y_true, y_pred)
+    gamma = 0.75
+
+    return K.pow((1 - pt_1), gamma)
+
+def sensitivity(y_true, y_pred):
+    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
+    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
+    return true_positives / (possible_positives + K.epsilon())
+
+def specificity(y_true, y_pred):
+    true_negatives = K.sum(K.round(K.clip((1 - y_true) * (1 - y_pred), 0, 1)))
+    possible_negatives = K.sum(K.round(K.clip(1 - y_true, 0, 1)))
+    return true_negatives / (possible_negatives + K.epsilon())

src/aix/models.py

@@ -0,0 +1,227 @@
+#from aix.constants import *
+
+import tensorflow as tf
+
+
+def initialize_model(img_width, img_height, img_channels):
+    #,
+    #                 optimizer = 'adam', model_loss = 'binary_crossentropy', data_augm = False):
+
+    inputs = tf.keras.layers.Input((img_width, img_height, img_channels), name='input')
+
+    #Contraction path
+    c1 = tf.keras.layers.Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block1_conv2d_1')(inputs)
+    c1 = tf.keras.layers.Dropout(0.1, name='block1_dropout')(c1)
+    c1 = tf.keras.layers.Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block1_conv2d_2')(c1)
+    p1 = tf.keras.layers.MaxPooling2D((2, 2), name='block1_max_pooling')(c1)
+
+    c2 = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block2_conv2d_1')(p1)
+    c2 = tf.keras.layers.Dropout(0.1, name='block2_dropout')(c2)
+    c2 = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block2_conv2d_2')(c2)
+    p2 = tf.keras.layers.MaxPooling2D((2, 2), name='block2_max_pooling')(c2)
+
+    c3 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block3_conv2d_1')(p2)
+    c3 = tf.keras.layers.Dropout(0.2, name='block3_dropout')(c3)
+    c3 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block3_conv2d_2')(c3)
+    p3 = tf.keras.layers.MaxPooling2D((2, 2), name='block3_max_pooling')(c3)
+
+    c4 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block4_conv2d_1')(p3)
+    c4 = tf.keras.layers.Dropout(0.2, name='block4_dropout')(c4)
+    c4 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block4_conv2d_2')(c4)
+    p4 = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), name='block4_max_pooling')(c4)
+
+    c5 = tf.keras.layers.Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block5_conv2d_1')(p4)
+    c5 = tf.keras.layers.Dropout(0.3, name='block5_dropout')(c5)
+    c5 = tf.keras.layers.Conv2D(256, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block5_conv2d_2')(c5)
+
+    #Expansive path
+    u6 = tf.keras.layers.Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same', name='block6_conv2d_transpose')(c5)
+    u6 = tf.keras.layers.concatenate([u6, c4], name='block6_concatenate')
+    c6 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block6_conv2d_1')(u6)
+    c6 = tf.keras.layers.Dropout(0.2, name='block6_dropout')(c6)
+    c6 = tf.keras.layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block6_conv2d_2')(c6)
+
+    u7 = tf.keras.layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same', name='block7_conv2d_transpose')(c6)
+    u7 = tf.keras.layers.concatenate([u7, c3], name='block7_concatenate')
+    c7 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block7_conv2d_1')(u7)
+    c7 = tf.keras.layers.Dropout(0.2, name='block7_dropout')(c7)
+    c7 = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block7_conv2d_2')(c7)
+
+    u8 = tf.keras.layers.Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same', name='block8_conv2d_transpose')(c7)
+    u8 = tf.keras.layers.concatenate([u8, c2], name='block8_concatenate')
+    c8 = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block8_conv2d_1')(u8)
+    c8 = tf.keras.layers.Dropout(0.1, name='block8_dropout')(c8)
+    c8 = tf.keras.layers.Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block8_conv2d_2')(c8)
+
+    u9 = tf.keras.layers.Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same', name='block9_conv2d_transpose')(c8)
+    u9 = tf.keras.layers.concatenate([u9, c1], axis=3, name='block9_concatenate')
+    c9 = tf.keras.layers.Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block9_conv2d_1')(u9)
+    c9 = tf.keras.layers.Dropout(0.1, name='block9_dropout')(c9)
+    c9 = tf.keras.layers.Conv2D(16, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same', name='block9_conv2d_2')(c9)
+
+    outputs = tf.keras.layers.Conv2D(1, (1, 1), activation='sigmoid', name='output')(c9)
+
+    model = tf.keras.Model(inputs = [inputs], outputs = [outputs])
+    #model.compile(optimizer = optimizer, loss = model_loss, metrics = [dice_coef])
+    #model.summary()
+
+    return model
+
+
+def initialize_model_v2(img_width, img_height, img_channels,
+                     optimizer = 'adam', model_loss = 'binary_crossentropy', data_augm = False):
+    
+    n = 1
+    inputs = tf.keras.layers.Input((img_width, img_height, img_channels))
+    #Contraction path
+    c1 = tf.keras.layers.Conv2D(16 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(inputs)
+    #c1 = tf.keras.layers.Dropout(0.1)(c1)
+    c1 = tf.keras.layers.Conv2D(16 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c1)
+    p1 = tf.keras.layers.MaxPooling2D((2, 2))(c1)
+
+    c2 = tf.keras.layers.Conv2D(32 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p1)
+    #c2 = tf.keras.layers.Dropout(0.1)(c2)
+    c2 = tf.keras.layers.Conv2D(32 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c2)
+    p2 = tf.keras.layers.MaxPooling2D((2, 2))(c2)
+
+    c3 = tf.keras.layers.Conv2D(64 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p2)
+    #c3 = tf.keras.layers.Dropout(0.2)(c3)
+    c3 = tf.keras.layers.Conv2D(64 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c3)
+    p3 = tf.keras.layers.MaxPooling2D((2, 2))(c3)
+
+    c4 = tf.keras.layers.Conv2D(128 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p3)
+    #c4 = tf.keras.layers.Dropout(0.2)(c4)
+    c4 = tf.keras.layers.Conv2D(128 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c4)
+    p4 = tf.keras.layers.MaxPooling2D(pool_size=(2, 2))(c4)
+
+    c5 = tf.keras.layers.Conv2D(256 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(p4)
+    #c5 = tf.keras.layers.Dropout(0.5)(c5)
+    c5 = tf.keras.layers.Conv2D(256 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c5)
+    c5 = tf.keras.layers.Dropout(0.5)(c5)
+
+    #Expansive path
+    u6 = tf.keras.layers.Conv2DTranspose(128 * n, (2, 2), strides=(2, 2), padding='same')(c5)
+    u6 = tf.keras.layers.concatenate([u6, c4])
+    c6 = tf.keras.layers.Conv2D(128 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u6)
+    #c6 = tf.keras.layers.Dropout(0.2)(c6)
+    c6 = tf.keras.layers.Conv2D(128 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c6)
+
+    u7 = tf.keras.layers.Conv2DTranspose(64 * n, (2, 2), strides=(2, 2), padding='same')(c6)
+    u7 = tf.keras.layers.concatenate([u7, c3])
+    c7 = tf.keras.layers.Conv2D(64 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u7)
+    #c7 = tf.keras.layers.Dropout(0.2)(c7)
+    c7 = tf.keras.layers.Conv2D(64 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c7)
+
+    u8 = tf.keras.layers.Conv2DTranspose(32 * n, (2, 2), strides=(2, 2), padding='same')(c7)
+    u8 = tf.keras.layers.concatenate([u8, c2])
+    c8 = tf.keras.layers.Conv2D(32 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u8)
+    #c8 = tf.keras.layers.Dropout(0.1)(c8)
+    c8 = tf.keras.layers.Conv2D(32 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c8)
+
+    u9 = tf.keras.layers.Conv2DTranspose(16 * n, (2, 2), strides=(2, 2), padding='same')(c8)
+    u9 = tf.keras.layers.concatenate([u9, c1], axis=3)
+    c9 = tf.keras.layers.Conv2D(16 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(u9)
+    #c9 = tf.keras.layers.Dropout(0.1)(c9)
+    c9 = tf.keras.layers.Conv2D(16 * n, (3, 3), activation='relu', kernel_initializer='he_normal', padding='same')(c9)
+
+    outputs = tf.keras.layers.Conv2D(1, (1, 1), activation='sigmoid')(c9)
+
+    model = tf.keras.Model(inputs = [inputs], outputs = [outputs])
+    #model.compile(optimizer = optimizer, loss = model_loss, metrics = [dice_coef])
+    #model.summary()
+
+    return model
+
+# From pix2pix (https://github.com/tensorflow/examples/blob/master/tensorflow_examples/models/pix2pix/pix2pix.py)
+#
+def pix2pix_upsample(filters, size, norm_type='batchnorm', apply_dropout=False):
+    """Upsamples an input.
+        Conv2DTranspose => Batchnorm => Dropout => Relu
+        Args:
+            filters: number of filters
+            size: filter size
+            norm_type: Normalization type; either 'batchnorm' or 'instancenorm'.
+            apply_dropout: If True, adds the dropout layer
+        Returns:
+            Upsample Sequential Model
+    """
+
+    initializer = tf.random_normal_initializer(0., 0.02)
+
+    result = tf.keras.Sequential()
+    result.add(
+        tf.keras.layers.Conv2DTranspose(filters, size, strides=2,
+                                      padding='same',
+                                      kernel_initializer=initializer,
+                                      use_bias=False))
+
+    if norm_type.lower() == 'batchnorm':
+        result.add(tf.keras.layers.BatchNormalization())
+    elif norm_type.lower() == 'instancenorm':
+        result.add(InstanceNormalization())
+
+    if apply_dropout:
+        result.add(tf.keras.layers.Dropout(0.5))
+
+    result.add(tf.keras.layers.ReLU())
+
+    return result
+
+# Adapted From: https://www.tensorflow.org/tutorials/images/segmentation
+
+def unet_model(output_channels:int, input_shape=[128, 128, 3],
+               optimizer = 'adam', model_loss = 'binary_crossentropy'):
+    base_model = tf.keras.applications.MobileNetV2(input_shape=input_shape, include_top=False)
+
+    # Use the activations of these layers
+    layer_names = [
+        'block_1_expand_relu',   # 64x64
+        'block_3_expand_relu',   # 32x32
+        'block_6_expand_relu',   # 16x16
+        'block_13_expand_relu',  # 8x8
+        'block_16_project',      # 4x4
+    ]
+    base_model_outputs = [base_model.get_layer(name).output for name in layer_names]
+
+    # Create the feature extraction model
+    down_stack = tf.keras.Model(inputs=base_model.input, outputs=base_model_outputs)
+
+    down_stack.trainable = False
+
+    up_stack = [
+        pix2pix_upsample(512, 3),  # 4x4 -> 8x8
+        pix2pix_upsample(256, 3),  # 8x8 -> 16x16
+        pix2pix_upsample(128, 3),  # 16x16 -> 32x32
+        pix2pix_upsample(64, 3),   # 32x32 -> 64x64
+    ]
+
+    inputs = tf.keras.layers.Input(shape=input_shape)
+
+    # Downsampling through the model
+    skips = down_stack(inputs)
+    x = skips[-1]
+    skips = reversed(skips[:-1])
+
+    # Upsampling and establishing the skip connections
+    for up, skip in zip(up_stack, skips):
+        x = up(x)
+        concat = tf.keras.layers.Concatenate()
+        x = concat([x, skip])
+
+    # This is the last layer of the model
+    last = tf.keras.layers.Conv2DTranspose(
+        filters=output_channels, kernel_size=3, strides=2,
+        padding='same')  #64x64 -> 128x128
+
+    x = last(x)
+
+    model = tf.keras.Model(inputs=inputs, outputs=x)
+
+    model.compile(optimizer=optimizer,
+                 #loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
+                  loss=model_loss,
+                  metrics=['acc', dice_coef]
+                  )
+
+
+    return model

src/aix/np_metrics.py

@@ -0,0 +1,44 @@
+# Metrics between masks in numpy
+import numpy as np
+
+
+def dice(img1: np.ndarray, img2: np.ndarray, epsilon=0.00001):
+    assert np.min(img1) >= 0.
+    assert np.max(img1) <= 1.
+    assert np.min(img2) >= 0.
+    assert np.max(img2) <= 1.
+    return (np.sum(np.multiply(img1, img2)) * 2 + epsilon) / (np.sum(img1) + np.sum(img2) + epsilon)
+
+
+def harden(img: np.ndarray):
+    h_img = np.zeros_like(img, dtype=np.uint8)
+    h_img[img > 0.5] = 1
+    return h_img
+
+def restrict(m: np.ndarray):
+    rm = np.copy(m)
+    rm[rm<0]=0.
+    rm[rm>1]=1.
+    return rm
+    
+def check_mask(m):
+    if np.min(m) < 0.:
+        print("WARNING: Mask contains pixels below 0, constraining it to be over 0")
+    if np.max(m) > 1.:
+        print("WARNING: Mask contains pixels over 1, constraining them to be below 1")
+    assert np.min(m) >= 0.
+    assert np.max(m) <= 1.
+    
+def hard_dice(img1: np.ndarray, img2: np.ndarray, epsilon=0.00001):
+    check_mask(img1)
+    check_mask(img2)
+    return dice(harden(img1), harden(img2), epsilon)
+
+
+def rel_size_diff(img_r: np.ndarray, img: np.ndarray, epsilon=0.00001):
+    
+    assert np.min(img) >= 0.
+    assert np.max(img) <= 1.
+    s_r = np.sum(img_r)
+    s = np.sum(img)
+    return np.abs(s_r-s) / s_r

src/aix/utils.py

@@ -0,0 +1,202 @@
+import numpy as np
+import gzip
+from pathlib import Path
+
+import cv2
+
+import skimage.morphology
+import skimage.filters.rank
+import skimage.util
+
+from tensorflow.keras import backend as K
+import tensorflow as tf
+import keras
+
+from aix import logger
+import aix.constants as C
+
+
+
+def dice_coef(y_true, y_pred, smooth = .0001):
+
+    intersection = K.sum(y_true * y_pred, axis = [1, 2, 3])
+    union = K.sum(y_true, axis = [1, 2, 3]) + K.sum(y_pred, axis = [1, 2, 3])
+    dice = K.mean((2. * intersection + smooth) / (union + smooth), axis = 0)
+
+    return dice
+
+def harden(y, threshold=0.5):
+    y2 = tf.where(y>threshold,1.,0.)
+    return y2
+
+@keras.saving.register_keras_serializable(package="aix.utils")
+def hardened_dice_coef(y_true, y_pred, smooth = .0001):
+    y_true2 = harden(y_true)
+    y_pred2 = harden(y_pred)
+    return dice_coef(y_true2,y_pred2)
+
+def dice_coef_loss(y_true, y_pred):
+
+    loss = - dice_coef(y_true, y_pred)
+
+    return loss
+
+def local_entropy(im, kernel_size=5, normalize=True):
+    kernel=skimage.morphology.disk(kernel_size)
+    entr_img = skimage.filters.rank.entropy(skimage.util.img_as_ubyte(im), kernel)
+    if normalize:
+        max_img = np.max(entr_img)
+        entr_img = (entr_img*255/max_img).astype(np.uint8)
+    return entr_img
+
+def calc_dim(contour):
+    c_0 = [ point[0][0] for point in contour]
+    c_1 = [ point[0][1] for point in contour]
+    return (min(c_0), max(c_0), min(c_1), max(c_1))
+
+def calc_size(dim):
+    return (dim[1] - dim[0]) * (dim[3] - dim[2])
+
+def calc_dist(dim1, dim2):
+    return None
+
+def extract_roi(img, threshold=135, kernel_size=5, min_fratio=.3, max_sratio=5, filled=True, border=.01):
+
+    entr_img = local_entropy(img, kernel_size=kernel_size)
+    _, mask = cv2.threshold(entr_img, threshold, 255, cv2.THRESH_BINARY)
+
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL,  cv2.CHAIN_APPROX_NONE)
+
+    contours_d = [calc_dim(c) for c in contours]
+    contours_sizes = [calc_size(c) for c in contours_d]
+    contour_indices = np.argsort(contours_sizes)[::-1]
+
+    # remove artifacts
+    fratio = min_fratio
+    sratio = max_sratio
+    idx = -1
+    while fratio<=min_fratio or sratio>=max_sratio:
+        idx += 1
+        biggest = contour_indices[idx]
+        filled_mask = np.zeros(img.shape, dtype=np.uint8)
+        filled_mask = cv2.fillPoly(filled_mask, [contours[biggest]], 255)
+        fratio = filled_mask.sum()/255/contours_sizes[biggest]
+        cdim = contours_d[biggest]
+        sratio = (cdim[3]-cdim[2])/(cdim[1]-cdim[0])
+        if sratio<1: sratio = 1 / sratio
+        #print(fratio, sratio, cdim, filled_mask.sum()//255)
+
+    # generating the mask
+    filled_mask = np.zeros(img.shape, dtype=np.uint8)
+
+    extra = ( int(img.shape[0] * border) , int(img.shape[1] * border) )
+    origin = (max(0, cdim[0]-extra[1]), max(0, cdim[2]-extra[0]))
+    to = (min(img.shape[1]-1 , cdim[1]+extra[1]), min(img.shape[0]-1 , cdim[3]+extra[0]))
+
+    if filled:
+        filled_mask = cv2.rectangle(filled_mask, origin, to, 255, -1)
+    else:
+        filled_mask = cv2.rectangle(filled_mask, origin, to, 255, 2)
+
+    return filled_mask, origin, to
+
+def preprocessor(input_img, img_rows, img_cols):
+    """
+    Resize input images to constants sizes
+    :param input_img: numpy array of images
+    :return: numpy array of preprocessed images
+    """
+    logger.debug("Preprocessing...")
+
+    input_img = np.swapaxes(input_img, 2, 3)
+    input_img = np.swapaxes(input_img, 1, 2)
+
+    logger.debug("Input: " + str(input_img.shape))
+
+    output_img = np.ndarray((input_img.shape[0], input_img.shape[1], img_rows, img_cols), dtype = np.uint8)
+    #print("INPUT")
+    #print(input_img.shape)
+    for i in range(input_img.shape[0]):
+        output_img[i, 0] = cv2.resize(input_img[i, 0], (img_cols, img_rows), interpolation = cv2.INTER_AREA)
+    #print("OUTPUT")
+    #print(output_img.shape)
+    output_img = np.swapaxes(output_img, 1, 2)
+    output_img = np.swapaxes(output_img, 2, 3)
+
+    logger.debug("Output: " + str(output_img.shape))
+
+    return output_img
+
+def load_train_data(imgs_path, masks_path):
+    """
+    Load training data from project path
+    :return: [X_train, y_train] numpy arrays containing the training data and their respective masks.
+    """
+
+    logger.debug("\nLoading train data ...\n")
+
+    X_train = np.load(gzip.open(imgs_path))
+    y_train = np.load(gzip.open(masks_path))
+
+    logger.debug(X_train.shape)
+    logger.debug(y_train.shape)
+
+    X_train = preprocessor(X_train, C.IMG_WIDTH, C.IMG_HEIGHT)
+    y_train = preprocessor(y_train, C.IMG_WIDTH, C.IMG_HEIGHT)
+
+    X_train = X_train.astype('float32')/255
+
+    mean = np.mean(X_train)  # mean for data centering
+    std = np.std(X_train)  # std for data normalization
+
+    X_train -= mean
+    X_train /= std
+
+    y_train = y_train.astype('float32')
+
+    return X_train, y_train
+
+def process_data(X, y):
+
+    logger.debug("\nLoading train data ...\n")
+
+    logger.debug(X.shape)
+    logger.debug(y.shape)
+
+    X = preprocessor(X, C.IMG_WIDTH, C.IMG_HEIGHT)
+    y = preprocessor(y, C.IMG_WIDTH, C.IMG_HEIGHT)
+
+    X = X.astype('float32')
+    y = y.astype('float32')
+
+    return X, y
+
+def load_skin_train_data(imgs_path, masks_path, img_width, img_height):
+    """
+    Load training data from project path
+    :return: [X_train, y_train] numpy arrays containing the training data and their respective masks.
+    """
+
+    logger.debug("\nLoading train data ...\n")
+
+    X_train = np.load(gzip.open(imgs_path))
+    y_train = np.load(gzip.open(masks_path))
+
+    logger.debug(X_train.shape)
+    logger.debug(y_train.shape)
+
+    X_train = preprocessor(X_train, C.IMG_WIDTH, C.IMG_HEIGHT)
+    y_train = preprocessor(y_train, C.IMG_WIDTH, C.IMG_HEIGHT)
+
+    X_train = X_train.astype('float32')
+
+    mean = np.mean(X_train)  # mean for data centering
+    std = np.std(X_train)  # std for data normalization
+
+    X_train -= mean
+    X_train /= std
+
+    y_train = y_train.astype('float32')
+    y_train /= 255.
+
+    return X_train, y_train