Python tflearn.input_data方法代码示例

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def resnext(width, height, frame_count, lr, output=9, model_name = 'sentnet_color.model'):
    net = input_data(shape=[None, width, height, 3], name='input')
    net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weight_decay=0.0001)
    net = tflearn.layers.conv.resnext_block(net, n, 16, 32)
    net = tflearn.resnext_block(net, 1, 32, 32, downsample=True)
    net = tflearn.resnext_block(net, n-1, 32, 32)
    net = tflearn.resnext_block(net, 1, 64, 32, downsample=True)
    net = tflearn.resnext_block(net, n-1, 64, 32)
    net = tflearn.batch_normalization(net)
    net = tflearn.activation(net, 'relu')
    net = tflearn.global_avg_pool(net)
    # Regression
    net = tflearn.fully_connected(net, output, activation='softmax')
    opt = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True)
    net = tflearn.regression(net, optimizer=opt,
                             loss='categorical_crossentropy')

    model = tflearn.DNN(net,
                        max_checkpoints=0, tensorboard_verbose=0, tensorboard_dir='log')

    return model 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def create_actor_network(self):
        with tf.variable_scope('actor'):
            inputs = tflearn.input_data(
                shape=[None, self.s_dim[0], self.s_dim[1]])
            _input = tf.expand_dims(inputs, -1)

            merge_net = tflearn.conv_2d(
                _input, FEATURE_NUM, KERNEL, activation='relu')
            merge_net = tflearn.conv_2d(
                merge_net, FEATURE_NUM, KERNEL, activation='relu')

            avg_net = tflearn.global_avg_pool(merge_net)
            out = tflearn.fully_connected(
                avg_net, self.a_dim, activation='softmax')

            return inputs, out 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def create_critic_network(self):
        with tf.variable_scope('critic'):
            inputs = tflearn.input_data(
                shape=[None, self.s_dim[0], self.s_dim[1]])
            _input = tf.expand_dims(inputs, -1)

            merge_net = tflearn.conv_2d(
                _input, FEATURE_NUM, KERNEL, activation='relu')
            merge_net = tflearn.conv_2d(
                merge_net, FEATURE_NUM, KERNEL, activation='relu')

            avg_net = tflearn.global_avg_pool(merge_net)
            # dense_net_0 = tflearn.fully_connected(
            #    merge_net, 64, activation='relu')
            #dense_net_0 = tflearn.dropout(dense_net_0, 0.8)
            out = tflearn.fully_connected(avg_net, 1, activation='linear')

            return inputs, out 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def create_network(self):
        with tf.variable_scope('innovation'):
            inputs = tflearn.input_data(shape=[None, self.s_dim[0], self.s_dim[1]])
            split_array = []
            for i in xrange(self.s_dim[0] - 1):
                split = tflearn.conv_1d(inputs[:, i:i + 1, :], FEATURE_NUM, KERNEL, activation='relu')
                flattern = tflearn.flatten(split)
                split_array.append(flattern)
            
            #dense_net= tflearn.fully_connected(inputs[:, -1:, 0:5], FEATURE_NUM, activation='relu')
            split_array.append(inputs[:, -1, 0:5])
            merge_net = tflearn.merge(split_array, 'concat')
            dense_net_0 = tflearn.fully_connected(merge_net, 64, activation='relu')

            out = tflearn.fully_connected(dense_net_0, self.a_dim, activation='softmax')

            return inputs, out 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def vqn_model(x):
    with tf.variable_scope('vqn'):
        inputs = tflearn.input_data(placeholder=x)
        _split_array = []

        for i in range(INPUT_SEQ):
            tmp_network = tf.reshape(
                inputs[:, i:i+1, :, :, :], [-1, INPUT_H, INPUT_W, INPUT_D])
            if i == 0:
                _split_array.append(CNN_Core(tmp_network))
            else:
                _split_array.append(CNN_Core(tmp_network, True))

        merge_net = tflearn.merge(_split_array, 'concat')
        merge_net = tflearn.flatten(merge_net)
        _count = merge_net.get_shape().as_list()[1]

        with tf.variable_scope('full-cnn'):
            net = tf.reshape(
                merge_net, [-1, _count / DENSE_SIZE, DENSE_SIZE, 1])
            out = vgg16(net, OUTPUT_DIM)

        return out 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def vqn_model(x):
    with tf.variable_scope('vqn'):
        inputs = tflearn.input_data(placeholder=x)
        _split_array = []

        for i in range(INPUT_SEQ):
            tmp_network = tf.reshape(
                inputs[:, i:i+1, :, :, :], [-1, INPUT_H, INPUT_W, INPUT_D])
            if i == 0:
                _split_array.append(CNN_Core(tmp_network))
            else:
                _split_array.append(CNN_Core(tmp_network,True))
            
        merge_net = tflearn.merge(_split_array, 'concat')
        merge_net = tflearn.flatten(merge_net)
        _count = merge_net.get_shape().as_list()[1]

        with tf.variable_scope('full-cnn'):
            net = tf.reshape(merge_net, [-1, _count / DENSE_SIZE, DENSE_SIZE, 1])
            out = vgg16(net, OUTPUT_DIM)

        return out 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def create_actor_network(self):
        with tf.variable_scope('actor'):
            inputs = tflearn.input_data(shape=[None, self.s_dim[0], self.s_dim[1]])
            split_array = []
            for i in xrange(self.s_dim[0] - 1):
                split = tflearn.conv_1d(inputs[:, i:i + 1, :], FEATURE_NUM, KERNEL, activation='relu')
                flattern = tflearn.flatten(split)
                split_array.append(flattern)
            
            dense_net= tflearn.fully_connected(inputs[:, -1:, :], FEATURE_NUM, activation='relu')
            split_array.append(dense_net)
            merge_net = tflearn.merge(split_array, 'concat')

            dense_net_0 = tflearn.fully_connected(merge_net, 64, activation='relu')
           # dense_net_0 = tflearn.dropout(dense_net_0, 0.8)
            out = tflearn.fully_connected(dense_net_0, self.a_dim, activation='softmax')

            return inputs, out 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def test_feed_dict_no_None(self):

        X = [[0., 0., 0., 0.], [1., 1., 1., 1.], [0., 0., 1., 0.], [1., 1., 1., 0.]]
        Y = [[1., 0.], [0., 1.], [1., 0.], [0., 1.]]

        with tf.Graph().as_default():
            g = tflearn.input_data(shape=[None, 4], name="X_in")
            g = tflearn.reshape(g, new_shape=[-1, 2, 2, 1])
            g = tflearn.conv_2d(g, 4, 2)
            g = tflearn.conv_2d(g, 4, 1)
            g = tflearn.max_pool_2d(g, 2)
            g = tflearn.fully_connected(g, 2, activation='softmax')
            g = tflearn.regression(g, optimizer='sgd', learning_rate=1.)

            m = tflearn.DNN(g)

            def do_fit():
                m.fit({"X_in": X, 'non_existent': X}, Y, n_epoch=30, snapshot_epoch=False)
            self.assertRaisesRegexp(Exception, "Feed dict asks for variable named 'non_existent' but no such variable is known to exist", do_fit) 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def createDNNLayers(self, x, y):

        ###############################################################
        #
        # Sets up the DNN layers, configuration in required/confs.json
        #
        ###############################################################
        
        net = tflearn.input_data(shape=[None, len(x[0])])

        for i in range(self._confs["NLU"]['FcLayers']):
            net = tflearn.fully_connected(net, self._confs["NLU"]['FcUnits'])

        net = tflearn.fully_connected(net, len(y[0]), activation=str(self._confs["NLU"]['Activation']))

        if self._confs["NLU"]['Regression']:
            net = tflearn.regression(net)

        return net 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def build_estimator(model_dir, model_type, embeddings,index_map, combination_method):
  """Build an estimator."""

  # Continuous base columns.
  node1 = tf.contrib.layers.real_valued_column("node1")

  deep_columns = [node1]
  
  if model_type == "regressor":
      
      tflearn.init_graph(num_cores=8, gpu_memory_fraction=0.5)
      if combination_method == 'concatenate':
          net = tflearn.input_data(shape=[None, embeddings.shape[1]*2])
      else:
        net = tflearn.input_data(shape=[None, embeddings.shape[1]] )
      net = tflearn.fully_connected(net, 100, activation='relu')
      net = tflearn.fully_connected(net, 2, activation='softmax')
      net = tflearn.regression(net, optimizer='adam', loss='categorical_crossentropy')
      m = tflearn.DNN(net)
  else:
    m = tf.contrib.learn.DNNLinearCombinedClassifier(
        model_dir=model_dir,
        linear_feature_columns=wide_columns,
        dnn_feature_columns=deep_columns,
        dnn_hidden_units=[100])
  return m 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def get_network(frames, input_size, num_classes):
    """Create our LSTM"""
    net = tflearn.input_data(shape=[None, frames, input_size])
    net = tflearn.lstm(net, 128, dropout=0.8, return_seq=True)
    net = tflearn.lstm(net, 128)
    net = tflearn.fully_connected(net, num_classes, activation='softmax')
    net = tflearn.regression(net, optimizer='adam',
                             loss='categorical_crossentropy', name="output1")
    return net 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def get_network_deep(frames, input_size, num_classes):
    """Create a deeper LSTM"""
    net = tflearn.input_data(shape=[None, frames, input_size])
    net = tflearn.lstm(net, 64, dropout=0.2, return_seq=True)
    net = tflearn.lstm(net, 64, dropout=0.2, return_seq=True)
    net = tflearn.lstm(net, 64, dropout=0.2)
    net = tflearn.fully_connected(net, num_classes, activation='softmax')
    net = tflearn.regression(net, optimizer='adam',
                             loss='categorical_crossentropy', name="output1")
    return net 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def get_network_wide(frames, input_size, num_classes):
    """Create a wider LSTM"""
    net = tflearn.input_data(shape=[None, frames, input_size])
    net = tflearn.lstm(net, 256, dropout=0.2)
    net = tflearn.fully_connected(net, num_classes, activation='softmax')
    net = tflearn.regression(net, optimizer='adam',
                             loss='categorical_crossentropy', name='output1')
    return net 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def get_network_wider(frames, input_size, num_classes):
    """Create a wider LSTM"""
    net = tflearn.input_data(shape=[None, frames, input_size])
    net = tflearn.lstm(net, 512, dropout=0.2)
    net = tflearn.fully_connected(net, num_classes, activation='softmax')
    net = tflearn.regression(net, optimizer='adam',
                             loss='categorical_crossentropy', name='output1')
    return net 

