Exemplo n.º 1
0
def inception_v2_ssd(img):
    with slim.arg_scope(inception_v2.inception_v2_arg_scope()):
        logits, end_point = inception_v2.inception_v2_base(img)
    c1 = end_point['Mixed_3c']
    c2 = end_point['Mixed_4e']
    c3 = end_point['Mixed_5c']
    return c1, c2, c3
def test_inception_v2(img_dir):
    """
    Test Inception-V2 with a single image.
    :param img_dir: Path of the image to be classified
    :return: classification result and probability of a single image
    """
    img = cv2.imread(img_dir)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img = cv2.resize(img, (224, 224)) / 255
    img = img.reshape((1, 224, 224, 3))

    tf.reset_default_graph()
    inputs = tf.placeholder(name='input_images',
                            shape=[None, 224, 224, 3],
                            dtype=tf.float32)
    with slim.arg_scope(inception_v2_arg_scope()):
        _, _ = inception_v2(inputs, 1001, is_training=False)

    with tf.Session() as sess:
        tf.train.Saver().restore(sess, './models/inception_v2.ckpt')
        inputs = sess.graph.get_tensor_by_name('input_images:0')
        outputs = sess.graph.get_tensor_by_name(
            'InceptionV2/Logits/SpatialSqueeze:0')
        pred = tf.argmax(tf.nn.softmax(outputs), axis=1)[0]
        prob = tf.reduce_max(tf.nn.softmax(outputs), axis=1)[0]

        pred, prob = sess.run([pred, prob], feed_dict={inputs: img})
        name = label_dict[pred]

    print('Result of Inception-V2:', name, prob)
    return name, prob
Exemplo n.º 3
0
def inception_v2_ssd(img):
    with slim.arg_scope(inception_v2.inception_v2_arg_scope()):
        logits, end_point = inception_v2.inception_v2_base(img)
        vbs = slim.get_variables_to_restore()

    c1 = end_point['Mixed_3c']
    c2 = end_point['Mixed_4e']
    c3 = end_point['Mixed_5c']
    return c1, c2, c3, vbs
def inception_v2_ssd(img,cfg):
    with slim.arg_scope(inception_v2.inception_v2_arg_scope()):
        logits, end_point = inception_v2.inception_v2_base(img)

        Mixed_3c = end_point['Mixed_3c']
        Mixed_4e = end_point['Mixed_4e']
        cell_11 = end_point['Mixed_5c']
        vbs = slim.get_trainable_variables()
        cell_11 = tf.image.resize_bilinear(cell_11,size=[32,32])
        cell_11 = tf.concat([cell_11,Mixed_4e],axis=3)

        cell_7 = tf.image.resize_bilinear(Mixed_4e,size=[64,64])
        cell_7 = tf.concat([cell_7,Mixed_3c],axis=3)





    cell_11 = slim.conv2d(cell_11,1024,kernel_size=1,activation_fn=slim.nn.relu)

    cell_7 = slim.conv2d(cell_7, 512, kernel_size=3, activation_fn=slim.nn.relu)
    cell_7 = slim.conv2d(cell_7, 256, kernel_size=1, activation_fn=slim.nn.relu)

    cv6 = slim.conv2d(cell_11, 1024, kernel_size=3, rate=6, activation_fn=slim.nn.relu, scope='conv6')
    cv7 = slim.conv2d(cv6, 1024, kernel_size=1, activation_fn=slim.nn.relu, scope='conv7')

    s = utils.normalize_to_target(cell_7, target_norm_value=12.0, dim=1)

    cv8 = slim.conv2d(cv7, 256, kernel_size=1, stride=1, scope='conv8_0')
    cv8 = slim.conv2d(cv8, 512, kernel_size=3, stride=2, scope='conv8_1')

    cv9 = slim.conv2d(cv8, 128, kernel_size=1, stride=1, scope='conv9_0')
    cv9 = slim.conv2d(cv9, 256, kernel_size=3, stride=2, scope='conv9_1')

    cv10 = slim.conv2d(cv9, 128, kernel_size=1, stride=1, scope='conv10_0')
    cv10 = slim.conv2d(cv10, 256, kernel_size=3, stride=2, scope='conv10_1')

    cv11 = slim.conv2d(cv10, 128, kernel_size=1, stride=1, scope='conv11_0')
    cv11 = slim.conv2d(cv11, 256, kernel_size=3, stride=2, scope='conv11_1')
    source = [s, cv7, cv8, cv9, cv10, cv11]
    conf = []
    loc = []
    for cv, num in zip(source, cfg.Config['aspect_num']):
        print(num)
        loc.append(slim.conv2d(cv, num * 4, kernel_size=3, stride=1, activation_fn=None))

        conf.append(
                slim.conv2d(cv, num * cfg.Config['num_classes'], kernel_size=3, stride=1, activation_fn=None))
        print(loc)
    loc = tf.concat([tf.reshape(o, shape=(cfg.batch_size, -1, 4)) for o in loc], axis=1)
    conf = tf.concat([tf.reshape(o, shape=(cfg.batch_size, -1, cfg.Config['num_classes'])) for o in conf],
                         axis=1)

    return loc, conf, vbs
