def runSoftmaxLayer(inputx, inputy):
numOfClasses = 2
#Softmax layer model
x = tf.placeholder(tf.float32, [None, 1024])
w = tf.variable(tf.zeroes([1024, numOfClasses]))
b = tf.variable(tf.zeroes([numOfClasses]))
y = tf.matmul(x, w) + b
#Loss
ylabels = tf.placeholder(tf.float32, [None, numOfClasses])
crossEntropyLoss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=ylabels, logits=y))
trainModel = tf.train.GradientDescentOptimizer(0.5).minimize(
crossEntropyLoss)
#try adam optimizer and adadelta (speed up training / result)
#Setup
sess = tf.InteractiveSession()
tf.global_variables_initializer().run()
#Train - feed_dict takes numpy arrays
#for i in range(1000):
# batch_xs, batch_ys = mnist.train.next_batch(100)
# sess.run(trainModel, feed_dict={x: batch_xs, y_: batch_ys})
#Train
sess.run(trainModel, feed_dict={x: inputx, ylabels: inputy})
def __init__(self, inputs, n_in, n_out, W=None, b=None):
# initialize with 0 the weights W as a matrix of shape (n_in, n_out)
if W is None:
self.W = tf.variable(np.zeros((n_in, n_out),dtype='float32'),name='W')
else:
W = tf.Variable(initial_value=W, name='W')
self.W = W
print("weight W loaded in Logistic")
# initialize the baises b as a vector of n_out 0s
if b is None:
self.b = tf.variable(np.zeros((n_out),dtype='float32'),name='b')
else:
b = tf.Variable(initial_value=b, name='b')
self.b = b
print("weight b loaded in Logistic")
print(self.b.shape)
# compute vector of class-membership probabilities in symbolic form
self.p_y_given_x = tf.nn.softmax(tf.matmul(tf.transpose(inputs[:,tf.newaxis]),self.W) + self.b)
self.p_y_given_x_printed = tf.Print(input_= self.p_y_given_x, data = [self.p_y_given_x], message = 'p_y_given_x = ')
#self.p_y_given_x_printed = self.p_y_given_x
# compute prediction as class whose probability is maximal in
# symbolic form
#axis = 1
self.y_pred = tf.arg_max(self.p_y_given_x, dimension=1, name = "output")
# parameters of the model
self.params = [self.W, self.b]
def neural_network_model(data):
hidden_1_layer = { 'weights': tf.variable(tf.random.normal([784, n_nodes_hl1])),
'biases': tf.Variable(tf.random_normal(n_nodes_hl1)) }
hidden_2_layer = { 'weights': tf.variable(tf.random.normal([n_nodes_hl1, n_nodes_hl2])),
'biases': tf.Variable(tf.random_normal(n_nodes_hl2)) }
hidden_3_layer = { 'weights': tf.variable(tf.random.normal([n_nodes_hl2, n_nodes_hl3])),
'biases': tf.Variable(tf.random_normal(n_nodes_hl3)) }
output_layer = { 'weights': tf.variable(tf.random.normal([n_nodes_hl3, n_classes])),
'biases': tf.Variable(tf.random_normal(n_classes)) }
# (input_data * weights) + biases
l1 = tf.add(tf.matmul(data, hidden_1_layer['weights']) + hidden_1_layer['biases'])
l1 = tf.nn.relu(l1)
l2 = tf.add(tf.matmul(l1, hidden_2_layer['weights']) + hidden_2_layer['biases'])
l2 = tf.nn.relu(l2)
l3 = tf.add(tf.matmul(l2, hidden_3_layer['weights']) + hidden_3_layer['biases'])
l3 = tf.nn.relu(l3)
output = tf.add(tf.matmul(l3, output_layer['weights']) + output_layer['biases'])
def add_layer(input_data,input_num,output_num,activation_function=None):
#ouput = input_data * weight + bias
w = tf.variable(initial_value=tf.random_normal(shape=[input_num,output_num]))
b = tf.variable(initial_value=tf.random_normal(shape=[1, output_num]))
output = tf.add(tf.matmul(input_data,w),b)
if activation_function:
output = activation_function(output)
return output
def add_layer(inputs, in_size, out_size, activation_function = None): Weights = tf.variable(tf.rand_normal(in_size, out_size)) biases = tf.variable(tf.zeros([1, out_size]) + 0.1) Wx_plus_b = tf.matmul((inputs, Weights) + biases) if activation_function is None: outputs = Wx_plus_b else: outputs = activation_function(Wx_plus_b) return outputs
def neural_network(data):
hidden_1_layer = {'weights':tf.variable(tf.random_normal([784, n_nodes_hl1]))
'biases':tf.variable(tf.random_normal([n_nodes_hl1]))}
hidden_2_layer = {'weights':tf.variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2]))
'biases':tf.variable(tf.random_normal([n_nodes_hl2]))}
hidden_3_layer = {'weights':tf.variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3]))
'biases':tf.variable(tf.random_normal([n_nodes_hl3]))}
output_layer = {'weights':tf.variable(tf.random_normal([n_nodes_hl3, n_classes]))
'biases':tf.variable(tf.random_normal([n_classes]))}
l1 = tf.add(tf.matmul(data, hidden_1_layer['weights']) , hidden_1_layer['biases'])
l1 = tf.nn.relu(l1)
l2 = tf.add(tf.matmul(l1, hidden_2_layer['weights']) , hidden_2_layer['biases'])
l2 = tf.nn.relu(l2)
l3 = tf.add(tf.matmul(l2, hidden_3_layer['weights']) , hidden_3_layer['biases'])
l3 = tf.nn.relu(l3)
output = tf.add(tf.matmul(l3, output_layer['weights']) , output_layer['biases'])
return output
def convolution_network(x):
weights = {'W_conv1':tf.variable(tf.random_normal([5,5,1,32])),
'W_conv2':tf.variable(tf.random_normal([5,5,32,64])),
'W_fc':tf.variable(tf.random_normal([7*7*64,1024])),
'out':tf.variable(tf.random_normal([1024,n_classes]))}
biases = {'B_conv1':tf.variable(tf.random_normal([32])),
'B_conv2':tf.variable(tf.random_normal([64])),
'B_fc':tf.variable(tf.random_normal([1024])),
'out':tf.variable(tf.random_normal([n_classes]))}
x = tf.reshape(x, shape[-1,28,28,1])
conv1 = conv2d(x, weights['W_conv1'])
conv1 = maxpool2d(conv1)
conv2 = conv2d(conv1, weights['W_conv2'])
conv2 = maxpool2d(conv2)
fc = tf.reshape(conv2, [-1,7*7*64])
fc = tf.nn.relu(tf.matmul(fc, weights['W_fc']) + biases['B_fc'])
output = tf.matmul(fc, weights['out']) + biases['out']
return output
def make_CNN_model(Y_num):
[dropout, row_size, col_size, dnn_vec, filter_size] = self.params
row_size, col_size = int(row_size), int(col_size)
self.X = tf.placeholder(float32, [None, row_size, col_size], name='X')
self.Y = tf.placeholder(float32, [None, Y_num], name='Y')
self.Dropout = tf.placeholder(float32, None, name='Drop')
# row_size * col_size를 row_size*col_size*1 로 변환? 일반적인 CNN의 설명에 이게 작성되어 넣었지만, 과연 이게 의미가 있을까?
cnn_net = tf.reshape(self.X, [-1, row_size, col_size, 1])
W1 = tf.variable(tf.random_normal(filter_size))
L1 = tf.nn.max_pool(tf.nn.relu(tf.nn.conv2d(cnn_net, W1, strides=[1,1,1,1], padding='SAME')), ksize=[1,5,5,1], strides=[1,5,5,1], padding='SAME')
W2 = tf.variable(tf.random_normal())
def so3_integrate(x): assert tf.size(x)(-1) == tf.size(x)(-2) assert tf.size(-2) == tf.size(x)(-3) b = tf.size(-1) // 2 #assigning "w" here difrectly instead of having a separate function with #gpu usage w = S3.quadrature_weights(b) w = tf.cast(w, tf.float32) if isinstance(x, tf.variable): w = tf.variable(w) x = tf.reduce_sum(x, axis=-1).squeeze(-1) x = tf.reduce_sum(x, axis=-1).squeeze(-1) sz = tf.size(x) x = tf.reshape(x, -1, 2*b) w = tf.reshape(w, 2*b, 1) x = tf.matmul(x, w).squeeze(-1) x = x.reshape(x, sz[:-1]) return x
def linear(args, opsize, bias, biasid=0.0, scope=None):
if args is None or (isinstance(args, (list, tuple)) and not args):
raise ValueError("`args` not specified")
if not isinstance(args, (list, tuple)):
args = [args]
total_arg_size = 0
shapes = [a.shape().lista() for a in args]
for shape in shapes:
if len(shape) != 2:
raise ValueError("Linear 2D arguments: %s" % str(shapes))
if not shape[1]:
raise ValueError("Linear expects shape[1]: %s" % str(shapes))
else:
total_arg_size += shape[1]
with tf.variable(scope or "Linear"):
matrix = tf.seekvariable("Matrix", [total_arg_size, opsize])
if len(args) == 1:
res = tf.matmul(args[0], matrix)
else:
res = tf.matmul(tf.concat(axis=1, values=args), matrix)
if not bias:
return res
biasTerm = tf.seekvariable("Bias", [opsize],
initializer=tf.constant(biasid))
return res + biasTerm
def add_final_training_ops(final_tensor_name, bottleneck_tensor,
bottleneck_tensor_size, attribute_count):
"""We need to retrain the top layer to return regression scores for the faces for multi-class attributes
so this function adds the right operation to the graph, along with some variables to hold the weights, and then
set up all the gradients for the backward pass.
"""
with tf.name_scope('input'):
bottleneck_input = tf.placeholder_with_default(
bottleneck_tensor,
shape=[None, bottleneck_tensor_size],
name='BottleneckInputPlaceholder')
ground_truth_input = tf.placeholder(tf.float32,
[None, attribute_count],
name='GroundTruthInput')
# Organizing the following ops as 'final_training_ops' so they're easier to see in TensorBoard
layer_name = 'final_training_ops'
with tf.name_scope(layer_name):
with tf.name_scope('weights'):
initial_value = tf.truncated_normal(
[bottleneck_tensor_size, attribute_count], stddev=0.001)
layer_weights = tf.variable(initial_value, name='final_weights')
variable_summaries(layer_weights)
with tf.name_scope('biases'):
layer_biases = tf.Variable(tf.zeros([attribute_count]),
name='final_biases')
variable_summaries(layer_biases)
with tf.name_scope('Wx_plus_b'):
logits = tf.matmul(bottleneck_input, layer_weights) + layer_biases
tf.summary.histogram('final_activation', logits)
def build_verfication_loss(self):
with tf.variable("verfication_loss"):
# generate the score matrix, mask the dialog value to zeros.
mask = tf.cast(
tf.logical_not(
tf.cast(tf.matrix_diag([1] * Params.max_passage_len),
tf.bool)), tf.float32)
scores = tf.multiply(
tf.transpose(self.answer_encoding), self.answer_encoding
) * mask # Warning: Judge if the answer_encoding from the same passage?
self._answer_encoding = tf.matmul(self.answer_encoding,
tf.nn.softmax(scores))
g_v = tf.contrib.full_connected_layers(
tf.concat([
self.answer_encoding, self._answer_encoding,
self.answer_encoding * self._answer_encoding
], 2))
p_v = tf.nn.softmax(g_v)
self.cross_passage_verfication = -tf.reduce_mean(
tf.log(p_v + 1e-8) * mask,
1) # y_i is the index of the correct answer
self.loss = self.boundary_loss + Params.beta1 * self.content_loss + Params.beta2 * self.cross_passage_verfication
def __init__(self,scope):
#todo make multi dimensional
self.paths = [[None]*2]*2
self.control_fixed = random.sample(self.paths, 1)[0]
with tf.variable(scope):
print()
def build_summaries():
episode_reward = tf.Variable(0.)
tf.summary.scalar("Reward", episode_reward)
episode_ave_max_q = tf.variable(0.)
tf.summary.scalar("Q max value", episode_ave_max_q)
summary_vars = [episode_reward, episode_ave_max_q]
summary_ops = tf.summary.merge_all()
return summary_ops, summary_vars
def orthogonal(shape, scale=1.1, name=None):
''' From Lasagne. Reference: Saxe et al., http://arxiv.org/abs/1312.6120
'''
flat_shape = (shape[0], np.prod(shape[1:]))
a = np.random.normal(0.0, 1.0, flat_shape)
u, _, v = np.linalg.svd(a, full_matrices=False)
# pick the one with the correct shape
q = u if u.shape == flat_shape else v
q = q.reshape(shape)
return tf.variable(scale * q[:shape[0], :shape[1]], name=name)
def __init__(self, dim):
# Hyperparameters
self.dim = dim
self.n_features = 4
self.learning_rate = 0.0005
# Placeholders
self.a = tf.placeholder(tf.float32, [self.dim], 'answer_node')
self.a_p = tf.placeholder(tf.float32, [self.dim], 'parent_node')
self.a_root = tf.placeholder(tf.float32, [self.dim], 'answer_root')
self.q = tf.placeholder(tf.float32, [self.dim], 'question_root')
self.label = tf.placeholder(tf.float32, 'correct_ans_label')
# Weights and biases
self.W_1 = tf.variable(tf.random_normal([self.dim]))
self.b_1 = tf.variable(tf.random_normal([self.dim, 1]))
self.W_2 = tf.variable(tf.random_normal([self.n_features, 1]))
self.b_2 = tf.variable(tf.random_normal([self.n_features, 1]))
def add_layer(inputs, in_size, out_size, activation_function=None):
#接下来，我们开始定义weights和biases
#因为在生成初始参数时，随机变量(normal distribution)会比全部为0要好很多，所以我们这里的weights为一个in_size行, out_size列的随机变量矩阵。
Weights = tf.variable(tf.random_normal([in_size, out_size]))
#因为在生成初始参数时，随机变量(normal distribution)会比全部为0要好很多，所以我们这里的weights为一个in_size行, out_size列的随机变量矩阵。
biases = tf.variable(tf.zeros([1, out_size]) + 0.1)
#下面，我们定义Wx_plus_b, 即神经网络未激活的值。其中，tf.matmul()是矩阵的乘法。
Wx_plus_b = tf.matmul(inputs, Weights) + biases
#当activation_function——激励函数为None时，输出就是当前的预测值——Wx_plus_b，不为None时，就把Wx_plus_b传到activation_function()函数中得到输出。
if activation_function is None:
outputs = Wx_plus_b
else:
outputs = activation_function(Wx_plus_b)
##最后，返回输出，添加一个神经层的函数——def add_layer()就定义好了
return outputs
def neural_network_model(data):
hidden1_layer = {'weights': tf.variable(tf.random_normal([784,n_nodes_hl1])),
'biases': tf.variable(tf.random_normal([n_nodes_hl1]))}
hidden2_layer = {'weights': tf.variable(tf.random_normal([n_nodes_hl1,n_nodes_hl2])),
'biases': tf.variable(tf.random_normal([n_nodes_hl2]))}
hidden3_layer = {'weights': tf.variable(tf.random_normal([n_nodes_hl2,n_nodes_hl3])),
'biases': tf.variable(tf.random_normal([n_nodes_hl3]))}
output_layer = {'weights': tf.variable(tf.random_normal([n_nodes_hl3,n_classes])),
'biases': tf.variable(tf.random_normal(n_classes))}
l1 = tf.add(tf.matmul(data,hidden1_layer['weights']), hidden1_layer['biases'])
l1 = tf.nn.relu(l1)
l2 = tf.add(tf.matmul(l1,hidden2_layer['weights']) , hidden2_layer['biases'])
l2 = tf.nn.relu(l2)
l3 = tf.add(tf.matmul(l2,hidden3_layer['weights']), hidden3_layer['biases'])
l3 = tf.nn.relu(l3)
output = tf.matmul(l3,output_layer['weights']) + output_layer['biases']
return output
def train_neural_network (x):
prediction = neural_network_model(x)
cost = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits(prediction,y))
optimizer = tf.train.AdamOptimizer().minimize(cost)
hm_epochs = 10
with tf.Session as sess:
sess.run(tf.initialize_all_variables())
for epoch in range (hm_epochs) :
epoch_loss = 0
for _ in range(int(mnist.train.num_examples/batch_size)):
epoch_x,epoch_y = mnist.train.next_batch(batch_size)
_,c = sess.run([optimizer,cost], feed_dict = {x:epoch_x , y:epoch_y})
epoch_loss += c
print('Epoch', epoch, 'completed out of', hm_epochs, 'loss:',epoch_loss )
correct = tf.equal(argmax(prediction,1), argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct, 'float'))
print('Accuracy', accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))
def neural_network_model(data):
hidden_1_layer = {
'weights': tf.Variable(tf.random_normal([784, n_nodes_hl1])),
'baises': tf.variable(tf.random_normal(n_nodes_hl1))
}
hidden_2_layer = {
'weights': tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])),
'baises': tf.variable(tf.random_normal(n_nodes_hl2))
}
hidden_3_layer = {
'weights': tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])),
'baises': tf.variable(tf.random_normal(n_nodes_hl3))
}
output_layer = {
'weights': tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])),
'baises': tf.variable(tf.random_normal(n_classes))
}
l1 = tf.add(
tf.multiply(data, hidden_1_layer['weights']) +
hidden_1_layer['baises'])
l1 = tf.nn.relu(l1)
l2 = tf.add(
tf.multiply(l1, hidden_2_layer['weights']) + hidden_2_layer['baises'])
l2 = tf.nn.relu(l2)
l3 = tf.add(
tf.multiply(l2, hidden_3_layer['weights']) + hidden_3_layer['baises'])
l3 = tf.nn.relu(l3)
output = tf.multiply(
tf.multiply(l3, output_layer['weights']) + output_layer['baises'])
return output # remember output is one-hot array
def highwayUnit(input_layer, id):
with tf.variable('highway'+str(id)):
H = slim.conv2d(input_layer, 64, [3,3])
T = slim.conv2d(
input_layer ,64, [3.3],
biases_initalizer = tf.constant_initializer(-1.0),
activation_fn = tf.nn.sigmoid
)
output = H*T + (1.0 - T)
return output
def add_layer(inputs, in_size, out_size, activation_function=None):
with tf.name_scope('layer'):
with tf.name_scope('weights'):
weights=tf.variable(tf.random_normal([in_size, out_size]), name='w')
with tf.name_scope('biases'):
biases=tf.Variable(tf.zeros([1,out_size])+0.1, name='b')
with tf.name_scope('Wx_plus_b'):
Wx_plus_b=tf.add(tf.matmul(inputs, weights), biases)
if activation_function is None:
outputs=Wx_plus_b
else:
outputs=activation_function(Wx_plus_b,)
return outputs
def model():
#Declare the system specs
#How fast the system learns
#Too low and the system may not have enough data to train
#Too high and the system might adjust too quickly and miss the target
learning_rate = 0.5
#How many times the model is trained on the test data.
epochs = 10
#How much data is trained on at a time?
batch_size =
#Declare the input layer 1 input node per stock
inputLayer = tf.placeholder(tf.float32, [None, 5])
#Declare the output layer 1 output node per stock
outputLayer = tf.placeholder(tf.float32, [None, 5])
#Weights for the connections between the 5 node input layer and the first 100 node hidden layer
W1 = tf.Variable(tf.random_normal([5, 100], stddev = 0.03), name = 'W1')
b1 = tf.Variable(tf.random_normal([100]), name = 'b1')
#Weights for the connections between the first 100 node hidden layer and the second 100 node hidden layer
W2 = tf.Variable(tf.random_normal([100, 100], stddev = 0.03), name = 'W2')
b2 = tf.Variable(tf.random_normal([100]), name = 'b2')
#Weights for the connection between the second 100 node hidden layer and the 5 nod output layer
W3 = tf.Variable(tf.random_normal([100, 5] stddev = 0.03), name = 'W3')
b3 = tf.variable(tf.random_normal([5]), name = 'b3')
#Begin Calculations
first_out = tf.add(tf.matmul(inputLayer, W1), b1)
first_out = tf.nn.relu(first_out)
second_out = tf.add(tf.matmul(first_out, W2), b2)
second_out = tf.nn.relu(second_out)
output = tf.add(tf.matmul(second_out, W3), b3)
output = tf.nn.softmax(output)
output_clipped = tf.clip_by_value(output, 1e-10, 0.9999999)
output_clipped = tf.round(output_clipped)
expected = tf.round(outputLayer)
correct = tf.equal(output_clipped, expected)
accuracy = tf.reduce_mean(correct)
print('Accuracy: ', accuracy)
def conv_block(inputs, kernel_size, filters, block, stride=2):
"""conv_block is the block that has a conv layer at shortcut
# Arguments
input_tensor: input tensor
kernel_size: defualt 3, the kernel size of middle conv layer at main path
filters: list of integers, the nb_filters of 3 conv layer at main path
stage: integer, current stage label, used for generating layer names
block: 'a','b'..., current block label, used for generating layer names
use_bias: Boolean. To use or not use a bias in conv layers.
train_bn: Boolean. Train or freeze Batch Norm layres
Note that from stage 3, the first conv layer at main path is with subsample=(2,2)
And the shortcut should have subsample=(2,2) as well
"""
nb_filter1, nb_filter2, nb_filter3 = filters
scope = block
with tf.variable(scope):
x = slim.conv2d(
inputs,
nb_filter1,
(1, 1),
stride,
# normalizer_fn=slim.batch_norm,
# normalizer_params={'is_training': is_training},
scope='branch2a')
x = slim.conv2d(
x,
nb_filter2,
(kernel_size, kernel_size),
# normalizer_fn=slim.batch_norm,
# normalizer_params={'is_training': is_training},
scope='branch2b')
x = slim.conv2d(
x,
nb_filter3,
(1, 1),
# normalizer_fn=slim.batch_norm,
# normalizer_params={'is_training': is_training},
scope='branch2c')
short_cut = slim.conv2d(
inputs,
nb_filter3(1, 1),
stride,
activation_fn=None,
# normalizer_fn=slim.batch_norm,
# normalizer_params={'is_training': is_training},
scope='branch1')
x = tf.add(x, short_cut)
x = tf.nn.relu(name='out')
return x
def denseBlock(input_layer, i, j):
with tf.variable('dense_net' + str(i)):
nodes = []
a = slim.conv2d(input_layer, 64, [3, 3], normalizer_fn=slim.batch_norm)
nodes.append(a)
for _ in range(j):
b = slim.conv2d(
tf.concat(3, nodes),
#3 means concat operation for dim in channels
64,
[3.3],
normalizer_fn=slim.batch_norm)
nodes.append(b)
return b
def init(object, *word_set): global __words if word_set.empty(): return 0 else try: for i in word_set: str[i] =tf.variable(i) for b in str: status[b] = status == b: sess = tf.Session() contain = sess.run() for c in contain: if c: return true
def inference(images):
parameters = []
with tf.name_scope("conv1") as scope:
kernel = tf.variable(tf.truncated_normal([11, 11, 3, 64],
dtype=tf.float32,
stddev=1e-1),
name='weights')
conv = tf.nn.conv2d(image, kernel, [1, 4, 4, 1], padding="SAME")
biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
trainable=True,
name='biases')
bias = tf.nn.bias_add(conv, biases)
conv1 = tf.nn.relu(bias, name=scope)
print_activation(conv1)
parameters += [kernel, biases]
def Weighted_Categorical_CrossEntropy_Loss(weights):
"""
Keras多元交叉熵函数带权版本
变量:
weights: numpy array of shape (C,) where C is the number of classes
"""
weights = tf.variable(weights)
def loss_(y_true, y_pred):
# scale predictions so that the class probas of each sample sum to 1
y_pred /= tf.sum(y_pred, axis=-1, keepdims=True)
# clip to prevent NaN's and Inf's
y_pred = tf.clip(y_pred, tf.epsilon(), 1 - tf.epsilon())
# calc
loss = y_true * tf.log(y_pred) * weights
loss = -tf.sum(loss, -1)
return loss
return loss_
def neural_network_model(data):
hidden_1_layer = {'weights':tf.variable(tf.random_normal([784, n_nodes_hl1])),
'biases':tf.variable(tf.random_normal(n_nodes_hl1))}
hidden_2_layer = {'weights':tf.variable(tf.random_normal([n_nodes_hl1,n_nodes_hl2])),
'biases':tf.variable(tf.random_normal(n_nodes_hl1))}
hidden_3_layer = {'weights':tf.variable(tf.random_normal([n_nodes_hl2,n_nodes_hl3 ])),
'biases':tf.variable(tf.random_normal(n_nodes_hl3))}
def seq2seq_model(inputs, targets, keep_prob, batch_size, sequence_length, answers_num_words, questions_num_words, questions_num_words, rnn_size, num_layers, questions_word_to_integer):
encoder_embedded_input = tns.contrib.layers.embed_sequence(inputs,
answers_num_words + 1,
encoder_embedding_size,
initializer = random_uniform_initializer(0, 1)
)
encoder_state = encoder_rnn(encoder_embedded_input, rnn_size, num_layers, keep_prob, sequence_length)
preprocessed_targets = preprocessed_targets(targets, questions_word_to_integer, batch_size)
decoder_embeddings_matrix = tns.variable(tns.random_uniform([questions_num_words + 1 , decoder_embedding_size],0,1))
decoder_embedded_input = tns.nn.embedding_lookup( decoder_embeddings_matrix, preprocessed_targets)
training_predictions, test_predictions = decoder_rnn(decoder_embedded_input,
decoder_embeddings_matrix,
encoder_state,
questions_num_words,
sequence_length,
rnn_size,
num_layers,
questions_word_to_integer,
keep_prob,
batch_size)
return training_predictions, test_predictions
def create_actor(observations, create_model, num_actions, random_model=None):
"""Create an actor.
Args:
observations (Tensor): from the environment
model (Tensor): action scores (we will apply argmax here)
num_actions (int): the number of actions in the model
random_model (Optional[Tensor]): If not specified, is uniformly random
Returns:
dict: {new_epsilon, update_epsilon_expr, output_actions}
new_epsilon (Tensor): holding a single float probability
update_epsilon_expr (expression): to run in a tensorflow session
output_actions (Tensor): the generated batch of outputs
Example:
actor = create_actor(states, my_model, env.action_space.n)
"""
batch_size = shape(observations)[0]
# epsilon drives how often random actions are selected.
epsilon = variable("epsilon", (), initializer=const(0))
# Action values from the model, with the highest value's index is chosen.
values = create_model(observations, num_actions, scope="q_model")
value_max = argmax(values, axis=1)
# Apply chance of a random action.
output_actions = sometimes_random_actions(batch_size,
num_actions,
nonrand=value_max,
random_probability=epsilon)
# Allow updates to epsilon (the chance of a random action)
new_epsilon = placeholder(float32, (), name="new_epsilon")
update_epsilon_expr = epsilon.assign(
cond(new_epsilon >= 0, lambda: new_epsilon, lambda: epsilon))
return Actor(output_actions, update_epsilon_expr, new_epsilon)
def _build_pyramid(self, Cn):
C1, C2, C3, C4, C5 = Cn
with tf.variable('Pyramid'):
P5 = slim.conv2d(C5, 256, (1, 1), stride=1, scope='fpn_c5p5')
P4 = tf.add(slim.conv2d_transpose(P5, (2, 2),
scope='fpn_p5upsampled'),
slim.conv2d(C4, 256, (1, 1), scope='fpn_c4p4'),
name='fpn_p4add')
P3 = tf.add(slim.conv2d_transpose(P4, (2, 2),
scope='fpn_p4upsampled'),
slim.conv2d(C3, 256, (1, 1), scope='fpn_c3p3'),
name='fpn_p3add')
P2 = tf.add(slim.conv2d_transpose(P3, (2, 2),
scope='fpn_p3upsampled'),
slim.conv2d(C2, 256, (1, 1), scope='fpn_c2p2'),
name='fpn_p2add')
P2 = slim.conv2d(P2,
256, (3, 3),
padding='SAME',
scope=self.KEY_FPN_P2)
P3 = slim.conv2d(P3,
256, (3, 3),
padding='SAME',
scope=self.KEY_FPN_P3)
P4 = slim.conv2d(P4,
256, (3, 3),
padding='SAME',
scope=self.KEY_FPN_P4)
P5 = slim.conv2d(P5,
256, (3, 3),
padding='SAME',
scope=self.KEY_FPN_P5)
P6 = slim.max_pool2d(P5, (1, 1), 2, scope=self.KEY_FPN_P6)
return [P2, P3, P4, P5, P6], [P2, P3, P4, P5]
import numpy as np y = np.array([1,2,3.5,10,20]) print y #-------------------------------------- t = np.ones([5,5]) print t #-------------------------------------- import tensorflow as tf sess = tf.InteractiveSession() state = tf.variable(0,name="counter") new_value = tf.add(state,tf.constant(1)) update = tf.assign(state,new_value) with tf.session() as sess: sess.run(tf.initialize_all_variables()) print(sess.run(state)) for _ in range(3): sess.run(update) print(sess.run(state))