# 需要导入模块: import tflearn [as 别名]
# 或者: from tflearn import input_data [as 别名]
def vgg_net_19(width, height):
    network = input_data(shape=[None, height, width, 3], name='input')
    network = conv_2d(network, 64, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 64, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = max_pool_2d(network, 2, strides=2)
    network = conv_2d(network, 128, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 128, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = max_pool_2d(network, 2, strides=2)
    network = conv_2d(network, 256, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 256, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 256, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 256, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = max_pool_2d(network, 2, strides=2)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = max_pool_2d(network, 2, strides=2)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = conv_2d(network, 512, 3, activation = 'relu', regularizer='L2', weight_decay=5e-4)
    network = max_pool_2d(network, 2, strides=2)
    network = fully_connected(network, 4096, activation='relu', weight_decay=5e-4)
    network = dropout(network, keep_prob=0.5)
    network = fully_connected(network, 4096, activation='relu', weight_decay=5e-4)
    network = dropout(network, keep_prob=0.5)
    network = fully_connected(network, 1000, activation='softmax', weight_decay=5e-4)
    
    opt = Momentum(learning_rate=0, momentum = 0.9)
    network = regression(network, optimizer=opt, loss='categorical_crossentropy', name='targets')
    
    model = DNN(network, checkpoint_path='', max_checkpoints=1, tensorboard_verbose=2, tensorboard_dir='')
    
    return model

#model of vgg-19 for testing of the activations 
#rename the output you want to test, connect it to the next layer and change the output layer at the bottom (model = DNN(...))
#make sure to use the correct test function (depending if your output is a tensor or a vector)