Exemplo n.º 5
0
def inception_v2_ssd(img,cfg):
    with slim.arg_scope(inception_v2.inception_v2_arg_scope()):
        logits, end_point = inception_v2.inception_v2_base(img)

        Mixed_3c = end_point['Mixed_3c']
        Mixed_4e = end_point['Mixed_4e']
        Mixed_5c = end_point['Mixed_5c']
        vbs = slim.get_trainable_variables()
        #vbs = None
        cell_11 = tf.image.resize_bilinear(Mixed_5c,size=[int(32*(cfg.image_size/512)),int(32*(cfg.image_size/512))])
        cell_11 = tf.concat([cell_11,Mixed_4e],axis=3)

        cell_7 = tf.image.resize_bilinear(Mixed_4e,size=[int(64*(cfg.image_size/512)),int(64*(cfg.image_size/512))])
        cell_7 = tf.concat([cell_7,Mixed_3c],axis=3)


    mask_fp = get_mask_fp(Mixed_3c ,Mixed_4e,Mixed_5c)

    cell_11 = slim.conv2d(cell_11,1024,kernel_size=1,activation_fn=slim.nn.relu)

    cell_7 = slim.conv2d(cell_7, 512, kernel_size=3, activation_fn=slim.nn.relu)
    cell_7 = slim.conv2d(cell_7, 256, kernel_size=1, activation_fn=slim.nn.relu)

    cv6 = slim.conv2d(cell_11, 1024, kernel_size=3, rate=6, activation_fn=slim.nn.relu, scope='conv6')
    cv7 = slim.conv2d(cv6, 1024, kernel_size=1, activation_fn=slim.nn.relu, scope='conv7')

    s = utils.normalize_to_target(cell_7, target_norm_value=cfg.norm_value, dim=1)

    cv8 = inception(cv7, out_put=512, name='cv8', stride=2)
    cv9 = inception(cv8, out_put=256, name='cv9', stride=2)
    cv10 = inception(cv9, out_put=256, name='cv10', stride=2)
    cv11 = inception(cv10, out_put=256,name= 'cv11', stride=2)

    source = [s, cv7, cv8, cv9, cv10, cv11]
    conf = []
    loc = []
    for cv, num in zip(source, cfg.Config['aspect_num']):

        loc.append(slim.conv2d(cv, num * 4, kernel_size=3, stride=1, activation_fn=None))

        conf.append(
                slim.conv2d(cv, num * cfg.Config['num_classes'], kernel_size=3, stride=1, activation_fn=None))

    loc = tf.concat([tf.reshape(o, shape=(cfg.batch_size, -1, 4)) for o in loc], axis=1)
    conf = tf.concat([tf.reshape(o, shape=(cfg.batch_size, -1, cfg.Config['num_classes'])) for o in conf],
                         axis=1)

    return loc, conf,mask_fp, vbs
