吴裕雄--天生自然 PYTHON数据分析：糖尿病视网膜病变数据分析（完整版）

Posted 2022-05-09 tszr

# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python
# For example, here‘s several helpful packages to load in 

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the "../input/" directory.
# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory

import os, sys
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import skimage.io
from skimage.transform import resize
#from imgaug import augmenters as iaa
from tqdm import tqdm
import PIL
from PIL import Image, ImageOps
import cv2
from sklearn.utils import class_weight, shuffle
from keras.losses import binary_crossentropy
from keras.applications.resnet50 import preprocess_input
import keras.backend as K
import tensorflow as tf
from sklearn.metrics import f1_score, fbeta_score
from keras.utils import Sequence
from keras.utils import to_categorical
from sklearn.model_selection import train_test_split

WORKERS = 2
CHANNEL = 3

import warnings
warnings.filterwarnings("ignore")
IMG_SIZE = 512
NUM_CLASSES = 5
SEED = 77
TRAIN_NUM = 1000 # use 1000 when you just want to explore new idea, use -1 for full train

df_train = pd.read_csv(‘F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\trainLabels19.csv‘)
df_test = pd.read_csv(‘F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\testImages19.csv‘)

x = df_train[‘id_code‘]
y = df_train[‘diagnosis‘]

x, y = shuffle(x, y, random_state=SEED)

train_x, valid_x, train_y, valid_y = train_test_split(x, y, test_size=0.15,stratify=y, random_state=SEED)
print(train_x.shape, train_y.shape, valid_x.shape, valid_y.shape)
train_y.hist()
valid_y.hist()

