def predict(image_path, model):
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
test_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
test_images = [image_path]
test_targets = [0]
test_dataset = ClassificationLoader(image_paths=test_images,
targets=test_targets,
resize=None,
augmentations=test_aug)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
num_workers=0)
predictions = Engine.predict(test_loader, model, DEVICE)
return np.vstack((predictions)).ravel()
def test(fold):
test_img_path = config.TEST_IMAGES
device = config.DEVICE
test_bs = config.TEST_BS
df_test = pd.read_csv(config.TEST_FILE).reset_index(drop=True)
model_ = model.SE_Resnext50_32x4d(pretrained=None)
model_.load_state_dict(torch.load(os.path.join(config.MODEL_PATH, f"model_fold_{fold}.bin")))
model_.to(device)
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
test_aug = alb.Compose([alb.Normalize(mean, std, max_pixel_value=255.0, always_apply=True)])
test_imgs = df_test.image_name.values.tolist()
test_imgs = [os.path.join(test_img_path, i + ".jpg") for i in test_imgs]
test_targets = np.zeros(len(test_imgs))
test_dataset = ClassificationLoader(
image_paths = test_imgs,
targets=test_targets,
resize=(256,256),
augmentations=test_aug
)
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size= test_bs, shuffle=False, num_workers=4
)
predictions = Engine.predict(test_loader, model_, device=device)
predictions = np.vstack((predictions)).ravel()
return predictions
def predict(image_path, model):
aug = albumentations.Compose(
[
albumentations.Normalize(mean, std, max_pixel_value=255.0, always_apply=True)
]
)
images = [image_path]
targets = [0]
test_dataset = ClassificationLoader(
image_paths=images,
targets=targets,
resize=None,
augmentations=aug,
)
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=1, shuffle=False, num_workers=4
)
predictions = Engine.predict(test_loader, model, DEVICE)
predictions = np.vstack((predictions)).ravel()
return predictions
def train_dataloader(images, targets):
dataset = ClassificationLoader(image_paths=images,
targets=targets,
resize=None,
augmentations=train_albumentation())
data_loader = DataLoader(dataset=dataset,
batch_size=TRAIN_BS,
shuffle=True,
num_workers=10)
return data_loader
def test_dataloader(images, targets):
dataset = ClassificationLoader(image_paths=images,
targets=targets,
resize=None,
augmentations=valid_albumentation())
data_loader = DataLoader(dataset=dataset,
batch_size=1,
shuffle=False,
num_workers=0)
return data_loader
def predict(fold):
training_data_path = "/media/vatsal/Movies & Games/down_siim-isic-melanoma-classification/test224/"
model_path = "/media/vatsal/Movies & Games/Melenoma-Deep-Learning/model/"
df_test = pd.read_csv(
"/media/vatsal/Movies & Games/down_siim-isic-melanoma-classification/test.csv"
)
df_test.loc[:, "target"] = 0
device = "cuda"
epochs = 50
test_bs = 8
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
test_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
test_images = df_test.image_name.values.tolist()
test_images = [
os.path.join(training_data_path, i + ".jpg") for i in test_images
]
test_targets = df_test.target.values
test_dataset = ClassificationLoader(
image_paths=test_images,
targets=test_targets,
resize=None,
augmentations=test_aug,
)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=8,
shuffle=False,
num_workers=4)
model = SEResNext50_32x4d(pretrained=None)
model.load_state_dict(
torch.load(os.path.join(model_path, f"model{fold}.bin")))
model.to(device)
predictions = Engine.predict(test_loader, model, device=device)
predictions = np.vstack((predictions)).ravel()
return predictions
def predict(fold):
test_data_path = ''
model_path = ""
df_test = pd.read_csv("/.../test.csv")
df_test.loc[:, 'target'] = 0
epochs = 50
device = 'cuda'
test_bs = 32 #train batch size
#valid_bs = 16
#normalize image pixel values
mean = (0.485, 0.456, 0.406) #these values are for this model
std = (0.229, 0.224, 0.225)
#df_train = df[df.kfold != fold].reset_index(drop=True) #absolutely removes the previous index
#df_valid = df[df.kfold == fold].reset_index(drop=True)
#for image augmentation
test_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
test_images = df_test.image_name.values.tolist()
test_images = [
os.path.join(testing_data_path, i + '.jpg') for i in test_images
]
test_targets = df_test.target.values
test_dataset = ClassificationLoader(image_paths=test_images,
targets=test_targets,
resize=None,
augmentation=test_aug)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=test_bs,
shuffle=True,
num_workers=4)
model = SEResNext50_32x4d(pretrained='imagenet')
model.load_state_dict(torch.load(os.path.join(model_path, f"model{fold}")))
model.to(device)
predictions = Engine.predict(test_loader, model, device)
return np.vstack((predictions)).ravel()
def predict(fold):
# train image path
test_data_path = input("Enter the test data path (resized image): ")
# csv data path that was created from folds
test_csv_path = input("Enter the test.csv file path: ")
df_test = pd.read_csv(test_csv_path)
df_test.loc[:, "target"] = 0
model_path = "model/"
device = "cuda"
epochs = 30
test_batch_size = 16
mean = (0.485, 0.456, 0.225)
standard_deviation = (0.229, 0.224, 0.225)
test_aug = albumentations.Compose([
albumentations.Normalize(mean,
std=standard_deviation,
max_pixel_value=255.0,
always_apply=True)
])
# train image mapping
test_images = df_test.image_name.values.tolist()
test_images = [
os.path.join(test_data_path, i + ".jpg") for i in test_images
]
test_targets = df_test.target.values
# create valid dataset
test_dataset = ClassificationLoader(image_paths=test_images,
targets=test_targets,
resize=None,
augmentations=test_aug)
# validation data loader
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=test_batch_size,
shuffle=False,
num_workers=4)
# import model
model = SEResNext(pretrained='imagenet')
model.load_state_dict(
torch.load(os.path.join(model_path, f"model{fold}.bin")))
model.to(device)
#
predictions = Engine.predict(test_loader, model, device)
return np.vstack((predictions)).ravel()
def test_dataloader(images, targets):
dataset = ClassificationLoader(image_paths=images,
targets=targets,
resize=None,
augmentations=albumentations.Compose([
albumentations.Normalize(
MEAN,
STD,
max_pixel_value=255.0,
always_apply=True)
]))
data_loader = DataLoader(dataset=dataset,
batch_size=1,
shuffle=False,
num_workers=0)
return data_loader
def predict(fold):
test_data_path = ""
model_path = ""
df_test = pd.read_csv("")
df_test.loc[:, "target"] = 0
device = "cuda"
epochs = 50
test_bs = 16
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.244, 0.255)
test_aug = albumentations.Compose(
[
albumentations.Normalize(mean, std, max_pixel_value=255.0, always_apply=True),
]
)
test_images = df_test.image_name.values.tolist()
test_images = [os.path.join(test_data_path, i + ".jpg") for i in test_images]
test_targets = np.zeros(len(test_images))
test_dataset = ClassificationLoader(
image_paths=test_images,
targets=test_targets,
resize=None,
augmentations=test_aug
)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=test_bs,
shuffle=False,
num_workers=4
)
model = SEResNext50_32x4d(pretrained=None)
model.load_state_dict(torch.load(os.path.join(model_path, f"model{fold}.bin")))
model.to(device)
predictions = Engine.predict(
test_loader,
model,
device=device
)
return np.vstack((predictions)).ravel()
def predict(fold):
print(f"Predicting fold #{fold}")
test_data_path = "/mnt/Data/MelanomaClassification/input/kaggle/working/test224/"
df = pd.read_csv("/mnt/Data/MelanomaClassification/input/test.csv")
device = "cuda"
model_path = os.path.join("/mnt/Data/MelanomaClassification/models/",
f"model_fold_{fold}.bin")
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True)
])
images = df.image_name.values.tolist()
images = [os.path.join(test_data_path, i + ".png") for i in images]
targets = np.zeros(len(images))
test_dataset = ClassificationLoader(
image_paths=images,
targets=targets,
resize=None,
augmentations=aug,
)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=16,
shuffle=False,
num_workers=4)
model = SEResNext50_32x4d(pretrained=None)
model.load_state_dict(torch.load(model_path))
model.to(device)
predictions = Engine.predict(test_loader, model, device=device)
predictions = np.vstack((predictions)).ravel()
return predictions
def predict(image_path, fold):
device = "cpu"
model_path = "../model/"
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
test_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
test_images = [image_path]
test_targets = [0]
test_dataset = ClassificationLoader(
image_paths=test_images,
targets=test_targets,
resize=None,
augmentations=test_aug,
)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=8,
shuffle=False,
num_workers=4)
model = SEResNext50_32x4d(pretrained=None)
model.load_state_dict(
torch.load(os.path.join(model_path, f"model_fold_{fold}.bin"))
) #if gets error here add map_location=torch.device('cpu')
predictions = Engine.predict(test_loader, model, device=device)
predictions = np.vstack((predictions)).ravel()
print(predictions)
return predictions[0]
def predict(fold):
#df load
test_data_path=img_path+"/test3/"
df=pd.read_csv(data_path+"/test.csv")
device="cuda" if torch.cuda.is_available() else "cpu"
model_path=saved_path+f"/model_fold_{fold}.bin"
test_bs=32
#augmentation
mean=(0.485, 0.456, 0.406)
std=(0.229, 0.224, 0.225)
aug=albumentations.Compose([
albumentations.Normalize(mean,std,max_pixel_value=255.0,always_apply=True)
])
#dataset
images=df.image_name.values.tolist()
images=[test_data_path+file+".jpg" for file in images]
targets=np.zeros(len(images))
test_dataset=ClassificationLoader(
image_paths=images,
targets=targets,
resize=None,
augmentations=aug,
)
#data loader
test_loader=torch.utils.data.DataLoader(
test_dataset,batch_size=test_bs,shuffle=False,num_workers=4)
#model
model=SEResnext50_32x4d(pretrained=True)
model.load_state_dict(torch.load(model_path))
model.to(device)
predictions=Engine.predict(test_loader,model,device)
predictions=np.vstack((predictions)).ravel()
return predictions
def train(fold):
training_data_path = "/home/sushi/code/Kaggle/Melanoma-Detection-/input/jpeg/train224"
df = pd.read_csv(
"/home/sushi/code/Kaggle/Melanoma-Detection-/input/train_folds.csv")
model_path = "/home/sushi/code/Kaggle/Melanoma-Detection-/models"
device = "cuda"
epochs = 50
train_bs = 32
valid_bs = 16
df_train = df[df.kfold != fold].reset_index(drop=True)
df_valid = df[df.kfold == fold].reset_index(drop=True)
train_aug = albumentations.Compose(
albumentations.Normalize(always_apply=True))
valid_aug = albumentations.Compose(
albumentations.Normalize(always_apply=True))
train_images = df_train.image_name.values.tolist()
train_images = [
os.path.join(training_data_path, i + ".jpg") for i in train_images
]
train_targets = df_train.targets.values
valid_images = df_valid.image_name.values.tolist()
valid_images = [
os.path.join(training_data_path, i + "jpg") for i in valid_images
]
valid_targets = df_valid.target.values
train_dataset = ClassificationLoader(image_paths=train_images,
targets=train_targets,
resize=None,
augmentations=train_aug)
valid_dataset = ClassificationLoader(image_paths=valid_images,
targets=train_targets,
resize=None,
augmentations=valid_aug)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=train_bs,
shuffle=False,
num_workers=4)
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=train_bs,
shuffle=False,
num_workers=4)
model = SEResNext50_32x4d(pretrained="imagenet")
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
patience=3,
mode="max")
#model,optimizer = amp.initialize(
# model,
# optimizer,
# opt_level ="01",
# verbosity=0
#)
es = EarlyStopping(patience=5, mode="max")
for epoch in range(epochs):
training_loss = Engine.train(train_loader,
model,
optimizer,
device,
fp16=True)
predictions, valid_loss = Engine.evaluate(
train_loader,
model,
optimizer,
device,
)
predictions = np.vstack((predictions)).ravel()
auc = metrics.roc_auc_score(valid_targets, predictions)
scheduler.step(auc)
print(f"epoch={epoch}, auc:{auc}")
es(auc, model, model_path)
if es.early_stop:
print("early stopping")
break
def train(fold):
training_data_path = "../input/siic-isic-224x224-images/train/"
df = pd.read_csv("/kaggle/working/train_folds.csv")
device = "cuda"
epochs = 50
train_bs = 32
valid_bs = 16
df_train = df[df.kfold != fold].reset_index(drop=True)
df_valid = df[df.kfold == fold].reset_index(drop=True)
model = SEResnext50_32x4d(pretrained="imagenet")
model.to(device)
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
train_aug = albumentations.Compose(
[
albumentations.Normalize(mean, std, max_pixel_value=255.0, always_apply=True),
albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=15),
albumentations.Flip(p=0.5)
]
)
valid_aug = albumentations.Compose(
[
albumentations.Normalize(mean, std, max_pixel_value=255.0, always_apply=True)
]
)
train_images = df_train.image_name.values.tolist()
train_images = [os.path.join(training_data_path, i + ".png") for i in train_images]
train_targets = df_train.target.values
valid_images = df_valid.image_name.values.tolist()
valid_images = [os.path.join(training_data_path, i + ".png") for i in valid_images]
valid_targets = df_valid.target.values
train_dataset = ClassificationLoader(
image_paths=train_images,
targets=train_targets,
resize=None,
augmentations=train_aug,
)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=train_bs, shuffle=True, num_workers=4
)
valid_dataset = ClassificationLoader(
image_paths=valid_images,
targets=valid_targets,
resize=None,
augmentations=valid_aug,
)
valid_loader = torch.utils.data.DataLoader(
valid_dataset, batch_size=valid_bs, shuffle=False, num_workers=4
)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
patience=3,
threshold=0.001,
mode="max"
)
es = EarlyStopping(patience=5, mode="max")
for epoch in range(epochs):
train_loss = Engine.train(train_loader, model, optimizer, device=device)
predictions, valid_loss = Engine.evaluate(
valid_loader, model, device=device
)
predictions = np.vstack((predictions)).ravel()
auc = metrics.roc_auc_score(valid_targets, predictions)
print(f"Epoch = {epoch}, AUC = {auc}")
scheduler.step(auc)
es(auc, model, model_path=f"model_fold_{fold}.bin")
if es.early_stop:
print("Early stopping")
break
def train(fold):
training_data_path = "/content/train_images/"
df = pd.read_csv("train_folds.csv")
model_path = "/content/checkpoints/"
device = "cpu"
epochs = 10
train_bs = 32
val_bs = 16
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
df_train = df[df.kfold != fold].reset_index(drop=True)
df_val = df[df.kfold == fold].reset_index(drop=True)
train_aug = albumentations.Compose(
[
albumentations.Normalize(mean, std, max_pixel_value=255, always_apply=True)
]
)
val_aug = albumentations.Compose(
[
albumentations.Normalize(mean, std, max_pixel_value=255, always_apply=True)
]
)
train_images = df_train.image_name.values.tolist()
train_images = [os.path.join(training_data_path, i + ".jpg") for i in train_images]
train_targets = df_train.target.values
val_images = df_val.image_name.values.tolist()
val_images = [os.path.join(training_data_path, i + ".jpg") for i in val_images]
val_targets = df_train.target.values
train_dataset = ClassificationLoader(
image_paths= train_images,
targets = train_targets,
resize=None,
augmentations=train_aug
)
train_loder = torch.utils.data.DataLoader(
train_dataset,
batch_size=train_bs,
shuffle=False,
num_workers=4
)
val_dataset = ClassificationLoader(
image_paths= val_images,
targets = val_targets,
resize=None,
augmentations=val_aug
)
val_loder = torch.utils.data.DataLoader(
val_dataset,
batch_size=val_bs,
num_workers=4
)
model = SEResNext50_32x4d(pretrained='imagenet')
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr= 1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
optimizer,
patience=3,
mode="max"
)
es = EarlyStopping(patience=5, mode= "max")
predictions = []
for epoch in range(epochs):
training_loss = Engine.train(train_loder, model, optimizer, device=device)
val_loss = engine.evaluate(val_loder)
predictions = np.vstack((engine.predict(val_loder))).ravel()
auc = metrics.roc_auc_score(val_targets, predictions)
scheduler.step(auc)
print(f"epoch = {epoch}, auc = {auc}")
es(auc, model, model_path)
if es.early_stop:
print("early stopping")
break
def train(fold):
training_data_path = "/home/abhishek/workspace/melanoma/input/jpeg/train224/"
model_path = "/home/abhishek/workspace/melanoma-deep-learning"
df = pd.read_csv("/home/abhishek/workspace/melanoma/input/train_folds.csv")
device = "cuda"
epochs = 50
train_bs = 32
valid_bs = 16
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
df_train = df[df.kfold != fold].reset_index(drop=True)
df_valid = df[df.kfold == fold].reset_index(drop=True)
train_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
valid_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
train_images = df_train.image_name.values.tolist()
train_images = [
os.path.join(training_data_path, i + ".jpg") for i in train_images
]
train_targets = df_train.target.values
valid_images = df_valid.image_name.values.tolist()
valid_images = [
os.path.join(training_data_path, i + ".jpg") for i in valid_images
]
valid_targets = df_valid.target.values
train_dataset = ClassificationLoader(image_paths=train_images,
targets=train_targets,
resize=None,
augmentations=train_aug)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=train_bs,
shuffle=True,
num_workers=4)
valid_dataset = ClassificationLoader(image_paths=valid_images,
targets=valid_targets,
resize=None,
augmentations=valid_aug)
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=valid_bs,
shuffle=False,
num_workers=4)
model = SEResNext50_32x4d(pretrained="imagenet")
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
patience=3,
mode="max")
model, optimizer = amp.initialize(model,
optimizer,
opt_level="O1",
verbosity=0)
es = EarlyStopping(patience=5, mode="max")
for epoch in range(epochs):
training_loss = Engine.train(train_loader,
model,
optimizer,
device,
fp16=True)
predictions, valid_loss = Engine.evaluate(train_loader, model,
optimizer, device)
predictions = np.vstack((predictions)).ravel()
auc = metrics.roc_auc_score(valid_targets, predictions)
scheduler.step(auc)
print(f"epoch={epoch}, auc={auc}")
es(auc, model, os.path.join(model_path, f"model{fold}.bin"))
if es.early_stop:
print("early stopping")
break
def train(fold):
# train image path
training_data_path = input("Enter the train data path (resized image): ")
# csv data path that was created from folds
fold_csv_path = input("Enter the train_fold.csv file path: ")
df = pd.read_csv(fold_csv_path)
model_path = "model/"
device = "cuda"
epochs = 30
train_batch_size = 32
valid_batch_size = 16
mean = (0.485, 0.456, 0.225)
standard_deviation = (0.229, 0.224, 0.225)
df_train = df[df.kfold != fold].reset_index(drop=True)
df_valid = df[df.kfold == fold].reset_index(drop=True)
# normalize images
train_aug = albumentations.Compose([
albumentations.Normalize(mean,
std=standard_deviation,
max_pixel_value=255.0,
always_apply=True)
])
valid_aug = albumentations.Compose([
albumentations.Normalize(mean,
std=standard_deviation,
max_pixel_value=255.0,
always_apply=True)
])
# train image mapping
train_images = df_train.image_name.values.tolist()
train_images = [
os.path.join(training_data_path, i + ".jpg") for i in train_images
]
train_targets = df_train.target.values
valid_images = df_train.image_name.values.tolist()
valid_images = [
os.path.join(training_data_path, i + ".jpg") for i in valid_images
]
valid_targets = df_valid.target.values
# create train loader
train_dataset = ClassificationLoader(image_paths=train_images,
targets=train_targets,
resize=None,
augmentations=train_aug)
# train loader
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=train_batch_size,
shuffle=True,
num_workers=4)
# create valid dataset
valid_dataset = ClassificationLoader(image_paths=valid_images,
targets=valid_targets,
resize=None,
augmentations=valid_aug)
# validation data loader
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=valid_batch_size,
shuffle=False,
num_workers=4)
# import model
model = SEResNext(pretrained='imagenet')
model.to(device)
#
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
# dynamic learning rate reducing based on validation measurements.
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
# https://pytorch.org/docs/master/optim.html#torch.optim.lr_scheduler.ReduceLROnPlateau
optimizer,
patience=4,
mode='max',
)
# use apex for mixed precision training
# amp: Automatic Mixed Precision
model, optimizer = amp.initialize(model,
optimizer,
opt_level='01',
verbosity=0)
# earlystopping
es = EarlyStopping(patience=5, mode='max')
# train the train data
# use thr wtfml module for calculating loss and evaluation
for epoch in range(epochs):
training_loss = Engine.train(train_loader,
model,
optimizer,
device,
fp16=True)
predictions, valid_loss = Engine.evaluate(train_loader, model,
optimizer, device)
predictions = np.vstack((predictions).ravel())
auc = metrics.roc_auc_score(valid_targets, predictions)
scheduler.step(auc)
print(f"epoch = {epoch}, auc= {auc}")
es(auc, model, os.path.join(model_path, f"model{fold}.bin"))
if es.early_stop:
print("Early Stopping")
break
def train(fold):
training_data_path = ''
model_path = ""
df = pd.read_csv("/.../train_folds.csv")
device = "cuda"
epochs = 50
train_bs = 32 #train batch size
valid_bs = 16
#normalize image pixel values
mean = (0.485, 0.456, 0.406) #these values are for this model
std = (0.229, 0.224, 0.225)
df_train = df[df.kfold != fold].reset_index(
drop=True) #absolutely removes the previous index
df_valid = df[df.kfold == fold].reset_index(drop=True)
#for image augmentation
train_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
valid_aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True),
])
train_images = df_train.image_name.values.tolist()
train_images = [
os.path.join(training_data_path, i + '.jpg') for i in train_images
]
train_targets = df_train.target.values
valid_images = df_valid.image_name.values.tolist()
valid_images = [
os.path.join(training_data_path, i + '.jpg') for i in valid_images
]
valid_targets = df_valid.target.values
train_dataset = ClassificationLoader(image_paths=train_images,
targets=train_targets,
resize=None,
augmentation=train_aug)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=train_bs,
shuffle=True,
num_workers=4)
valid_dataset = ClassificationLoader(image_paths=valid_images,
targets=valid_targets,
resize=None,
augmentation=valid_aug)
valid_loader = torch.utils.data.DataLoader(valid_dataset,
batch_size=valid_bs,
shuffle=True,
num_workers=4)
model = SEResNext50_32x4d(pretrained='imagenet')
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( # reduce learning rate if it plateaus at any level
optimizer,
patience=3,
mode=
"max" #max because we'll be using scheduler on AUC(area under ROC curve)
)
model, optimizer = amp.initialize( #apex is used for mixed precision training, it trains faster with less memory
model,
optimizer,
opt_level="01",
verbosity=0)
es = EarlyStopping(patience=5, mode="max")
for epoch in range(epochs):
training_loss = Engine.train(train_loader,
model,
optimizer,
device,
fp16=True)
predictions, valid_loss = Engine.evaluate(train_loader, model,
optimizer, device)
predictions = np.vstack((predictions)).ravel()
auc = metrics.roc_auc_score(
valid_targets, predictions
) #this is why valid_data should not be shuffled as opposed to training data
scheduler.step(auc)
print("epoch={}, auc={}".format(epoch, auc))
es(auc, model, os.path.join(model_path, f"model{fold}.bin"))
if es.early_stop:
print('early stopping')
break
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True)
])
train_images, valid_images, train_targets, valid_targets = train_test_split(
images, targets)
train_dataset = ClassificationLoader(
image_paths=train_images,
targets=train_targets,
resize=(128, 128),
augmentations=aug,
)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=16,
shuffle=True,
num_workers=4)
valid_dataset = ClassificationLoader(
image_paths=valid_images,
targets=valid_targets,
resize=(128, 128),
augmentations=aug,
)