Exemplo n.º 6
0
def model(img):
    with slim.arg_scope(inception_v2.inception_v2_arg_scope()):
        with slim.arg_scope([slim.batch_norm], is_training=True):
            with slim.arg_scope([slim.conv2d], trainable=True):
                logits, end_point = inception_v2.inception_v2_base(img)

    c1 = end_point['Mixed_3c']
    c2 = end_point['Mixed_4e']
    c3 = end_point['Mixed_5c']
    vbs = slim.get_variables_to_restore()

    c3 = slim.conv2d(c3, 256, 1, 1, activation_fn=None)

    c2 = slim.conv2d(c2, 256, 1, 1,
                     activation_fn=None) + tf.image.resize_bilinear(
                         c3, size=tf.shape(c2)[1:3])

    c1 = slim.conv2d(c1, 256, 1, 1,
                     activation_fn=None) + tf.image.resize_bilinear(
                         c2, size=tf.shape(c1)[1:3])

    return c1, c2, c3, vbs
     'shape': [1, 224, 224, 3],
     'scope': resnet_v2.resnet_arg_scope(),
     'net': resnet_v2.resnet_v2_152,
     'num_classes': 1001,
     'end_point': 'global_pool'
 },
 'inception_v1': {
     'shape': [1, 224, 224, 3],
     'scope': inception_v1.inception_v1_arg_scope(),
     'net': inception_v1.inception_v1,
     'num_classes': 1000,
     'end_point': 'AvgPool_0a_7x7'
 },
 'inception_v2': {
     'shape': [1, 224, 224, 3],
     'scope': inception_v2.inception_v2_arg_scope(),
     'net': inception_v2.inception_v2,
     'num_classes': 1000
 },
 'inception_v3': {
     'shape': [1, 299, 299, 3],
     'scope': inception_v3.inception_v3_arg_scope(),
     'net': inception_v3.inception_v3,
     'num_classes': 1000
 },
 'vgg_16': {
     'shape': [1, 224, 224, 3],
     'scope': vgg.vgg_arg_scope(),
     'net': vgg.vgg_16,
     'num_classes': 1000
 },
