我在colab中训练了多输出模型，模型分支将使用激情损失对图像进行分类，另一个分支将使用二进制交叉熵损失进行分割，并使用dicecoef作为精度，当在colab上训练时，模型给出了良好的结果精度:99,dicecoef:90
然而，当在我的本地机器上训练时，两个中的一个通常在第一个epoch后精确地变为零，使用相同的代码没有任何变化，相同的数据唯一的区别是我使用tensorflow 2.5，而在colab上它是2.6。
我为肮脏的编码道歉。
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # or any {'0', '1', '2'}
import tensorflow as tf
import random
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from skimage.io import imread , imshow
from skimage.transform import resize
# example of pixel normalization
from numpy import asarray
# load image
import shutil
#import cv2 as cv
import tensorflow.keras.backend as K
from tensorflow.keras.losses import binary_crossentropy
beta = 0.25
alpha = 0.25
gamma = 2
epsilon = 1e-5
smooth = 1
class Semantic_loss_functions(object):
def __init__(self):
print ("semantic loss functions initialized")
def dice_coef(self, y_true, y_pred):
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + K.epsilon()) / (
K.sum(y_true_f) + K.sum(y_pred_f) + K.epsilon())
def sensitivity(self, y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
return true_positives / (possible_positives + K.epsilon())
def specificity(self, y_true, y_pred):
true_negatives = K.sum(
K.round(K.clip((1 - y_true) * (1 - y_pred), 0, 1)))
possible_negatives = K.sum(K.round(K.clip(1 - y_true, 0, 1)))
return true_negatives / (possible_negatives + K.epsilon())
def convert_to_logits(self, y_pred):
y_pred = tf.clip_by_value(y_pred, tf.keras.backend.epsilon(),
1 - tf.keras.backend.epsilon())
return tf.math.log(y_pred / (1 - y_pred))
def weighted_cross_entropyloss(self, y_true, y_pred):
y_pred = self.convert_to_logits(y_pred)
pos_weight = beta / (1 - beta)
loss = tf.nn.weighted_cross_entropy_with_logits(logits=y_pred,
targets=y_true,
pos_weight=pos_weight)
return tf.reduce_mean(loss)
def focal_loss_with_logits(self, logits, targets, alpha, gamma, y_pred):
weight_a = alpha * (1 - y_pred) ** gamma * targets
weight_b = (1 - alpha) * y_pred ** gamma * (1 - targets)
return (tf.math.log1p(tf.exp(-tf.abs(logits))) + tf.nn.relu(
-logits)) * (weight_a + weight_b) + logits * weight_b
def focal_loss(self, y_true, y_pred):
y_pred = tf.clip_by_value(y_pred, tf.keras.backend.epsilon(),
1 - tf.keras.backend.epsilon())
logits = tf.math.log(y_pred / (1 - y_pred))
loss = self.focal_loss_with_logits(logits=logits, targets=y_true,
alpha=alpha, gamma=gamma, y_pred=y_pred)
return tf.reduce_mean(loss)
def depth_softmax(self, matrix):
sigmoid = lambda x: 1 / (1 + K.exp(-x))
sigmoided_matrix = sigmoid(matrix)
softmax_matrix = sigmoided_matrix / K.sum(sigmoided_matrix, axis=0)
return softmax_matrix
def generalized_dice_coefficient(self, y_true, y_pred):
smooth = 1.
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
score = (2. * intersection + smooth) / (
K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
return score
def dice_loss(self, y_true, y_pred):
loss = 1 - self.generalized_dice_coefficient(y_true, y_pred)
return loss
def bce_dice_loss(self, y_true, y_pred):
loss = binary_crossentropy(y_true, y_pred) +
self.dice_loss(y_true, y_pred)
return loss / 2.0
def confusion(self, y_true, y_pred):
smooth = 1
y_pred_pos = K.clip(y_pred, 0, 1)
y_pred_neg = 1 - y_pred_pos
y_pos = K.clip(y_true, 0, 1)
y_neg = 1 - y_pos
tp = K.sum(y_pos * y_pred_pos)
fp = K.sum(y_neg * y_pred_pos)
fn = K.sum(y_pos * y_pred_neg)
prec = (tp + smooth) / (tp + fp + smooth)
recall = (tp + smooth) / (tp + fn + smooth)
return prec, recall
def true_positive(self, y_true, y_pred):
smooth = 1
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pos = K.round(K.clip(y_true, 0, 1))
tp = (K.sum(y_pos * y_pred_pos) + smooth) / (K.sum(y_pos) + smooth)
return tp
def true_negative(self, y_true, y_pred):
smooth = 1
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = 1 - y_pred_pos
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = 1 - y_pos
tn = (K.sum(y_neg * y_pred_neg) + smooth) / (K.sum(y_neg) + smooth)
return tn
def tversky_index(self, y_true, y_pred):
y_true_pos = K.flatten(y_true)
y_pred_pos = K.flatten(y_pred)
true_pos = K.sum(y_true_pos * y_pred_pos)
false_neg = K.sum(y_true_pos * (1 - y_pred_pos))
false_pos = K.sum((1 - y_true_pos) * y_pred_pos)
alpha = 0.7
return (true_pos + smooth) / (true_pos + alpha * false_neg + (
1 - alpha) * false_pos + smooth)
def tversky_loss(self, y_true, y_pred):
return 1 - self.tversky_index(y_true, y_pred)
def focal_tversky(self, y_true, y_pred):
pt_1 = self.tversky_index(y_true, y_pred)
gamma = 0.75
return K.pow((1 - pt_1), gamma)
def log_cosh_dice_loss(self, y_true, y_pred):
x = self.dice_loss(y_true, y_pred)
return tf.math.log((tf.exp(x) + tf.exp(-x)) / 2.0)
########
n_filters=50
epochs=50
batch_size=6
Img_wedth =128
Img_height = 128
Img_channels = 1
#####################################
import h5py
paths=os.listdir('C:/Users/ASUS/Desktop/imageData/')
## save images in arrays ##
X_train = np.zeros((len(paths) , Img_height , Img_wedth , Img_channels) , dtype = np.float32)
y_train = np.zeros((len(paths) , Img_height , Img_wedth , Img_channels ) , dtype = np.float32)
y_train_label=[]
#####################################
for n, id_ in tqdm(enumerate(paths) , total = len(paths)) :
ttt=[0,0,0]
path = 'C:/Users/ASUS/Desktop/imageData/'+id_
#print('path.. ',path)
#print('id.. ',id_)
#img = imread(path + '/image/' +id_ + '.png') [: , : ]
img1=h5py.File(path,'r')
# print('path.. ',path)
img=img1['cjdata']['image']
img = resize(img , (Img_height , Img_wedth , Img_channels) , mode = 'constant' , preserve_range=True)
#print(img.shape)
# imshow(img,cmap="gray")
# plt.show()
img = asarray(img)
img = img.astype('float32')
# normalize to the range 0-1
img = tf.image.per_image_standardization(img)
# print(img[55][55])
#print(img.shape)
X_train[n] = img
# print('path.. ',path)
mask=img1['cjdata']['tumorMask']
mask = asarray(mask)
mask = mask.astype('float32')
#_,mask=cv.threshold(mask, 0.01, 1, 0 )
mask = resize(mask , (Img_height , Img_wedth , Img_channels) , mode = 'constant' , preserve_range=True)
#print(img.shape)
# imshow(img,cmap="gray")
# plt.show()
# normalize to the range 0-1
ttt[int(img1['cjdata']['label'][0][0])-1]=img1['cjdata']['label'][0][0]
y_train_label.append(ttt)
y_train[n] = mask
# print(Mask_[55][55])
# Mask_ = np.expand_dims(resize(Mask_ , (Img_height , Img_wedth) , mode = 'constant' ,
# preserve_range = True) , axis = -1)
# Mask = np.maximum(Mask , Mask_ )
# Mask = np.zeros((Img_height , Img_wedth , 1) , dtype = np.bool)
y_train_label=np.array(y_train_label)
paths_test=os.listdir('C:/Users/ASUS/Desktop/test')[10:20]
X_test = np.zeros((len(paths_test) , Img_height , Img_wedth , Img_channels ) , dtype = np.float32)
y_test = np.zeros((len(paths_test) , Img_height , Img_wedth , Img_channels ) , dtype = np.float32)
y_test_label= []
print('resizing test images')
for n, id_ in tqdm(enumerate(paths_test) , total = len(paths_test)) :
path = 'C:/Users/ASUS/Desktop/test/'+id_
ttt1=[0,0,0]
img1=h5py.File(path,'r')
# print('path.. ',path)
img=img1['cjdata']['image']
img = resize(img , (Img_height , Img_wedth , Img_channels) , mode = 'constant' , preserve_range=True)
#print(img.shape)
# imshow(img,cmap="gray")
# plt.show()
img = asarray(img)
img = img.astype('float32')
img = tf.image.per_image_standardization(img)
# normalize to the range 0-1
X_test[n]=img
mask=h5py.File(path,'r')
# print('path.. ',path)
mask1=mask['cjdata']['tumorMask']
mask1 = asarray(mask1)
mask1 = mask1.astype('float32')
# _,mask1=cv.threshold(mask1, 0.01, 1, 0 )
mask1 = resize(mask1 , (Img_height , Img_wedth , Img_channels) , mode = 'constant' , preserve_range=True)
#print(img.shape)
# imshow(img,cmap="gray")
# plt.show()
# normalize to the range 0-1
ttt1[int(img1['cjdata']['label'][0][0])-1]=img1['cjdata']['label'][0][0]
y_test_label.append(ttt1)
y_test[n]=mask1
#print('imagetestid..',n,'imagetestname',id_)
#imshow(img)
#plt.show()
#image_x = random.randint(0 , len(Train_ids))
#imshow(X_train[image_x])
#plt.show()
#imshow(np.squeeze( y_train[image_x]))
#plt.show()
## U-net Moudel
inputs = tf.keras.Input((Img_wedth , Img_height , Img_channels ))
c1 = tf.keras.layers.Conv2D(n_filters*1 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(inputs)
c1 = tf.keras.layers.Dropout(0.1 )(c1)
p1 = tf.keras.layers.MaxPooling2D((2,2 ))(c1)
print ('Done_c1')
c2 = tf.keras.layers.Conv2D(n_filters*2 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(p1)
c2 = tf.keras.layers.Dropout(0.1 )(c2)
p2 = tf.keras.layers.MaxPooling2D((2,2 ))(c2)
print ('Done_c2')
c3 = tf.keras.layers.Conv2D(n_filters*4 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(p2)
c3 = tf.keras.layers.Dropout(0.2 )(c3)
p3 = tf.keras.layers.MaxPooling2D((2,2 ))(c3)
print ('Done_c3')
c4 = tf.keras.layers.Conv2D(n_filters*8 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(p3)
c4 = tf.keras.layers.Dropout(0.2 )(c4)
p4 = tf.keras.layers.MaxPooling2D(pool_size=((2,2 )))(c4)
print ('Done_c4')
c5 = tf.keras.layers.Conv2D(n_filters*16 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(p4)
c5 = tf.keras.layers.Dropout(0.3 )(c5)
c5 = tf.keras.layers.Conv2D(n_filters*16, (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(c5)
print ('Done_c5')
F1=tf.keras.layers.Flatten()(c5)
D1=tf.keras.layers.Dense(32,activation='relu')(F1)
D2=tf.keras.layers.Dense(3,activation='softmax',name='clas')(D1)
u6 = tf.keras.layers.Conv2DTranspose(n_filters*8 , (2,2) , strides=(2,2) , padding='same')(c5)
print ('Done_c61')
u6 = tf.keras.layers.Concatenate(axis=-1)([u6 , c4])
print ('Done_c62')
c6 = tf.keras.layers.Conv2D(n_filters*8 ,(3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(u6)
print ('Done_c63')
c6 = tf.keras.layers.Dropout(0.2 )(c6)
c6 = tf.keras.layers.Conv2D(n_filters*8, (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(c6)
print ('Done_c6')
u7 = tf.keras.layers.Conv2DTranspose(n_filters*4 , (2,2) , strides=(2,2) , padding='same')(c6)
u7 = tf.keras.layers.Concatenate(axis=-1)([u7 , c3])
c7 = tf.keras.layers.Conv2D(n_filters*4 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(u7)
c7 = tf.keras.layers.Dropout(0.2 )(c7)
c7 = tf.keras.layers.Conv2D(n_filters*4 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(c7)
print ('Done_c7')
u8 = tf.keras.layers.Conv2DTranspose(n_filters*2 , (2,2) , strides=(2,2) , padding='same')(c7)
u8 = tf.keras.layers.Concatenate(axis=-1)([u8 , c2])
c8 = tf.keras.layers.Conv2D(n_filters*2 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(u8)
c8 = tf.keras.layers.Dropout(0.2)(c8)
c8 = tf.keras.layers.Conv2D(n_filters*2 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(c8)
print ('Done_c8')
u9 = tf.keras.layers.Conv2DTranspose(n_filters*1 , (2,2) , strides=(2,2) , padding='same')(c8)
print ('Done_c91')
u9 = tf.keras.layers.Concatenate(axis=-1)([u9 , c1])
print ('Done_c92')
c9 = tf.keras.layers.Conv2D(n_filters*1 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(u9)
print ('Done_c93')
c9 = tf.keras.layers.Dropout(0.4)(c9)
print ('Done_c94')
c9 = tf.keras.layers.Conv2D(n_filters*1 , (3,3) , activation='relu'
, kernel_initializer='he_normal' , padding='same')(c9)
print ('Done_c9')
outputs = tf.keras.layers.Conv2D(1 , (1,1) , activation='sigmoid',name='seg')(c9)
print ('Done_out')
model = tf.keras.Model(inputs=[inputs] , outputs=[outputs,D2])
print ('Done_model1')
def dice_coef1(y_true, y_pred, smooth=1):
print(y_true.shape,y_pred.shape)
intersection = K.sum((y_true )*( tf.round(y_pred)), axis=[1,2,3])
union = K.sum((y_true), axis=[1,2,3]) + K.sum((tf.round(y_pred)), axis=[1,2,3])
dice = K.mean((2. * intersection + smooth)/(union + smooth), axis=0)
return dice
loss={"seg":binary_crossentropy,
"clas":tf.keras.losses.poisson}
metricss={'seg':dice_coef1,
'clas':'Accuracy'}
opt=tf.keras.optimizers.Adam(clipvalue=1,clipnorm=1,lr=0.0001)
s = Semantic_loss_functions()
model.compile(optimizer=opt, loss=loss, metrics=metricss)
model.summary()
#############
# modelchecpoints
from tensorflow.keras import callbacks
results = model.fit(X_train , [y_train,y_train_label] ,shuffle=True, batch_size =batch_size, epochs=epochs )
当相同的代码产生两个不同的输出时，通常有两个原因之一:
- 随机种子不同，所以如果你还没有尝试过，你应该把它设置为一个常量值(对于每个库)
- 不同的库版本，所以在这种情况下，你可能应该看看你正在使用的任何函数是否有不同的行为或不同的默认值对于同一个包的不同版本。