%%time
fig = plt.figure(figsize=(25, 16))
# display 10 images from each class
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_train.loc[df_train[‘diagnosis‘] == class_id].sample(5, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, 5, class_id * 5 + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = cv2.imread(path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
        plt.imshow(image)
        ax.set_title(‘Label: %d-%d-%s‘ % (class_id, idx, row[‘id_code‘]) )

%%time
fig = plt.figure(figsize=(25, 16))
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_train.loc[df_train[‘diagnosis‘] == class_id].sample(5, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, 5, class_id * 5 + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = cv2.imread(path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#         image=cv2.addWeighted ( image, 0 , cv2.GaussianBlur( image , (0 ,0 ) , 10) ,-4 ,128)
        image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
        plt.imshow(image, cmap=‘gray‘)
        ax.set_title(‘Label: %d-%d-%s‘ % (class_id, idx, row[‘id_code‘]) )

dpi = 80 #inch

# path=f"../input/aptos2019-blindness-detection/train_images/5c7ab966a3ee.png" # notice upper part
path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\cd54d022e37d.jpg" # lower-right, this still looks not so severe, can be class3
image = cv2.imread(path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
height, width = image.shape
print(height, width)

SCALE=2
figsize = (width / float(dpi))/SCALE, (height / float(dpi))/SCALE

fig = plt.figure(figsize=figsize)
plt.imshow(image, cmap=‘gray‘)

%%time
fig = plt.figure(figsize=(25, 16))
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_train.loc[df_train[‘diagnosis‘] == class_id].sample(5, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, 5, class_id * 5 + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = cv2.imread(path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#         image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
        image=cv2.addWeighted ( image,4, cv2.GaussianBlur( image , (0,0) , IMG_SIZE/10) ,-4 ,128) # the trick is to add this line

        plt.imshow(image, cmap=‘gray‘)
        ax.set_title(‘Label: %d-%d-%s‘ % (class_id, idx, row[‘id_code‘]) )

def crop_image1(img,tol=7):
    # img is image data
    # tol  is tolerance   
    mask = img>tol
    return img[np.ix_(mask.any(1),mask.any(0))]

def crop_image_from_gray(img,tol=7):
    if img.ndim ==2:
        mask = img>tol
        return img[np.ix_(mask.any(1),mask.any(0))]
    elif img.ndim==3:
        gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
        mask = gray_img>tol
        check_shape = img[:,:,0][np.ix_(mask.any(1),mask.any(0))].shape[0]
        if (check_shape == 0): # image is too dark so that we crop out everything,
            return img # return original image
        else:
            img1=img[:,:,0][np.ix_(mask.any(1),mask.any(0))]
            img2=img[:,:,1][np.ix_(mask.any(1),mask.any(0))]
            img3=img[:,:,2][np.ix_(mask.any(1),mask.any(0))]
    #         print(img1.shape,img2.shape,img3.shape)
            img = np.stack([img1,img2,img3],axis=-1)
    #         print(img.shape)
        return img

def load_ben_color(path, sigmaX=10):
    image = cv2.imread(path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image = crop_image_from_gray(image)
    image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
    image=cv2.addWeighted ( image,4, cv2.GaussianBlur( image , (0,0) , sigmaX) ,-4 ,128)
    return image

%%time

NUM_SAMP=7
fig = plt.figure(figsize=(25, 16))
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_train.loc[df_train[‘diagnosis‘] == class_id].sample(NUM_SAMP, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, NUM_SAMP, class_id * NUM_SAMP + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = load_ben_color(path,sigmaX=30)
        plt.imshow(image)
        ax.set_title(‘%d-%d-%s‘ % (class_id, idx, row[‘id_code‘]) )

def circle_crop(img, sigmaX=10):   
    """
    Create circular crop around image centre    
    """    
    img = cv2.imread(img)
    img = crop_image_from_gray(img)    
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    height, width, depth = img.shape    
    x = int(width/2)
    y = int(height/2)
    r = np.amin((x,y))
    circle_img = np.zeros((height, width), np.uint8)
    cv2.circle(circle_img, (x,y), int(r), 1, thickness=-1)
    img = cv2.bitwise_and(img, img, mask=circle_img)
    img = crop_image_from_gray(img)
    img=cv2.addWeighted ( img,4, cv2.GaussianBlur( img , (0,0) , sigmaX) ,-4 ,128)
    return img 

%%time
## try circle crop
NUM_SAMP=7
fig = plt.figure(figsize=(25, 16))
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_train.loc[df_train[‘diagnosis‘] == class_id].sample(NUM_SAMP, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, NUM_SAMP, class_id * NUM_SAMP + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = circle_crop(path,sigmaX=30)
        plt.imshow(image)
        ax.set_title(‘%d-%d-%s‘ % (class_id, idx, row[‘id_code‘]) )

dpi = 80 #inch
path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized train 19\\\\cd54d022e37d.jpg"
image = load_ben_color(path,sigmaX=10)

height, width = IMG_SIZE, IMG_SIZE
print(height, width)

SCALE=1
figsize = (width / float(dpi))/SCALE, (height / float(dpi))/SCALE

fig = plt.figure(figsize=figsize)
plt.imshow(image, cmap=‘gray‘)

%%time
NUM_SAMP=10
fig = plt.figure(figsize=(25, 16))
for jj in range(5):
    for i, (idx, row) in enumerate(df_test.sample(NUM_SAMP,random_state=SEED+jj).iterrows()):
        ax = fig.add_subplot(5, NUM_SAMP, jj * NUM_SAMP + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized test 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = load_ben_color(path,sigmaX=30)
        plt.imshow(image)
        ax.set_title(‘%d-%s‘ % (idx, row[‘id_code‘]) )

%%time
NUM_SAMP=10
fig = plt.figure(figsize=(25, 16))
for jj in range(5):
    for i, (idx, row) in enumerate(df_test.sample(NUM_SAMP,random_state=SEED+jj).iterrows()):
        ax = fig.add_subplot(5, NUM_SAMP, jj * NUM_SAMP + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized test 19\\\\"+str(row[‘id_code‘])+".jpg"
        image = load_ben_color(path,sigmaX=50)
        plt.imshow(image, cmap=‘gray‘)
        ax.set_title(‘%d-%s‘ % (idx, row[‘id_code‘]) )

df_old = pd.read_csv(‘F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\trainLabels.csv‘)
df_old.head()

NUM_SAMP=10
fig = plt.figure(figsize=(25, 16))
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_old.loc[df_old[‘level‘] == class_id].sample(NUM_SAMP, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, NUM_SAMP, class_id * NUM_SAMP + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized_train\\\\"+row[‘image‘]+".jpeg"
        image = load_ben_color(path,sigmaX=30)
        plt.imshow(image)
        ax.set_title(‘%d-%d-%s‘ % (class_id, idx, row[‘image‘]) )

NUM_SAMP=10
fig = plt.figure(figsize=(25, 16))
for class_id in sorted(train_y.unique()):
    for i, (idx, row) in enumerate(df_old.loc[df_old[‘level‘] == class_id].sample(NUM_SAMP, random_state=SEED).iterrows()):
        ax = fig.add_subplot(5, NUM_SAMP, class_id * NUM_SAMP + i + 1, xticks=[], yticks=[])
        path="F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized_train\\\\"+row[‘image‘]+".jpeg"
        image = cv2.imread(path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
        plt.imshow(image, cmap=‘gray‘)
        ax.set_title(‘%d-%d-%s‘ % (class_id, idx, row[‘image‘]) )

dpi = 80 #inch

path=f"F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized_train\\\\31590_right.jpeg" # too many vessels?
image = load_ben_color(path,sigmaX=30)
# image = cv2.imread(path)
# image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# image = crop_image1(image)
# image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
# image=cv2.addWeighted ( image,4, cv2.GaussianBlur( image , (0,0) , IMG_SIZE/10) ,-4 ,128)

height, width = IMG_SIZE, IMG_SIZE
print(height, width)
SCALE=1
figsize = (width / float(dpi))/SCALE, (height / float(dpi))/SCALE
fig = plt.figure(figsize=figsize)
plt.imshow(image, cmap=‘gray‘)

dpi = 80 #inch

path_jpg=f"F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized_train_cropped\\\\18017_left.jpeg" # too many vessels?
path_png=f"F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\rescaled_train_896\\\\18017_left.png" # details are lost
image = cv2.imread(path_png)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))

image2 =  cv2.imread(path_jpg)
image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2RGB)
image2 = cv2.resize(image2, (IMG_SIZE, IMG_SIZE))

height, width = IMG_SIZE, IMG_SIZE
print(height, width)

SCALE=1/4
figsize = (width / float(dpi))/SCALE, (height / float(dpi))/SCALE

fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(2, 2, 1, xticks=[], yticks=[])
ax.set_title(‘png format original‘ )
plt.imshow(image, cmap=‘gray‘)
ax = fig.add_subplot(2, 2, 2, xticks=[], yticks=[])
ax.set_title(‘jpg format original‘ )
plt.imshow(image2, cmap=‘gray‘)

image = load_ben_color(path_png,sigmaX=30)
image2 = load_ben_color(path_jpg,sigmaX=30)
ax = fig.add_subplot(2, 2, 3, xticks=[], yticks=[])
ax.set_title(‘png format transformed‘ )
plt.imshow(image, cmap=‘gray‘)
ax = fig.add_subplot(2, 2, 4, xticks=[], yticks=[])
ax.set_title(‘jpg format transformed‘ )
plt.imshow(image2, cmap=‘gray‘)

import json
import math
import os

import cv2
from PIL import Image
import numpy as np
from keras import layers
from keras.applications import DenseNet121
from keras.callbacks import Callback, ModelCheckpoint
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.optimizers import Adam
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import cohen_kappa_score, accuracy_score
import scipy
from tqdm import tqdm

%matplotlib inline

train_df = pd.read_csv(‘F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\trainLabels19.csv‘)
test_df = pd.read_csv(‘F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\testImages19.csv‘)
print(train_df.shape)
print(test_df.shape)
test_df.head()

def get_pad_width(im, new_shape, is_rgb=True):
    pad_diff = new_shape - im.shape[0], new_shape - im.shape[1]
    t, b = math.floor(pad_diff[0]/2), math.ceil(pad_diff[0]/2)
    l, r = math.floor(pad_diff[1]/2), math.ceil(pad_diff[1]/2)
    if is_rgb:
        pad_width = ((t,b), (l,r), (0, 0))
    else:
        pad_width = ((t,b), (l,r))
    return pad_width

def preprocess_image(image_path, desired_size=224):
    im = Image.open(image_path)
    im = im.resize((desired_size, )*2, resample=Image.LANCZOS)
    return im

N = test_df.shape[0]
x_test = np.empty((N, 224, 224, 3), dtype=np.uint8)

for i, image_id in enumerate(tqdm(test_df[‘id_code‘])):
    x_test[i, :, :, :] = preprocess_image("F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized test 19\\\\"+str(image_id)+".jpg")

# model.summary()
def load_image_ben_orig(path,resize=True,crop=False,norm255=True,keras=False):
    image = cv2.imread(path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)   
    image=cv2.addWeighted( image,4, cv2.GaussianBlur( image , (0,0) ,  10) ,-4 ,128)
    if norm255:
        return image/255
    elif keras:
        #see https://github.com/keras-team/keras-applications/blob/master/keras_applications/imagenet_utils.py for mode
        #see https://github.com/keras-team/keras-applications/blob/master/keras_applications/xception.py for inception,xception mode
        #the use of tf based preprocessing (- and / by 127 respectively) will results in [-1,1] so it will not visualize correctly (directly)
        image = np.expand_dims(image, axis=0)
        return preprocess_input(image)[0]
    else:
        return image.astype(np.int16)
    return image

def transform_image_ben(img,resize=True,crop=False,norm255=True,keras=False):  
    image=cv2.addWeighted( img,4, cv2.GaussianBlur( img , (0,0) ,  10) ,-4 ,128)
    if norm255:
        return image/255
    elif keras:
        image = np.expand_dims(image, axis=0)
        return preprocess_input(image)[0]
    else:
        return image.astype(np.int16)
    return image

def display_samples(df, columns=5, rows=2, Ben=True):
    fig=plt.figure(figsize=(5*columns, 4*rows))
    for i in range(columns*rows):
        image_path = df.loc[i,‘id_code‘]
        path = f"F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized test 19\\\\"+str(image_path)+".jpg"
        if Ben:
            img = load_image_ben_orig(path)
        else:
            img = cv2.imread(path)
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        fig.add_subplot(rows, columns, i+1)
        plt.imshow(img)
    plt.tight_layout()
display_samples(test_df, Ben=False)
display_samples(test_df, Ben=True)

from keras import layers
from keras.models import Model
import keras.backend as K

K.clear_session()
densenet = DenseNet121(weights=None,include_top=False,input_shape=(None,None,3))

GAP_layer = layers.GlobalAveragePooling2D()
drop_layer = layers.Dropout(0.5)
dense_layer = layers.Dense(5, activation=‘sigmoid‘, name=‘final_output‘)

def build_model_sequential():
    model = Sequential()
    model.add(densenet)
    model.add(GAP_layer)
    model.add(drop_layer)
    model.add(dense_layer)
    return model

modelA = build_model_sequential()
modelA.load_weights(‘F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\dense_xhlulu_731.h5‘)
modelA.summary()

model = build_model_functional() # with pretrained weights, and layers we want
model.summary()

y_test = model.predict(x_test) > 0.5
y_test = y_test.astype(int).sum(axis=1) - 1

import seaborn as sns
import cv2

SIZE=224
def create_pred_hist(pred_level_y,title=‘NoTitle‘):
    results = pd.DataFrame(‘diagnosis‘:pred_level_y)
    f, ax = plt.subplots(figsize=(7, 4))
    ax = sns.countplot(x="diagnosis", data=results, palette="GnBu_d")
    sns.despine()
    plt.title(title)
    plt.show()

create_pred_hist(y_test,title=‘predicted level distribution in test set‘)

def gen_heatmap_img(img, model0, layer_name=‘last_conv_layer‘,viz_img=None,orig_img=None):
    preds_raw = model0.predict(img[np.newaxis])
    preds = preds_raw > 0.5 # use the same threshold as @xhlulu original kernel
    class_idx = (preds.astype(int).sum(axis=1) - 1)[0]
    class_output_tensor = model0.output[:, class_idx]
    
    viz_layer = model0.get_layer(layer_name)
    grads = K.gradients(class_output_tensor ,viz_layer.output)[0] # gradients of viz_layer wrt output_tensor of predicted class
    pooled_grads=K.mean(grads,axis=(0,1,2))
    iterate=K.function([model0.input],[pooled_grads, viz_layer.output[0]])
    pooled_grad_value, viz_layer_out_value = iterate([img[np.newaxis]])
    for i in range(pooled_grad_value.shape[0]):
        viz_layer_out_value[:,:,i] *= pooled_grad_value[i]
    heatmap = np.mean(viz_layer_out_value, axis=-1)
    heatmap = np.maximum(heatmap,0)
    heatmap /= np.max(heatmap)
    viz_img=cv2.resize(viz_img,(img.shape[1],img.shape[0]))
    heatmap=cv2.resize(heatmap,(viz_img.shape[1],viz_img.shape[0]))
    heatmap_color = cv2.applyColorMap(np.uint8(heatmap*255), cv2.COLORMAP_SPRING)/255
    heated_img = heatmap_color*0.5 + viz_img*0.5
    print(‘raw output from model : ‘)
    print_pred(preds_raw)
    if orig_img is None:
        show_Nimages([img,viz_img,heatmap_color,heated_img])
    else:
        show_Nimages([orig_img,img,viz_img,heatmap_color,heated_img])
    plt.show()
    return heated_img

def show_image(image,figsize=None,title=None):
    if figsize is not None:
        fig = plt.figure(figsize=figsize) 
    if image.ndim == 2:
        plt.imshow(image,cmap=‘gray‘)
    else:
        plt.imshow(image)
    if title is not None:
        plt.title(title)

def show_Nimages(imgs,scale=1):
    N=len(imgs)
    fig = plt.figure(figsize=(25/scale, 16/scale))
    for i, img in enumerate(imgs):
        ax = fig.add_subplot(1, N, i + 1, xticks=[], yticks=[])
        show_image(img)
        
def print_pred(array_of_classes):
    xx = array_of_classes
    s1,s2 = xx.shape
    for i in range(s1):
        for j in range(s2):
            print(‘%.3f ‘ % xx[i,j],end=‘‘)
        print(‘‘)

NUM_SAMP=10
SEED=77
layer_name = ‘relu‘ #‘conv5_block16_concat‘
for i, (idx, row) in enumerate(test_df[:NUM_SAMP].iterrows()):
    path=f"F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized test 19\\\\"+str(row["id_code"])+".jpg"
    ben_img = load_image_ben_orig(path)
    input_img = np.empty((1,224, 224, 3), dtype=np.uint8)
    input_img[0,:,:,:] = preprocess_image(path)
    print(‘test pic no.%d‘ % (i+1))
    _ = gen_heatmap_img(input_img[0],model, layer_name=layer_name,viz_img=ben_img)

from albumentations import *
import time

IMG_SIZE = (224,224)

‘‘‘Use case from https://www.kaggle.com/alexanderliao/image-augmentation-demo-with-albumentation/‘‘‘
def albaugment(aug0, img):
    return aug0(image=img)[‘image‘]
idx=8
image1=x_test[idx]

‘‘‘1. Rotate or Flip‘‘‘
aug1 = OneOf([Rotate(p=0.99, limit=160, border_mode=0,value=0), Flip(p=0.5)],p=1)

‘‘‘2. Adjust Brightness or Contrast‘‘‘
aug2 = RandomBrightnessContrast(brightness_limit=0.45, contrast_limit=0.45,p=1)
h_min=np.round(IMG_SIZE[1]*0.72).astype(int)
h_max= np.round(IMG_SIZE[1]*0.9).astype(int)
print(h_min,h_max)

‘‘‘3. Random Crop and then Resize‘‘‘
#w2h_ratio = aspect ratio of cropping
aug3 = RandomSizedCrop((h_min, h_max),IMG_SIZE[1],IMG_SIZE[0], w2h_ratio=IMG_SIZE[0]/IMG_SIZE[1],p=1)

‘‘‘4. CutOut Augmentation‘‘‘
max_hole_size = int(IMG_SIZE[1]/10)
aug4 = Cutout(p=1,max_h_size=max_hole_size,max_w_size=max_hole_size,num_holes=8 )#default num_holes=8

‘‘‘5. SunFlare Augmentation‘‘‘
aug5 = RandomSunFlare(src_radius=max_hole_size,num_flare_circles_lower=10,num_flare_circles_upper=20,p=1)

‘‘‘6. Ultimate Augmentation -- combine everything‘‘‘
final_aug = Compose([aug1,aug2,aug3,aug4,aug5],p=1)

img1 = albaugment(aug1,image1)
img2 = albaugment(aug1,image1)
print(‘Rotate or Flip‘)
show_Nimages([image1,img1,img2],scale=2)
# time.sleep(1)

img1 = albaugment(aug2,image1)
img2 = albaugment(aug2,image1)
img3 = albaugment(aug2,image1)
print(‘Brightness or Contrast‘)
show_Nimages([img3,img1,img2],scale=2)
# time.sleep(1)

img1 = albaugment(aug3,image1)
img2 = albaugment(aug3,image1)
img3 = albaugment(aug3,image1)
print(‘Rotate and Resize‘)
show_Nimages([img3,img1,img2],scale=2)
print(img1.shape,img2.shape)
# time.sleep(1)

img1 = albaugment(aug4,image1)
img2 = albaugment(aug4,image1)
img3 = albaugment(aug4,image1)
print(‘CutOut‘)
show_Nimages([img3,img1,img2],scale=2)
# time.sleep(1)

img1 = albaugment(aug5,image1)
img2 = albaugment(aug5,image1)
img3 = albaugment(aug5,image1)
print(‘Sun Flare‘)
show_Nimages([img3,img1,img2],scale=2)
# time.sleep(1)

img1 = albaugment(final_aug,image1)
img2 = albaugment(final_aug,image1)
img3 = albaugment(final_aug,image1)
print(‘All above combined‘)
show_Nimages([img3,img1,img2],scale=2)
print(img1.shape,img2.shape)

aug_list = [aug5, aug2, aug3, aug4, aug1, final_aug]
aug_name = [‘SunFlare‘, ‘brightness or contrast‘, ‘crop and resized‘, ‘CutOut‘, ‘rotate or flip‘, ‘Everything Combined‘]

idx=8
layer_name = ‘relu‘ 
for i in range(len(aug_list)):
    path=f"F:\\\\kaggleDataSet\\\\diabeticRetinopathy\\\\resized test 19\\\\"+str(row["id_code"])+".jpg"
    input_img = np.empty((1,224, 224, 3), dtype=np.uint8)
    input_img[0,:,:,:] = preprocess_image(path)
    aug_img = albaugment(aug_list[i],input_img[0,:,:,:])
    ben_img = transform_image_ben(aug_img)
    print(‘test pic no.%d -- augmentation: %s‘ % (i+1, aug_name[i]))
    _ = gen_heatmap_img(aug_img,model, layer_name=layer_name,viz_img=ben_img,orig_img=input_img[0])