def dnn_layers(input_layers, layers):
if layers and isinstance(layers, dict):
return tflayers.stack(input_layers, tflayers.fully_connected,
layers['layers'],
activation=layers.get('activation'),
dropout=layers.get('dropout'))
elif layers:
return tflayers.stack(input_layers, tflayers.fully_connected, layers)
else:
return input_layers
def dnn_layers(input_layers, layers):
if layers and isinstance(layers, dict):
return tflayers.stack(input_layers, tflayers.fully_connected,
layers['layers'],
activation=layers.get('activation'),
dropout=layers.get('dropout'))
elif layers:
return tflayers.stack(input_layers, tflayers.fully_connected, layers)
else:
return input_layers
def dnn_stack(input, layers):
if layers and isinstance(layers, dict):
dnn_out = tflayers.stack(input,
tflayers.fully_connected,
layers['layers'],
activation_fn=layers.get('activation'))
elif layers:
dnn_out = tflayers.stack(input, tflayers.fully_connected, layers)
W_fc1 = weight_variable([layers['layers'][-1], 1])
b_fc1 = bias_variable([1])
pred = tf.add(tf.matmul(dnn_out, W_fc1), b_fc1, name='dnnout')
return pred
def dnn_stack(input, layers): ###全连接层使用tflayers里面的stack，这样不用自己手动写连接
if layers and isinstance(layers, dict):
dnn_out = tflayers.stack(input,
tflayers.fully_connected,
layers['layers'],
activation_fn=layers.get('activation'))
elif layers:
dnn_out = tflayers.stack(input, tflayers.fully_connected, layers)
W_fc1 = weight_variable([layers['layers'][-1], 1])
b_fc1 = bias_variable([1])
pred = tf.add(tf.matmul(dnn_out, W_fc1), b_fc1,
name='dnnout') ###dnn的输出结果和label对应是一个数字
return pred
def embed_condition_images(condition_image,
scope,
reuse=tf.AUTO_REUSE,
fc_layers=None,
use_spatial_softmax=True):
"""Independently embed a (meta)-batch of images.
Args:
condition_image: A rank 4 tensor of images: [N, H, W, C].
scope: Name of the tf variable_scope.
reuse: The variable_scope reuse setting.
fc_layers: An optional tuple of ints describing the number of units in each
fully-connected hidden layer, or 1x1 conv layer when excluding spatial
softmax.
use_spatial_softmax: Whether to use a spatial softmax or not.
Returns:
A rank 2 tensor of embeddings: [N, embedding size] if spatial_softmax is
True. Otherwise, a rank 4 tensor of visual features [N, H, W, embedding
size]
Raises:
ValueError if `condition_image` has incorrect rank.
"""
if len(condition_image.shape) != 4:
raise ValueError('Image has unexpected shape {}.'.format(
condition_image.shape))
with tf.variable_scope(scope, reuse=reuse, use_resource=True):
image_embedding, _ = vision_layers.BuildImagesToFeaturesModel(
condition_image, use_spatial_softmax=use_spatial_softmax)
if fc_layers is not None:
if len(image_embedding.shape) == 2:
image_embedding = layers.stack(image_embedding,
layers.fully_connected,
fc_layers[:-1],
activation_fn=tf.nn.relu,
normalizer_fn=layers.layer_norm)
image_embedding = layers.fully_connected(image_embedding,
fc_layers[-1],
activation_fn=None)
else:
image_embedding = layers.stack(image_embedding,
layers.conv2d,
fc_layers[:-1],
kernel_size=[1, 1],
activation_fn=tf.nn.relu,
normalizer_fn=layers.layer_norm)
image_embedding = layers.conv2d(image_embedding,
fc_layers[-1],
activation_fn=None)
return image_embedding
def lstm_model(X, y):
X = tf.reshape(
X, [-1, n_steps, n_input]) # shape: [batch_size, n_steps, n_input]
X = tf.transpose(X, [1, 0, 2]) # shape: [n_steps, batch_size, n_input]
X = tf.reshape(X, [-1, n_input]) # shape: [n_steps*batch_size, n_input]
# Split data for sequences
X = tf.split(0, n_steps, X) # n_steps * (batch_size, n_input)
init = tf.random_normal_initializer(batch_size, stddev=0.05)
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden, forget_bias=forget_bias)
# Dropout
lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell,
output_keep_prob=keep_prob)
output, _ = tf.nn.rnn(lstm_cell, X, dtype=tf.float32)
# Fully connected layer with dropout
output = tf.nn.dropout(
layers.stack(output[0], layers.fully_connected, dnn_hidden), keep_prob)
regression = skflow.models.linear_regression(
output, y) # Use output[0] if omitting fully connected layer
return regression
def _vgg_11(self, x):
net = repeat(x, 2, conv2d, 64, [3, 3], scope='conv1')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool1')
net = repeat(net, 2, conv2d, 128, [3, 3], scope='conv2')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool2')
net = repeat(net, 3, conv2d, 256, [3, 3], scope='conv3')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool3')
net = repeat(net, 3, conv2d, 512, [3, 3], scope='conv4')
net = tf.layers.max_pooling2d(net, [2, 2],
strides=2,
data_format='channels_first',
name='pool4')
net = tf.layers.flatten(net, name='flatten')
net = stack(net, fully_connected, self.layer_sizes, scope='fc5')
features = dropout(net, scope='drop5')
logits = fully_connected(features,
self._num_classes,
activation_fn=None,
normalizer_fn=None,
scope='unscaled_logits')
return logits, features
def my_model(features, target):
"""DNN with three hidden layers, and dropout of 0.1 probability."""
# Convert the target to a one-hot tensor of shape (length of features, 3) and
# with a on-value of 1 for each one-hot vector of length 3.
target = tf.one_hot(target, 3, 1, 0)
# Create three fully connected layers respectively of size 10, 20, and 10 with
# each layer having a dropout probability of 0.1.
normalizer_fn = layers.dropout
normalizer_params = {'keep_prob': 0.9}
features = layers.stack(features, layers.fully_connected, [10, 20, 10],
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params)
# Compute logits (1 per class) and compute loss.
logits = layers.fully_connected(features, 3, activation_fn=None)
loss = tf.contrib.losses.softmax_cross_entropy(logits, target)
# Create a tensor for training op.
train_op = tf.contrib.layers.optimize_loss(
loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad',
learning_rate=0.1)
return ({
'class': tf.argmax(logits, 1),
'prob': tf.nn.softmax(logits)}, loss, train_op)
def my_model(features, target):
"""DNN with three hidden layers, and dropout of 0.1 probability."""
# Convert the target to a one-hot tensor of shape (length of features, 3) and
# with a on-value of 1 for each one-hot vector of length 3.
target = tf.one_hot(target, 3, 1, 0)
# Create three fully connected layers respectively of size 10, 20, and 10 with
# each layer having a dropout probability of 0.1.
normalizer_fn = layers.dropout
normalizer_params = {'keep_prob': 0.9}
features = layers.stack(features,
layers.fully_connected, [10, 20, 10],
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params)
# Compute logits (1 per class) and compute loss.
logits = layers.fully_connected(features, 3, activation_fn=None)
loss = tf.contrib.losses.softmax_cross_entropy(logits, target)
# Create a tensor for training op.
train_op = tf.contrib.layers.optimize_loss(
loss,
tf.contrib.framework.get_global_step(),
optimizer='Adagrad',
learning_rate=0.1)
return ({
'class': tf.argmax(logits, 1),
'prob': tf.nn.softmax(logits)
}, loss, train_op)
def my_model(features, target):
"""DNN with three hidden layers, and dropout of 0.1 probability."""
# Convert the target to a one-hot tensor of shape (length of features, 3) and
# with a on-value of 1 for each one-hot vector of length 3.
target = tf.one_hot(target, 3, 1, 0)
# Create three fully connected layers respectively of size 10, 20, and 10 with
# each layer having a dropout probability of 0.1.
normalizer_fn = layers.dropout
normalizer_params = {'keep_prob': 0.9}
features = layers.stack(features,
layers.fully_connected, [10, 20, 10],
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params)
# Create two tensors respectively for prediction and loss.
prediction, loss = (tf.contrib.learn.models.logistic_regression(
features, target))
# Create a tensor for training op.
train_op = tf.contrib.layers.optimize_loss(
loss,
tf.contrib.framework.get_global_step(),
optimizer='Adagrad',
learning_rate=0.1)
return {
'class': tf.argmax(prediction, 1),
'prob': prediction
}, loss, train_op
def model(features, target):
global args
regularizer = None
regularization_type = args.regularization_type.lower()
regularization_value = args.regularization_value
if regularization_type == "l1":
print("Using L1 regularizer, val =", regularization_value)
regularizer = tf.contrib.layers.l1_regularizer(regularization_value)
elif regularization_type == "l2":
print("Using L2 regularizer, val =", regularization_value)
regularizer = tf.contrib.layers.l2_regularizer(regularization_value)
else:
print("Not using regularization")
target = tf.one_hot(target, 3, 1, 0)
with tf.variable_scope(MODEL_NAME, regularizer=regularizer):
features = layers.stack(features, layers.fully_connected, [10, 20, 10])
logits = layers.fully_connected(features, 3, activation_fn=None)
loss = tf.contrib.losses.softmax_cross_entropy(logits, target)
if regularizer:
loss = loss + sum(tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES))
train_op = tf.contrib.layers.optimize_loss(
loss,
tf.contrib.framework.get_global_step(),
optimizer='Adagrad',
learning_rate=0.1)
return ({
'class': tf.argmax(logits, 1),
'prob': tf.nn.softmax(logits)
}, loss, train_op)
def dnn_layers(input_layers, layers):
logging.info("building dense rnn layers...")
if layers and isinstance(layers, dict):
# stack required layers in to one
return tflayers.stack(input_layers,
tflayers.fully_connected,
layers['layers'],
activation=layers.get('activation'),
dropout=layers.get('dropout'))
elif layers:
return tflayers.stack(input_layers, tflayers.fully_connected,
layers)
else:
return input_layers
def embed_condition_images(
condition_image,
scope,
reuse=tf.AUTO_REUSE,
fc_layers = None):
"""Independently embed a (meta)-batch of images.
Args:
condition_image: A rank 4 tensor of images: [N, H, W, C].
scope: Name of the tf variable_scope.
reuse: The variable_scope reuse setting.
fc_layers: An optional tuple of ints describing the number of units in each
fully-connected hidden layer.
Returns:
A rank 2 tensor of embeddings: [N, embedding size].
Raises:
ValueError if `condition_image` has incorrect rank.
"""
if len(condition_image.shape) != 4:
raise ValueError(
'Image has unexpected shape {}.'.format(condition_image.shape))
with tf.variable_scope(scope, reuse=reuse, use_resource=True):
image_embedding, _ = vision_layers.BuildImagesToFeaturesModel(
condition_image)
if fc_layers is not None:
image_embedding = layers.stack(
image_embedding,
layers.fully_connected,
fc_layers[:-1],
activation_fn=tf.nn.relu,
normalizer_fn=layers.layer_norm)
image_embedding = layers.fully_connected(
image_embedding, fc_layers[-1], activation_fn=None)
return image_embedding
def dnn_tanh(features, target):
target = tf.one_hot(target, 2, 1.0, 0.0)
# Organize continues features.
final_features = [
tf.expand_dims(tf.cast(features[var], tf.float32), 1)
for var in continues_vars
]
# Embed categorical variables into distributed representation.
for var in categorical_vars:
feature = learn.ops.categorical_variable(
features[var + '_ids'],
len(categorical_var_encoders[var].classes_),
embedding_size=CATEGORICAL_EMBED_SIZE,
name=var)
final_features.append(feature)
# Concatenate all features into one vector.
features = tf.concat(1, final_features)
# Deep Neural Network
logits = layers.stack(features,
layers.fully_connected, [10, 20, 10],
activation_fn=tf.tanh)
prediction, loss = learn.models.logistic_regression(logits, target)
train_op = layers.optimize_loss(loss,
tf.contrib.framework.get_global_step(),
optimizer='SGD',
learning_rate=0.05)
return tf.argmax(prediction, dimension=1), loss, train_op
def my_model(features, target):
target = tf.one_hot(target, 3, 1, 0)
features = layers.stack(features, layers.fully_connected, [10, 20, 10])
prediction, loss = tf.contrib.learn.models.logistic_regression_zero_init(features, target)
train_op = tf.contrib.layers.optmize_loss(loss, tf.contrib.framework.get_global_step(),
optimizer='Adagrad', learning_rate=0.1)
return {'class': tf.arg_max(prediction, 1), 'prob': prediction}, loss, train_op
def model_function(features, targets, mode):
hlayers = layers.stack(
features,
layers.fully_connected, [1000, 100, 50, 20],
activation_fn=tf.nn.relu,
weights_regularizer=layers.l1_l2_regularizer(1.0, 2.0),
weights_initializer=layers.xavier_initializer(uniform=True, seed=100))
# hidden layers have to be fully connected for best performance. So, no option in tensorflow for
# non-fully connected layers; need to write custom code to do that
outputs = layers.fully_connected(
inputs=hlayers,
num_outputs=10, # 10 perceptrons in output layer for 10 numbers (0 to 9)
activation_fn=None
) # Use "None" as activation function specified in "softmax_cross_entropy" loss
# Calculate loss using cross-entropy error; also use the 'softmax' activation function
loss = losses.softmax_cross_entropy(outputs, targets)
optimizer = layers.optimize_loss(
loss=loss,
global_step=tf.contrib.framework.get_global_step(),
learning_rate=0.8,
optimizer="SGD")
# Class of output (i.e., predicted number) corresponds to the perceptron returning the highest fractional value
# Returning both fractional values and corresponding labels
probs = tf.nn.softmax(outputs)
return {'probs': probs, 'labels': tf.argmax(probs, 1)}, loss, optimizer
def model_function(features, targets, mode):
# Two hidden layers - 20,10 = # perceptrons in layer1, layer2. Both have ReLU activation
# More concise syntax
hlayers = layers.stack(features,
layers.fully_connected, [20, 10],
activation_fn=tf.nn.relu)
# hidden layers have to be fully connected for best performance. So, no option in tensorflow for
# non-fully connected layers; need to write custom code to do that
outputs = layers.fully_connected(
inputs=hlayers,
num_outputs=10, # 10 perceptrons in output layer for 10 numbers (0 to 9)
activation_fn=None
) # Use "None" as activation function specified in "softmax_cross_entropy" loss
# Calculate loss using cross-entropy error; also use the 'softmax' activation function
loss = losses.softmax_cross_entropy(outputs, targets)
optimizer = layers.optimize_loss(
loss=loss,
global_step=tf.contrib.framework.get_global_step(),
learning_rate=0.001,
optimizer="SGD")
# Class of output (i.e., predicted number) corresponds to the perceptron returning the highest fractional value
# Returning both fractional values and corresponding labels
probs = tf.nn.softmax(outputs)
return {'probs': probs, 'labels': tf.argmax(probs, 1)}, loss, optimizer
def my_model(features, target):
"""DNN with three hidden layers, and dropout of 0.1 probability."""
# Convert the target to a one-hot tensor of shape (length of features, 3) and
# with a on-value of 1 for each one-hot vector of length 3.
target = tf.one_hot(target, 3, 1, 0)
# Create three fully connected layers respectively of size 10, 20, and 10 with
# each layer having a dropout probability of 0.1.
normalizer_fn = layers.dropout
normalizer_params = {'keep_prob': 0.9}
features = layers.stack(features, layers.fully_connected, [10, 20, 10],
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params)
# Create two tensors respectively for prediction and loss.
prediction, loss = (
tf.contrib.learn.models.logistic_regression(features, target)
)
# Create a tensor for training op.
train_op = tf.contrib.layers.optimize_loss(
loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad',
learning_rate=0.1)
return {'class': tf.argmax(prediction, 1), 'prob': prediction}, loss, train_op
def embed_fullstate(fullstate,
embed_size,
scope,
reuse=tf.AUTO_REUSE,
fc_layers=(100, )):
"""Embed full state pose (non-image) observations.
Args:
fullstate: A rank 2 tensor: [N, F].
embed_size: Integer, the output embedding size.
scope: Name of the tf variable scope.
reuse: The variable_scope reuse setting.
fc_layers: A tuple of ints describing the number of units in each hidden
layer.
Returns:
A rank 2 tensor: [N, embed_size].
"""
with tf.variable_scope(scope, reuse=reuse, use_resource=True):
embedding = layers.stack(fullstate,
layers.fully_connected,
fc_layers,
activation_fn=tf.nn.relu,
normalizer_fn=layers.layer_norm)
embedding = layers.fully_connected(embedding,
embed_size,
activation_fn=None)
return embedding
def dnn_tanh(features, target):
target = tf.one_hot(target, 2, 1.0, 0.0)
logits = layers.stack(features, layers.fully_connected, [10, 20, 10],
activation_fn=tf.tanh)
prediction, loss = learn.models.logistic_regression(logits, target)
train_op = layers.optimize_loss(loss,
tf.contrib.framework.get_global_step(), optimizer='SGD', learning_rate=0.05)
return tf.argmax(prediction, dimension=1), loss, train_op
def dnn_tanh(features, target):
target = tf.one_hot(target, 2, 1.0, 0.0)
logits = layers.stack(features, layers.fully_connected, [10, 20, 10],
activation_fn=tf.tanh)
prediction, loss = learn.models.logistic_regression(logits, target)
train_op = layers.optimize_loss(loss,
tf.contrib.framework.get_global_step(), optimizer='SGD', learning_rate=0.05)
return tf.argmax(prediction, dimension=1), loss, train_op
def fit(self, X):
h_layers = self.h_layers
assert len(h_layers) >= 1, 'Must give at least one layer.'
l2_pen = self.l2_pen
nb_epoch =self.nb_epoch
X_data = X.reshape(X.shape[0],-1)
n_inputs = X_data.shape[1]
n_outputs = n_inputs
if self.batch_size is None:
self.batch_size = n_inputs
batch_size = self.batch_size
lr = self.lr
# CONTSTRUCTION PHASE
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name='X')
with arg_scope(
[layers.fully_connected],
activation_fn=self.activation_fn,
weights_regularizer=layers.l2_regularizer(l2_pen),
weights_initializer=layers.variance_scaling_initializer()):
hidden = layers.stack(X, layers.fully_connected, h_layers, scope='hidden')
out = layers.fully_connected(hidden, n_outputs, activation_fn=None, scope='out')
model_loss = tf.reduce_mean(tf.square(out-X))
reg_loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
total_loss = model_loss + reg_loss
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
training_op = optimizer.minimize(total_loss)
init = tf.global_variables_initializer()
#from tensorflow.examples.tutorials.mnist import input_data
#mnist = input_data.read_data_sets("/tmp/data/")
with tf.Session() as sess:
sess.run(init)
for epoch in range(nb_epoch):
for b_idx in range(int(X_data.shape[0]/batch_size)):
x_batch = X_data[b_idx*batch_size:(b_idx+1)*batch_size]
# run training op
sess.run(training_op, feed_dict={X:x_batch})
# check loss after each epoch
epoch_loss = sess.run(model_loss, feed_dict={X:X_data})
print 'Epoch: ' , epoch, ' Loss: ', epoch_loss
# get weights from fully_connected layer(s)
weights = []
for i in range(1,len(h_layers)+1):
with tf.variable_scope('hidden/hidden_%i'%i, reuse=True):
h_w = tf.get_variable('weights')
h_w = sess.run(h_w)
weights.append(h_w)
with tf.variable_scope('out', reuse=True):
o_w = tf.get_variable('weights')
weights.append(sess.run(o_w))
self.weights_ = weights
def reduce_temporal_embeddings(temporal_embedding,
output_size,
scope,
reuse=tf.AUTO_REUSE,
conv1d_layers=(64, ),
fc_hidden_layers=(100, ),
combine_mode='temporal_conv'):
"""Combine embedding across the episode temporal dimension.
Args:
temporal_embedding: A rank 3 tensor: [N, time dim, feature dim].
output_size: The dimension of the output embedding.
scope: Name of the tf variable_scope.
reuse: The variable_scope reuse setting.
conv1d_layers: An optional tuple of ints describing the number of feature
maps in each 1D conv layer.
fc_hidden_layers: A tuple of ints describing the number of units in each
fully-connected hidden layer.
combine_mode: How to reduce across time to get a fixed length vector.
Returns:
A rank 2 tensor: [N, output_size].
Raises:
ValueError if `temporal_embedding` has incorrect rank.
"""
if len(temporal_embedding.shape) == 5:
temporal_embedding = tf.reduce_mean(temporal_embedding, axis=[2, 3])
if len(temporal_embedding.shape) != 3:
raise ValueError('Temporal embedding has unexpected shape {}.'.format(
temporal_embedding.shape))
embedding = temporal_embedding
with tf.variable_scope(scope, reuse=reuse, use_resource=True):
if 'temporal_conv' not in combine_mode:
# Just average
embedding = tf.reduce_mean(embedding, axis=1)
else:
if conv1d_layers is not None:
for num_filters in conv1d_layers:
embedding = tf.layers.conv1d(embedding,
num_filters,
10,
activation=tf.nn.relu,
use_bias=False)
embedding = layers.layer_norm(embedding)
if combine_mode == 'temporal_conv_avg_after':
embedding = tf.reduce_mean(embedding, axis=1)
else:
embedding = layers.flatten(embedding)
embedding = layers.stack(embedding,
layers.fully_connected,
fc_hidden_layers,
activation_fn=tf.nn.relu,
normalizer_fn=layers.layer_norm)
embedding = layers.fully_connected(embedding,
output_size,
activation_fn=None)
return embedding
def _mlp(self, x):
net = stack(x, fully_connected, self.layer_sizes, scope='fc')
features = tf.nn.dropout(
net, keep_prob=self._dropout_keep_prob) # For group dropout
logits = fully_connected(features,
num_outputs=2,
activation_fn=None,
scope='unscaled_logits')
return logits, features
def my_model(features,target):
target=tf.one_hot(target,3,1,0)
#3- the depth of the one hot dimension.
# [[1., 0., 0.],#长度是3！因为输入数据的种类和长度以一样的，索引一般这depth也可以用class理解
# [0., 1., 0.],
# [0., 0., 1.]]
features=layers.stack(features,layers.fully_connected,[10,20,10])#叠加多个fc层，每层节点10,20,10
prediction,loss=tf.contrib.learn.models.logistic_regression_zero_init(features,target)#初始0的逻辑回归
train_op=tf.contrib.layers.optimize_loss(loss,tf.contrib.framework.get_global_step(),optimizer='Adagrad',learning_rate=0.1)
return {'class':tf.argmax(prediction,1),'prob':prediction},loss,train_op
def predict(self, feat_ab, name, reuse=False):
with tf.variable_scope(name, reuse=reuse):
out = layers.stack(feat_ab,
layers.fully_connected, [1024, 256],
scope='fc')
out = layers.fully_connected(out,
1,
activation_fn=None,
scope='fc_out')
return out
def _build_model(self, data, target):
ids = tensorflow.split(1, self.n_ids, data)
node_vectors = [
learn.ops.categorical_variable(ids[i], self.vocabulary_sizes[i], self.layer_size, str(i))
for i in range(self.n_ids)
]
activation_in = tensorflow.squeeze(tensorflow.concat(2, node_vectors), [1])
activation_out = layers.stack(activation_in, layers.fully_connected, self.hidden_units_formation)
prediction, loss = learn.models.linear_regression(activation_out, target)
train_op = layers.optimize_loss(loss, framework.get_global_step(), self.learning_rate, "SGD")
return prediction, loss, train_op
def dnn_layers(input_layers, layers):
'''
Defines the optional dense layers
*note: A dense layer is a kind of hidden layer where every node is connected
to every other node in the next layer
INPUT:
- input_layers:
- layers: same as dense_layers
'''
if layers and isinstance(layers, dict):
return tflayers.stack(input_layers,
tflayers.fully_connected,
layers['layers'],
activation=layers.get('activation'),
dropout=layers.get('dropout'))
elif layers:
return tflayers.stack(input_layers, tflayers.fully_connected,
layers)
else:
return input_layers
def my_model(features, target):
"""DNN with 10, 20, 10 hidden layers, and dropout of 0.1 probability."""
target = tf.one_hot(target, 3, 1, 0)
features = layers.stack(features, layers.fully_connected, [10, 20, 10])
prediction, loss = (
tf.contrib.learn.models.logistic_regression_zero_init(features, target)
)
train_op = tf.contrib.layers.optimize_loss(
loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad',
learning_rate=0.1)
return {'class': tf.argmax(prediction, 1), 'prob': prediction}, loss, train_op
def _lstm_model(X, y):
x_ = tf.unstack(X, num=time_steps, axis=1)
stacked_lstm = rnn.MultiRNNCell(lstm_cells(), state_is_tuple=True)
output, lastState = rnn.static_rnn(stacked_lstm, x_, dtype=dtypes.float32)
output = tflayers.stack(output[-1], tflayers.fully_connected, fcDim)
prediction, loss = tflearn.models.linear_regression(output, y)
train_op = tf.contrib.layers.optimize_loss(
loss, tf.contrib.framework.get_global_step(), optimizer=optimizer,
learning_rate = tf.train.exponential_decay(learning_rate, tf.contrib.framework.get_global_step(),
decay_steps = 100, decay_rate = 0.9, staircase=False, name=None))
return prediction, loss, train_op
def my_model(features, target):
#features是数据的特征，targets是数据特征每一行的目标或者分类的标识。
target = tf.onr_hot(target, 3,1,0) #读热编码，使损失函数的计算更方便
#使用layers.stack叠加多层layers.fully_connected完全连接的深度神经网络
#每一层分别有10、20、10个隐藏节点
features = layers.stack(features, layers.fully_connected,[10,20,10])
prediction,loss = tf.contrib.learn.models.logistic_regression_zero_init(features,target)
#使用contrib.layers.optimize_loss函数对损失值进行优化
train_op = tf.contrib.layers.optimize_loss(
los, tf.contrib.framwork.get_global_step(),optimizer='Adagrad',
learning_rate = 0.1)
return {'class':tf.argmax(prediction,1),'prob':prediction},loss,train_op
def model(X, y):
basics = [tf.nn.rnn_cell.BasicLSTMCell(5, state_is_tuple=True)]
stacked_lstm = tf.nn.rnn_cell.MultiRNNCell(basics, state_is_tuple=True)
x_ = tf.unpack(X, axis=1, num=10)
output, layers = tf.nn.rnn(stacked_lstm, x_, dtype=dtypes.float32)
output = tflayers.stack(output[-1], tflayers.fully_connected, [10, 10])
prediction, loss = tflearn.models.linear_regression(output, y)
train_op = tf.contrib.layers.optimize_loss(
loss,
tf.contrib.framework.get_global_step(),
optimizer='Adagrad',
learning_rate=0.1)
return prediction, loss, train_op
def dnn_layers(input_layers, layers):
## Why suport different formats?? The use of a variable that could be either
## a scalar type (int/char/whatever) or a dict (much more complex), or NoneType
## is interesting to me. Need to pay attention to use here.
## tflayers is alias for tf.contrib.layers
if layers and isinstance(layers, dict):
## tflayers.stack() (alias of tf.contrib.layers.stack)
## Calls stack_layers repeatedly. What does stack_layers do?
## identical between versions.
## activation, dropout are kwargs passed directly to stack_layers
## In this layer, every cell is connected to every other cell.
return tflayers.stack(input_layers, tflayers.fully_connected,
layers['layers'],
activation=layers.get('activation'),
dropout=layers.get('dropout'))
elif layers:
## Find out what activation and ropout parameters do, and why they're excluded here
return tflayers.stack(input_layers, tflayers.fully_connected, layers)
else:
## Why does this exist? Should there be an exception here? in this case, the function
## does nothing.
return input_layers
def dnn_layers(input_layers, layers):
if layers and isinstance(layers, dict):
return tflayers.stack(input_layers,
tflayers.fully_connected,
layers['layers'],
activation=layers.get('activation'),
dropout=layers.get('dropout'))
elif layers:
return tflayers.stack(input_layers, tflayers.fully_connected,
layers)
else:
return input_layers
def lstm_model_(X, y):
stacked_lstm = rnn.MultiRNNCell(lstm_cells(rnn_layers),
state_is_tuple=True)
x_ = tf.unstack(X, num=time_steps, axis=1)
output, layers = rnn.static_rnn(stacked_lstm,
x_,
dtype=dtypes.float32)
output = dnn_layers(output[-1], dense_layers)
prediction, loss = tflearn.model.linearn_regression(output, y)
train_op = tf.contrib.layers.optimize_loss(
loss,
tf.contrib.framework.get_global_step(),
optimizer=optimizer,
learning_rate=tf.train.exponential_decay(
learning_rate,
tf.contrib.framework.get_global_step(),
decay_steps=1010,
decay_rate=0.9,
staircase=FAlse,
name=None))
print('learning rate', learning_rate)
return prediction, loss, train_op
return lstm_model_
def decoder(z):
"""Make reconstruction network.
Parameters
----------
z
Returns
-------
Reconstruction distribution p(x|z;\theta) with Bernoulli distribution.
Here, Bernoulli was chosen since pixel space is bounded by [0, 255].
"""
net = stack(flatten(z), fc, [256, 512])
logits = fc(net, 28 * 28, activation_fn=None)
return Bernoulli(logits=logits)
def linear_network(states,
scope=None,
reuse=False,
layers=None,
activation_fn=tf.tanh):
layers = layers or [16, 16]
with tf.variable_scope(scope or "network") as scope:
if reuse:
scope.reuse_variables()
hidden_state = tflayers.stack(states,
tflayers.fully_connected,
layers,
activation_fn=activation_fn)
return hidden_state
def dnn_tanh(features, target):
target = tf.one_hot(target, 2, 1.0, 0.0)
# Organize continues features.
final_features = [tf.expand_dims(tf.cast(features[var], tf.float32), 1) for var in continues_vars]
# Embed categorical variables into distributed representation.
for var in categorical_vars:
feature = learn.ops.categorical_variable(
features[var + '_ids'], len(categorical_var_encoders[var].classes_),
embedding_size=CATEGORICAL_EMBED_SIZE, name=var)
final_features.append(feature)
# Concatenate all features into one vector.
features = tf.concat(1, final_features)
# Deep Neural Network
logits = layers.stack(features, layers.fully_connected, [10, 20, 10],
activation_fn=tf.tanh)
prediction, loss = learn.models.logistic_regression(logits, target)
train_op = layers.optimize_loss(loss,
tf.contrib.framework.get_global_step(), optimizer='SGD', learning_rate=0.05)
return tf.argmax(prediction, dimension=1), loss, train_op
def my_model(features, target):
"""DNN with three hidden layers, and dropout of 0.1 probability.
Note: If you want to run this example with multiple GPUs, Cuda Toolkit 7.0 and
CUDNN 6.5 V2 from NVIDIA need to be installed beforehand.
Args:
features: `Tensor` of input features.
target: `Tensor` of targets.
Returns:
Tuple of predictions, loss and training op.
"""
# Convert the target to a one-hot tensor of shape (length of features, 3) and
# with a on-value of 1 for each one-hot vector of length 3.
target = tf.one_hot(target, 3, 1, 0)
# Create three fully connected layers respectively of size 10, 20, and 10 with
# each layer having a dropout probability of 0.1.
normalizer_fn = layers.dropout
normalizer_params = {'keep_prob': 0.5}
with tf.device('/gpu:1'):
features = layers.stack(features, layers.fully_connected, [10, 20, 10],
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params)
with tf.device('/gpu:2'):
# Compute logits (1 per class) and compute loss.
logits = layers.fully_connected(features, 3, activation_fn=None)
loss = tf.contrib.losses.softmax_cross_entropy(logits, target)
# Create a tensor for training op.
train_op = tf.contrib.layers.optimize_loss(
loss, tf.contrib.framework.get_global_step(), optimizer='Adagrad',
learning_rate=0.1)
return ({
'class': tf.argmax(logits, 1),
'prob': tf.nn.softmax(logits)}, loss, train_op)
