def get_batch_vali_imgs(img_paths):
all_images = []
for one_protein_vali in img_paths:
loaded_b_img_vali = utils_image.load_img(one_protein_vali[0])
loaded_g_img_vali = utils_image.load_img(one_protein_vali[1])
loaded_r_img_vali = utils_image.load_img(one_protein_vali[2])
loaded_y_img_vali = utils_image.load_img(one_protein_vali[3])
# print("loaded_b_img_vali",loaded_b_img_vali.shape)
# (512, 512)
loaded_b_img_vali = utils_image.resize_img(loaded_b_img_vali, 224, 224)
loaded_g_img_vali = utils_image.resize_img(loaded_g_img_vali, 224, 224)
loaded_r_img_vali = utils_image.resize_img(loaded_r_img_vali, 224, 224)
loaded_y_img_vali = utils_image.resize_img(loaded_y_img_vali, 224, 224)
# print("loaded_b_img_vali",loaded_b_img_vali.shape)
# (224, 224)
all_images.append([
loaded_b_img_vali, loaded_g_img_vali, loaded_r_img_vali,
loaded_y_img_vali
])
all_images_vali_stacked = np.stack(all_images, axis=0)
# print("all_images_vali_stacked",all_images_vali_stacked.shape)
# (2, 4, 224, 224)
return all_images_vali_stacked
def generate_dense_dataset(dense_d_bs_pa, img_h, img_w):
dense_ori_ph = []
dense_ref_ph = []
for one_img in range(len(dense_d_bs_pa)):
# c o_dense_ori_img_p: one dense train image path
o_dense_ori_img_p = dense_d_bs_pa[one_img][0].strip()
# print("o_dense_ori_img_p",o_dense_ori_img_p)
# c o_dense_r_gt_img_p: one dense gt image path
o_dense_r_gt_img_p = dense_d_bs_pa[one_img][1].strip()
# print("o_dense_r_gt_img_p",o_dense_r_gt_img_p)
# --------------------------------------------------------------------------------
# c ol_dense_tr_i: one loaded dense train image
ol_dense_tr_i = utils_image.load_img(o_dense_ori_img_p) / 255.0
# ol_dense_tr_i=(ol_dense_tr_i-np.mean(ol_dense_tr_i))/(np.std(ol_dense_tr_i)+0.000001)
# ol_dense_tr_i=(ol_dense_tr_i-np.min(ol_dense_tr_i))/np.ptp(ol_dense_tr_i)
# ol_dense_tr_i[ol_dense_tr_i==0.0]=0.0001
# print("ol_dense_tr_i",ol_dense_tr_i)
# plt.imshow(ol_dense_tr_i)
# plt.show()
ol_dense_R_gt_i = utils_image.load_img(o_dense_r_gt_img_p) / 255.0
# c ol_iiw_tr_i: one loaded iiw train image
# --------------------------------------------------------------------------------
# c ol_r_dense_tr_i: one loaded resized dense train image
ol_r_dense_tr_i = utils_image.resize_img(ol_dense_tr_i, img_h, img_w)
ol_r_dense_R_gt_i = utils_image.resize_img(ol_dense_R_gt_i, img_h,
img_w)
dense_ori_ph.append(ol_r_dense_tr_i)
dense_ref_ph.append(ol_r_dense_R_gt_i)
dense_ori_imgs = np.stack(dense_ori_ph, axis=0).transpose(0, 3, 1, 2)
dense_ref_imgs = np.stack(dense_ref_ph, axis=0).transpose(0, 3, 1, 2)
return dense_ori_imgs, dense_ref_imgs
def initialize_grad_cam(model, list_of_img_paths, args):
# @ Get your trained network
# print("model",model)
# ================================================================================
# @ Deep copy your trained network having FC
model_with_fc = copy.deepcopy(model)
# model = models.resnet50(pretrained=True)
# del model.fc
# print(model)
# del model_with_fc.fc
# del list(model_with_fc.layer4.children())[-1].cbam
# ================================================================================
# @ Delete last fully connected layer
del model.fc
# del list(model.layer4.children())[-1].cbam
# print("model",list(model.layer4.children())[-1])
# print("model",dir(model))
# print("model",dir(model.layer4))
# print("model",model)
# ================================================================================
grad_cam = GradCam(model, model_with_fc, target_layer_names=["layer1"])
# ================================================================================
for img_p in list_of_img_paths:
loaded_img = utils_image.load_img(img_p) / 255.0
loaded_img = utils_image.resize(loaded_img, (224, 224))
loaded_img = loaded_img.astype("float32")
input = preprocess_image(loaded_img)
# <class 'torch.Tensor'>
target_index = None
mask = grad_cam(input, target_index)
import scipy.misc
# scipy.misc.imsave('./mask.png',mask)
# afaf 1: mask = grad_cam(input, target_index)
i = 0
i = i + 1
show_cam_on_image(loaded_img, mask, i)
def load_skin_cancer_dense(bs_paths_dense,args):
# print("bs_paths_dense",bs_paths_dense)
# [['/mnt/1T-5e7/Code_projects/Bio_related/Skin_related/kaggle.com_kmader_skin-cancer-mnist-ham10000/kaggle.com_saketc_skin-lesion-analyser-sla/base_dir/train_dir/bcc/_36_6146895.jpg', 'bcc'], ['/mnt/1T-5e7/Code_projects/Bio_related/Skin_related/kaggle.com_kmader_skin-cancer-mnist-ham10000/kaggle.com_saketc_skin-lesion-analyser-sla/base_dir/train_dir/nv/ISIC_0024755.jpg', 'nv'], ['/mnt/1T-5e7/Code_projects/Bio_related/Skin_related/kaggle.com_kmader_skin-cancer-mnist-ham10000/kaggle.com_saketc_skin-lesion-analyser-sla/base_dir/train_dir/bcc/_4_7667536.jpg', 'bcc']]
# ================================================================================
lo_img_and_class_data=[]
for one_img_and_class_path in bs_paths_dense:
img_path=one_img_and_class_path[0]
class_name=one_img_and_class_path[1]
loaded_img=utils_image.load_img(img_path,gray=False)
print("loaded_img",loaded_img.shape)
# (450, 600, 3)
# ================================================================================
lo_img_and_class_data.append([loaded_img,class_name])
print("lo_img_and_class_data",lo_img_and_class_data)
afaf
def detect_img_less_than_256(txt_file_containing_paths_of_img):
"""
Act
*
Params
* txt_file_containing_paths_of_img
"/mnt/1T-5e7/image/whole_dataset/text_for_colab/real/temp/bigtime_trn.txt"
Return
* have_small_img
If 0, you have no small image
* small_lens
[199,200] means you have images which has 199 or 200 lengths
"""
p_l_full, num_img = utils_common.return_path_list_from_txt(
txt_file_containing_paths_of_img)
# print("num_img",num_img)
# 8400
# c col_i_szs: collection of image sizes
col_i_szs = []
# c col_i_pa_szs: collection of image paths and sizes
col_i_pa_szs = []
for one_path in p_l_full:
one_path = one_path.replace("\n", "")
one_lo_img = utils_image.load_img(one_path)
col_i_szs.append(one_lo_img.shape[:2])
col_i_pa_szs.append([one_path, one_lo_img.shape[:2]])
col_i_szs = list(set(col_i_szs))
col_i_szs_np = np.array(col_i_szs)
# c have_small_img: you have small images?
have_small_img = np.sum(col_i_szs_np < 256)
# print("have_small_img",have_small_img)
# c small_lens: small length
small_lens = col_i_szs_np[col_i_szs_np < 256]
return have_small_img, small_lens
def generate_cgmit_dataset(cgmit_d_bs_pa, img_h, img_w):
cgmit_tr_3c_img = []
cgmit_gt_R_3c_img = []
cgmit_gt_S_1c_img = []
cgmit_mask_3c_img = []
for one_img in range(len(cgmit_d_bs_pa)):
# c one_iiw_tr_img_p: one iiw train image path
one_cgmit_tr_img_p = cgmit_d_bs_pa[one_img][0].strip()
# print("one_cgmit_tr_img_p",one_cgmit_tr_img_p)
# c one_cgmit_r_gt_p: one iiw json gt path
one_cgmit_r_gt_p = cgmit_d_bs_pa[one_img][1].strip()
# print("one_cgmit_r_gt_p",one_cgmit_r_gt_p)
# --------------------------------------------------------------------------------
ol_cgmit_tr_i = utils_image.load_img(one_cgmit_tr_img_p) / 255.0
# ol_iiw_tr_i=np.where(ol_iiw_tr_i==0.0,0.0001,ol_dense_tr_i)
# ol_iiw_tr_i[ol_iiw_tr_i==0.0]=0.0001
ol_cgmit_r_gt_i = utils_image.load_img(one_cgmit_r_gt_p) / 255.0
# --------------------------------------------------------------------------------
ol_cgmit_tr_i = utils_image.resize_img(ol_cgmit_tr_i, img_h, img_w)
ol_cgmit_r_gt_i = utils_image.resize_img(ol_cgmit_r_gt_i, img_h, img_w)
# --------------------------------------------------------------------------------
# c srgb_img: actually rgb original image than srgb original image
srgb_img = ol_cgmit_tr_i
gt_R = ol_cgmit_r_gt_i
mask = np.ones((srgb_img.shape[0], srgb_img.shape[1]))
# print("mask",mask.shape)
# mask (341, 512)
# c gt_R_gray: mean of R gt image
gt_R_gray = np.mean(gt_R, 2)
mask[gt_R_gray < 1e-6] = 0
# mean of original image
mask[np.mean(srgb_img, 2) < 1e-6] = 0
# plt.imshow(mask,cmap="gray")
# plt.show()
mask = skimage.morphology.binary_erosion(mask, square(11))
mask = np.expand_dims(mask, axis=2)
mask = np.repeat(mask, 3, axis=2)
gt_R[gt_R < 1e-6] = 1e-6
rgb_img = srgb_img
gt_S = rgb_img / gt_R
# plt.imshow(gt_S[:,:,0],cmap='gray')
# plt.show()
# search_name=path[:-4]+".rgbe"
# irridiance=self.stat_dict[search_name]
# if irridiance<0.25:
# srgb_img=denoise_tv_chambolle(srgb_img,weight=0.05,multichannel=True)
# gt_S=denoise_tv_chambolle(gt_S,weight=0.1,multichannel=True)
mask[gt_S > 10] = 0
gt_S[gt_S > 20] = 20
mask[gt_S < 1e-4] = 0
gt_S[gt_S < 1e-4] = 1e-4
if np.sum(mask) < 10:
max_S = 1.0
else:
max_S = np.percentile(gt_S[mask > 0.5], 90)
gt_S = gt_S / max_S
gt_S = np.mean(gt_S, 2)
gt_S = np.expand_dims(gt_S, axis=2)
#gt_R=np.mean(gt_R,2)
gt_R = np.expand_dims(gt_R, axis=2)
tr_3c_img = srgb_img.squeeze()
gt_R_3c_img = gt_R.squeeze()
gt_S_1c_img = gt_S.squeeze()[:, :, np.newaxis]
mask_3c_img = mask.squeeze()
# print("tr_3c_img",tr_3c_img.shape)
# print("gt_R_3c_img",gt_R_3c_img.shape)
# print("gt_S_1c_img",gt_S_1c_img.shape)
# print("mask_3c_img",mask_3c_img.shape)
# tr_3c_img (1024, 1024, 3)
# gt_R_3c_img (1024, 1024, 3)
# gt_S_1c_img (1024, 1024, 1)
# mask_3c_img (1024, 1024, 3)
# --------------------------------------------------------------------------------
cgmit_tr_3c_img.append(tr_3c_img)
cgmit_gt_R_3c_img.append(gt_R_3c_img)
cgmit_gt_S_1c_img.append(gt_S_1c_img)
cgmit_mask_3c_img.append(mask_3c_img.astype("float16"))
cgmit_tr_3c_imgs = np.stack(cgmit_tr_3c_img, axis=0).transpose(0, 3, 1, 2)
cgmit_gt_R_3c_imgs = np.stack(cgmit_gt_R_3c_img,
axis=0).transpose(0, 3, 1, 2)
cgmit_gt_S_1c_imgs = np.stack(cgmit_gt_S_1c_img,
axis=0).transpose(0, 3, 1, 2)
cgmit_mask_3c_imgs = np.stack(cgmit_mask_3c_img,
axis=0).transpose(0, 3, 1, 2)
# print("cgmit_tr_3c_imgs",cgmit_tr_3c_imgs.shape)
# print("cgmit_gt_R_3c_imgs",cgmit_gt_R_3c_imgs.shape)
# print("cgmit_gt_S_1c_imgs",cgmit_gt_S_1c_imgs.shape)
# print("cgmit_mask_3c_imgs",cgmit_mask_3c_imgs.shape)
# cgmit_tr_3c_imgs (4, 3, 1024, 1024)
# cgmit_gt_R_3c_imgs (4, 3, 1024, 1024)
# cgmit_gt_S_1c_imgs (4, 1, 1024, 1024)
# cgmit_mask_3c_imgs (4, 3, 1024, 1024)
return cgmit_tr_3c_imgs, cgmit_gt_R_3c_imgs, cgmit_gt_S_1c_imgs, cgmit_mask_3c_imgs
def generate_sparse_dataset(iiw_d_bs_pa, img_h, img_w):
iiw_tr_ph = []
iiw_ori_ph = []
iiw_json_ph = []
applied_DAs = []
iiw_img_after_DA_before_rs_ph = []
for one_img in range(len(iiw_d_bs_pa)):
# c one_iiw_tr_img_p: one iiw train image path
one_iiw_tr_img_p = iiw_d_bs_pa[one_img][0].strip()
# print("one_iiw_tr_img_p",one_iiw_tr_img_p)
# c one_iiw_json_gt_p: one iiw json gt path
one_iiw_json_gt_p = iiw_d_bs_pa[one_img][1].strip()
# print("one_iiw_json_gt_p",one_iiw_json_gt_p)
# --------------------------------------------------------------------------------
ol_iiw_tr_i = utils_image.load_img(one_iiw_tr_img_p) / 255.0
# ol_iiw_tr_i=np.where(ol_iiw_tr_i==0.0,0.0001,ol_dense_tr_i)
# ol_iiw_tr_i[ol_iiw_tr_i==0.0]=0.0001
# --------------------------------------------------------------------------------
# c kind_of_DA: you create list which contains kind of data augmentation
kind_of_DA = ["no_DA", "ud", "lr", "p3", "p6", "p9", "n3", "n6", "n9"]
# c chosen_DA: you get chosen kind of data augmentation
chosen_DA = np.random.choice(kind_of_DA, 1, replace=False)[0]
# print("chosen_DA",chosen_DA)
# chosen_DA n9
if chosen_DA == "ud":
iiw_img_after_DA = np.flipud(ol_iiw_tr_i)
elif chosen_DA == "lr":
iiw_img_after_DA = np.fliplr(ol_iiw_tr_i)
elif chosen_DA == "p3":
iiw_img_after_DA = scipy.ndimage.interpolation.rotate(
ol_iiw_tr_i, angle=3, reshape=True, mode="reflect")
elif chosen_DA == "p6":
iiw_img_after_DA = scipy.ndimage.interpolation.rotate(
ol_iiw_tr_i, angle=6, reshape=True, mode="reflect")
elif chosen_DA == "p9":
iiw_img_after_DA = scipy.ndimage.interpolation.rotate(
ol_iiw_tr_i, angle=9, reshape=True, mode="reflect")
elif chosen_DA == "n3":
iiw_img_after_DA = scipy.ndimage.interpolation.rotate(
ol_iiw_tr_i, angle=-3, reshape=True, mode="reflect")
elif chosen_DA == "n6":
iiw_img_after_DA = scipy.ndimage.interpolation.rotate(
ol_iiw_tr_i, angle=-6, reshape=True, mode="reflect")
elif chosen_DA == "n9":
iiw_img_after_DA = scipy.ndimage.interpolation.rotate(
ol_iiw_tr_i, angle=-9, reshape=True, mode="reflect")
else:
iiw_img_after_DA = ol_iiw_tr_i
# plt.imshow(iiw_img_after_DA)
# plt.show()
# afaf
iiw_img_after_DA = cv2.normalize(iiw_img_after_DA,
None,
alpha=0,
beta=1,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_32F)
iiw_img_after_DA[iiw_img_after_DA < 1e-6] = 1e-6
iiw_img_after_DA_before_rs = iiw_img_after_DA
# --------------------------------------------------------------------------------
iiw_img_after_DA_after_rs = utils_image.resize_img(
iiw_img_after_DA, img_h, img_w)
# plt.imshow(iiw_img_after_DA_after_rs)
# plt.show()
# afaf
# --------------------------------------------------------------------------------
# iiw_ori_ph: original size
iiw_ori_ph.append(ol_iiw_tr_i)
# iiw_tr_ph: resized size
iiw_tr_ph.append(iiw_img_after_DA_after_rs)
iiw_json_ph.append(one_iiw_json_gt_p)
applied_DAs.append(chosen_DA)
iiw_img_after_DA_before_rs_ph.append(iiw_img_after_DA_before_rs)
iiw_tr_imgs = np.stack(iiw_tr_ph, axis=0).transpose(0, 3, 1, 2)
return iiw_tr_imgs, iiw_ori_ph, iiw_json_ph, applied_DAs, iiw_img_after_DA_before_rs_ph
def train(args):
k_fold=3
epoch=int(args.epoch)
batch_size=int(args.batch_size)
# print("epoch",epoch)
# print("batch_size",batch_size)
# 9
# 2
# ================================================================================
text_file_instance=text_file_path_api_module.Path_Of_Text_Files(args)
txt_of_train_data=text_file_instance.train_data
# print("txt_of_train_data",txt_of_train_data)
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train_csv_path.txt
# ================================================================================
contents_of_txt,num_line=utils_common.return_path_list_from_txt(txt_of_train_data)
# print("contents_of_txt",contents_of_txt)
# ['/mnt/1T-5e7/mycodehtml/prac_data_science/kaggle/hivprogression/My_code/Data/training_data.csv']
# ================================================================================
train_data_df=pd.read_csv(contents_of_txt[0],encoding='utf8')
train_data_df=train_data_df.dropna()
# print("train_data_df",train_data_df.shape)
# (920, 6)
train_data_wo_id_df=train_data_df.iloc[:,1:]
# print("train_data_wo_id_df",train_data_wo_id_df.shape)
# (920, 5)
# ================================================================================
train_k,vali_k=utils_data.get_k_folds(train_data_wo_id_df)
# ================================================================================
# c loss_list: list which will stores loss values to plot loss
loss_list=[]
f1_score_list=[]
# ================================================================================
# c model_api_instance: instance of model API
model_api_instance=model_api_module.Model_API_class(args)
# print("model_api_instance",model_api_instance)
# <src.api_model.model_api_module.Model_API_class object at 0x7fb305557b00>
# ================================================================================
# # @ Test Grad CAM
# imgs=["/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_split/33/82d4d190d2fed1be255fc3bac36a37c860bb31c0.tif",
# "/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_split/33/82a5300cd61628fb9bae332cdb7d5e7e37b1fb36.tif"]
# grad_cam.initialize_grad_cam(model=model_api_instance.gen_net,list_of_img_paths=imgs,args=args)
# ================================================================================
if args.task_mode=="train": # If you're in train mode
# ================================================================================
# @ Configure learning rate scheduler
# Update learning rate 4 times during entire epochs
# For example, if you use 10 epochs, int(10/4), 1 2 / 3 4 / 5 6 / 7 8 / 9 10
# 0-1 epochs: 0.001 -> 2-3 epochs: 0.0001 -> 4-5 epochs: 0.00001 -> 5-6 epochs: 0.000001
scheduler=StepLR(model_api_instance.optimizer,step_size=int(epoch/4),gamma=0.1)
# ================================================================================
for one_k in range(k_fold):
single_train_k=train_k[one_k]
single_vali_k=vali_k[one_k]
single_train_lbl_k=train_lbl_k[one_k]
single_vali_lbl_k=vali_lbl_k[one_k]
# ================================================================================
# @ Validation dataset
dataset_inst_vali=custom_ds.Custom_DS_vali(single_vali_k,single_vali_lbl_k,args=args)
dataloader_vali=torch.utils.data.DataLoader(
dataset=dataset_inst_vali,batch_size=batch_size,shuffle=False,num_workers=3)
for one_ep in range(epoch): # @ Iterates all epochs
# print("single_train_k",len(single_train_k))
# 20714
# print("single_vali_k",len(single_vali_k))
# 10358
# print("single_train_lbl_k",len(single_train_lbl_k))
# 20714
# print("single_vali_lbl_k",len(single_vali_lbl_k))
# 10358
# ================================================================================
# c dataset_inst_trn: dataset instance of tumor
dataset_inst_trn=custom_ds.Custom_DS(single_train_k,single_train_lbl_k,args=args)
# Test iterator
# iter_dataset_inst_trn=iter(dataset_inst_trn)
# trn=next(iter_dataset_inst_trn)
# print("trn",trn)
# ================================================================================
# c dataloader_trn: create dataloader
dataloader_trn=torch.utils.data.DataLoader(
dataset=dataset_inst_trn,batch_size=batch_size,shuffle=False,num_workers=3)
# # c dataloader_trn_iter: iterator of dataloader
# dataloader_trn_iter=iter(dataloader_trn)
# # Test dataloader
# pairs=next(dataloader_trn_iter)
# # print("pairs",pairs)
# ================================================================================
# c num_imgs_trn: number of train image
num_imgs_trn=len(dataset_inst_trn)
# print("num_imgs_trn",num_imgs_trn)
# 20714
args.__setattr__("num_imgs_trn",num_imgs_trn)
# print("args",args)
# ================================================================================
# print("Current batch size:",batch_size)
# print("Possible batch size:",list(utils_common.divisorGenerator(num_imgs_trn)))
# assert str(num_imgs_trn/batch_size).split(".")[-1]==str(0),"Check batch size, currently it's incorrect"
# ================================================================================
# @ If you don't use Augmentor
if args.use_augmentor=="False":
pass
else: # @ If you use Augmentor
# @ Iterate all images in dataset during single epoch
for idx,data in enumerate(dataloader_trn):
bs_pa_tumor_d=utils_data.create_batch_pair_of_paths(data,args)
# print("bs_pa_tumor_d",bs_pa_tumor_d)
# [[('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/292d9824-bba1-11e8-b2b9-ac1f6b6435d0_blue.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/292d9824-bba1-11e8-b2b9-ac1f6b6435d0_green.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/292d9824-bba1-11e8-b2b9-ac1f6b6435d0_red.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/292d9824-bba1-11e8-b2b9-ac1f6b6435d0_yellow.png'),
# ('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/7f1e4598-bbc0-11e8-b2bb-ac1f6b6435d0_blue.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/7f1e4598-bbc0-11e8-b2bb-ac1f6b6435d0_green.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/7f1e4598-bbc0-11e8-b2bb-ac1f6b6435d0_red.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/7f1e4598-bbc0-11e8-b2bb-ac1f6b6435d0_yellow.png')],
# array(['3','23'],dtype='<U2')]
# ================================================================================
# @ Perform data augmentation
sampled_trn_imgs,label_values=utils_data.use_augmetor_for_data(bs_pa_tumor_d,args)
# afaf 1: sampled_trn_imgs,label_values=utils_data.use_augmetor_for_data(bs_pa_tumor_d,args)
# print("sampled_trn_imgs",sampled_trn_imgs.shape)
# (2, 4, 224, 224)
# print("label_values",label_values)
# [[4], [14]]
# print("label_values",np.array(label_values).shape)
# (2, 2)
# ================================================================================
oh_label_arr=utils_common.one_hot_label(batch_size,label_values)
# print("oh_label_arr",oh_label_arr)
# [[0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
# ================================================================================
trn_imgs_tcv=utils_pytorch.get_Variable(sampled_trn_imgs)
# print("trn_imgs_tcv",trn_imgs_tcv.shape)
# torch.Size([2, 4, 224, 224])
# ================================================================================
# @ Remove existing gradients
model_api_instance.remove_existing_gradients_before_starting_new_training()
# ================================================================================
# @ c predicted_labels: pass input images and get predictions
predicted_labels=model_api_instance.gen_net(trn_imgs_tcv)
# print("predicted_labels",predicted_labels)
# tensor([[-0.2858, -0.7700, -0.0600, 0.3553, 0.0367, -0.4130, 0.3102, -0.2443,
# -0.1775, -0.1839, 0.0499, -0.1489, -0.9805, 0.1817, -0.0504, 0.8930,
# -0.4017, -0.1899, 0.0937, -0.3465, 0.2830, -0.2755, 0.4233, -0.1301,
# 1.1688, 0.2110, 0.1423, -0.3933],
# [-0.2858, -0.7700, -0.0600, 0.3553, 0.0367, -0.4130, 0.3102, -0.2443,
# -0.1775, -0.1839, 0.0499, -0.1489, -0.9805, 0.1817, -0.0504, 0.8930,
# -0.4017, -0.1899, 0.0937, -0.3465, 0.2830, -0.2755, 0.4233, -0.1301,
# 1.1688, 0.2110, 0.1423, -0.3933]], device='cuda:0',grad_fn=<AddmmBackward>)
label_tc=Variable(torch.tensor(oh_label_arr,device=predicted_labels.device).float())
# print("label_tc",label_tc)
# tensor([[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
# [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],
# device='cuda:0',dtype=torch.float16)
# ================================================================================
# @ Calculate loss values
loss_val=loss_functions_module.FocalLoss(predicted_labels,label_tc)
# print("loss_val",loss_val)
# tensor(6.5374, device='cuda:0', grad_fn=<MeanBackward1>)
# ================================================================================
# @ Calculate gradient values through backpropagation
loss_val.backward()
# ================================================================================
# @ Update parameters of the network based on gradients
model_api_instance.optimizer.step()
# ================================================================================
# @ If you want to print loss
if args.use_loss_display=="True":
if idx%int(args.leapping_term_when_displaying_loss)==0:
print("Epoch:",one_ep,", Batch:",idx)
print("loss_from_one_batch",loss_val.item())
loss_list.append(loss_val.item())
# ================================================================================
# @ Save model after every batch you configure
# by using args.leapping_term_when_saving_model_after_batch
if idx%int(args.leapping_term_when_saving_model_after_batch)==0:
num_batch="batch_"+str(idx)
model_api_instance.save_model_after_epoch(num_batch)
# ================================================================================
# print("end of single batch")
# ================================================================================
# print("end of all batches")
# ================================================================================
# @ Save model after epoch
num_epoch="epoch_"+str(one_ep)
model_api_instance.save_model_after_epoch(num_epoch)
# ================================================================================
# @ Update learning rate
scheduler.step()
# print("scheduler.base_lrs",scheduler.base_lrs)
# ================================================================================
# print("End of single epoch")
# ================================================================================
# print("end of all epochs")
# ================================================================================
with torch.no_grad():
n=28
TP=torch.tensor(np.zeros(n)).float().cuda()
FP=torch.tensor(np.zeros(n)).float().cuda()
FN=torch.tensor(np.zeros(n)).float().cuda()
for idx_vali,data_vali in enumerate(dataloader_vali):
bs_pa_tumor_d_vali=utils_data.create_batch_pair_of_paths(data_vali,args)
# print("bs_pa_tumor_d_vali",bs_pa_tumor_d_vali)
# [[('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/0020af02-bbba-11e8-b2ba-ac1f6b6435d0_blue.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/0020af02-bbba-11e8-b2ba-ac1f6b6435d0_green.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/0020af02-bbba-11e8-b2ba-ac1f6b6435d0_red.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/0020af02-bbba-11e8-b2ba-ac1f6b6435d0_yellow.png'),
# ('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_blue.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_green.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_red.png',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_yellow.png')],
# array(['25 2','16 0'],dtype='<U4')]
img_paths=bs_pa_tumor_d_vali[0]
labels=bs_pa_tumor_d_vali[1]
# print("labels",labels)
# labels ['2 0' '1']
# print("labels",labels.shape)
labels=[one_protein_lbl.strip().split(" ") for one_protein_lbl in labels]
# [['5'], ['0'], ['25'], ['2'], ['23'], ['25', '4'], ['12'], ['22', '2'], ['3'], ['0', '21'], ['2'], ['25', '18', '3', '0'], ['5'], ['2', '0', '21'], ['0', '21'], ['25'], ['25'], ['23'], ['23', '0'], ['25', '2', '0']]
# print("labels",labels)
labels_oh=utils_common.one_hot_label_vali(batch_size,labels)
# print("labels_oh",labels_oh)
# [[1. 1. 1. 0. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
# [0. 0. 1. 0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]
labels_oh_np=np.array(labels_oh)
labels_oh_tc=torch.tensor(labels_oh_np).cuda()
all_images_vali_stacked=utils_data.get_batch_vali_imgs(img_paths)
# print("all_images_vali_stacked",all_images_vali_stacked.shape)
# (2, 4, 224, 224)
all_images_vali_stacked_tc=utils_pytorch.get_Variable(all_images_vali_stacked)
# print("all_images_vali_stacked_tc",all_images_vali_stacked_tc.shape)
# torch.Size([2, 4, 224, 224])
model_eval=model_api_instance.gen_net.eval()
pred_vali=model_eval(all_images_vali_stacked_tc)
# print("pred_vali",pred_vali)
# print("pred_vali",pred_vali.shape)
# torch.Size([2, 28])
# ================================================================================
single_TP,single_FP,single_FN=metrics_module.calculate_f1_score(pred_vali,labels_oh_tc)
TP+=single_TP
FP+=single_FP
FN+=single_FN
score=(2.0*TP/(2.0*TP+FP+FN+1e-6)).mean()
print("score",score)
f1_score_list.append(score.item())
# tensor(0.0238, device='cuda:0')
# ================================================================================
# @ Plot loss value
plt.plot(loss_list)
plt.title("Loss value: 1st fold, 2nd fold, 3rd fold, continuously")
plt.savefig("loss.png")
plt.show()
plt.plot(f1_score_list)
plt.title("F1 score: 1st fold, 2nd fold, 3rd fold, continuously")
plt.savefig("f1_score.png")
plt.show()
# ================================================================================
elif args.task_mode=="validation":
with torch.no_grad(): # @ Use network without calculating gradients
# tumor_trn=args.dir_where_text_file_for_image_paths_is_in+"/tumor_trn.txt"
# tumor_lbl=args.dir_where_text_file_for_image_paths_is_in+"/train_labels.csv"
# print("tumor_trn",tumor_trn)
# print("tumor_lbl",tumor_lbl)
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/tumor_trn.txt
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_labels.csv
# ================================================================================
# @ Dataset and Dataloader
# @ c dataset_inst_test_tumor: dataset instance of tumor dataset
dataset_inst_test_tumor=custom_ds.custom_ds(
txt_containing_paths=tumor_trn,txt_containing_labels=tumor_lbl,is_train=False,args=args)
# @ c dataloader_tumor_test: dataloader instance of tumor dataset
dataloader_tumor_test=torch.utils.data.DataLoader(
dataset=dataset_inst_test_tumor,batch_size=batch_size,shuffle=False,num_workers=3)
# ================================================================================
# @ c num_imgs_test: number of entire test images
num_imgs_test=len(dataset_inst_test_tumor)
# ================================================================================
# @ Create network and optimizer
if args.train_method=="train_by_transfer_learning_using_resnet":
model_api_instance=model_api_module.Model_API_class(args)
# ================================================================================
predicted_values=[]
true_values=[]
img_paths=[]
# ================================================================================
# @ Iterate all batches (batch1+batch2+...+batchn=entire images)
for idx,data in enumerate(dataloader_tumor_test):
# print("idx",idx)
# print("data",data)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/e693f9ac4097289c317831960514b78701999cd9.tif\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/e6941f6c6825e7c409b9364e2fb6c2d629df8a76.tif\n',),
# [('e693f9ac4097289c317831960514b78701999cd9','e6941f6c6825e7c409b9364e2fb6c2d629df8a76'),tensor([1,0])]]
# ================================================================================
# @ c imgs: paths of validation images
imgs=data[0]
img_paths.extend(imgs)
# @ c imgs: labels to validation images
lbls=data[1][1].numpy()
# @ c num_imgs: number of validation image in one batch
num_imgs=lbls.shape[0]
# print("num_imgs",num_imgs)
# 11
# @ Load images from paths
# ================================================================================
test_imgs_list=[]
for one_img_path in imgs:
one_loaded_img=utils_image.load_img(one_img_path)
# print("one_loaded_img",one_loaded_img.shape)
# (96, 96, 3)
one_loaded_img=resize(one_loaded_img,(224,224))
test_imgs_list.append(one_loaded_img)
# ================================================================================
test_imgs_np=np.array(test_imgs_list).transpose(0,3,1,2)
# @ If you want to use center (48,48) image from (96,96) image
# test_imgs_np=test_imgs_np[:,:,24:72,24:72]
# print("test_imgs_np",test_imgs_np.shape)
# (11, 3, 48, 48)
test_imgs_tc=Variable(torch.Tensor(test_imgs_np).cuda())
# ================================================================================
# @ Make predictions
prediction=model_api_instance.gen_net(test_imgs_tc)
# print("prediction",prediction)
# tensor([[-2.0675],
# [-2.9296],
sigmoid=torch.nn.Sigmoid()
prediction_np=sigmoid(prediction).cpu().numpy()
# ================================================================================
# @ Make predicted labels
prediction_np=np.where(prediction_np>0.5,1,0).squeeze()
# print("prediction_np",prediction_np)
# [0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0]
# print("lbls",lbls)
# [1 0 0 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0]
predicted_values.extend(prediction_np)
true_values.extend(lbls)
# ================================================================================
y_true=true_values
y_pred=predicted_values
# ================================================================================
# @ Binary Confusion Matrix
b_c_mat=confusion_matrix(true_values,predicted_values,labels=[0,1])
# print("b_c_mat",b_c_mat)
# [[30 2]
# [ 0 68]]
# True Positive (Tumor pic is predicted as tumor) False Negative (Tumor pic is predicted as non-tumor)
# False Positive (Non-tumor pic is predicted as tumor) True Negative (Non-tumor pic is predicted as non-tumor)
# ================================================================================
# @ metric report
report=classification_report(y_true,y_pred,target_names=['class Non tumor (neg)', 'class Tumor (pos)'])
# print(report)
# precision recall f1-score support
# class Non tumor (neg) 0.97 1.00 0.99 68
# class Tumor (pos) 1.00 0.94 0.97 32
# micro avg 0.98 0.98 0.98 100
# macro avg 0.99 0.97 0.98 100
# weighted avg 0.98 0.98 0.98 100
# ================================================================================
print("accuracy_score",accuracy_score(y_true,y_pred))
# 0.98
print("precision_score",precision_score(y_true,y_pred))
# 1.0
print("recall_score",recall_score(y_true,y_pred))
# 0.9375
# print("fbeta_score",fbeta_score(y_true, y_pred, beta))
print("f1_score",fbeta_score(y_true,y_pred,beta=1))
# 0.967741935483871
# ================================================================================
# @ ROC curve
fpr,tpr,thresholds=roc_curve(y_true,y_pred)
plt.plot(fpr,tpr,'o-',label="Logistic Regression")
plt.title('Receiver operating characteristic example')
plt.show()
elif args.task_mode=="submission":
with torch.no_grad(): # @ Use network without calculating gradients
sub_ds=custom_ds_test.custom_ds_Submission()
print("sub_ds",sub_ds)
sub_dl=torch.utils.data.DataLoader(
dataset=sub_ds,batch_size=batch_size,shuffle=False,num_workers=3)
print("sub_dl",sub_dl)
# ================================================================================
# @ c num_imgs_test: number of entire test images
num_imgs_test=len(sub_ds)
# ================================================================================
# @ Create network and optimizer
if args.train_method=="train_by_transfer_learning_using_resnet":
model_api_instance=model_api_module.Model_API_class(args)
# ================================================================================
label_submission=pd.read_csv("/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/sample_submission.csv",encoding='utf8')
base_names=label_submission.iloc[:,0].tolist()
# print("base_names",base_names)
# ================================================================================
predicted_values=[]
# @ Iterate all batches (batch1+batch2+...+batchn=entire images)
for idx,data in enumerate(sub_dl):
# print("idx",idx)
# print("data",data)
# 0
# ['/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/test/0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5.tif',
imgs=data
# ================================================================================
test_imgs_list=[]
for one_img_path in imgs:
one_loaded_img=utils_image.load_img(one_img_path)
# print("one_loaded_img",one_loaded_img.shape)
# (96, 96, 3)
one_loaded_img=resize(one_loaded_img,(224,224))
test_imgs_list.append(one_loaded_img)
# ================================================================================
test_imgs_np=np.array(test_imgs_list).transpose(0,3,1,2)
# @ If you want to use center (48,48) image from (96,96) image
# test_imgs_np=test_imgs_np[:,:,24:72,24:72]
# print("test_imgs_np",test_imgs_np.shape)
# (11, 3, 48, 48)
test_imgs_tc=Variable(torch.Tensor(test_imgs_np).cuda())
# print("test_imgs_tc",test_imgs_tc.shape)
# torch.Size([30, 3, 224, 224])
# ================================================================================
# @ Make predictions
prediction=model_api_instance.gen_net(test_imgs_tc)
# print("prediction",prediction)
# tensor([[-2.0675],
# ...
# [-1.2222]], device='cuda:0')
sigmoid=torch.nn.Sigmoid()
prediction_np=sigmoid(prediction).cpu().numpy()
# ================================================================================
# @ Make predicted labels
prediction_np=np.where(prediction_np>0.5,1,0).squeeze()
# print("prediction_np",prediction_np)
# [0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0]
# print("lbls",lbls)
# [1 0 0 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0]
predicted_values.extend(prediction_np)
my_submission=pd.DataFrame({'id': base_names,'label': predicted_values})
my_submission.to_csv('youngminpar2559_submission.csv',index=False)
def train(args):
epoch = int(args.epoch)
batch_size = int(args.batch_size)
# print("epoch",epoch)
# print("batch_size",batch_size)
# 200
# 22
# ================================================================================
text_file_instance = text_file_path_api_module.Path_Of_Text_Files(args)
tumor_trn = text_file_instance.tumor_trn
tumor_lbl = text_file_instance.tumor_lbl
# print("tumor_trn",tumor_trn)
# print("tumor_lbl",tumor_lbl)
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/trn_txt_file_processed.txt
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_labels.csv
# ================================================================================
# c tumor_loss_temp: list which will stores loss values to plot loss
tumor_loss_temp = []
# ================================================================================
# c model_api_instance: instance of model API
model_api_instance = model_api_module.Model_API_class(args)
# ================================================================================
# @ Test Grad CAM
imgs = [
"/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_split/00/02dcc00fde8ae55761b3d8e70d34b9153ea81bd9.tif",
"/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/test/ffcc29cf0e363737b577d1db470df0bb1adf7957.tif"
]
grad_cam.initialize_grad_cam(model=model_api_instance.gen_net,
list_of_img_paths=imgs,
args=args)
# afaf 1: grad_cam.initialize_grad_cam(model=model_api_instance.gen_net,list_of_img_paths=imgs,args=args)
# ================================================================================
if args.task_mode == "train": # If you're in train mode
# ================================================================================
# @ Configure learning rate scheduler
# Update learning rate 4 times during entire epochs
# For example, if you use 10 epochs, int(10/4), 1 2 / 3 4 / 5 6 / 7 8 / 9 10
# 0-1 epochs: 0.001 -> 2-3 epochs: 0.0001 -> 4-5 epochs: 0.00001 -> 5-6 epochs: 0.000001
scheduler = StepLR(model_api_instance.optimizer,
step_size=int(epoch / 4),
gamma=0.1)
# ================================================================================
for one_ep in range(epoch): # @ Iterates all epochs
# c dataset_inst_trn_tumor: dataset instance of tumor
dataset_inst_trn_tumor = dataset_tumor.Dataset_Tumor(
txt_containing_paths=tumor_trn,
txt_containing_labels=tumor_lbl,
is_train=True,
args=args)
# Test iterator
# iter_dataset_inst_trn_tumor=iter(dataset_inst_trn_tumor)
# trn=next(iter_dataset_inst_trn_tumor)
# print("trn",trn)
# ('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/4036b2e1e551e14b88f7f9ada275935ec4b5bdcc.tif\n',
# ['4036b2e1e551e14b88f7f9ada275935ec4b5bdcc', 0])
# ================================================================================
# c dataloader_tumor_trn: create dataloader
dataloader_tumor_trn = torch.utils.data.DataLoader(
dataset=dataset_inst_trn_tumor,
batch_size=batch_size,
shuffle=False,
num_workers=3)
# c dataloader_tumor_trn_iter: iterator of dataloader
# dataloader_tumor_trn_iter=iter(dataloader_tumor_trn)
# Test dataloader
# pairs=next(dataloader_tumor_trn_iter)
# print("pairs",pairs)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/45da9ea0958e83c3a5d6efe1e9912e80ab204b59.tif\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/9f49570e69b43a10e58566c5207f87c4a96f04d2.tif\n'),
# [('45da9ea0958e83c3a5d6efe1e9912e80ab204b59',
# '9f49570e69b43a10e58566c5207f87c4a96f04d2'),
# tensor([1, 0])]]
# ================================================================================
# c num_imgs_trn: number of train image
num_imgs_trn = len(dataset_inst_trn_tumor)
# print("num_imgs_trn",num_imgs_trn)
# 198022
args.__setattr__("num_imgs_trn", num_imgs_trn)
# print("args",args)
# print("Current batch size:",batch_size)
# print("Possible batch size:",list(utils_common.divisorGenerator(num_imgs_trn)))
# assert str(num_imgs_trn/batch_size).split(".")[-1]==str(0),"Check batch size, currently it's incorrect"
# ================================================================================
# @ If you don't use Augmentor
if args.use_augmentor == "False":
pass
else: # @ If you use Augmentor
# @ Iterate all images in dataset during single epoch
for idx, data in enumerate(dataloader_tumor_trn):
# c paths_of_imgs: paths of images
paths_of_imgs = data[0]
# print("paths_of_imgs",paths_of_imgs)
# c labels_in_scalar: label values of images
labels_in_scalar = np.array(data[1][1])
# print("labels_in_scalar",labels_in_scalar)
# labels_in_scalar [1 0 1 1 0 0 0 1 0 1 0 1 0 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 1 0 0 1 1 0 0 0 1
# c bs_pa_tumor_d: batchsized paths of tumor dataset
bs_pa_tumor_d = [paths_of_imgs, labels_in_scalar]
# ================================================================================
# @ Perform data augmentation
# c sampled_trn_imgs_tc: sampled train images in torch tensor
# c label_values: corresponding label values
sampled_trn_imgs_tc, label_values = utils_data.use_augmetor_for_tumor_data(
bs_pa_tumor_d, args)
# print("sampled_trn_imgs_tc",sampled_trn_imgs_tc.shape)
# (10, 3, 48, 48)
# print("label_values",label_values)
# [1, 1, 0, 0, 0, 1, 0, 0, 0, 0]
# ================================================================================
trn_imgs_tcv = utils_pytorch.get_dense_data_Variable(
sampled_trn_imgs_tc)
# print("trn_imgs_tcv",trn_imgs_tcv.shape)
# torch.Size([10, 3, 48, 48])
# ================================================================================
# @ Remove existing gradients
model_api_instance.remove_existing_gradients_before_starting_new_training(
)
# ================================================================================
# @ c predicted_labels: pass input images and get predictions
predicted_labels = model_api_instance.gen_net(trn_imgs_tcv)
# print("predicted_labels",predicted_labels)
# tensor([[-0.0724],
# [-0.0299],
# [-0.1650],
# [-0.2458],
# [-0.3437],
# [-0.1207],
# [-0.3087],
# [-0.2381],
# [ 0.0811],
# [-0.2436]], device='cuda:0', grad_fn=<AddmmBackward>)
label_tc = Variable(
torch.tensor(label_values,
device=predicted_labels.device))
# ================================================================================
# @ Calculate loss values
criterion = nn.BCEWithLogitsLoss()
loss_val = criterion(predicted_labels.squeeze(), label_tc)
# print("loss_val",loss_val)
loss_val = 10.0 * loss_val
# ================================================================================
# @ When you use 2 feature output and Cross Entropy loss function
# # c m: LogSoftmax layer
# m=nn.LogSoftmax()
# # c loss: NLLLoss layer
# loss=nn.NLLLoss()
# # c loss_val: calculated loss value
# loss_val=loss(m(predicted_labels),Variable(torch.Tensor(label_values).long().cuda()))
# ================================================================================
# @ Calculate gradient values through backpropagation
loss_val.backward()
# ================================================================================
# @ Update parameters of the network based on gradients
model_api_instance.optimizer.step()
# ================================================================================
# @ If you want to print loss
if args.use_loss_display == "True":
if idx % int(
args.leapping_term_when_displaying_loss) == 0:
print("Epoch:", one_ep, ", Batch:", idx)
print("loss_from_one_batch", loss_val.item())
tumor_loss_temp.append(loss_val.item())
# ================================================================================
# @ Save model after every batch you configure
# by using args.leapping_term_when_saving_model_after_batch
if idx % int(
args.leapping_term_when_saving_model_after_batch
) == 0:
num_batch = "batch_" + str(idx)
model_api_instance.save_model_after_epoch(num_batch)
# ================================================================================
# @ Save model after epoch
num_epoch = "epoch_" + str(one_ep)
model_api_instance.save_model_after_epoch(num_epoch)
# ================================================================================
# @ Update learning rate
scheduler.step()
# print("scheduler.base_lrs",scheduler.base_lrs)
# ================================================================================
# @ Plot loss value
plt.plot(tumor_loss_temp)
plt.savefig("loss.png")
plt.show()
# ================================================================================
elif args.task_mode == "validation":
with torch.no_grad(): # @ Use network without calculating gradients
# tumor_trn=args.dir_where_text_file_for_image_paths_is_in+"/tumor_trn.txt"
# tumor_lbl=args.dir_where_text_file_for_image_paths_is_in+"/train_labels.csv"
# print("tumor_trn",tumor_trn)
# print("tumor_lbl",tumor_lbl)
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/tumor_trn.txt
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_labels.csv
# ================================================================================
# @ Dataset and Dataloader
# @ c dataset_inst_test_tumor: dataset instance of tumor dataset
dataset_inst_test_tumor = dataset_tumor.Dataset_Tumor(
txt_containing_paths=tumor_trn,
txt_containing_labels=tumor_lbl,
is_train=False,
args=args)
# @ c dataloader_tumor_test: dataloader instance of tumor dataset
dataloader_tumor_test = torch.utils.data.DataLoader(
dataset=dataset_inst_test_tumor,
batch_size=batch_size,
shuffle=False,
num_workers=3)
# ================================================================================
# @ c num_imgs_test: number of entire test images
num_imgs_test = len(dataset_inst_test_tumor)
# ================================================================================
# @ Create network and optimizer
if args.train_method == "train_by_transfer_learning_using_resnet":
model_api_instance = model_api_module.Model_API_class(args)
# ================================================================================
predicted_values = []
true_values = []
img_paths = []
# ================================================================================
# @ Iterate all batches (batch1+batch2+...+batchn=entire images)
for idx, data in enumerate(dataloader_tumor_test):
# print("idx",idx)
# print("data",data)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/e693f9ac4097289c317831960514b78701999cd9.tif\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/e6941f6c6825e7c409b9364e2fb6c2d629df8a76.tif\n',),
# [('e693f9ac4097289c317831960514b78701999cd9','e6941f6c6825e7c409b9364e2fb6c2d629df8a76'),tensor([1,0])]]
# ================================================================================
# @ c imgs: paths of validation images
imgs = data[0]
img_paths.extend(imgs)
# @ c imgs: labels to validation images
lbls = data[1][1].numpy()
# @ c num_imgs: number of validation image in one batch
num_imgs = lbls.shape[0]
# print("num_imgs",num_imgs)
# 11
# @ Load images from paths
# ================================================================================
test_imgs_list = []
for one_img_path in imgs:
one_loaded_img = utils_image.load_img(one_img_path)
# print("one_loaded_img",one_loaded_img.shape)
# (96, 96, 3)
one_loaded_img = resize(one_loaded_img, (224, 224))
test_imgs_list.append(one_loaded_img)
# ================================================================================
test_imgs_np = np.array(test_imgs_list).transpose(0, 3, 1, 2)
# @ If you want to use center (48,48) image from (96,96) image
# test_imgs_np=test_imgs_np[:,:,24:72,24:72]
# print("test_imgs_np",test_imgs_np.shape)
# (11, 3, 48, 48)
test_imgs_tc = Variable(torch.Tensor(test_imgs_np).cuda())
# ================================================================================
# @ Make predictions
prediction = model_api_instance.gen_net(test_imgs_tc)
# print("prediction",prediction)
# tensor([[-2.0675],
# [-2.9296],
sigmoid = torch.nn.Sigmoid()
prediction_np = sigmoid(prediction).cpu().numpy()
# ================================================================================
# @ Make predicted labels
prediction_np = np.where(prediction_np > 0.5, 1, 0).squeeze()
# print("prediction_np",prediction_np)
# [0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0]
# print("lbls",lbls)
# [1 0 0 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0]
predicted_values.extend(prediction_np)
true_values.extend(lbls)
# ================================================================================
y_true = true_values
y_pred = predicted_values
# ================================================================================
# @ Binary Confusion Matrix
b_c_mat = confusion_matrix(true_values,
predicted_values,
labels=[0, 1])
# print("b_c_mat",b_c_mat)
# [[30 2]
# [ 0 68]]
# True Positive (Tumor pic is predicted as tumor) False Negative (Tumor pic is predicted as non-tumor)
# False Positive (Non-tumor pic is predicted as tumor) True Negative (Non-tumor pic is predicted as non-tumor)
# ================================================================================
# @ metric report
report = classification_report(
y_true,
y_pred,
target_names=['class Non tumor (neg)', 'class Tumor (pos)'])
# print(report)
# precision recall f1-score support
# class Non tumor (neg) 0.97 1.00 0.99 68
# class Tumor (pos) 1.00 0.94 0.97 32
# micro avg 0.98 0.98 0.98 100
# macro avg 0.99 0.97 0.98 100
# weighted avg 0.98 0.98 0.98 100
# ================================================================================
print("accuracy_score", accuracy_score(y_true, y_pred))
# 0.98
print("precision_score", precision_score(y_true, y_pred))
# 1.0
print("recall_score", recall_score(y_true, y_pred))
# 0.9375
# print("fbeta_score",fbeta_score(y_true, y_pred, beta))
print("f1_score", fbeta_score(y_true, y_pred, beta=1))
# 0.967741935483871
# ================================================================================
# @ ROC curve
fpr, tpr, thresholds = roc_curve(y_true, y_pred)
plt.plot(fpr, tpr, 'o-', label="Logistic Regression")
plt.title('Receiver operating characteristic example')
plt.show()
elif args.task_mode == "submission":
with torch.no_grad(): # @ Use network without calculating gradients
sub_ds = dataset_tumor_test.Dataset_Tumor_Submission()
print("sub_ds", sub_ds)
sub_dl = torch.utils.data.DataLoader(dataset=sub_ds,
batch_size=batch_size,
shuffle=False,
num_workers=3)
print("sub_dl", sub_dl)
# ================================================================================
# @ c num_imgs_test: number of entire test images
num_imgs_test = len(sub_ds)
# ================================================================================
# @ Create network and optimizer
if args.train_method == "train_by_transfer_learning_using_resnet":
model_api_instance = model_api_module.Model_API_class(args)
# ================================================================================
label_submission = pd.read_csv(
"/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/sample_submission.csv",
encoding='utf8')
base_names = label_submission.iloc[:, 0].tolist()
# print("base_names",base_names)
# ================================================================================
predicted_values = []
# @ Iterate all batches (batch1+batch2+...+batchn=entire images)
for idx, data in enumerate(sub_dl):
# print("idx",idx)
# print("data",data)
# 0
# ['/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/test/0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5.tif',
imgs = data
# ================================================================================
test_imgs_list = []
for one_img_path in imgs:
one_loaded_img = utils_image.load_img(one_img_path)
# print("one_loaded_img",one_loaded_img.shape)
# (96, 96, 3)
one_loaded_img = resize(one_loaded_img, (224, 224))
test_imgs_list.append(one_loaded_img)
# ================================================================================
test_imgs_np = np.array(test_imgs_list).transpose(0, 3, 1, 2)
# @ If you want to use center (48,48) image from (96,96) image
# test_imgs_np=test_imgs_np[:,:,24:72,24:72]
# print("test_imgs_np",test_imgs_np.shape)
# (11, 3, 48, 48)
test_imgs_tc = Variable(torch.Tensor(test_imgs_np).cuda())
# print("test_imgs_tc",test_imgs_tc.shape)
# torch.Size([30, 3, 224, 224])
# ================================================================================
# @ Make predictions
prediction = model_api_instance.gen_net(test_imgs_tc)
# print("prediction",prediction)
# tensor([[-2.0675],
# ...
# [-1.2222]], device='cuda:0')
sigmoid = torch.nn.Sigmoid()
prediction_np = sigmoid(prediction).cpu().numpy()
# ================================================================================
# @ Make predicted labels
prediction_np = np.where(prediction_np > 0.5, 1, 0).squeeze()
# print("prediction_np",prediction_np)
# [0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0]
# print("lbls",lbls)
# [1 0 0 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0]
predicted_values.extend(prediction_np)
my_submission = pd.DataFrame({
'id': base_names,
'label': predicted_values
})
my_submission.to_csv('youngminpar2559_submission.csv', index=False)
# print(model)
grad_cam = GradCam(model, target_layer_names = ["layer4"], use_cuda=args.use_cuda)
# x=os.walk(args.image_path)
# for root,dirs,filename in x:
# # print(type(grad_cam))
# print(filename)
# for s in filename:
# image.append(cv2.imread(args.image_path+s,1))
#img = cv2.imread(filename, 1)
image=[
"/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/test/ffcaef8b9006b4d0b128328e6df6e4d139d3c40a.tif",
"/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/test/ffcc29cf0e363737b577d1db470df0bb1adf7957.tif"]
for img in image:
img=utils_image.load_img(img)/255.0
img=img.astype("float32")
# img = np.float32(cv2.resize(img, (224, 224))) / 255
input = preprocess_image(img)
# print("input",input.grad_fn)
# None
print('input.size()=',input.size())
# If None, returns the map for the highest scoring category.
# Otherwise, targets the requested index.
target_index =None
mask = grad_cam(input, target_index)
# print(type(mask))
i=i+1
show_cam_on_image(img, mask,i)
def visualize_images(args):
# ================================================================================
loaded_path, num_imgs = utils_common.return_path_list_from_txt(train_imgs)
# print("loaded_path",loaded_path)
# ['/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_blue.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_green.png\n',
# print("num_imgs",num_imgs)
# 124288
loaded_path_chunked = []
for i in range(0, int(num_imgs / 4), 4):
one_protein = loaded_path[i:i + 4]
# print("one_protein",one_protein)
# ['/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_blue.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_green.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_red.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_yellow.png\n']
loaded_path_chunked.append(one_protein)
# print("loaded_path_chunked",loaded_path_chunked)
# [['/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_blue.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_green.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_red.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle/human-protein-atlas-image-classification/Data/train/00070df0-bbc3-11e8-b2bc-ac1f6b6435d0_yellow.png\n'
path_3_proteins = loaded_path_chunked[:3]
# ================================================================================
images_of_3_proteins = []
for one_protein in path_3_proteins:
b_img = one_protein[0].replace("\n", "")
g_img = one_protein[1].replace("\n", "")
r_img = one_protein[2].replace("\n", "")
y_img = one_protein[3].replace("\n", "")
b_img = utils_image.load_img(b_img)
g_img = utils_image.load_img(g_img)
r_img = utils_image.load_img(r_img)
y_img = utils_image.load_img(y_img)
# print("b_img",b_img.shape)
# (512, 512)
# print("g_img",g_img.shape)
# (512, 512)
# print("r_img",r_img.shape)
# (512, 512)
# print("y_img",y_img.shape)
# (512, 512)
images_of_3_proteins.append([b_img, g_img, r_img, y_img])
i = 0
for one_protein_img in images_of_3_proteins:
bg_img = np.zeros(
(one_protein_img[0].shape[0], one_protein_img[0].shape[1], 3))
# print("bg_img",bg_img.shape)
# (512, 512, 3)
bg_img_flat_for_b = bg_img.reshape(-1, 3).copy()
bg_img_flat_for_g = bg_img.reshape(-1, 3).copy()
bg_img_flat_for_r = bg_img.reshape(-1, 3).copy()
bg_img_flat_for_y = bg_img.reshape(-1, 3).copy()
# print("one_protein_img[0]",one_protein_img[0].shape)
# (512, 512)
# print("one_protein_img[1]",one_protein_img[1].shape)
# (512, 512)
# print("one_protein_img[2]",one_protein_img[2].shape)
# (512, 512)
# print("one_protein_img[3]",one_protein_img[3].shape)
# (512, 512)
b_img = one_protein_img[0].reshape(-1)
g_img = one_protein_img[1].reshape(-1)
r_img = one_protein_img[2].reshape(-1)
y_img = one_protein_img[3].reshape(-1)
rgb_img = np.stack((one_protein_img[0], one_protein_img[1],
one_protein_img[2])).transpose(1, 2, 0)
# print("rgb_img",rgb_img.shape)
# ================================================================================
import scipy.misc
scipy.misc.imsave('./img_out/rgb_img_' + str(i) + '.png', rgb_img)
bg_img_flat_for_b[:, 2] = b_img
scipy.misc.imsave('./img_out/b_img_' + str(i) + '.png',
bg_img_flat_for_b.reshape(512, 512, 3))
bg_img_flat_for_g[:, 1] = g_img
scipy.misc.imsave('./img_out/g_img_' + str(i) + '.png',
bg_img_flat_for_g.reshape(512, 512, 3))
bg_img_flat_for_r[:, 0] = r_img
scipy.misc.imsave('./img_out/r_img_' + str(i) + '.png',
bg_img_flat_for_r.reshape(512, 512, 3))
bg_img_flat_for_y[:, 0] = y_img
scipy.misc.imsave('./img_out/y_img_' + str(i) + '.png',
bg_img_flat_for_y.reshape(512, 512, 3))
i = i + 1
def train(args):
epoch = int(args.epoch)
batch_size = int(args.batch_size)
# print("epoch",epoch)
# print("batch_size",batch_size)
# 9
# 2
# ================================================================================
text_file_instance = text_file_path_api_module.Path_Of_Text_Files(args)
txt_of_image_data = text_file_instance.train_data
# print("txt_of_image_data",txt_of_image_data)
# /mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/trn_imgs_paths.txt
txt_of_label_data = text_file_instance.label_data
# print("txt_of_label_data",txt_of_label_data)
# /mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/trn_imgs_labels.csv
# ================================================================================
model_api_instance = model_api_module.Model_API_class(args)
path_of_imgs_tumor = []
with open(txt_of_image_data) as f:
lines = f.readlines()
path_of_imgs_tumor.extend(lines)
# print("path_of_imgs_tumor",path_of_imgs_tumor)
# ['/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0004.png\n', '/mnt/1T-5e7/mycodehtml/
pre_sale = pd.read_csv(txt_of_label_data, encoding='utf8')
# print("pre_sale",pre_sale)
# Image ID Class
# 0 4 ecoli
# 1 5 salmonella
bacteria_label_np = np.array(pre_sale.iloc[:, 1])
# print("bacteria_label_np",bacteria_label_np)
# ['ecoli' 'salmonella' 'staphylococus' 'listeria' 'ecoli' 'ecoli'
zipped = list(zip(path_of_imgs_tumor, bacteria_label_np))
# print("zipped",zipped)
# zipped [('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0004.png\n', array([4, 'ecoli'], dtype=object)), ('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0005.png\n', array([5,
# [('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0004.png\n', 'ecoli'), ('/mnt/1T-5e7/
shuffle(zipped)
zipped_np = np.array(zipped)
X = zipped_np[:, 0]
y = zipped_np[:, 1]
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.10,
random_state=42)
# print("X_train",np.array(X_train).shape)
# # (545,)
# print("y_train",np.array(y_train).shape)
# # (545,)
# print("X_test",np.array(X_test).shape)
# # (61,)
# print("y_test",np.array(y_test).shape)
# # (61,)
# ================================================================================
# @ Test Grad CAM
# imgs=["/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_split/33/82d4d190d2fed1be255fc3bac36a37c860bb31c0.tif",
# "/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_split/33/82a5300cd61628fb9bae332cdb7d5e7e37b1fb36.tif"]
# grad_cam.initialize_grad_cam(model=model_api_instance.gen_net,list_of_img_paths=imgs,args=args)
# afaf 1: grad_cam.initialize_grad_cam(model=model_api_instance.gen_net,list_of_img_paths=imgs,args=args)
tumor_loss_temp = []
# ================================================================================
if args.task_mode == "train": # If you're in train mode
# ================================================================================
# @ Configure learning rate scheduler
# Update learning rate 4 times during entire epochs
# For example, if you use 10 epochs, int(10/4), 1 2 / 3 4 / 5 6 / 7 8 / 9 10
# 0-1 epochs: 0.001 -> 2-3 epochs: 0.0001 -> 4-5 epochs: 0.00001 -> 5-6 epochs: 0.000001
# scheduler=StepLR(model_api_instance.optimizer,step_size=int(epoch/4),gamma=0.1)
# ================================================================================
for one_ep in range(epoch): # @ Iterates all epochs
# c dataset_inst_trn_tumor: dataset instance of tumor
dataset_inst_trn_tumor = custom_ds.Custom_DS(
single_train_k=X_train, single_train_lbl_k=y_train, args=args)
# Test iterator
# iter_dataset_inst_trn_tumor=iter(dataset_inst_trn_tumor)
# trn=next(iter_dataset_inst_trn_tumor)
# print("trn",trn)
# ('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/4036b2e1e551e14b88f7f9ada275935ec4b5bdcc.tif\n',
# ['4036b2e1e551e14b88f7f9ada275935ec4b5bdcc', 0])
# ================================================================================
# c dataloader_tumor_trn: create dataloader
dataloader_tumor_trn = torch.utils.data.DataLoader(
dataset=dataset_inst_trn_tumor,
batch_size=batch_size,
shuffle=False,
num_workers=3)
# c dataloader_tumor_trn_iter: iterator of dataloader
# dataloader_tumor_trn_iter=iter(dataloader_tumor_trn)
# Test dataloader
# pairs=next(dataloader_tumor_trn_iter)
# print("pairs",pairs)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/45da9ea0958e83c3a5d6efe1e9912e80ab204b59.tif\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/9f49570e69b43a10e58566c5207f87c4a96f04d2.tif\n'),
# [('45da9ea0958e83c3a5d6efe1e9912e80ab204b59',
# '9f49570e69b43a10e58566c5207f87c4a96f04d2'),
# tensor([1, 0])]]
# ================================================================================
# c num_imgs_trn: number of train image
num_imgs_trn = len(dataset_inst_trn_tumor)
# print("num_imgs_trn",num_imgs_trn)
# 198022
args.__setattr__("num_imgs_trn", num_imgs_trn)
# print("args",args)
# print("Current batch size:",batch_size)
# print("Possible batch size:",list(utils_common.divisorGenerator(num_imgs_trn)))
# assert str(num_imgs_trn/batch_size).split(".")[-1]==str(0),"Check batch size, currently it's incorrect"
# ================================================================================
# @ If you don't use Augmentor
if args.use_augmentor == "False":
pass
else: # @ If you use Augmentor
# @ Iterate all images in dataset during single epoch
for idx, data in enumerate(dataloader_tumor_trn):
# print("data",data)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/1611.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/1475.png\n'),
# ('staphylococus', 'staphylococus')]
# c paths_of_imgs: paths of images
paths_of_imgs = data[0]
# print("paths_of_imgs",paths_of_imgs)
# ('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0849.png\n', '/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0969.png\n')
# c labels_in_scalar: label values of images
labels_in_scalar = np.array(data[1])
# print("labels_in_scalar",labels_in_scalar)
# ['ecoli' 'salmonella']
# c bs_pa_tumor_d: batchsized paths of tumor dataset
bs_pa_tumor_d = [paths_of_imgs, labels_in_scalar]
# ================================================================================
# @ Perform data augmentation
# c sampled_trn_imgs_tc: sampled train images in torch tensor
# c label_values: corresponding label values
sampled_trn_imgs_tc, label_values = utils_data.use_augmetor_for_tumor_data(
bs_pa_tumor_d, args)
# print("sampled_trn_imgs_tc",sampled_trn_imgs_tc.shape)
# (2, 1, 224, 224)
# print("label_values",label_values)
# ['ecoli', 'staphylococus']
I_4x4 = np.eye(4)
# print("I_4x4",I_4x4)
# [[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
bac_name_dict = {
'ecoli': [
1.,
0.,
0.,
0.,
],
'salmonella': [0., 1., 0., 0.],
'staphylococus': [0., 0., 1., 0.],
'listeria': [0., 0., 0., 1.]
}
one_hot_label = []
for one_bac_name in label_values:
# print("one_bac_name",one_bac_name)
# listeria
one_hot = bac_name_dict[one_bac_name]
# print("one_hot",one_hot)
# [0.0, 0.0, 0.0, 1.0]
one_hot_label.append(one_hot)
# print("one_hot_label",one_hot_label)
# [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]
# bac_name_dict={'ecoli':1,'salmonella':2,'staphylococus':3,'listeria':4}
# one_hot_label=[]
# for one_bac_name in label_values:
# # print("one_bac_name",one_bac_name)
# # listeria
# one_hot=bac_name_dict[one_bac_name]
# # print("one_hot",one_hot)
# # [0.0, 0.0, 0.0, 1.0]
# one_hot_label.append(one_hot)
# # print("one_hot_label",one_hot_label)
# # [3, 3]
y1 = torch.FloatTensor(one_hot_label)
_, targets = y1.max(dim=1)
# print("targets",targets)
# afaf
# ================================================================================
trn_imgs_tcv = utils_pytorch.get_Variable(
sampled_trn_imgs_tc)
# print("trn_imgs_tcv",trn_imgs_tcv.shape)
# torch.Size([2, 1, 224, 224])
# ================================================================================
# @ Remove existing gradients
model_api_instance.remove_existing_gradients_before_starting_new_training(
)
# ================================================================================
# @ c predicted_labels: pass input images and get predictions
predicted_labels = model_api_instance.gen_net(trn_imgs_tcv)
# print("predicted_labels",predicted_labels)
# tensor([[-0.1724, -0.1855, -0.1478, 0.1190],
# [-0.1837, -0.1834, -0.1849, 0.0015]], device='cuda:0',
# grad_fn=<AddmmBackward>)
# max_indics=torch.argmax(predicted_labels,dim=1)
# # print("max_indics",max_indics)
# # tensor([3, 3], device='cuda:0')
# print("max_indics",max_indics.shape)
# afaf
label_tc = Variable(
torch.tensor(targets, device=predicted_labels.device))
# print("label_tc",label_tc)
# tensor([[0., 1., 0., 0.],
# [0., 1., 0., 0.]], device='cuda:0')
# ================================================================================
# @ Calculate loss values
criterion = nn.CrossEntropyLoss()
# print("max_indics",max_indics)
# tensor([2, 2], device='cuda:0')
# print("label_tc",label_tc)
# tensor([2, 1], device='cuda:0')
print("predicted_labels", predicted_labels.shape)
# print("label_tc",label_tc.shape)
# predicted_labels torch.Size([2, 4])
# label_tc torch.Size([2])
loss_val = criterion(predicted_labels, label_tc.long())
# print("loss_val",loss_val)
# tensor(1.7040, device='cuda:0', grad_fn=<NllLossBackward>)
loss_val = 10.0 * loss_val
# ================================================================================
# @ When you use 2 feature output and Cross Entropy loss function
# # c m: LogSoftmax layer
# m=nn.LogSoftmax()
# # c loss: NLLLoss layer
# loss=nn.NLLLoss()
# # c loss_val: calculated loss value
# loss_val=loss(m(predicted_labels),Variable(torch.Tensor(label_values).long().cuda()))
# ================================================================================
# @ Calculate gradient values through backpropagation
loss_val.backward()
# ================================================================================
# @ Update parameters of the network based on gradients
model_api_instance.optimizer.step()
# ================================================================================
# @ If you want to print loss
if args.use_loss_display == "True":
if idx % int(
args.leapping_term_when_displaying_loss) == 0:
print("Epoch:", one_ep, ", Batch:", idx)
print("loss_from_one_batch", loss_val.item())
tumor_loss_temp.append(loss_val.item())
# ================================================================================
# @ Save model after every batch you configure
# by using args.leapping_term_when_saving_model_after_batch
if idx % int(
args.leapping_term_when_saving_model_after_batch
) == 0:
num_batch = "batch_" + str(idx)
model_api_instance.save_model_after_epoch(num_batch)
# ================================================================================
# @ Save model after epoch
num_epoch = "epoch_" + str(one_ep)
model_api_instance.save_model_after_epoch(num_epoch)
# ================================================================================
# @ Update learning rate
# scheduler.step()
# print("scheduler.base_lrs",scheduler.base_lrs)
# ================================================================================
# @ Plot loss value
plt.plot(tumor_loss_temp)
plt.savefig("loss.png")
plt.show()
with torch.no_grad():
dataset_inst_vali_tumor = custom_ds.Custom_DS_vali(
single_vali_k=X_test, single_vali_lbl_k=y_test, args=args)
dataloader_tumor_vali = torch.utils.data.DataLoader(
dataset=dataset_inst_vali_tumor,
batch_size=5,
shuffle=False,
num_workers=3)
# ================================================================================
num_imgs_trn = len(dataset_inst_vali_tumor)
# print("num_imgs_trn",num_imgs_trn)
# 198022
pred_np_li = []
label_np_li = []
# @ Iterate all images in dataset during single epoch
for idx, data in enumerate(dataloader_tumor_vali):
# print("data",data)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/1611.png\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/1475.png\n'),
# ('staphylococus', 'staphylococus')]
# c paths_of_imgs: paths of images
paths_of_imgs = data[0]
# print("paths_of_imgs",paths_of_imgs)
# ('/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0849.png\n', '/mnt/1T-5e7/mycodehtml/bio_health/Bacteria/bacteria-classification-at-the-genus-level/Data/bacteria-classification-at-the-genus-level/Train_Images/0969.png\n')
intput_imgs = []
for one_path in paths_of_imgs:
loaded_img = utils_image.load_img(
one_path.replace("\n", ""))
# print("loaded_img",loaded_img.shape)
# (1024, 1280)
loaded_img = utils_image.resize_img(loaded_img, 224, 224)
intput_imgs.append(loaded_img)
intput_imgs_np = np.array(intput_imgs)
# print("intput_imgs_np",intput_imgs_np.shape)
# (2, 224, 224)
intput_imgs_np = intput_imgs_np[:, np.newaxis, :, :]
intput_imgs_tc = torch.tensor(intput_imgs_np).float()
trn_imgs_tcv = utils_pytorch.get_Variable(intput_imgs_tc)
# print("trn_imgs_tcv",trn_imgs_tcv.shape)
# torch.Size([2, 1, 224, 224])
# c labels_in_scalar: label values of images
labels_in_scalar = np.array(data[1])
# print("labels_in_scalar",labels_in_scalar)
# ['salmonella' 'listeria' 'salmonella' 'salmonella' 'salmonella']
I_4x4 = np.eye(4)
# print("I_4x4",I_4x4)
# [[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
bac_name_dict = {
'ecoli': [
1.,
0.,
0.,
0.,
],
'salmonella': [0., 1., 0., 0.],
'staphylococus': [0., 0., 1., 0.],
'listeria': [0., 0., 0., 1.]
}
one_hot_label = []
for one_bac_name in labels_in_scalar:
# print("one_bac_name",one_bac_name)
# salmonella
one_hot = bac_name_dict[one_bac_name]
# print("one_hot",one_hot)
# [1.0, 0.0, 0.0, 0.0]
one_hot_label.append(one_hot)
# print("one_hot_label",one_hot_label)
# [[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]
y1 = torch.FloatTensor(one_hot_label)
_, targets = y1.max(dim=1)
# print("targets",targets)
# tensor([1, 0, 1, 1, 3])
# ================================================================================
# @ Remove existing gradients
# model_api_instance.remove_existing_gradients_before_starting_new_training()
# ================================================================================
# @ c predicted_labels: pass input images and get predictions
predicted_labels = model_api_instance.gen_net(trn_imgs_tcv)
# print("predicted_labels",predicted_labels)
# tensor([[ 0.6513, -0.1330, -0.5001, -0.0210],
# [ 0.1990, 0.1838, -0.1278, -0.1546]], device='cuda:0')
max_indics = torch.argmax(predicted_labels, dim=1)
# print("max_indics",max_indics)
# tensor([0, 0], device='cuda:0')
# print("targets",targets)
# tensor([0, 1])
label_tc = Variable(
torch.tensor(targets, device=predicted_labels.device))
# print("label_tc",label_tc)
# tensor([1, 3, 2, 0, 2], device='cuda:0')
pred_np = max_indics.detach().cpu().numpy()
label_np = label_tc.detach().cpu().numpy()
pred_np_li.append(pred_np)
label_np_li.append(label_np)
# pred_np_li [array([0, 1])]
# label_np_li [array([3, 1])]
label_np_li_len = len(label_np_li)
y_true = np.array(label_np_li)
y_pred = np.array(pred_np_li)
print("y_true", y_true)
# y_true [
# array([2, 1, 2, 2, 1]) array([0, 2, 2, 3, 2]) array([1, 1, 0, 0, 2])
# array([1, 0, 1, 3, 2]) array([2, 3, 3, 0, 0]) array([0, 3, 3, 3, 1])
# array([3, 2, 3, 2, 1]) array([1, 2, 3, 0, 2]) array([1, 1, 2, 3, 3])
# array([1, 3, 3, 0, 3]) array([0, 1, 0, 3, 2]) array([3, 3, 3, 3, 1])
# array([1])]
print("y_pred", y_pred)
# y_pred [
# array([2, 0, 2, 2, 0]) array([0, 2, 2, 3, 2]) array([1, 1, 0, 0, 2])
# array([1, 0, 1, 3, 2]) array([2, 3, 3, 0, 0]) array([0, 3, 3, 3, 1])
# array([3, 2, 3, 2, 1]) array([1, 2, 3, 0, 2]) array([1, 1, 2, 3, 3])
# array([1, 3, 2, 0, 3]) array([0, 1, 0, 3, 2]) array([3, 2, 3, 3, 1])
# array([0])]
num_entire_sam = 0
num_matched = 0
for one_pair in list(zip(y_true, y_pred)):
y_one_true = one_pair[0]
y_one_pred = one_pair[1]
num_sample = y_one_true.reshape(-1).shape[0]
num_entire_sam = num_sample + num_entire_sam
y_one_true = np.array(y_one_true)
y_one_pred = np.array(y_one_pred)
matched = (y_one_true == y_one_pred)
matched_num = matched.sum()
num_matched = num_matched + matched_num
acc = num_matched / num_entire_sam
print("acc", acc)
afaf
y_true_rs = np.reshape(y_true, (-1))
print("y_true_rs", y_true_rs.shape)
# (10,)
num_sam = y_true_rs.shape[0]
print("num_sam", num_sam)
matched = np.array(y_true == y_pred)
print("matched", matched)
# [[False True]]
matched_num = matched.sum()
print("matched_num", matched_num)
# 1
print("label_np_li_len", label_np_li_len)
acc = matched_num / num_sam
print("acc", acc)
afaf
# zpped=list(zip(y_true,y_pred))
# n_classes = 4
# y_true_oh=[]
# y_pred_oh=[]
# for o_true,o_pred in zpped:
# aa=np.eye(n_classes)[o_true]
# bb=np.eye(n_classes)[o_pred]
# y_true_oh.append(list(aa))
# y_pred_oh.append(list(bb))
# # print("y_true_oh",y_true_oh)
# # print("y_pred_oh",y_pred_oh)
# # [array([[0., 0., 0., 1.],
# # [1., 0., 0., 0.]])]
# # [array([[0., 0., 1., 0.],
# # [0., 0., 1., 0.]])]
# y_true=np.array(y_true_oh)
# y_pred=np.array(y_pred_oh)
# # print("y_true",y_true)
# # print("y_pred",y_pred)
# # print("y_true",type(y_true))
# # print("y_pred",type(y_pred))
# ================================================================================
# @ Binary Confusion Matrix
# b_c_mat=confusion_matrix(y_true,y_pred,labels=[0,1,2,3])
# print("b_c_mat",b_c_mat)
# [[30 2]
# [ 0 68]]
# True Positive (Tumor pic is predicted as tumor) False Negative (Tumor pic is predicted as non-tumor)
# False Positive (Non-tumor pic is predicted as tumor) True Negative (Non-tumor pic is predicted as non-tumor)
# ================================================================================
# @ metric report
# report=classification_report(y_true,y_pred,target_names=['class Non tumor (neg)', 'class Tumor (pos)'])
# print(report)
# precision recall f1-score support
# class Non tumor (neg) 0.97 1.00 0.99 68
# class Tumor (pos) 1.00 0.94 0.97 32
# micro avg 0.98 0.98 0.98 100
# macro avg 0.99 0.97 0.98 100
# weighted avg 0.98 0.98 0.98 100
# ================================================================================
print("accuracy_score", accuracy_score(y_true, y_pred))
# 0.98
print("precision_score", precision_score(y_true, y_pred))
# 1.0
print("recall_score", recall_score(y_true, y_pred))
# 0.9375
# print("fbeta_score",fbeta_score(y_true, y_pred, beta))
print("f1_score", fbeta_score(y_true, y_pred, beta=1))
# 0.967741935483871
# ================================================================================
# @ ROC curve
fpr, tpr, thresholds = roc_curve(y_true, y_pred)
plt.plot(fpr, tpr, 'o-', label="Logistic Regression")
plt.title('Receiver operating characteristic example')
plt.show()
afaf
# ================================================================================
elif args.task_mode == "validation":
with torch.no_grad(): # @ Use network without calculating gradients
# tumor_trn=args.dir_where_text_file_for_image_paths_is_in+"/tumor_trn.txt"
# tumor_lbl=args.dir_where_text_file_for_image_paths_is_in+"/train_labels.csv"
# print("tumor_trn",tumor_trn)
# print("tumor_lbl",tumor_lbl)
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/tumor_trn.txt
# /mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train_labels.csv
# ================================================================================
# @ Dataset and Dataloader
# @ c dataset_inst_test_tumor: dataset instance of tumor dataset
dataset_inst_test_tumor = dataset_tumor.Dataset_Tumor(
txt_containing_paths=tumor_trn,
txt_containing_labels=tumor_lbl,
is_train=False,
args=args)
# @ c dataloader_tumor_test: dataloader instance of tumor dataset
dataloader_tumor_test = torch.utils.data.DataLoader(
dataset=dataset_inst_test_tumor,
batch_size=batch_size,
shuffle=False,
num_workers=3)
# ================================================================================
# @ c num_imgs_test: number of entire test images
num_imgs_test = len(dataset_inst_test_tumor)
# ================================================================================
# @ Create network and optimizer
if args.train_method == "train_by_transfer_learning_using_resnet":
model_api_instance = model_api_module.Model_API_class(args)
# ================================================================================
predicted_values = []
true_values = []
img_paths = []
# ================================================================================
# @ Iterate all batches (batch1+batch2+...+batchn=entire images)
for idx, data in enumerate(dataloader_tumor_test):
# print("idx",idx)
# print("data",data)
# [('/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/e693f9ac4097289c317831960514b78701999cd9.tif\n',
# '/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/train/e6941f6c6825e7c409b9364e2fb6c2d629df8a76.tif\n',),
# [('e693f9ac4097289c317831960514b78701999cd9','e6941f6c6825e7c409b9364e2fb6c2d629df8a76'),tensor([1,0])]]
# ================================================================================
# @ c imgs: paths of validation images
imgs = data[0]
img_paths.extend(imgs)
# @ c imgs: labels to validation images
lbls = data[1][1].numpy()
# @ c num_imgs: number of validation image in one batch
num_imgs = lbls.shape[0]
# print("num_imgs",num_imgs)
# 11
# @ Load images from paths
# ================================================================================
test_imgs_list = []
for one_img_path in imgs:
one_loaded_img = utils_image.load_img(one_img_path)
# print("one_loaded_img",one_loaded_img.shape)
# (96, 96, 3)
one_loaded_img = resize(one_loaded_img, (224, 224))
test_imgs_list.append(one_loaded_img)
# ================================================================================
test_imgs_np = np.array(test_imgs_list).transpose(0, 3, 1, 2)
# @ If you want to use center (48,48) image from (96,96) image
# test_imgs_np=test_imgs_np[:,:,24:72,24:72]
# print("test_imgs_np",test_imgs_np.shape)
# (11, 3, 48, 48)
test_imgs_tc = Variable(torch.Tensor(test_imgs_np).cuda())
# ================================================================================
# @ Make predictions
prediction = model_api_instance.gen_net(test_imgs_tc)
# print("prediction",prediction)
# tensor([[-2.0675],
# [-2.9296],
sigmoid = torch.nn.Sigmoid()
prediction_np = sigmoid(prediction).cpu().numpy()
# ================================================================================
# @ Make predicted labels
prediction_np = np.where(prediction_np > 0.5, 1, 0).squeeze()
# print("prediction_np",prediction_np)
# [0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0]
# print("lbls",lbls)
# [1 0 0 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0]
predicted_values.extend(prediction_np)
true_values.extend(lbls)
# ================================================================================
y_true = true_values
y_pred = predicted_values
# ================================================================================
# @ Binary Confusion Matrix
b_c_mat = confusion_matrix(true_values,
predicted_values,
labels=[0, 1])
# print("b_c_mat",b_c_mat)
# [[30 2]
# [ 0 68]]
# True Positive (Tumor pic is predicted as tumor) False Negative (Tumor pic is predicted as non-tumor)
# False Positive (Non-tumor pic is predicted as tumor) True Negative (Non-tumor pic is predicted as non-tumor)
# ================================================================================
# @ metric report
report = classification_report(
y_true,
y_pred,
target_names=['class Non tumor (neg)', 'class Tumor (pos)'])
# print(report)
# precision recall f1-score support
# class Non tumor (neg) 0.97 1.00 0.99 68
# class Tumor (pos) 1.00 0.94 0.97 32
# micro avg 0.98 0.98 0.98 100
# macro avg 0.99 0.97 0.98 100
# weighted avg 0.98 0.98 0.98 100
# ================================================================================
print("accuracy_score", accuracy_score(y_true, y_pred))
# 0.98
print("precision_score", precision_score(y_true, y_pred))
# 1.0
print("recall_score", recall_score(y_true, y_pred))
# 0.9375
# print("fbeta_score",fbeta_score(y_true, y_pred, beta))
print("f1_score", fbeta_score(y_true, y_pred, beta=1))
# 0.967741935483871
# ================================================================================
# @ ROC curve
fpr, tpr, thresholds = roc_curve(y_true, y_pred)
plt.plot(fpr, tpr, 'o-', label="Logistic Regression")
plt.title('Receiver operating characteristic example')
plt.show()
elif args.task_mode == "submission":
with torch.no_grad(): # @ Use network without calculating gradients
sub_ds = dataset_tumor_test.Dataset_Tumor_Submission()
print("sub_ds", sub_ds)
sub_dl = torch.utils.data.DataLoader(dataset=sub_ds,
batch_size=batch_size,
shuffle=False,
num_workers=3)
print("sub_dl", sub_dl)
# ================================================================================
# @ c num_imgs_test: number of entire test images
num_imgs_test = len(sub_ds)
# ================================================================================
# @ Create network and optimizer
if args.train_method == "train_by_transfer_learning_using_resnet":
model_api_instance = model_api_module.Model_API_class(args)
# ================================================================================
label_submission = pd.read_csv(
"/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/sample_submission.csv",
encoding='utf8')
base_names = label_submission.iloc[:, 0].tolist()
# print("base_names",base_names)
# ================================================================================
predicted_values = []
# @ Iterate all batches (batch1+batch2+...+batchn=entire images)
for idx, data in enumerate(sub_dl):
# print("idx",idx)
# print("data",data)
# 0
# ['/mnt/1T-5e7/mycodehtml/bio_health/Kaggle_histopathologic-cancer-detection/Data/test/0b2ea2a822ad23fdb1b5dd26653da899fbd2c0d5.tif',
imgs = data
# ================================================================================
test_imgs_list = []
for one_img_path in imgs:
one_loaded_img = utils_image.load_img(one_img_path)
# print("one_loaded_img",one_loaded_img.shape)
# (96, 96, 3)
one_loaded_img = resize(one_loaded_img, (224, 224))
test_imgs_list.append(one_loaded_img)
# ================================================================================
test_imgs_np = np.array(test_imgs_list).transpose(0, 3, 1, 2)
# @ If you want to use center (48,48) image from (96,96) image
# test_imgs_np=test_imgs_np[:,:,24:72,24:72]
# print("test_imgs_np",test_imgs_np.shape)
# (11, 3, 48, 48)
test_imgs_tc = Variable(torch.Tensor(test_imgs_np).cuda())
# print("test_imgs_tc",test_imgs_tc.shape)
# torch.Size([30, 3, 224, 224])
# ================================================================================
# @ Make predictions
prediction = model_api_instance.gen_net(test_imgs_tc)
# print("prediction",prediction)
# tensor([[-2.0675],
# ...
# [-1.2222]], device='cuda:0')
sigmoid = torch.nn.Sigmoid()
prediction_np = sigmoid(prediction).cpu().numpy()
# ================================================================================
# @ Make predicted labels
prediction_np = np.where(prediction_np > 0.5, 1, 0).squeeze()
# print("prediction_np",prediction_np)
# [0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 1 0 0]
# print("lbls",lbls)
# [1 0 0 0 0 1 0 0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 1 0 1 1 1 0]
predicted_values.extend(prediction_np)
my_submission = pd.DataFrame({
'id': base_names,
'label': predicted_values
})
my_submission.to_csv('youngminpar2559_submission.csv', index=False)
def train(args):
epoch=int(args.epoch)
batch_size=int(args.batch_size)
# ================================================================================
if args.use_visdom=="True":
global plotter
plotter=visdom_module.VisdomLinePlotter(env_name='IID network plot')
visdom_i=1
# vis=visdom.Visdom(port=8097,server="http://localhost/")
vis=visdom.Visdom(env="IID network plot")
# ================================================================================
# @ Create network and optimizer
model_api_inst=model_api_module.Model_API_class(args)
# ================================================================================
# @ c hyper_param_inst: instance of hyper parameter class
hyper_param_inst=set_hyper_parameters.Set_h_p(args)
# ================================================================================
# @ For graph illustration of loss values
lists_for_visualizing_losses=visualize_loss_values.Visualize_Loss_Values()
# ================================================================================
# @ c path_of_text_files
path_of_text_files=text_file_api_module.Path_Of_Text_Files(args)
# c txt_paths_in_dict: path of text files in dictionary
txt_paths_in_dict=path_of_text_files.__dict__
# print("txt_paths_in_dict",txt_paths_in_dict)
# ================================================================================
# # @ Check exception for batch size
# (This is commented out because Pytorch's DataSet and DataLoader can manage this potential issue)
# cgmit=len(dataset_dense_inst)
# assert cgmit==len(dataset_iiw_inst),"The number of 'cgmit images' and 'iiw images' is different"
# print("Current number of 'cgmit images' and 'iiw images':",cgmit)
# print("Current cgmit/iiw batch size:",batch_size)
# print("Possible cgmit/iiw batch size:",list(utils_common.divisorGenerator(cgmit)))
# assert str(cgmit/batch_size).split(".")[-1]==str(0),"Check batch size"
# ================================================================================
# @ Grad CAM (tested visualization on gradient on trained network)
# cam=utils_visualize_gradients.CAM(gen_decoder_R)
# gen_decoder_S.right_conv_6.register_forward_hook(utils_hook_functions.printnorm)
# gen_decoder_S.right_conv_6.register_backward_hook(utils_hook_functions.printgradnorm)
# ================================================================================
# @ Measure training time
if args.measure_train_time=="True":
start=timeit.default_timer()
else:
pass
# ================================================================================
if args.train_mode=="True":
# @ Iterates all epochs
for one_ep in range(epoch):
# ================================================================================
# c dataset_dense_inst: dataset instance of dense dataset
dataset_dense_inst=dataset_returning_one_pair_of_path.Dataset_Returning_One_Pair_Of_Path(
txt_paths_in_dict["cgintrinsic_trn"],txt_paths_in_dict["cgintrinsic_rgt"],args)
dataset_dense_iter=iter(dataset_dense_inst)
# ================================================================================
dataset_tinghuiz_inst=dataset_returning_one_pair_of_path.Dataset_Returning_One_Pair_Of_Path(
txt_paths_in_dict["tinghuiz_trn"],txt_paths_in_dict["tinghuiz_rgt"],args)
dataset_tinghuiz_iter=iter(dataset_tinghuiz_inst)
# ================================================================================
# In my test, CGINTRINSIC + Tinghuiz + IIW was not that good
# I thinks it's because CGINTRINSIC + Tinghuiz and IIW are too diferent in its format of dataset
# This joint training was tested by being inspired by CGINTRINSICS project
# Original code: https://github.com/lixx2938/CGIntrinsics
# c dataset_iiw_inst: instance of dataset iiw
# dataset_iiw_inst=dataset_returning_one_pair_of_path.Dataset_Returning_One_Pair_Of_Path(
# txt_paths_in_dict["iiw_trn"],txt_paths_in_dict["iiw_json"],args)
# dataset_iiw_iter=iter(dataset_iiw_inst)
# ================================================================================
# Tested joint training along with SAW dataset, but my test with SAW didn't create good result
# Original code: https://github.com/lixx2938/CGIntrinsics
# dataset_saw_inst=dataset_returning_one_pair_of_path.Dataset_Returning_One_Pair_Of_Path(
# txt_paths_in_dict["saw_trn"],txt_paths_in_dict["saw_npy"],args)
# dataset_saw_iter=iter(dataset_saw_inst)
# ================================================================================
# BigTime data is designed to train IID network in unsupervised manners
# Original code: https://github.com/lixx2938/unsupervised-learning-intrinsic-images
# dataset_bigtime_inst=dataset_returning_one_pair_of_path.Dataset_Returning_One_Pair_Of_Path_non_shuffle(
# txt_paths_in_dict["bigtime_trn"],txt_paths_in_dict["bigtime_mask"],args)
# dataset_bigtime_iter=iter(dataset_bigtime_inst)
# ================================================================================
# num_entire_imgs=len(dataset_dense_inst)+len(dataset_tinghuiz_inst)+len(dataset_iiw_inst)
num_entire_imgs=len(dataset_dense_inst)+len(dataset_tinghuiz_inst)
# print("num_entire_imgs",num_entire_imgs)
# 16
args.__setattr__("num_entire_imgs",num_entire_imgs)
# ================================================================================
num_iteration_for_iter=int(len(dataset_dense_inst)/int(args.batch_size))
print("args.leaping_batchsize_for_saving_model)",args.leaping_batchsize_for_saving_model)
print("num_iteration_for_iter",num_iteration_for_iter)
if int(args.leaping_batchsize_for_saving_model)==num_iteration_for_iter or int(args.leaping_batchsize_for_saving_model)>num_iteration_for_iter:
raise Exception("args.leaping_batchsize_for_saving_model must be smaller than num_iteration_for_iter")
else:
pass
# ================================================================================
# If you don't use Augmentor
if args.use_augmentor=="False":
# c dense_d_bs_pa: dense dataset batch size paths
dense_d_bs_pa=dense_d_list[bs:bs+batch_size]
cgmit_d_bs_pa=cgmit_d_list[bs:bs+batch_size]
# ================================================================================
dense_trn_imgs,dense_rgt_imgs=utils_common.generate_dense_dataset(
dense_d_bs_pa,img_h=512,img_w=512)
trn_imgs_dense,rgt_imgs_dense,sgt_imgs_dense,mask_imgs_dense=\
utils_common.generate_cgmit_dataset(cgmit_d_bs_pa,img_h=512,img_w=512)
else: # If you use Augmentor
# @ Iterate all entire images during single epoch
for one_iter in range(num_iteration_for_iter):
# @ Remove gradients
model_api_inst.remove_existing_gradients_before_starting_new_training()
# ================================================================================
# @ Train over dense dataset
loss_r_data_dense,loss_s_data_dense,loss_o_data_dense,loss_o_grad_dense,loss_s_grad_dense,loss_r_grad_dense,pred_r_color_dense,pred_s_dense=\
train_over_dense_dataset.train(
dataset_dense_iter,batch_size,model_api_inst,hyper_param_inst,lists_for_visualizing_losses,args)
# ================================================================================
# @ Train over tinghuiz dataset
loss_r_data_tinghuiz,loss_s_data_tinghuiz,loss_o_data_tinghuiz,loss_o_grad_tinghuiz,loss_s_grad_tinghuiz,loss_r_grad_tinghuiz,tinghuiz_r,tinghuiz_s=\
train_over_tinghuiz_dataset.train(
dataset_tinghuiz_iter,batch_size,model_api_inst,hyper_param_inst,lists_for_visualizing_losses,args)
# ================================================================================
# @ Train over IIW dataset
# iiw_I_loss
# loss_iiw=train_over_iiw_dataset.train(
# dataset_iiw_iter,batch_size,model_api_inst,hyper_param_inst,lists_for_visualizing_losses,args)
# print("loss_iiw",loss_iiw)
# tensor([0.0001], device='cuda:0', grad_fn=<MulBackward0>)
# 3.633527994155884
# Took large time
# 0:02:10.749899
# After removing "for loop in data augmentation", small time
# 0:00:00.720973
# After one-image-by-one-image traing, more small time
# 0:00:00.405261
# ================================================================================
# @ Train over SAW dataset
# saw_I_loss
# saw_loss,saw_I_loss=train_over_saw_dataset.train(
# dataset_saw_iter,batch_size,model_api_inst,hyper_param_inst,lists_for_visualizing_losses,args)
# print("saw_loss",saw_loss)
# 1.520530343055725
# ================================================================================
# Update based on bigtime dataset (BT)
# bigtime_loss_I
# bigtime_loss_r,bigtime_loss_I=train_over_bigtime_dataset.train(
# dataset_bigtime_iter,batch_size,model_api_inst,hyper_param_inst,lists_for_visualizing_losses,args)
# print("bigtime_loss_I",bigtime_loss_I)
# print("bigtime_loss_r",bigtime_loss_r)
# ================================================================================
entire_loss=loss_r_data_dense+loss_s_data_dense+loss_o_data_dense+loss_o_grad_dense+loss_s_grad_dense+loss_r_grad_dense+\
loss_r_data_tinghuiz+loss_s_data_tinghuiz+loss_o_data_tinghuiz+loss_o_grad_tinghuiz+loss_s_grad_tinghuiz+loss_r_grad_tinghuiz
entire_loss.backward()
model_api_inst.optimizer.step()
model_api_inst.empty_cache_of_gpu_after_training_batch()
# ================================================================================
# region @ Save loss into tensorboard
# (I tested tensorboard but this had been commented out because I can plot losses and predicted image by using visdom)
# --------------------------------------------------------------------------------
# conda activate py36gputorch100 &&
# cd /mnt/1T-5e7/papers/cv/IID/Deep_Adversial_Residual_Network_for_IID/prj_root/src/tensorboard &&
# tensorboard --logdir='./logs' --port=6006
# --------------------------------------------------------------------------------
# tb_logger=logger.Logger('./src/tensorboard/logs')
# --------------------------------------------------------------------------------
# print(lists_for_visualizing_losses.lo_list)
# [('loss_r_data_dense',[75.04694366455078]),
# ('loss_r_grad_dense',[1.0475735664367676]),
# ('loss_s_data_dense',[48.632972717285156]),
# ('loss_s_grad_dense',[0.5619246363639832]),
# ('loss_o_data_dense',[46.09053039550781]),
# ('loss_o_grad_dense',[1.4934182167053223]),
# ('iiw_loss_temp',[2.321777105331421]),
# ('saw_loss_temp',[0.8101050853729248]),
# ('bigtime_loss_temp',[0.346628874540329])]
# --------------------------------------------------------------------------------
# aaa,bbb,ccc,ddd,eee,fff,ggg,hhh,iii=lists_for_visualizing_losses.lo_list
# print("a",a)
# a ('loss_r_data_dense', [82.376953125])
# --------------------------------------------------------------------------------
# info={aaa[0]:aaa[1][0],bbb[0]:bbb[1][0],ccc[0]:ccc[1][0],ddd[0]:ddd[1][0],eee[0]:eee[1][0],
# fff[0]:fff[1][0],ggg[0]:ggg[1][0],hhh[0]:hhh[1][0],iii[0]:iii[1][0]}
# --------------------------------------------------------------------------------
# for tag,value in info.items():
# tb_logger.scalar_summary(tag,value,int(one_iter)+1)
# endregion
# ================================================================================
# region @ Use visdom
if args.use_visdom=="True":
# pip install visdom
# conda install -c conda-forge visdom
# python -m visdom.server
# http://localhost:8097
# <your_remote_server_ip>:<visdom port (default 8097)>
plotter.plot("loss_r_data_dense","train","loss_r_data_dense",visdom_i,loss_r_data_dense.item())
plotter.plot("loss_s_data_dense","train","loss_s_data_dense",visdom_i,loss_s_data_dense.item())
plotter.plot("loss_o_data_dense","train","loss_o_data_dense",visdom_i,loss_o_data_dense.item())
plotter.plot("loss_o_grad_dense","train","loss_o_grad_dense",visdom_i,loss_o_grad_dense.item())
plotter.plot("loss_s_grad_dense","train","loss_s_grad_dense",visdom_i,loss_s_grad_dense.item())
plotter.plot("loss_r_grad_dense","train","loss_r_grad_dense",visdom_i,loss_r_grad_dense.item())
plotter.plot("loss_r_data_tinghuiz","train","loss_r_data_tinghuiz",visdom_i,loss_r_data_tinghuiz.item())
plotter.plot("loss_s_data_tinghuiz","train","loss_s_data_tinghuiz",visdom_i,loss_s_data_tinghuiz.item())
plotter.plot("loss_o_data_tinghuiz","train","loss_o_data_tinghuiz",visdom_i,loss_o_data_tinghuiz.item())
plotter.plot("loss_o_grad_tinghuiz","train","loss_o_grad_tinghuiz",visdom_i,loss_o_grad_tinghuiz.item())
plotter.plot("loss_s_grad_tinghuiz","train","loss_s_grad_tinghuiz",visdom_i,loss_s_grad_tinghuiz.item())
plotter.plot("loss_r_grad_tinghuiz","train","loss_r_grad_tinghuiz",visdom_i,loss_r_grad_tinghuiz.item())
# plotter.plot("loss_iiw","train","loss_iiw",visdom_i,loss_iiw.item())
# images
vis.images(Variable(torch.tensor(pred_r_color_dense[:2,:,:,:])),opts=dict(title='Reflectance', caption='Reflectance.'),win='wazzup')
vis.images(Variable(torch.tensor(pred_s_dense[:2,:,:,:])),opts=dict(title='Shading', caption='Shading.'),win='wazzup2')
visdom_i=visdom_i+1
# endregion
# ================================================================================
del loss_r_data_dense,loss_s_data_dense,loss_o_data_dense,loss_o_grad_dense,loss_s_grad_dense,loss_r_grad_dense,\
loss_r_data_tinghuiz,loss_s_data_tinghuiz,loss_o_data_tinghuiz,loss_o_grad_tinghuiz,loss_s_grad_tinghuiz,loss_r_grad_tinghuiz
# ================================================================================
# @ Save model after batch
if int(one_iter)==0:
pass
elif one_iter%int(args.leaping_batchsize_for_saving_model)==0:
model_api_inst.save_model(is_batch=True,iter_num=one_iter)
else:
pass
# ================================================================================
# @ Save model after epoch
model_api_inst.save_model(is_batch=False,iter_num=one_ep)
# ================================================================================
# @ Time for single epoch
if args.measure_train_time=="True":
stop=timeit.default_timer()
took_time_sec=int(stop-start)
took_time_min=str(datetime.timedelta(seconds=took_time_sec))
print("Took minutes until finishing epoch of "+str(one_ep)+\
" with "+str(args.scheduler)+" scheduler:",took_time_min)
else:
pass
# ================================================================================
# @ Visualize loss at the end of training
if args.visualize_loss_values=="True":
loss_list=lists_for_visualizing_losses.lo_list
for i,tup in enumerate(loss_list):
plt.subplot(int(np.ceil(len(loss_list)/3)),3,i+1)
plt.title(tup[0])
plt.plot(tup[1])
plt.savefig("loss.png")
plt.show()
else:
pass
# ================================================================================
else: # @ Test trained model
with torch.no_grad():
# @ Set test directories
dense_trn_img_p="./Data/Images_for_inference/*.png"
# dense_trn_img_p="/mnt/1T-5e7/mycodehtml/data_col/cv/IID_f_w_w/iiw-dataset/test/*.png"
# dense_trn_img_p="/mnt/1T-5e7/mycodehtml/data_col/cv/IID_f_w_w/iiw-dataset/office/*.png"
# dense_trn_img_p="/home/young/Downloads/images/training/temp/*.jpg"
# dense_trn_img_p="/home/young/Downloads/Sticheo_example_video/0_No_Movement/sample/FPS15/*.png"
# dense_trn_img_p="/home/young/Downloads/Sticheo_example_video/1_Small_Movement/sample/original_frame_FPS15/*.png"
# dense_trn_img_p="/home/young/Downloads/Sticheo_example_video/2_Medium_Movement/sample/original_frame_FPS15/*.png"
# @ For video frames
# r_images="/home/young/Downloads/Sticheo_example_video/0_No_Movement/sample/FPS15/Decomposed/R/*.png"
# s_images="/home/young/Downloads/Sticheo_example_video/0_No_Movement/sample/FPS15/Decomposed/S/*.png"
# r_images="/home/young/Downloads/Sticheo_example_video/1_Small_Movement/sample/original_frame_FPS15/R/*.png"
# s_images="/home/young/Downloads/Sticheo_example_video/1_Small_Movement/sample/original_frame_FPS15/S/*.png"
# r_images="/home/young/Downloads/Sticheo_example_video/2_Medium_Movement/sample/R/*.png"
# s_images="/home/young/Downloads/Sticheo_example_video/2_Medium_Movement/sample/S/*.png"
# @ Recovered directories
# recovered_imgs="/home/young/Downloads/Sticheo_example_video/0_No_Movement/sample/FPS15/Decomposed/Recovered/*.png"
# recovered_imgs="/home/young/Downloads/Sticheo_example_video/1_Small_Movement/sample/original_frame_FPS15/Recovered/*.png"
# recovered_imgs="/home/young/Downloads/Sticheo_example_video/2_Medium_Movement/sample/Recovered/*.png"
# ================================================================================
# @ Following codes can enhance resolution and can adjust brightness and gamma level
# r_img_li=utils_common.get_file_list(r_images)
# s_img_li=utils_common.get_file_list(s_images)
# for one_pair in list(zip(r_img_li,s_img_li)):
# # print("one_pair[0]",one_pair[0])
# # /home/young/Downloads/Sticheo_example_video/0_No_Movement/sample/FPS15/Decomposed/R/dinner_0001_predref.png
# recovered_fn=one_pair[0].replace("_predref","").replace("/R/","/Recovered/")
# one_r_img=utils_image.load_img(one_pair[0])/255.0
# one_s_img=utils_image.load_img(one_pair[1])/255.0
# one_s_img=one_s_img[:,:,np.newaxis]
# recovered_img=one_r_img*one_s_img
# # recovered_img=cv2.normalize(recovered_img,None,alpha=0,beta=1,norm_type=cv2.NORM_MINMAX,dtype=cv2.CV_32F)
# # print("np.min(recovered_img)",np.min(recovered_img))
# # print("np.max(recovered_img)",np.max(recovered_img))
# # kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
# # kernel = np.array([[-0.1,-0.1,-0.1], [-0.1,0.9,-0.1], [-0.1,-0.1,-0.1]])
# # recovered_img = cv2.filter2D(recovered_img, -1, kernel)
# scipy.misc.imsave(recovered_fn,recovered_img)
# # ================================================================================
# @ Following codes can enhance resolution and can adjust brightness and gamma level
# recovered_img_li=utils_common.get_file_list(recovered_imgs)
# for one_img in recovered_img_li:
# fn=one_img.replace("/Recovered/","/Recovered_Sharpened_Edited_brightness_and_constrast/")
# img = cv2.imread(one_img, 1)[:,:,::-1]
# # kernel = np.array([[-1,-1,-1], [-1,5,-1], [-1,-1,-1]])
# kernel = np.array([[-1,-1,-1,-1,-1],
# [-1,2,2,2,-1],
# [-1,2,8,2,-1],
# [-2,2,2,2,-1],
# [-1,-1,-1,-1,-1]])/8.0
# im = cv2.filter2D(img, -1, kernel)
# brightness = 50
# contrast = 30
# img = np.int16(im)
# img = img * (contrast/127+1) - contrast + brightness
# img = np.clip(img, 0, 255)
# im = np.uint8(img)
# # img = cv2.imread('your path',0)
# # brt = 40
# # img[img < 255-brt] += brt //change any value in the 2D list < max limit
# # cv2.imshow('img'+ img)
# scipy.misc.imsave(fn,im)
# ================================================================================
dense_tr_img_li=utils_common.get_file_list(dense_trn_img_p)
iteration=int(len(dense_tr_img_li))
num_imgs=len(dense_tr_img_li)
# Iterates all train images
for itr in range(iteration):
fn=dense_tr_img_li[itr].split("/")[-1].split(".")[0]
ol_dense_tr_i=utils_image.load_img(dense_tr_img_li[itr])/255.0
ori_h=ol_dense_tr_i.shape[0]
ori_w=ol_dense_tr_i.shape[1]
# Test various input resolutions
ol_dense_tr_i=utils_image.resize_img(ol_dense_tr_i,img_h=512,img_w=512)
# ol_dense_tr_i=utils_image.resize_img(ol_dense_tr_i,img_h=1280,img_w=1280)
# ol_dense_tr_i=utils_image.resize_img(ol_dense_tr_i,img_h=1536,img_w=1536)
# ol_dense_tr_i=utils_image.resize_img(ol_dense_tr_i,img_h=1792,img_w=1792)
# ol_dense_tr_i=utils_image.resize_img(ol_dense_tr_i,img_h=1920,img_w=1920)
# ol_dense_tr_i=utils_image.resize_img(ol_dense_tr_i,img_h=2048,img_w=2048)
# ================================================================================
ol_dense_tr_i=ol_dense_tr_i.transpose(2,0,1)
ol_dense_tr_i=ol_dense_tr_i[np.newaxis,:,:,:]
con_O_img_arr=Variable(torch.Tensor(ol_dense_tr_i).cuda())
# ================================================================================
if args.use_integrated_decoders=="True":
dense_pred_S_imgs_direct=model_api_inst.gen_net(con_O_img_arr)
for one_pred_img in range(dense_pred_S_imgs_direct.shape[0]):
# --------------------------------------------------------------------------------
pred_one_S_img=dense_pred_S_imgs_direct[one_pred_img,:,:,:].unsqueeze(0)
pred_one_S_img=torch.nn.functional.interpolate(
pred_one_S_img,size=(ori_h,ori_w),scale_factor=None,mode='bilinear',align_corners=True)
one_tr_img=con_O_img_arr[one_pred_img,:,:,:].unsqueeze(0)
one_tr_img=torch.nn.functional.interpolate(
one_tr_img,size=(ori_h,ori_w),scale_factor=None,mode='bilinear',align_corners=True)
# --------------------------------------------------------------------------------
one_tr_img=one_tr_img.detach().cpu().numpy().squeeze().transpose(1,2,0)
pred_one_S_img=pred_one_S_img.detach().cpu().numpy().squeeze()
# pred_one_S_img=np.clip(pred_one_S_img,0.0,1.3)
# pred_one_S_img=(pred_one_S_img-np.min(pred_one_S_img))/np.ptp(pred_one_S_img)
pred_one_S_img[pred_one_S_img==0.0]=0.001
pred_one_S_img=pred_one_S_img[:,:,np.newaxis]
pred_one_R_img=one_tr_img/pred_one_S_img
print("pred_one_R_img",np.min(pred_one_R_img))
print("pred_one_R_img",np.max(pred_one_R_img))
pred_one_R_img=np.clip(pred_one_R_img,0.0,1.2)
pred_one_R_img=(pred_one_R_img-np.min(pred_one_R_img))/np.ptp(pred_one_R_img)
# Tested various combinations, for example,
# option1: no normalize + colorize
# option2: normalize + colorize + clip
# option2: no normalize + colorize + clip
# ...
# pred_one_S_img=np.clip(pred_one_S_img,0.0,1.3)
# pred_one_S_img=(pred_one_S_img-np.min(pred_one_S_img))/np.ptp(pred_one_S_img)
# img=np.clip(pred_one_R_img,0.0,1.2)
# img=(img-np.mean(img))/np.std(img)
# pred_one_R_img=(img-np.min(img))/np.ptp(img)
# pred_one_R_img=utils_image.bilateral_f(one_tr_img,pred_one_R_img)
# pred_one_R_img=utils_image.colorize_tc(pred_one_R_img,one_tr_img)
# pred_one_R_img=pred_one_R_img.detach().cpu().numpy().squeeze().transpose(1,2,0)
# pred_one_S_img=pred_one_S_img.detach().cpu().numpy().squeeze()
# print("pred_one_R_img",np.min(pred_one_R_img))
# print("pred_one_R_img",np.max(pred_one_R_img))
# print("pred_one_S_img",np.min(pred_one_S_img))
# print("pred_one_S_img",np.max(pred_one_S_img))
scipy.misc.imsave('./result/'+fn+'_predsha.png',pred_one_S_img.squeeze())
scipy.misc.imsave('./result/'+fn+'_predref.png',pred_one_R_img)
if args.measure_train_time=="True":
stop=timeit.default_timer()
time_for_inference=stop-start
else:
pass
else:
o_conv_8_avgpool,o_conv_7_avgpool,o_conv_6_avgpool,o_conv_5_avgpool,\
o_conv_4_avgpool,o_conv_3_avgpool,o_conv_2_avgpool,o_conv_1_avgpool=gen_encoder(con_O_img_arr)
dense_pred_R_imgs_direct=gen_decoder_R(
o_conv_8_avgpool,o_conv_7_avgpool,o_conv_6_avgpool,o_conv_5_avgpool,\
o_conv_4_avgpool,o_conv_3_avgpool,o_conv_2_avgpool,o_conv_1_avgpool)
dense_pred_S_imgs_direct=gen_decoder_S(
o_conv_8_avgpool,o_conv_7_avgpool,o_conv_6_avgpool,o_conv_5_avgpool,\
o_conv_4_avgpool,o_conv_3_avgpool,o_conv_2_avgpool,o_conv_1_avgpool)
# out=cam.get_cam(0)
for one_pred_img in range(dense_pred_S_imgs_direct.shape[0]):
# --------------------------------------------------------------------------------
# Resizebytorch.nn.functional.interpolate()
pred_one_R_img=dense_pred_R_imgs_direct[one_pred_img,:,:,:].unsqueeze(0)
pred_one_R_img=torch.nn.functional.interpolate(
pred_one_R_img,size=(ori_h,ori_w),scale_factor=None,mode='bilinear',align_corners=True)
pred_one_S_img=dense_pred_S_imgs_direct[one_pred_img,:,:,:].unsqueeze(0)
pred_one_S_img=torch.nn.functional.interpolate(
pred_one_S_img,size=(ori_h,ori_w),scale_factor=None,mode='bilinear',align_corners=True)
one_tr_img=con_O_img_arr[one_pred_img,:,:,:].unsqueeze(0)
one_tr_img=torch.nn.functional.interpolate(
one_tr_img,size=(ori_h,ori_w),scale_factor=None,mode='bilinear',align_corners=True)
# --------------------------------------------------------------------------------
pred_one_R_img=pred_one_R_img.detach().cpu().numpy().squeeze()
one_tr_img=one_tr_img.detach().cpu().numpy().squeeze().transpose(1,2,0)
# pred_one_R_img,sha=utils_image.colorize(pred_one_R_img,one_tr_img)
# img=np.clip(pred_one_R_img,0.0,1.2)
# img=(img-np.mean(img))/np.std(img)
# pred_one_R_img=(img-np.min(img))/np.ptp(img)
# pred_one_R_img=utils_image.bilateral_f(one_tr_img,pred_one_R_img)
pred_one_S_img=pred_one_S_img.detach().cpu().numpy().squeeze()
# pred_one_R_img=utils_image.colorize_tc(pred_one_R_img,one_tr_img)
# pred_one_R_img=pred_one_R_img.detach().cpu().numpy().squeeze().transpose(1,2,0)
# pred_one_S_img=pred_one_S_img.detach().cpu().numpy().squeeze()
# print("pred_one_R_img",np.min(pred_one_R_img))
# print("pred_one_R_img",np.max(pred_one_R_img))
# print("pred_one_S_img",np.min(pred_one_S_img))
# print("pred_one_S_img",np.max(pred_one_S_img))
scipy.misc.imsave('./result/'+fn+'_predsha.png',pred_one_S_img)
scipy.misc.imsave('./result/'+fn+'_predref.png',pred_one_R_img)
print("input_size",args.input_size)
print("args.batchsize",args.batch_size)
print("num_imgs",num_imgs)
print("time_for_inference",time_for_inference)
def visualize(args):
img_crop_path = "/mnt/1T-5e7/mycodehtml/bio_health/SPIE-AAPM-NCI_BreastPathQ_Cancer_Cellularity_Challenge_2019/Data/breastpathq/datasets/cells/1_Region 1_crop.tif"
loaded_img_crop = utils_image.load_img(img_crop_path)
# print("loaded_img",loaded_img.shape)
# (451, 521, 3)
xml_key_path = "/mnt/1T-5e7/mycodehtml/bio_health/SPIE-AAPM-NCI_BreastPathQ_Cancer_Cellularity_Challenge_2019/Data/breastpathq/datasets/cells/1_Region 1_key.xml"
whole_xml_key_data = utils_data.load_xml_file(xml_key_path)
img_mask_path = "/mnt/1T-5e7/mycodehtml/bio_health/SPIE-AAPM-NCI_BreastPathQ_Cancer_Cellularity_Challenge_2019/Data/breastpathq/datasets/cells/1_Region 1_mask.tif"
loaded_img_mask = utils_image.load_img(img_mask_path)
xml_crop_path = "/mnt/1T-5e7/mycodehtml/bio_health/SPIE-AAPM-NCI_BreastPathQ_Cancer_Cellularity_Challenge_2019/Data/breastpathq/datasets/cells/Sedeen/1_Region 1_crop.session.xml"
whole_xml_crop_data = utils_data.load_xml_file(xml_crop_path)
# ================================================================================
# print("whole_xml_key_data",whole_xml_key_data)
data_name = whole_xml_key_data[0][0]
data_region = whole_xml_key_data[0][1]
data_color = whole_xml_key_data[0][2]
data_points = whole_xml_key_data[0][3]
# print("data_points",dir(data_points))
data_points_li = str(data_points).replace("\n", "").replace(
"<point-list>", "").replace("<point>",
"").replace("</point-list>",
"").split("</point>")[:-1]
# print("data_points_li",data_points_li)
# ['32,18', '51,13',
x_vals = []
y_vals = []
for one_coord in data_points_li:
x_val = one_coord.split(",")[0]
y_val = one_coord.split(",")[1]
x_vals.append(x_val)
y_vals.append(y_val)
# print("x_vals",x_vals)
# ['32', '51',
# print("y_vals",y_vals)
# ['18', '13',
x_vals = list(map(int, x_vals))
y_vals = list(map(int, y_vals))
# print("x_vals",x_vals)
# [32, 51,
# print("y_vals",y_vals)
# [18, 13,
# ================================================================================
data_name_1 = whole_xml_key_data[1][0]
data_region_1 = whole_xml_key_data[1][1]
data_color_1 = whole_xml_key_data[1][2]
data_points_1 = whole_xml_key_data[1][3]
# print("data_points_1",data_points_1)
data_points_1_li = str(data_points_1).replace("\n", "").replace(
"<point-list>", "").replace("<point>",
"").replace("</point-list>",
"").split("</point>")[:-1]
# print("data_points_1_li",data_points_1_li)
# ['32,18', '51,13',
x_vals_1 = []
y_vals_1 = []
for one_coord in data_points_1_li:
x_val_1 = one_coord.split(",")[0]
y_val_1 = one_coord.split(",")[1]
x_vals_1.append(x_val_1)
y_vals_1.append(y_val_1)
# print("x_vals_1",x_vals_1)
# ['32', '51',
# print("y_vals_1",y_vals_1)
# ['18', '13',
x_vals_1 = list(map(int, x_vals_1))
y_vals_1 = list(map(int, y_vals_1))
# print("x_vals_1",x_vals_1)
# [32, 51,
# print("y_vals_1",y_vals_1)
# [18, 13,
# fafaf
# ================================================================================
data_name_2 = whole_xml_key_data[2][0]
data_region_2 = whole_xml_key_data[2][1]
data_color_2 = whole_xml_key_data[2][2]
data_points_2 = whole_xml_key_data[2][3]
# print("data_points_2",dir(data_points_2))
data_points_2_li = str(data_points_2).replace("\n", "").replace(
"<point-list>", "").replace("<point>",
"").replace("</point-list>",
"").split("</point>")[:-1]
# print("data_points_2_li",data_points_2_li)
# ['32,18', '51,13',
x_vals_2 = []
y_vals_2 = []
for one_coord in data_points_2_li:
x_val_2 = one_coord.split(",")[0]
y_val_2 = one_coord.split(",")[1]
x_vals_2.append(x_val_2)
y_vals_2.append(y_val_2)
# print("x_vals_2",x_vals_2)
# ['32', '51',
# print("y_vals_2",y_vals_2)
# ['18', '13',
x_vals_2 = list(map(int, x_vals_2))
y_vals_2 = list(map(int, y_vals_2))
# print("x_vals_2",x_vals_2)
# [32, 51,
# print("y_vals_2",y_vals_2)
# [18, 13,
# ================================================================================
utils_image.scatter_points_onto_img(
loaded_img_crop,
x_vals,
y_vals,
color="b",
title="Image: 1_Region 1_crop.tif, XML: 1_Region 1_key.xml Region 2")
# /home/young/Pictures/2019_04_14_01:14:03.png
utils_image.scatter_points_onto_img(
loaded_img_crop,
x_vals_1,
y_vals_1,
color="g",
title="Image: 1_Region 1_crop.tif, XML: 1_Region 1_key.xml Region 3")
# /home/young/Pictures/2019_04_14_01:14:35.png
utils_image.scatter_points_onto_img(
loaded_img_crop,
x_vals_2,
y_vals_2,
color="r",
title="Image: 1_Region 1_crop.tif, XML: 1_Region 1_key.xml Region 4")
# /home/young/Pictures/2019_04_14_01:14:58.png
# ================================================================================
# print(np.unique(loaded_img_mask))
# [ 0 85 127 255]
# print("loaded_img_mask",loaded_img_mask[:,:,:3])
unique_colors = list(
set(tuple(v) for m2d in loaded_img_mask[:, :, :3] for v in m2d))
# print("unique_colors",unique_colors)
# [(0, 255, 127), (0, 0, 0), (255, 255, 255), (0, 85, 0)]
def use_mask_tif():
for one_color in unique_colors:
# print("one_color",one_color)
# (0, 255, 127)
# new_img=np.where(loaded_img_mask[:,:,:3]==np.array(one_color),1.0,0.0)
loaded_img_mask_proc = loaded_img_mask[:, :, :3]
# (0, 255, 127) locations are True
new_img = np.all(loaded_img_mask_proc == np.array(one_color),
axis=2)
# print("new_img",new_img.shape)
# print("new_img",new_img)
new_img = skimage.morphology.binary_dilation(new_img, square(3))
new_img = new_img[:, :, np.newaxis].astype("uint8")
# None (0, 255, 127) locations are 1
new_img = np.where(new_img == 0, 1, 0)
# print("new_img",new_img)
masked_img = loaded_img_crop * new_img
stacked = np.vstack(masked_img)
# # print("stacked",stacked.shape)
# # (234971, 3)
# # afaf
# # stacked=loaded_img_crop_mask.reshape((-1,3))
# # print("stacked",stacked.shape)
# # (234971, 3)
idx = np.all(stacked == [0, 0, 0], 1)
# # print("idx",idxs.shape)
# # idx (234971,)
# # print("idx",idx)
# # afaf
# a1=np.vstack(loaded_img_crop)
stacked[idx] = [0, 255, 0]
# # print("a1",a1.shape)
# # a1 (234971, 3)
loaded_img_crop_new = stacked.reshape(loaded_img_crop.shape[0],
loaded_img_crop.shape[1], 3)
# print("loaded_img_crop",loaded_img_crop.shape)
# loaded_img_crop_masked=loaded_img_crop[loaded_img_crop_mask]
# print("loaded_img_crop_masked",loaded_img_crop_masked)
# # loaded_img_crop[loaded_img_crop_mask] (18, 3)
# # loaded_img_crop[loaded_img_crop_mask] (387, 3)
# # loaded_img_crop[loaded_img_crop_mask] (234971, 3)
# # loaded_img_crop[loaded_img_crop_mask] (1629, 3)
# loaded_img_crop[loaded_img_crop_mask]=[0,250,0]
# # print("loaded_img_crop",loaded_img_crop)
# plt.imshow(loaded_img_crop*nesw_img)
plt.imshow(loaded_img_crop_new)
plt.title("File: 1_Region 1_mask.tif, " + str(one_color))
# /home/young/Pictures/2019_04_14_10:01:03.png
# /home/young/Pictures/2019_04_14_10:01:18.png
# /home/young/Pictures/2019_04_14_10:01:34.png
plt.show()
use_mask_tif()
# ================================================================================
# print("whole_xml_crop_data",whole_xml_crop_data)
data_name = whole_xml_crop_data[0][0]
data_region = whole_xml_crop_data[0][1]
data_color = whole_xml_crop_data[0][2]
data_points = whole_xml_crop_data[0][3]
# print("data_points",dir(data_points))
data_points_li = str(data_points).replace("\n", "").replace(
"<point-list>", "").replace("<point>",
"").replace("</point-list>",
"").split("</point>")[:-1]
# print("data_points_li",data_points_li)
# ['32,18', '51,13',
x_vals = []
y_vals = []
for one_coord in data_points_li:
x_val = one_coord.split(",")[0]
y_val = one_coord.split(",")[1]
x_vals.append(x_val)
y_vals.append(y_val)
# print("x_vals",x_vals)
# ['32', '51',
# print("y_vals",y_vals)
# ['18', '13',
x_vals = list(map(int, x_vals))
y_vals = list(map(int, y_vals))
# print("x_vals",x_vals)
# [32, 51,
# print("y_vals",y_vals)
# [18, 13,
# ================================================================================
data_name_1 = whole_xml_crop_data[1][0]
data_region_1 = whole_xml_crop_data[1][1]
data_color_1 = whole_xml_crop_data[1][2]
data_points_1 = whole_xml_crop_data[1][3]
# print("data_points_1",data_points_1)
# afaf
data_points_1_li = str(data_points_1).replace("\n", "").replace(
"<point-list>", "").replace("<point>",
"").replace("</point-list>",
"").split("</point>")[:-1]
# print("data_points_1_li",data_points_1_li)
# ['32,18', '51,13',
x_vals_1 = []
y_vals_1 = []
for one_coord in data_points_1_li:
x_val_1 = one_coord.split(",")[0]
y_val_1 = one_coord.split(",")[1]
x_vals_1.append(x_val_1)
y_vals_1.append(y_val_1)
# print("x_vals_1",x_vals_1)
# ['32', '51',
# print("y_vals_1",y_vals_1)
# ['18', '13',
x_vals_1 = list(map(int, x_vals_1))
y_vals_1 = list(map(int, y_vals_1))
# print("x_vals_1",x_vals_1)
# [32, 51,
# print("y_vals_1",y_vals_1)
# [18, 13,
# fafaf
# ================================================================================
data_name_2 = whole_xml_crop_data[2][0]
data_region_2 = whole_xml_crop_data[2][1]
data_color_2 = whole_xml_crop_data[2][2]
data_points_2 = whole_xml_crop_data[2][3]
# print("data_points_2",dir(data_points_2))
data_points_2_li = str(data_points_2).replace("\n", "").replace(
"<point-list>", "").replace("<point>",
"").replace("</point-list>",
"").split("</point>")[:-1]
# print("data_points_2_li",data_points_2_li)
# ['32,18', '51,13',
x_vals_2 = []
y_vals_2 = []
for one_coord in data_points_2_li:
x_val_2 = one_coord.split(",")[0]
y_val_2 = one_coord.split(",")[1]
x_vals_2.append(x_val_2)
y_vals_2.append(y_val_2)
# print("x_vals_2",x_vals_2)
# ['32', '51',
# print("y_vals_2",y_vals_2)
# ['18', '13',
x_vals_2 = list(map(int, x_vals_2))
y_vals_2 = list(map(int, y_vals_2))
# print("x_vals_2",x_vals_2)
# [32, 51,
# print("y_vals_2",y_vals_2)
# [18, 13,
# ================================================================================
utils_image.scatter_points_onto_img(
loaded_img_crop,
x_vals,
y_vals,
color="b",
title=
"Image: 1_Region 1_crop.tif, XML: 1_Region 1_crop.session.xml Region 2"
)
# /home/young/Pictures/2019_04_14_10:02:20.png
utils_image.scatter_points_onto_img(
loaded_img_crop,
x_vals_1,
y_vals_1,
color="g",
title=
"Image: 1_Region 1_crop.tif, XML: 1_Region 1_crop.session.xml Region 3"
)
# /home/young/Pictures/2019_04_14_10:02:44.png
utils_image.scatter_points_onto_img(
loaded_img_crop,
x_vals_2,
y_vals_2,
color="r",
title=
"Image: 1_Region 1_crop.tif, XML: 1_Region 1_crop.session.xml Region 4"
)
