译文 | 简明 TensorFlow 教程：所有的模型

import tensorflow as tf 
import numpy as np 
# Create input data 
X = np.random.randn(2, 10, 8) 
# The second example is of length 6 
X[1,6,:] = 0 
X_lengths = [10, 6] 
cell = tf.nn.rnn_cell.LSTMCell(num_units=64, state_is_tuple=True) 
cell = tf.nn.rnn_cell.DropoutWrapper(cell=cell, output_keep_prob=0.5) 
cell = tf.nn.rnn_cell.MultiRNNCell(cells=[cell] * 4, state_is_tuple=True) 
outputs, last_states = tf.nn.dynamic_rnn(    
cell=cell,    
dtype=tf.float64,    
sequence_length=X_lengths,   
 inputs=X) 
result = tf.contrib.learn.run_n(    {"outputs": outputs, "last_states": last_states},    
n=1,   
 feed_dict=None)

### Convolutional network 
def max_pool_2x2(tensor_in):  
return tf.nn.max_pool(     
 tensor_in, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') 
def conv_model(X, y):  
# reshape X to 4d tensor with 2nd and 3rd dimensions being image width and 
 # height final dimension being the number of color channels.  
X = tf.reshape(X, [-1, 28, 28, 1])  
# first conv layer will compute 32 features for each 5x5 patch  
with tf.variable_scope('conv_layer1'):        
h_conv1 = learn.ops.conv2d(X, n_filters=32, filter_shape=[5, 5],                               
bias=True, activation=tf.nn.relu)    
h_pool1 = max_pool_2x2(h_conv1)  
# second conv layer will compute 64 features for each 5x5 patch.  
with tf.variable_scope('conv_layer2'):    
h_conv2 = learn.ops.conv2d(h_pool1, n_filters=64, filter_shape=[5, 5],                               bias=True, activation=tf.nn.relu)    
h_pool2 = max_pool_2x2(h_conv2)    
# reshape tensor into a batch of vectors    
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])  
# densely connected layer with 1024 neurons.  
h_fc1 = learn.ops.dnn(      
h_pool2_flat, [1024], activation=tf.nn.relu, dropout=0.5)  
return learn.models.logistic_regression(h_fc1, y)

def init_weights(shape):    
return tf.Variable(tf.random_normal(shape, stddev=0.01)) 
def model(X, w_h, w_o):    
h = tf.nn.sigmoid(tf.matmul(X, w_h)) 
# this is a basic mlp, think 2 stacked logistic regressions    
return tf.matmul(h, w_o) # note that we dont take the softmax at the end because our cost fn does that for us 
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels 
X = tf.placeholder("float", [None, 784]) 
Y = tf.placeholder("float", [None, 10]) 
w_h = init_weights([784, 625]) # create symbolic variables 
w_o = init_weights([625, 10]) py_x = model(X, w_h, w_o) 
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(py_x, Y)) # compute costs train_op = tf.train.GradientDescentOptimizer(0.05).minimize(cost) # construct an optimizer predict_op = tf.argmax(py_x, 1) 
# Launch the graph in a session 
with tf.Session() as sess:    # you need to initialize all variables   
tf.initialize_all_variables().run()
for i in range(100):        
for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):            
sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end]})        
print(i, np.mean(np.argmax(teY, axis=1) ==                         
sess.run(predict_op, feed_dict={X: teX, Y: teY})))

import numpy as np 
import tensorflow as tf 
import numpy as np 
import tensorflow as tf 
def weight_variable(shape):    
initial = tf.truncated_normal(shape, stddev=1)   
 return tf.Variable(initial) 
# dataset 
xx = np.random.randint(0,1000,[1000,3])/1000. 
yy = xx[:,0] * 2 + xx[:,1] * 1.4 + xx[:,2] * 3 
# model 
x = tf.placeholder(tf.float32, shape=[None, 3]) 
y_ = tf.placeholder(tf.float32, shape=[None]) 
W1 = weight_variable([3, 1]) 
y = tf.matmul(x, W1) 
# training and cost function 
cost_function = tf.reduce_mean(tf.square(tf.squeeze(y) - y_)) 
train_function = tf.train.AdamOptimizer(1e-2).minimize(cost_function) 
# create a session 
sess = tf.Session() # train sess.run(tf.initialize_all_variables()) 
for i in range(10000):    
sess.run(train_function, feed_dict={x:xx, y_:yy})    
if i % 1000 == 0:        
print(sess.run(cost_function, feed_dict={x:xx, y_:yy}))