Exemplo n.º 8
0
def compute_feature_of_batch_ts_with_cnn(file_path_of_ts, file_path_of_feature,
                                         cnn_model_name,
                                         file_path_of_pretrained_model):
    r'''
    compute feature of somme time series with pretrained CNN
    :param file_path_of_ts: file path of time series
    :param file_path_of_feature: file path of saving feature
    :param cnn_model_name: name of CNN model
    :param file_path_of_pretrained_model: file path of pretrained CNN
    :return: ''
    '''
    #tf.reset_default_graph()
    #read data
    data = pd.read_csv(file_path_of_ts)
    #data=data.sample(20)
    #change dataframe to list
    id_list = data.iloc[:, 0].tolist()
    data_list = change_dataframe_to_dict_(data)

    model = cnn_model_name
    checkpoint_file = file_path_of_pretrained_model

    # I only have these because I thought some take in size of (299,299), but maybe not
    if 'inception' in model: height, width, channels = 224, 224, 3
    if 'resnet' in model: height, width, channels = 224, 224, 3
    if 'vgg' in model: height, width, channels = 224, 224, 3

    if model == 'inception_resnet_v2': height, width, channels = 299, 299, 3

    x = tf.placeholder(tf.float32, shape=(1, height, width, channels))

    # load up model specific stuff
    if model == 'inception_v1':
        #from inception_v1 import *
        from nets import inception_v1

        arg_scope = inception_v1.inception_v1_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = inception_v1.inception_v1(x,
                                                           is_training=False,
                                                           num_classes=None)
            features = end_points['AvgPool_0a_7x7']
            # print('logits')
            # print(logits.shape)
            # print('features')
            # print(features.shape)
    elif model == 'inception_v2':
        #from inception_v2 import *
        from nets import inception_v2

        arg_scope = inception_v2.inception_v2_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = inception_v2(x,
                                              is_training=False,
                                              num_classes=None)
            features = end_points['AvgPool_1a']
    elif model == 'inception_v3':
        #from inception_v3 import *
        from nets import inception_v3

        arg_scope = inception_v3.inception_v3_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = inception_v3(x,
                                              is_training=False,
                                              num_classes=None)
            features = end_points['AvgPool_1a']
    elif model == 'inception_resnet_v2':
        #from inception_resnet_v2 import *
        from nets import inception_resnet_v2

        arg_scope = inception_resnet_v2.inception_resnet_v2_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = inception_resnet_v2(x,
                                                     is_training=False,
                                                     num_classes=1001)
            features = end_points['PreLogitsFlatten']
    elif model == 'resnet_v1_50':
        #from resnet_v1 import *

        from nets import resnet_v1

        arg_scope = resnet_v1.resnet_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = resnet_v1.resnet_v1_50(x,
                                                        is_training=False,
                                                        num_classes=1000)
            features = end_points['global_pool']
    elif model == 'resnet_v1_101':
        #from resnet_v1 import *
        from nets import resnet_v1

        arg_scope = resnet_v1.resnet_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = resnet_v1.resnet_v1_101(x,
                                                         is_training=False,
                                                         num_classes=1000)
            features = end_points['global_pool']
    elif model == 'vgg_16':
        #from vgg import *
        from nets import vgg

        arg_scope = vgg.vgg_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = vgg.vgg_16(x, is_training=False)
            features = end_points['vgg_16/fc8']
    elif model == 'vgg_19':
        #from vgg import *
        from nets import vgg

        arg_scope = vgg.vgg_arg_scope()
        with slim.arg_scope(arg_scope):
            logits, end_points = vgg.vgg_19(x, is_training=False)
            features = end_points['vgg_19/fc8']
    #cpu_config = tf.ConfigProto(intra_op_parallelism_threads = 8, inter_op_parallelism_threads = 8, device_count = {'CPU': 3})
    #sess = tf.Session(config = cpu_config)
    sess = tf.Session()
    saver = tf.train.Saver()
    saver.restore(sess, checkpoint_file)
    feature_list = []
    count_temp = 0

    for i in range(len(data_list)):
        count_temp = count_temp + 1
        #imaging ts
        ts_dict = data_list[i]
        ts = ts_dict['ts']
        id = ts_dict['id']
        new_ts = min_max_transform(ts)
        normalized = np.array(new_ts)
        fig, ax = plt.subplots()
        #plt.imshow(recurrence_plot.rec_plot(normalized), cmap=plt.cm.gray)
        plt.imshow(recurrence_plot.rec_plot(normalized))
        ax.set_xticks([])
        ax.set_yticks([])
        #print(id)
        path = "inception-v1/" + id + ".jpg"
        plt.savefig(path)
        plt.close(fig)
        #compute feature
        # #begin to compute features
        image = misc.imread(path)
        #from matplotlib.pyplot import imread
        #image=imread(path)
        # print('image')
        # print(image.size)
        image = misc.imresize(image, (height, width))
        image = np.expand_dims(image, 0)
        feature = np.squeeze(sess.run(features, feed_dict={x: image}))
        feature_list.append(feature)
        # print('feature-test')
        # print(feature)
        os.remove(path)
        if count_temp % 100 == 0:
            print(count_temp)
        #begin to process parellel result and write_to_csv
    feature_array = np.array(feature_list)

    feature_df = pd.DataFrame(feature_array)
    # print(feature_df.shape)
    # print(len(id_list))
    #add id
    feature_df.insert(loc=0, column='id', value=id_list)
    # print(feature_final_df.shape)
    # print(feature_final_df.head())
    feature_df.to_csv(file_path_of_feature, index=False)
    gc.collect()
Exemplo n.º 9
0
n_classes = 101
n_test_data = len(testing_set)
Size = 224
Height = Width = Size
batchsize = 1

