def __init__(self,
df,
df_controls,
stats_experiments,
img_dir,
mode,
verbose=True,
channels=[1, 2, 3, 4, 5, 6]):
self.records = deepcopy(df).to_records(index=False)
df_conts = deepcopy(df_controls)
mask = (df_conts['well_type'] == 'negative_control') & \
(df_conts['well'] == 'B02')
df_neg_conts = df_conts[mask]
self.records_neg_conts = df_neg_conts.to_records(index=False)
mask = (df_conts['well_type'] == 'positive_control')
df_pos_conts = df_conts[mask]
self.records_pos_conts = df_pos_conts.to_records(index=False)
self.stats_exps = stats_experiments
self.mode = mode
self.channels = channels
self.img_dir = img_dir
self.len = df.shape[0]
self.transform_train = Compose([
VerticalFlip(p=0.5),
HorizontalFlip(p=0.5),
ShiftScaleRotate(
shift_limit=0, scale_limit=0, rotate_limit=180, p=1.0),
RandomCrop(height=364, width=364, p=1.0)
],
p=1.0)
self.transform_val = Compose(
[CenterCrop(height=364, width=364, p=1.0)], p=1.0)
if verbose:
print()
self.imgs = self._load_imgs(self.records,
desc='Images',
verbose=verbose)
self.imgs_neg_conts = self._load_imgs(self.records_neg_conts,
desc='Negative controls',
verbose=verbose)
self.imgs_pos_conts = self._load_imgs(self.records_pos_conts,
desc='Positive controls',
verbose=verbose)
def __init__(self,
df=None,
size=150,
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
augment=True,
frames=30,
stochastic=True):
""" Dataset initialization
Parameters
----------
df : pd.DataFrame
Dataframe with preprocessed data
transform : torchvision.transforms
Transformation operations for loaded images
path : str
Path to folder with the data
frames : int
Frames to load per video
"""
assert df is not None, 'Missing dataframe for data'
self.frames = frames
self.df = df[df['nframes'] >= frames]
self.stochastic = stochastic
addtl_img = {}
for idx in range(frames):
addtl_img['image{}'.format(idx)] = 'image'
if augment:
self.transform = albumentations.Compose(
[
ShiftScaleRotate(p=0.3,
scale_limit=0.25,
border_mode=1,
rotate_limit=15),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(
p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize(mean, std)
],
additional_targets=addtl_img)
else:
self.transform = albumentations.Compose([Normalize(mean, std)])
self.resize = transforms.Resize((size, size))
def transform(self, img: t.Any) -> t.Any:
max_hw = max(img.shape[0:2])
img = PadIfNeeded(max_hw, max_hw, border_mode=cv2.BORDER_REPLICATE)(image=img)[
"image"
]
img = Resize(self.resolution, self.resolution)(image=img)["image"]
img = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225],)(
image=img
)["image"]
if self.mode == "Train":
img = RandomResizedCrop(self.resolution, self.resolution)(image=img)[
"image"
]
img = Cutout(p=0.2)(image=img)["image"]
img = HorizontalFlip(p=0.5)(image=img)["image"]
img = ShiftScaleRotate(
shift_limit=0.1, scale_limit=0.0, rotate_limit=10, p=0.3
)(image=img)["image"]
img = ToTensorV2()(image=img)["image"]
return img
def train_dataloader(self):
augmentations = Compose([
RandomResizedCrop(
height=self.hparams.sz,
width=self.hparams.sz,
scale=(0.7, 1.0),
),
# ToGray(),
GridDistortion(),
RandomBrightnessContrast(),
ShiftScaleRotate(),
Flip(p=0.5),
CoarseDropout(
max_height=int(self.hparams.sz / 10),
max_width=int(self.hparams.sz / 10),
),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255,
),
ToTensorV2(),
])
train_ds = MelanomaDataset(
df=self.train_df,
images_path=self.train_images_path,
augmentations=augmentations,
train_or_valid=True,
)
return DataLoader(
train_ds,
# sampler=sampler,
batch_size=self.hparams.bs,
shuffle=True,
num_workers=os.cpu_count(),
pin_memory=False,
)
return loss
### Dataloaders
X, val_X, y, val_y = get_random_sampling(paths, y, val_paths, val_y)
print('There are ' + str(y.count(1)) + ' fake train samples')
print('There are ' + str(y.count(0)) + ' real train samples')
print('There are ' + str(val_y.count(1)) + ' fake val samples')
print('There are ' + str(val_y.count(0)) + ' real val samples')
import albumentations
from albumentations.augmentations.transforms import ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression
train_transform = albumentations.Compose([
ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize()
])
val_transform = albumentations.Compose([
Normalize()
])
train_dataset = ImageDataset(X, y, transform=train_transform)
val_dataset = ImageDataset(val_X, val_y, transform=val_transform)
test_size=0.1,
random_state=seed,
stratify=train.iloc[:, 0])
train_df = train_df.reset_index(drop=True)
val_df = val_df.reset_index(drop=True)
train_augmentations = Compose([
albumentations.OneOf([
GridMask(num_grid=3, mode=0, rotate=15),
GridMask(num_grid=3, mode=2, rotate=15),
],
p=0.7),
RandomAugMix(severity=4, width=3, alpha=1.0, p=0.7),
Resize(*img_size),
ShiftScaleRotate(shift_limit=0, scale_limit=0, rotate_limit=10, p=0.5),
ToFloat(max_value=255),
ToTensor()
],
p=1)
val_augmentations = Compose(
[Resize(*img_size), ToFloat(max_value=255),
ToTensor()], p=1)
train_dataset = digitdataset(data=train_df, transform=train_augmentations)
val_dataset = digitdataset(data=val_df, transform=val_augmentations)
# =============================================================================
# image , label = train_dataset.__getitem__(15)
#
# plt.imshow(image["image"].permute(1 , 2 , 0).numpy(), cmap = 'gray')
def get_transforms(config, mode: str = "train") -> Compose:
"""
Composes albumentations transforms.
Returns the full list of transforms when mode is "train".
mode should be one of "train", "val".
"""
# compose validation transforms
if mode == "val":
transforms = Compose(
[],
bbox_params=BboxParams(
format="pascal_voc",
min_area=0.0,
min_visibility=0.0,
label_fields=["category_id"],
),
)
# compose train transforms
# TODO: make transformation parameters configurable from yml
elif mode == "train":
transforms = Compose(
[
LongestMaxSize(
max_size=config["LONGESTMAXSIZE_MAXSIZE"],
p=config["LONGESTMAXSIZE_P"],
),
# PadIfNeeded(min_height=768, min_width=768, border_mode=0, p=1),
RandomSizedBBoxSafeCrop(
height=config["RANDOMSIZEDBBOXSAFECROP_HEIGHT"],
width=config["RANDOMSIZEDBBOXSAFECROP_WIDTH"],
p=config["LONGESTMAXSIZE_P"],
),
ShiftScaleRotate(
shift_limit=config["SHIFTSCALEROTATE_SHIFTLIMIT"],
scale_limit=config["SHIFTSCALEROTATE_SCALELIMIT"],
rotate_limit=config["SHIFTSCALEROTATE_ROTATELIMIT"],
p=config["SHIFTSCALEROTATE_P"],
),
HorizontalFlip(p=config["HORIZONTALFLIP_P"]),
RandomRotate90(p=config["RANDOMROTATE90_P"]),
RandomBrightnessContrast(
brightness_limit=config[
"RANDOMBRIGHTNESSCONTRAST_BRIGHTNESSLIMIT"],
contrast_limit=config[
"RANDOMBRIGHTNESSCONTRAST_CONTRASTLIMIT"],
p=config["RANDOMBRIGHTNESSCONTRAST_P"],
),
RandomGamma(
gamma_limit=config["RANDOMGAMMA_GAMMALIMIT"],
p=config["RANDOMGAMMA_P"],
),
HueSaturationValue(
hue_shift_limit=config["HUESATURATIONVALUE_HUESHIFTLIMIT"],
sat_shift_limit=config["HUESATURATIONVALUE_SATSHIFTLIMIT"],
val_shift_limit=config["HUESATURATIONVALUE_VALSHIFTLIMIT"],
p=config["HUESATURATIONVALUE_P"],
),
MotionBlur(
blur_limit=tuple(config["MOTIONBLUR_BLURLIMIT"]),
p=config["MOTIONBLUR_P"],
),
JpegCompression(
quality_lower=config["JPEGCOMPRESSION_QUALITYLOWER"],
quality_upper=config["JPEGCOMPRESSION_QUALITYUPPER"],
p=config["JPEGCOMPRESSION_P"],
),
],
bbox_params=BboxParams(
format="pascal_voc",
min_area=0.0,
min_visibility=0.0,
label_fields=["category_id"],
),
)
return transforms