DRSN代码调试未成功

#coding=utf-8
import warnings
import tensorflow as tf
warnings.filterwarnings('ignore', category=FutureWarning)
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import numpy as np
import keras
from keras import optimizers
from keras.layers import Input, Dense, ZeroPadding2D, Dropout, Activation, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D
from keras.models import Model
import matplotlib.pyplot as plt
from PIL import Image
from tensorflow.keras.optimizers import Adam
def convert_to_one_hot(Y, C):
    Y = np.eye(C)[Y.reshape(-1)].T
    return Y
# 数据文件夹

train_data_dir = "D:\\单子\\数据集\\AllTrain"
test_data_dir = "D:\\单子\\数据集\\AllTest"



classNum = 3

def read_data(data_dir):
    datas = []
    labels = []
    fpaths = []
    for fname in os.listdir(data_dir):
        fpath = os.path.join(data_dir, fname)
        fpaths.append(fpath)
        image = Image.open(fpath)

        data = np.array(image) / 255.0
        label = int(fname.split("_")[0])
        datas.append(data)
        labels.append(label)

    datas = np.array(datas)
    labels = np.array(labels)
    #datas=datas.reshape(datas.shape[0],100,100,1)
    print("shape of datas: {}\tshape of labels: {}".format(datas.shape, labels.shape))
    return fpaths, datas, labels
train_fpaths, train_imageData, train_imageLabel = read_data(train_data_dir)
test_fpaths, test_imageData, test_imageLabel = read_data(test_data_dir)

print("111111111111111111111111111")

# 随机打乱训练数据和标签
N = train_imageData.shape[0]
index = np.random.permutation(N)
train_data  = train_imageData[index,:,:]
train_label = train_imageLabel[index]  ###################对标签调整

# 对训练数据升维,标签one-hot
print("zhiqian",train_data.shape)
train_data  = np.expand_dims(train_data, axis=3)
train_label = convert_to_one_hot(train_label,classNum).T

print("zhihou",train_data.shape)
# 随机打乱测试数据和标签
N_test = test_imageData.shape[0]
test_index = np.random.permutation(N_test)
test_data  = test_imageData[test_index,:,:]
test_label = test_imageLabel[test_index] ###################对标签调整
# 对测试数据升维,标签one-hot

test_data  = np.expand_dims(test_data, axis=3)
test_label = convert_to_one_hot(test_label,classNum).T

print(test_label.shape)
# 划分数据集
#N = data.shape[0]
#num_train = round(N*0.8)
X_train = train_data
Y_train = train_label

X_test  = test_data
Y_test  = test_label

# wid_size=40
# hig_size=80
wid_size=200
hig_size=12
print ("X_train shape: " + str(X_train.shape))
print ("Y_train shape: " + str(Y_train.shape))
print ("X_test shape: " + str(X_test.shape))
print ("Y_test shape: " + str(Y_test.shape))

#写一个LossHistory类，保存loss和acc
class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self.losses = {'batch':[], 'epoch':[]}
        self.accuracy = {'batch':[], 'epoch':[]}
        self.val_loss = {'batch':[], 'epoch':[]}
        self.val_acc = {'batch':[], 'epoch':[]}

    def on_batch_end(self, batch, logs={}):
        self.losses['batch'].append(logs.get('loss'))
        self.accuracy['batch'].append(logs.get('acc'))
        self.val_loss['batch'].append(logs.get('val_loss'))
        self.val_acc['batch'].append(logs.get('val_acc'))

    def on_epoch_end(self, batch, logs={}):
        self.losses['epoch'].append(logs.get('loss'))
        self.accuracy['epoch'].append(logs.get('acc'))
        self.val_loss['epoch'].append(logs.get('val_loss'))
        self.val_acc['epoch'].append(logs.get('val_acc'))

    def loss_plot(self, loss_type):
        iters = range(len(self.losses[loss_type]))
        plt.figure("loss")
        # acc
        #plt.plot(iters, self.accuracy[loss_type], 'r', label='train acc')
        # loss
        plt.plot(iters, self.losses[loss_type], 'g', label='train loss')
        if loss_type == 'epoch':
            # val_acc
            #plt.plot(iters, self.val_acc[loss_type], 'b', label='val acc')
            # val_loss
            plt.plot(iters, self.val_loss[loss_type], 'k', label='val loss')
        plt.grid(True)
        plt.xlabel(loss_type)
        plt.ylabel('acc-loss')
        plt.legend(loc="upper right")
        plt.show()
    def acc_plot(self, loss_type):
        iters = range(len(self.losses[loss_type]))
        plt.figure("acc")
        # acc
        plt.plot(iters, self.accuracy[loss_type], 'r', label='train acc')
        if loss_type == 'epoch':
            # val_acc
            plt.plot(iters, self.val_acc[loss_type], 'b', label='val acc')
        plt.grid(True)
        plt.xlabel(loss_type)
        plt.ylabel('acc-loss')
        plt.legend(loc="upper right")
        plt.show()