conf = cf.configuration(batchsize, data_list, label_list)

# define variable
with tf.name_scope('input_data'):
    x = tf.placeholder(tf.float32, [None, Height, Width, 3], name='x1')
    y = tf.placeholder(tf.int32, [None], name='y')
    y_onehot = tf.one_hot(y, n_classes, name='label')

slim = tf.contrib.slim
with slim.arg_scope(net.inception_v2_arg_scope()) as sc:
    _, end_points = net.inception_v2(x,
                                     num_classes=101,
                                     is_training=False,
                                     reuse=None)
init_cnn = slim.assign_from_checkpoint_fn('pass/to/save/model.ckpt',
                                          slim.get_model_variables())

logits = end_points['Logits']

with tf.name_scope('accuracy'):
    pred = tf.nn.softmax(logits, 1)
    pred_restore = tf.placeholder(pred.dtype, pred.shape)
    correct_pred = tf.equal(tf.argmax(pred_restore, 1), tf.argmax(y_onehot, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
Exemplo n.º 10
0
def main():

    #-------------解析参数-------------#
    args = parse_args()
    if args.cfg_file is not None:
        cfg_from_file(args.cfg_file)  #读取args.cfg_file文件内容并融合到cfg中
    pprint.pprint(cfg)

    #-------------任务相关配置-------------#
    tf.logging.set_verbosity(tf.logging.INFO)  #设置日志级别
    os.environ['CUDA_VISBLE_DEVICES'] = cfg.GPUS
    tf.logging.set_verbosity(tf.logging.INFO)  #设置日志级别

    #-------------搭建计算图-------------#
    # 读取数据,tsn_batch形式:(batch_size*num_seg*new_length) * h * w * num_channels
    with tf.device('/cpu:0'):
        # 简单计算放在CPU上进行
        ite = TSNDataReader(
            cfg.INPUT.DATA_DIR,
            cfg.INPUT.MODALITY,  # flow模态读取方式与rgb稍有不同
            cfg.INPUT.NUM_SEGMENTS,
            cfg.INPUT.NEW_LENGTH,
            cfg.INPUT.SPLIT_PATH,
            cfg.TRAIN.BATCH_SIZE,
            isTraining=False).get_dataset_iter()
    # 读取数据,tsn_batch形式:(batch_size*num_seg*new_length) * h * w * num_channels
    tsn_batch, labels = ite.get_next()
    if cfg.INPUT.MODALITY == 'rgb':
        tsn_batch = tf.reshape(tsn_batch, [
            cfg.TRAIN.BATCH_SIZE * cfg.INPUT.NUM_SEGMENTS *
            cfg.INPUT.NEW_LENGTH, 224, 224, 3
        ])
    elif cfg.INPUT.MODALITY == 'flow':
        tsn_batch = tf.reshape(tsn_batch, [
            cfg.TRAIN.BATCH_SIZE * cfg.INPUT.NUM_SEGMENTS *
            cfg.INPUT.NEW_LENGTH, 224, 224, 2
        ])
    else:
        raise ValueError("modality must be one of rgb or flow")

    # 获取网络, 并完成前传
    with slim.arg_scope(inception_v2_arg_scope()):
        logits, _ = inception_v2(tsn_batch,
                                 num_classes=cfg.NUM_CLASSES,
                                 is_training=False,
                                 dropout_keep_prob=cfg.TRAIN.DROPOUT_KEEP_PROB,
                                 min_depth=16,
                                 depth_multiplier=1.0,
                                 prediction_fn=slim.softmax,
                                 spatial_squeeze=True,
                                 reuse=None,
                                 scope='InceptionV2',
                                 global_pool=False)
    logits = tf.reshape(logits, [
        cfg.TRAIN.BATCH_SIZE, cfg.INPUT.NUM_SEGMENTS * cfg.INPUT.NEW_LENGTH, -1
    ])
    logits = tf.reduce_mean(logits, 1)  # 取采样图片输出的平均值
    # 做一个batch准确度的预测
    prediction = tf.nn.softmax(logits)
    acc_batch = tf.reduce_mean(
        tf.cast(tf.equal(tf.argmax(prediction, 1), tf.argmax(labels, 1)),
                tf.float32))

    # saver
    model_variables_map = {}
    for variable in tf.global_variables():
        if variable.name.split('/')[0] == 'InceptionV2' and variable.name.find(
                'Conv2d_1c_1x1') == -1:
            model_variables_map[variable.name.replace(':0', '')] = variable
    print '####################################################'
    for i in model_variables_map.keys():
        print i
    print '#####################################################'
    saver = tf.train.Saver(var_list=model_variables_map)

    with tf.Session() as sess:
        #初始化变量
        tf.global_variables_initializer().run()
        saver.restore(sess, 'models/tsn_rgb_bk_v1.ckpt-4401')

        acc = []
        sess.graph.finalize()
        for i in range(200):
            try:
                print 'testing the %dth vid' % i
                prediction = sess.run(acc_batch)
                print prediction
                acc.append(prediction)
            except:
                continue
        acc = np.mean(acc)

        print "the accu is %f" % acc
Exemplo n.º 11
0
def main():

    #-------------解析参数-------------#
    args = _parse_args()
    if args.cfg_file is not None:
        cfg_from_file(args.cfg_file)  #读取args.cfg_file文件内容并融合到cfg中
    pprint.pprint(cfg)

    #-------------任务相关配置-------------#
    os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
    os.environ['CUDA_VISBLE_DEVICES'] = cfg.GPUS
    tf.logging.set_verbosity(tf.logging.INFO)  #设置日志级别

    #-------------搭建计算图-------------#
    with tf.device('/cpu:0'):
        # 操作密集型放在CPU上进行
        global_step = tf.get_variable('global_step', [],
                                      dtype=None,
                                      initializer=tf.constant_initializer(0),
                                      trainable=False)
        lr = tf.train.exponential_decay(cfg.TRAIN.LEARNING_RATE_BASE,
                                        global_step,
                                        cfg.TRAIN.DECAY_STEP,
                                        cfg.TRAIN.DECAY_RATE,
                                        staircase=True)  # 学习率
        tf.summary.scalar('learnrate', lr)
        opt = tf.train.MomentumOptimizer(lr, cfg.TRAIN.MOMENTUM)  # 优化函数
        #opt = tf.train.GradientDescentOptimizer(lr)  # 优化函数
        num_gpus = len(cfg.GPUS.split(','))
        # 建立dataset,获取iterator
        reader.set_param(
            cfg.INPUT.DATA_DIR,
            cfg.INPUT.MODALITY,  # flow模态读取方式与rgb稍有不同
            cfg.VALID.SPLIT_PATH,
            cfg.VALID.BATCH_SIZE,
            num_segments=cfg.INPUT.NUM_SEGMENTS,
            new_length=cfg.INPUT.NEW_LENGTH,
            train_split_path=cfg.INPUT.SPLIT_PATH,
            train_batch_size=cfg.TRAIN.BATCH_SIZE,
            isTraining=True)
        ite_train, ite_valid = reader.get_dataset_iter()
        tsn_batch, label_batch = ite_train.get_next()
        tsn_batch_splits = tf.split(tsn_batch,
                                    num_or_size_splits=num_gpus,
                                    axis=0)
        label_batch_splits = tf.split(label_batch,
                                      num_or_size_splits=num_gpus,
                                      axis=0)

        tsn_valid_batch, label_valid_batch = ite_valid.get_next()

    # 在GPU上运行训练(并行)
    tower_grads = []
    with tf.variable_scope(tf.get_variable_scope(
    )) as vscope:  # 见https://github.com/tensorflow/tensorflow/issues/6220
        for i in range(num_gpus):
            with tf.device('/gpu:%d' % i), tf.name_scope('GPU_%d' %
                                                         i) as scope:
                # 获取数据,tsn_batch形式:(batch_size/num_gpus*num_seg*new_length) * h * w * num_channels
                tsn_batch_split, label_batch_split = tsn_batch_splits[
                    i], label_batch_splits[i]
                if cfg.INPUT.MODALITY == 'rgb':
                    tsn_batch_split = tf.reshape(tsn_batch_split, [
                        cfg.TRAIN.BATCH_SIZE / num_gpus *
                        cfg.INPUT.NUM_SEGMENTS * cfg.INPUT.NEW_LENGTH, 224,
                        224, 3
                    ])
                elif cfg.INPUT.MODALITY == 'flow':
                    tsn_batch_split = tf.reshape(tsn_batch_split, [
                        cfg.TRAIN.BATCH_SIZE / num_gpus *
                        cfg.INPUT.NUM_SEGMENTS * cfg.INPUT.NEW_LENGTH, 224,
                        224, 2
                    ])
                else:
                    raise ValueError("modality must be one of rgb or flow")

                # 获取网络,并完成前传
                with slim.arg_scope(inception_v2_arg_scope()):
                    logits, _ = inception_v2(
                        tsn_batch_split,
                        num_classes=cfg.NUM_CLASSES,
                        is_training=True,
                        dropout_keep_prob=cfg.TRAIN.DROPOUT_KEEP_PROB,
                        min_depth=16,
                        depth_multiplier=1.0,
                        prediction_fn=slim.softmax,
                        spatial_squeeze=True,
                        reuse=None,
                        scope='InceptionV2',
                        global_pool=False)
                tf.get_variable_scope().reuse_variables()
                logits = tf.reshape(logits, [
                    cfg.TRAIN.BATCH_SIZE / num_gpus,
                    cfg.INPUT.NUM_SEGMENTS * cfg.INPUT.NEW_LENGTH, -1
                ])  #tsn的特殊性决定
                logits = tf.reduce_mean(logits, 1)  # 取采样图片输出的平均值
                # 做一个batch准确度的预测
                prediction = tf.nn.softmax(logits)
                acc_batch = tf.reduce_mean(
                    tf.cast(
                        tf.equal(tf.argmax(prediction, 1),
                                 tf.argmax(label_batch_split, 1)), tf.float32))
                tf.summary.scalar('acc_on_batch', acc_batch)
                # 求loss
                for variable in tf.global_variables():
                    if variable.name.find(
                            'weights'
                    ) > 0:  # 把参数w加入集合tf.GraphKeys.WEIGHTS,方便做正则化(此句必须放在正则化之前)
                        tf.add_to_collection(tf.GraphKeys.WEIGHTS, variable)
                loss = tsn_loss(logits, label_batch_split, regularization=True)
                tf.summary.scalar('loss', loss)
                # 计算梯度,并由tower_grads收集
                grads_and_vars = opt.compute_gradients(
                    loss, var_list=tf.trainable_variables(
                    ))  # (gradient, variable)组成的列表
                tower_grads.append(grads_and_vars)
    grads_and_vars = average_gradients(tower_grads)  # 求取各GPU平均梯度
    train_step = opt.apply_gradients(grads_and_vars, global_step=global_step)

    # 在GPU上运行验证(串行)
    with tf.variable_scope(tf.get_variable_scope(
    )) as vscope:  # 见https://github.com/tensorflow/tensorflow/issues/6220
        with tf.device('/gpu:0'), tf.name_scope('VALID') as scope:
            tf.get_variable_scope().reuse_variables()
            if cfg.INPUT.MODALITY == 'rgb':
                tsn_valid_batch = tf.reshape(
                    tsn_valid_batch, [cfg.VALID.BATCH_SIZE * 25, 224, 224, 3])
            elif cfg.INPUT.MODALITY == 'flow':
                tsn_valid_batch = tf.reshape(
                    tsn_valid_batch, [cfg.VALID.BATCH_SIZE * 25, 224, 224, 2])
            else:
                raise ValueError("modality must be one of rgb or flow")

            with slim.arg_scope(inception_v2_arg_scope()):
                logits_valid, _ = inception_v2(
                    tsn_valid_batch,
                    num_classes=cfg.NUM_CLASSES,
                    is_training=False,
                    dropout_keep_prob=cfg.TRAIN.DROPOUT_KEEP_PROB,
                    min_depth=16,
                    depth_multiplier=1.0,
                    prediction_fn=slim.softmax,
                    spatial_squeeze=True,
                    reuse=None,
                    scope='InceptionV2',
                    global_pool=False)
            logits_valid = tf.reshape(
                logits_valid, [cfg.VALID.BATCH_SIZE, 25, -1])  #tsn的特殊性决定
            logits_valid = tf.reduce_mean(logits_valid, 1)  # 取采样图片输出的平均值
            # 做一个batch准确度的预测
            prediction_valid = tf.nn.softmax(logits_valid)
            acc_valid_batch = tf.reduce_mean(
                tf.cast(
                    tf.equal(tf.argmax(prediction_valid, 1),
                             tf.argmax(label_valid_batch, 1)), tf.float32))

    merged = tf.summary.merge_all()

    # saver
    model_variables_map = {}
    for variable in tf.global_variables():
        if variable.name.split('/')[0] == 'InceptionV2' and variable.name.find(
                'Conv2d_1c_1x1') == -1 and variable.name.find(
                    'Momentum') == -1:
            model_variables_map[variable.name.replace(':0', '')] = variable
    print '####################################################'
    for i in model_variables_map.keys():
        print i
    print '#####################################################'
    saver_model = tf.train.Saver(
        var_list=model_variables_map,
        max_to_keep=20)  #不加载'InceptionV2/Logits/Conv2d_1c_1x1/'下的参数

    #-------------启动Session-------------#
    # (预测验证集,求取精度)
    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8)
    config = tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True)
    with tf.Session(config=config) as sess:
        run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
        run_metadata = tf.RunMetadata()
        joint_writer = tf.summary.FileWriter(cfg.SUMMARY_DIR, sess.graph)
        summary_writer = tf.summary.FileWriter(cfg.SUMMARY_DIR, sess.graph)

        #初始化变量(或加载pretrained models)
        tf.global_variables_initializer().run()
        saver_model.restore(sess, cfg.TRAIN.PRETRAINED_MODEL_NAME)

        sess.graph.finalize()
        start_time = time.time()
        for i in range(cfg.TRAIN.MAX_ITE):
            _, learnrate, loss_value, step, summary = sess.run(
                [train_step, lr, loss, global_step, merged],
                options=run_options,
                run_metadata=run_metadata)
            if i == 0:
                start_time = time.time()
            if i % 10 == 0:
                if i >= 1:
                    end_time = time.time()
                    avg_time = (end_time - start_time) / float(i + 1)
                    print("Average time consumed per step is %0.2f secs." %
                          avg_time)
                print(
                    "After %d training step(s), learning rate is %g, loss on training batch is %g."
                    % (step, learnrate, loss_value))

            # 每个epoch验证一次,保存模型
            if i % 100 == 0:
                print '#############################################'
                print 'valid and save model'
                accs = []
                num = 0
                for j in range(849):
                    num += 1
                    acc = sess.run(acc_valid_batch)
                    accs.append(acc)
                print num
                acc_valid = np.mean(np.array(accs))
                print 'accuracy on validation set is %0.4f' % acc_valid
                print 'saving model...'
                saver_model.save(sess,
                                 cfg.TRAIN.SAVED_MODEL_PATTERN,
                                 global_step=global_step)
                print 'successfully saved !'
                print '#############################################'

            joint_writer.add_run_metadata(run_metadata, 'step%03d' % i)
            summary_writer.add_summary(summary, i)
            end_time = time.time()
            #print '%dth time step,consuming %f secs'%(i, start_time-end_time)

    summary_writer.close()