def input_fn():      
return {          
'example_id': tf.constant(['1', '2', '3']),          
'price': tf.constant([[0.6], [0.8], [0.3]]),         
 'sq_footage': tf.constant([[900.0], [700.0], [600.0]]),         
 'country': tf.SparseTensor(              
values=['IT', 'US', 'GB'],              
indices=[[0, 0], [1, 3], [2, 1]],              
shape=[3, 5]),         
 'weights': tf.constant([[3.0], [1.0], [1.0]])      
}, tf.constant([[1], [0], [1]]) 
price = tf.contrib.layers.real_valued_column('price')    
sq_footage_bucket = tf.contrib.layers.bucketized_column(        tf.contrib.layers.real_valued_column('sq_footage'),        
boundaries=[650.0, 800.0])    
country = tf.contrib.layers.sparse_column_with_hash_bucket(        
'country', hash_bucket_size=5)    
sq_footage_country = tf.contrib.layers.crossed_column(        
[sq_footage_bucket, country], hash_bucket_size=10)    
svm_classifier = tf.contrib.learn.SVM(        
feature_columns=[price, sq_footage_bucket, country, sq_footage_country],        example_id_column='example_id',       
 weight_column_name='weights',       
 l1_regularization=0.1,       
 l2_regularization=1.0) 
svm_classifier.fit(input_fn=input_fn, steps=30)    
accuracy = svm_classifier.evaluate(input_fn=input_fn, steps=1)['accuracy']

def input_fn(df, train=False):  
"""Input builder function."""  
# Creates a dictionary mapping from each continuous feature column name (k) to  
# the values of that column stored in a constant Tensor.  
continuous_cols = {k: tf.constant(df[k].values) for k in CONTINUOUS_COLUMNS}  
# Creates a dictionary mapping from each categorical feature column name (k)  
# to the values of that column stored in a tf.SparseTensor.  
categorical_cols = {k: tf.SparseTensor(    
indices=[[i, 0] for i in range(df[k].size)],    
values=df[k].values,    
shape=[df[k].size, 1])                      
for k in CATEGORICAL_COLUMNS}  
# Merges the two dictionaries into one.  
feature_cols = dict(continuous_cols)  
feature_cols.update(categorical_cols)  
# Converts the label column into a constant Tensor.  
if train:   
label = tf.constant(df[SURVIVED_COLUMN].values)      
# Returns the feature columns and the label.    
return feature_cols, label  
else:    
return feature_cols 
m = build_estimator(model_dir) 
m.fit(input_fn=lambda: input_fn(df_train, True), steps=200) 
print m.predict(input_fn=lambda: input_fn(df_test)) 
results = m.evaluate(input_fn=lambda: input_fn(df_train, True), steps=1) 
for key in sorted(results):  
print("%s: %s" % (key, results[key]))

hparams = tf.contrib.tensor_forest.python.tensor_forest.ForestHParams(        
num_trees=3, max_nodes=1000, num_classes=3, num_features=4) 
classifier = tf.contrib.learn.TensorForestEstimator(hparams) 
iris = tf.contrib.learn.datasets.load_iris() data = iris.data.astype(np.float32)
 target = iris.target.astype(np.float32) 
monitors = [tf.contrib.learn.TensorForestLossMonitor(10, 10)] 
classifier.fit(x=data, y=target, steps=100, monitors=monitors) 
classifier.evaluate(x=data, y=target, steps=10)

"""Build the Split-Apply-Merge Model.  
Route each value of input [-1, -1, 1, 1] through one of the  
functions, plus_1, minus_1.  The decision for routing is made by  
4 Bernoulli R.V.s whose parameters are determined by a neural network  
applied to the input.  REINFORCE is used to update the NN parameters.  
Returns:    
The 3-tuple (route_selection, routing_loss, final_loss), where:      
- route_selection is an int 4-vector     
 - routing_loss is a float 4-vector      
- final_loss is a float scalar.  
"""  
inputs = tf.constant([[-1.0], [-1.0], [1.0], [1.0]])  
targets = tf.constant([[0.0], [0.0], [0.0], [0.0]])  
paths = [plus_1, minus_1]  weights = tf.get_variable("w", [1, 2])  
bias = tf.get_variable("b", [1, 1])  
logits = tf.matmul(inputs, weights) + bias 
# REINFORCE forward step  
route_selection = st.StochasticTensor(      
distributions.Categorical, logits=logits)

# Train for a fixed number of iterations. 
session.run(tf.initialize_all_variables())  
for i in range(1000):   
 tf_unary_scores, tf_transition_params, _ = session.run(      
 [unary_scores, transition_params, train_op])    
if i % 100 == 0:      
correct_labels = 0      
total_labels = 0      
for tf_unary_scores_, y_, sequence_length_ in zip(tf_unary_scores, y, sequence_lengths):        
# Remove padding from the scores and tag sequence.        
tf_unary_scores_ = tf_unary_scores_[:sequence_length_]        
y_ = y_[:sequence_length_]        
# Compute the highest scoring sequence.       
 viterbi_sequence, _ = tf.contrib.crf.viterbi_decode(           
 tf_unary_scores_, tf_transition_params)        
# Evaluate word-level accuracy.        
correct_labels += np.sum(np.equal(viterbi_sequence, y_))        
total_labels += sequence_length_      
accuracy = 100.0 * correct_labels / float(total_labels)      
print("Accuracy: %.2f%%" % accuracy)