Beispiel #1
0
 def __init__(self,
              name,
              input_shape,
              n_classes,
              momentum=0.9,
              n_features=4096,
              batch_size=32,
              learning_rate=0.01):
     """
         name: string, name of model using for saving graph
         input_shape: tuple, shape of image
         n_classes: int, number of classes
         momentum: float, use for momentum optimizer
         n_features: int, size of embedded features
         batch_size: int, number of images of a batch
         learning_rate: float, learning rate of opitmizer
     
     """
     Resnet.__init__(self,
                     name=name,
                     input_shape=input_shape,
                     n_classes=n_classes,
                     n_features=n_features,
                     batch_size=batch_size,
                     learning_rate=learning_rate)
     self.momentum = momentum
Beispiel #2
0
 def __init__(self,
              name,
              input_shape,
              n_classes,
              margin=0.5,
              threshold=0.5,
              momentum=0.9,
              n_features=4096,
              batch_size=32,
              learning_rate=1e-3):
     """
         name: string, name of model using for saving graph
         input_shape: tuple, shape of image
         n_classes: int, number of classes
         margin: float, margin between negative and possitive distance
         threshold: float, threshold for deciding 2 images are in the same class or not
         momentum: float, use for momentum optimizer
         n_features: int, size of embedded features
         batch_size: int, number of images of a batch
         learning_rate: float, learning rate of opitmizer
     
     """
     Resnet.__init__(self,
                     name=name,
                     input_shape=input_shape,
                     n_classes=n_classes,
                     n_features=n_features,
                     batch_size=batch_size,
                     learning_rate=learning_rate)
     self.margin = margin
     self.threshold = threshold
     self.momentum = momentum
    def run(self):
        sys.stdout = Logger("train_record.txt")
        start = time.clock()

        if self.type_name == 'HA':
            self.l_name1 = [
                'H1', 'H3', 'H4', 'H5', 'H6', 'H7', 'H9', 'H10', 'H11', 'H2',
                'H13', 'H16'
            ]
            self.l_name2 = ['H2', 'H13', 'H16']
            # self.num_classes = 12
        elif self.type_name == 'NA':
            self.l_name1 = ['N1', 'N2', 'N3', 'N6', 'N7', 'N8', 'N9', 'N5']
            self.l_name2 = ['N5']
            # self.num_classes = 8

        # if self.multi==0:
        for l in self.l_name1:
            sequences, label, max_len, num_acid = load_dataset(
                l, self.type_name)
            # split train and valid data
            x_train, x_val, y_train, y_val = train_test_split(sequences,
                                                              label,
                                                              test_size=0.2)

            x_val = x_val.reshape(x_val.shape[0], max_len, num_acid, 1)
            x_train = x_train.reshape(x_train.shape[0], max_len, num_acid, 1)
            print('x_val shape is', x_val.shape)
            print('x_train shape is', x_train.shape)

            # make a history object
            history = LossHistory()
            resnet = Resnet(l, history, self.args)
            model = resnet.set_model(max_len, num_acid)

            if l in self.l_name2:
                model.load_weights('./result/' + self.type_name +
                                   '/weight/model_weights_' + self.best_l +
                                   '_8:2.h5')
            resnet.run(model, x_train, x_val, y_train, y_val)
            if l in self.l_name1:
                if self.min_loss > history.val_loss['epoch'][-1]:
                    self.min_loss = history.val_loss['epoch'][-1]
                    self.best_l = l
        print('the training is ok!')
        end = time.clock()
        print('Time cost is:', end - start)

        history.acc_plot('epoch', l, self.type_name)
        history.loss_plot('epoch', l, self.type_name)
        '''        
Beispiel #4
0
def prepare_Resnet(output_dim,
                   sess=None, inputT=None, input_dim=None,
                   checkpoint_dir=None, reuse=False):

    print(" [*] Preparing Resnet ... ")

    if inputT is not None:
        model = Resnet(inputT=inputT, output_dim=output_dim, reuse=reuse)
    elif input_dim is not None:
        inputT = tf.placeholder(tf.float32, [None, input_dim, input_dim, 3])  # RGB by default
        model = Resnet(inputT=inputT, output_dim=output_dim, reuse=reuse)
    else:
        raise Exception("Either inputT should be provided or input_dim should be specified!")

    if checkpoint_dir and sess:

        # scope = tf.get_default_graph().get_name_scope()
        # print(scope)
        #
        # trainable_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=scope)
        # map = {}
        # for idx, var in enumerate(trainable_variables):
        #     if scope in var.name:
        #         name = var.name[len(scope)+1:-2]
        #         map[name] = var
        # saver = tf.train.Saver(var_list=map)

        print(" [*] Reading checkpoints...")

        saver = tf.train.Saver()

        ckpt = tf.train.get_checkpoint_state(checkpoint_dir)

        if ckpt and ckpt.model_checkpoint_path:

            ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
            saver.restore(sess, os.path.join(checkpoint_dir, ckpt_name))
            print(" [*] Success to read {}".format(ckpt_name))

        else:
            print(" [*] Failed to find a checkpoint")

    return inputT, model
Beispiel #5
0
    def __init__(self, device):
        super().__init__()
        self.clean_img_train = None
        self.noised_img_train = None
        self.output = None
        self.loss = None
        model = Resnet().cuda()
        criterion = nn.MSELoss()
        optimizer = torch.optim.Adam(model.parameters(), lr=self.learning_rate, weight_decay=1e-5)

        train_load = Dataset.CIFAR_train_loader()
        for epoch in range(self.num_epochs):
            for i, data in enumerate(train_load):
                self.clean_img_train, _ = data[0], data[1]
                self.noised_img_train = torch.tensor(random_noise(self.clean_img_train,
                                                                  mode='s&p',
                                                                  salt_vs_pepper=0.5,
                                                                  clip=True))
                random_noise(self.clean_img_train, mode='s&p', salt_vs_pepper=0.5, clip=True)
                # fixing "RuntimeError: Input type (torch.FloatTensor) and weight type (torch.cuda.FloatTensor) should be the same"
                self.clean_img_train, self.noised_img_train = self.clean_img_train.to(device), self.noised_img_train.to(device)
                output = model(self.noised_img_train)
                self.loss = criterion(output, self.clean_img_train)
                # backward
                self.loss.backward()
                optimizer.step()
                optimizer.zero_grad()
                # period of the number of photos in dateset
                if i == self.num_train_images_in_epoch:
                    break
                # log
            print(f'epoch [{epoch + 1}/{self.num_epochs}], loss:{self.loss.item():.4f}')

            # saving image during learning
            if epoch % 10 == 0 and self.saving_image_during_learning:
                combined_img = torch.cat((self.clean_img_train, self.noised_img_train, self.output), 3) #combining images
                image_save(combined_img, f"./{epoch}_all_vs1.png")

        torch.save(model, self.Resnet_model_save_PATH)
def get_cnn(architecture='resnet18', embedding_dim=300):
    if architecture == 'resnet18':
        cnn = Resnet(embedding_dim=embedding_dim)
    elif architecture == 'resnet152':
        cnn = Resnet152(embedding_dim=embedding_dim)
    elif architecture == 'alexnet':
        cnn = Alexnet(embedding_dim=embedding_dim)
    elif architecture == 'vgg':
        cnn = Vgg(embedding_dim=embedding_dim)
    elif architecture == 'inception':
        cnn = Inception(embedding_dim=embedding_dim)
    elif architecture == 'squeeze':
        cnn = SqueezeNet(embedding_dim=embedding_dim)
    elif architecture == 'dense':
        cnn = DenseNet(embedding_dim=embedding_dim)
    return cnn
Beispiel #7
0
    dev_dataloader = DataLoader(dev_dir, transform)
    dev_data = dev_dataloader.gen_data()
    toc = time.time()
    print('dev_data loaded %.2f' % ((toc - tic) / 60))

    embedding_dim = 64
    # model_name = 'alexnet'
    # model_name = 'resnet'
    model_name = 'resnet152'
    if not os.path.exists(model_name):
        os.makedirs(model_name)

    if model_name == 'alexnet':
        cnn = Alexnet(embedding_dim=embedding_dim, pretrained=False)
    elif model_name == 'resnet':
        cnn = Resnet(embedding_dim=embedding_dim, pretrained=False)
    elif model_name == 'resnet152':
        cnn = Resnet152(embedding_dim=embedding_dim, pretrained=False)
    triplet_net = TripletNet(cnn)

    gpu_device = 1
    if torch.cuda.is_available():
        with torch.cuda.device(gpu_device):
            triplet_net.cuda()

    num_epochs = 100000
    minibatch_size = 8
    learning_rate = 1e-4
    params = triplet_net.parameters()
    optimizer = torch.optim.Adam(params, lr=learning_rate)
Beispiel #8
0
def train(model, epoch=EPOCH, batch_size=16, dev=False, checkpoint_path='tmp'):
    tf.reset_default_graph()

    # graph
    y_, train_flag_, image_, width_, height_ = input_holder()
    image = image_test_stream(image_, width_, height_)
    x_ = tf.placeholder_with_default(image, (None, 224, 224, CHANEL),
                                     name='x_train')
    print("开始重建网络resnet")
    start = time.time()
    #logits = resnet(x_, is_train=train_flag_)
    resnet_obj = Resnet(input_x=x_, input_y=y_, is_train=True)
    cost = resnet_obj.cost
    acc = resnet_obj.acc
    step = resnet_obj.step
    output = resnet_obj.output

    end = time.time()
    print("重建网络resnet时间为:%f秒" % (end - start))

    min_pred = tf.reduce_min(output)
    pred = tf.identity(min_pred, name='pred')

    which_box = tf.argmin(output)
    which_box = tf.cast(which_box, dtype=tf.int32)
    row = which_box // 6
    column = which_box[0] % 6
    points = [
        width_ * column / 6, height_ * row / 3, width_ * (column + 1) / 6,
        height_ * (row + 1) / 3
    ]
    points = tf.identity(points, name='points')

    train_x, train_y, valid_x, valid_y, test_x, test_y = process_data_set()

    sess = tf.InteractiveSession()
    sess.run(tf.global_variables_initializer())
    sess.run(tf.local_variables_initializer())

    saver = tf.train.Saver(max_to_keep=20, )

    counter = 0
    start_time = time.clock()
    current_time = time.clock()
    cost_list = []
    acc_list = []
    extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    best_valid_acc = 0

    saver.save(sess, './checkpoints/' + checkpoint_path + 'zxq2max')

    with tf.device("/gpu:0"):
        for i in range(epoch):
            for x_batch, y_batch in gen_batch(train_x, train_y, batch_size):
                #print("counter=%d"%counter)
                if counter % 100 == 0:
                    val_cost_list = []
                    val_acc_list = []
                    for test_x_batch, test_y_batch in gen_batch(
                            test_x, test_y, batch_size):
                        step_test_cost, step_test_acc = sess.run(
                            [cost, acc],
                            feed_dict={
                                x_: test_x_batch,
                                y_: test_y_batch,
                                train_flag_: False
                            })
                        val_cost_list.append(step_test_cost)
                        val_acc_list.append(step_test_acc)
                    test_cost = np.mean(val_cost_list)
                    test_acc = np.mean(val_acc_list)
                    if best_valid_acc < test_acc:
                        resnet_obj.save_model(sess)
                        best_valid_acc = test_acc
                        saver.save(
                            sess,
                            './checkpoints/' + checkpoint_path + 'zxq2max')

                    time_per_step = time.clock() - current_time
                    seconds = time_per_step * (epoch - i) * len(train_x) / (
                        100 * batch_size)
                    m, s = divmod(seconds, 60)
                    h, m = divmod(m, 60)
                    eta = "%02d:%02d:%02d" % (h, m, s)
                    current_time = time.clock()
                    print(
                        'Step:{:>4d}, ETA:{}, Test_cost:{:.5F},best_valid_acc:{:.5F} ,Test_acc:{:.4F}'
                        .format(counter, eta, test_cost, best_valid_acc,
                                test_acc))

                if counter % 500 == 0 and counter > 0:
                    # saver.save(sess,'./checkpoints/'+checkpoint_path,global_step=i)
                    print('checkpoint save as ' + checkpoint_path + str(i))
                _, __, step_cost, step_acc, _ = sess.run([
                    step, extra_update_ops, cost, acc,
                    resnet_obj.maintain_averages_op
                ],
                                                         feed_dict={
                                                             x_: x_batch,
                                                             y_: y_batch,
                                                             train_flag_: True
                                                         })

                cost_list.append(step_cost)
                acc_list.append(step_acc)
                counter = counter + 1
                if dev and counter % 10 == 0:
                    update_op = [
                        resnet_obj.mean_list[0],
                        resnet_obj.ema.average(resnet_obj.mean_list[0]),
                        resnet_obj.learning_rate
                    ]
                    mean1, sh_mean1, learn_rate = sess.run(update_op,
                                                           feed_dict={
                                                               x_: x_batch,
                                                               y_: y_batch,
                                                               train_flag_:
                                                               False
                                                           })
                    cur_acc = np.mean(acc_list[-10:])
                    cur_cost = np.mean(cost_list[-10:])
                    print("Step: ", counter, " Cost: ", cur_cost,
                          " Accuracy: ", cur_acc, "learn_rate=", learn_rate)

                #print("counter=%d" % counter)
        sess.close()
        show_train(acc_list)
Beispiel #9
0
    def __init__(self, inputT, output_dim,
                 num_logits=100, reuse=False):

        print(" [*] Constructing GBP_End2End ... ")

        """
        GBP Defense
        :param inputT: 4D tensor, has to be provided
        :param output_dim: has to be provided
        :param num_logits: the num of logits of the shallow CNN used for the GBP reconstruction
        """

        self.inputT = inputT
        self.output_dim = output_dim

        self.num_logits = num_logits
        self.reuse = reuse

        print("Output dim = {}".format(self.output_dim))
        print("Reuse = {}, (T)Testing/(F)Training".format(self.reuse))

        self.layers_dic = {}
        self.layers_dic['GBP_End2End_input'] = self.inputT

        with tf.variable_scope("GBP_End2End") as scope:

            if self.reuse:
                scope.reuse_variables()

            eval_graph = tf.get_default_graph() # get the graph

            # Construct the shallow CNN used for the GBP reconstruction
            # The gradient has to be overwritten
            # The gradient registration happens in Prepare_Model
            with eval_graph.gradient_override_map({'Relu': 'GuidedRelu'}):
                self.NN1 = Shallow_CNN(self.inputT, output_dim=self.num_logits, reuse=self.reuse)


            ##################################### GBP Reconstruction ###############################################

            logits = self.NN1.logits  # get the logits

            # randomly pick one logit
            index = tf.random_uniform([1], minval=0, maxval=self.num_logits, dtype=tf.int32)[0]

            # raw gbp reconstruction
            tfOp_gbp_raw = tf.gradients(logits[:, index], self.inputT)[0]

            # normalizations
            tfOp_gbp_submin = tf.map_fn(lambda img: img - tf.reduce_min(img), tfOp_gbp_raw)
            tfOp_gbp_divmax = tf.map_fn(lambda img: img / tf.reduce_max(img), tfOp_gbp_submin)

            # just a port for the visualization if necessary
            tfOp_gbp_255 = tf.map_fn(lambda img: tf.cast(img * 255, tf.int32), tfOp_gbp_divmax, dtype=tf.int32)

            ##################################### GBP Reconstruction ###############################################

            # now use a Resnet to classify these GBP reconstructions
            self.NN2 = Resnet(tfOp_gbp_divmax, output_dim=self.output_dim, reuse=self.reuse)

        self.phase = self.NN2.phase
        self.kp = self.NN2.kp

        self.gbp_reconstructions = tfOp_gbp_255 # an output port for visualizing GBP reconstructions

        self.logits = self.NN2.logits
        self.probs = tf.nn.softmax(self.logits)

        self.layers_dic.update(self.NN1.layers_dic)
        self.layers_dic.update(self.NN2.layers_dic)
Beispiel #10
0
    def run(self):
        '''
        if self.multi==1:
            sequences, label, max_len, num_acid = load_multidata(self.type_name, isTrain=False)
            seq_test = sequences.reshape(sequences.shape[0], max_len, num_acid, 1)
            print('the shape of test seqs is', seq_test.shape)
            print('label is', label)
        
            history = LossHistory()
            res = Resnet('test', history, self.args)
            model = res.set_multimodel(max_len, num_acid)
            
            model.load_weights('./result/'+self.type_name+'/weight/multi_model_weights_8:2.h5')
            result = model.predict(seq_test, batch_size=64, verbose=0)
            predict = [-1 for i in range(len(result))]
            print('result is:', result)
            for i in range(len(result)):
                predict[i] = np.argmax(result[i])
            print('predict is:', predict)
            # evaluate
            accuracy = accuracy_score(label, predict)
            print('accuracy of test is', accuracy)
            print('class accuracy is:\n',classification_report(label, predict))
        '''

        result_final = []
        predict = []
        if self.type_name == 'HA':
            self.label_list = [
                'H1', 'H10', 'H11', 'H13', 'H16', 'H2', 'H3', 'H4', 'H5', 'H6',
                'H7', 'H9'
            ]
        elif self.type_name == 'NA':
            self.label_list = ['N1', 'N2', 'N3', 'N5', 'N6', 'N7', 'N8', 'N9']

        label_dic = labels_dic(self.label_list)

        sequences, label, max_len, num_acid = load_dataset('test',
                                                           self.type_name,
                                                           isTrain=False)
        seq_test = sequences.reshape(sequences.shape[0], max_len, num_acid, 1)
        print('the shape of test seqs is', seq_test.shape)
        print('label is', label)
        print('set label is', set(label))

        history = LossHistory()
        res = Resnet('test', history, self.args)
        model = res.set_model(max_len, num_acid)

        # for each subtype, calculate voting score
        for l_name in self.label_list:
            print('current l_name is', l_name)

            model.load_weights('./result/' + self.type_name +
                               '/weight/model_weights_' + l_name + '_8:2.h5')
            result = model.predict(seq_test, batch_size=64, verbose=0)
            result_final.append(result)
            # print('result is', result)
            # print('the shape of result is', result.shape)
        result_final = np.array(result_final)
        print('final result shape is', result_final.shape)
        # print('final result is', result_final)

        # for each test example, cal the predict label
        for i in range(result_final.shape[1]):
            classes = []
            score = []
            # for each classifer, cal the possibility
            for j in range(len(self.label_list)):
                if result_final[j][i] > 0.5:
                    classes.append(j)
                    score.append(result_final[j][i])
                    # print('score is', score)
                    # print('classes shape is', len(classes))
            if len(classes) == 0:
                classes.append(-1)
            if len(classes) == 1:
                predict.append(classes[0])
            else:
                predict.append(max_class(score, classes))

        print('predict is', predict)
        predict = np.array(predict)
        print('set predict is', set(predict))

        # evaluate
        accuracy = accuracy_score(label, predict)
        print('accuracy of test is', accuracy)
        print('class accuracy is:\n', classification_report(label, predict))
Beispiel #11
0
# # root/cat/123.png
# # root/cat/nsdf3.png
# # root/cat/asd932_.png
######################

##############数据装载###############
train_loader = torch.utils.data.DataLoader(
    dataset=train_dataset,  # 装载数据
    batch_size=args.batch_size,  # 设置批大小
    shuffle=True)  # 是否随机打乱
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=args.batch_size,
                                          shuffle=True)

#############模型载入#################
Resnet = Resnet()
if not args.no_cuda:
    print('正在使用gpu')
    Resnet.cuda()
print(Resnet)

###############损失函数##################
criterion = nn.CrossEntropyLoss()  # 内置标准损失
optimizer = torch.optim.Adam(Resnet.parameters(), lr=args.lr)  # Adam优化器
#############训练过程#####################
total_loss = 0  #内存循环使用
for epoch in range(args.epochs):
    for i, (images, labels) in enumerate(train_loader):  # 枚举出来
        if not args.no_cuda:  # 数据处理是否用gpu
            images = images.cuda()
            labels = labels.cuda()