def residual_shrinkage_block(inputs, out_channels, downsample_strides=1):
    
    in_channels = inputs.shape[-1]
    
    residual = tf.keras.layers.BatchNormalization()(inputs)
    residual = tf.keras.layers.Activation('relu')(residual)
    residual = tf.keras.layers.Conv2D(out_channels, 3, strides=(downsample_strides, downsample_strides), 
                                      padding='same')(residual)

    residual = tf.keras.layers.BatchNormalization()(residual)
    residual = tf.keras.layers.Activation('relu')(residual)
    residual = tf.keras.layers.Conv2D(out_channels, 3, padding='same')(residual)
    
    residual_abs = tf.abs(residual)
    abs_mean = tf.keras.layers.GlobalAveragePooling2D()(residual_abs)
    
    scales = tf.keras.layers.Dense(out_channels, activation=None)(abs_mean)
    scales = tf.keras.layers.BatchNormalization()(scales)
    scales = tf.keras.layers.Activation('relu')(scales)
    scales = tf.keras.layers.Dense(out_channels, activation='sigmoid')(scales)
    
    thres = tf.keras.layers.multiply([abs_mean, scales])
    
    sub = tf.keras.layers.subtract([residual_abs, thres])
    zeros = tf.keras.layers.subtract([sub, sub])
    n_sub = tf.keras.layers.maximum([sub, zeros])
    residual = tf.keras.layers.multiply([tf.sign(residual), n_sub])
    
    out_channels = residual.shape[-1]
    
    if in_channels != out_channels:
        identity = tf.keras.layers.Conv2D(out_channels, 1, strides=(downsample_strides, downsample_strides), padding='same')(inputs)
    
    residual = tf.keras.layers.add([residual, identity])

    #input = np.zeros((1, wid_size, hig_size, 3), np.float32)
    #input = np.zeros((1,wid_size,hig_size,3), np.float32)

    #residual = residual_shrinkage_block(input, 8)

    model = tf.keras.Model(input1, outputs = residual)
    
    #return residual
    return model

#print("111111111111111111111111111")

# input = np.zeros((1, 224, 224, 3), np.float32)
#input = np.zeros((1,wid_size,hig_size,3), np.float32)

#residual = residual_shrinkage_block(input, 8)
#residual_shrinkage_block(inputs, 8).shape

#model = tf.keras.Model(inputs = input, outputs = residual)

input1 = np.zeros((1,wid_size,hig_size,3), np.float32)

print("111111111111111111111111111")

model = residual_shrinkage_block(input1, 8)

model.summary()

sgd=Adam(learning_rate=0.001,decay=1e-6, amsgrad=False)
model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
history = LossHistory() # 创建一个history实例


model.fit(X_train, Y_train, epochs=200, batch_size=16, verbose=1,
            validation_data=(X_test, Y_test),callbacks=[history])

print("111111111111111111111111111")

#model = tf.keras.Model(inputs = input, outputs = residual)



# def CNN(input_shape=(wid_size, hig_size, 1) , classes=classNum):
#     X_input = Input(input_shape)

#     X = Conv2D(filters=8, kernel_size=(20,3), strides=(1, 1), padding='same', activation='relu', name='conv1')(
#         X_input)
#     X = MaxPooling2D((10, 1), strides=(10, 1), name='pool1')(X)
#     ####12
#     X = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu', name='conv2')(X)
#     X = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(X)

#     # X = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu', name='conv3')(X)
#     # X = MaxPooling2D((3, 3), strides=(2, 2), name='pool3')(X)

#     X = Flatten(name='flatten')(X)
#     X = Dropout(0.5)(X)
#     X = Dense(16, activation='relu', name='fc1')(X)
#     X = Dropout(0.5)(X)
#     X = Dense(classes, activation='softmax', name='fc2')(X)

#     model = Model(inputs=X_input, outputs=X, name='CNN')
#     return model


# model = CNN(input_shape=(wid_size, hig_size, 1), classes=classNum)

model.summary()



import time
start = time.time()
 #sgd=Adam(lr=0.001,decay=1e-6, amsgrad=False)
 #参数已经弃用
sgd=Adam(learning_rate=0.001,decay=1e-6, amsgrad=False)
model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])

history = LossHistory() # 创建一个history实例


model.fit(X_train, Y_train, epochs=200, batch_size=16, verbose=1,
            validation_data=(X_test, Y_test),callbacks=[history])

preds_train = model.evaluate(X_train, Y_train)
print("Train Loss = " + str(preds_train[0]))
print("Train Accuracy = " + str(preds_train[1]))
# #
# # model.save('E:\\oymotion\\DataBase\\gForceOct\\xiaotuiData\\noActSeg\\WUD_model.h5')

# preds_test  = model.evaluate(X_test, Y_test)
# print("Test Loss = " + str(preds_test[0]))
# print("Test Accuracy = " + str(preds_test[1]))

# end = time.time()
# print("time:",end-start)

# history.loss_plot('epoch')
# # history.acc_plot('epoch')