There is a road to the mountain of books. Diligence is the path. There is no end to learning. It is hard to make a boat
What I can't create, I can't understand
1. Installation and introduction
1.1 installation
promat at anaconda
pip install tensorflow
If it cannot be installed, the external installation website
https://www.lfd.uci.edu/~gohlke/pythonlibs/#xgboost
The website can install tensorflow and other libraries. Tensorflow must be 64 bits
After downloading the cd, enter the location of the file and install pip
pip install file name
Version number
tensorflow.version
1.2 what is tensorflow
Tensorflow is a secondgeneration machine learning system developed by Google. It overcomes the limitations of the firstgeneration system DistBelief, which can only develop neural network algorithms, is difficult to configure and depends on Google's internal hardware. It is more widely used, improves flexibility and portability, and greatly improves speed and scalability. Literally, tensorflow is a framework for implementing and executing machine learning algorithms by means of tensor flow on the graph. It has the following characteristics:
 Flexibility. TensorFlow is not a strict "neural network" library. As long as the calculation can be represented as a data flow graph, TensorFlow can be used, such as partial differential solution in scientific calculation. (in fact, the orientation of TF in the introduction of its official website is a scientific computing library based on data flow graph, not just a machine learning library)
 Portability. The same code can be deployed to PC s, servers or mobile devices with any number of CPU s, GPU s or TPU s (Tensor Processing Unit, a processor specially developed by Google for machine learning) without modification.
 Automatic differentiation. Like Theano, TensorFlow also supports automatic differentiation. Users do not need to solve the gradient through back propagation.
 Multilingual support. TensorFlow officially supports python, C + +, Go and Java interfaces. Users can experiment with Python in machines with good hardware configuration and deploy with C + + in environments with tight resources or low latency.
 Performance. Although TensorFlow only supported standalone when it was first released and was not excellent in performance evaluation, with Google's strong development strength, TensorFlow's performance has caught up with other frameworks
2. Variable operation
2.1 creating variables
Create variables in Python and assign values as long as a = 3
All variables in tensorflow must be in tensor format. You need to specify a standard format first
Specify variables and operations, but they have not been executed and initialized
First open a session and open up a computable area. To execute anything, you must actually run in the computable area of the session.
The initialization method of global variables is defined. Maybe run it actually
a = 3 # Create a variable w = tf.Variable([[0.5,1.0]]) x = tf.Variable([[2.0],[1.0]]) y = tf.matmul(w, x) #The operation is also a tensorflow format #Global variable initialization init_op = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init_op) # run initialization print (y.eval())
[[ 2.]]
Many operations of tensorflow are similar to numpy

tf.zeros([3, 4], int32) ==> [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

tf.zeros_like(tensor) ==> [[0, 0, 0], [0, 0, 0]]

tf.ones([2, 3], int32) ==> [[1, 1, 1], [1, 1, 1]]

tf.ones_like(tensor) ==> [[1, 1, 1], [1, 1, 1]]

tensor = tf.constant([1, 2, 3, 4, 5, 6, 7]) => [1 2 3 4 5 6 7]

tensor = tf.constant(1.0, shape=[2, 3]) => [[1. 1. 1.] [1. 1. 1.]]

tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0 11.0 12.0]

tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
#The resulting values follow a normal distribution with a specified mean and standard deviation norm = tf.random_normal([2, 3], mean=1, stddev=4) # shuffle the cards c = tf.constant([[1, 2], [3, 4], [5, 6]]) shuff = tf.random_shuffle(c) # Each execution result will be different sess = tf.Session() print (sess.run(norm)) print (sess.run(shuff))
[[5.58110332 0.84881377 7.51961231]
[ 3.27404118 7.22483826 7.70631599]]
[[5 6]
[1 2]
[3 4]]
run in the session to get the value
Each time the tensor adds 1, assign is the assignment operation. Run the initialization of the global variable with session, and then perform the update operation
state = tf.Variable(0) new_value = tf.add(state, tf.constant(1)) update = tf.assign(state, new_value) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) print(sess.run(state)) for _ in range(3): sess.run(update) print(sess.run(state))
0
1
2
3
2.2 calculation
Convert Numpy to tensor
import numpy as np a = np.zeros((3,3)) ta = tf.convert_to_tensor(a) with tf.Session() as sess: print(sess.run(ta))
Arithmetic operation
a = tf.constant(5.0) b = tf.constant(10.0) x = tf.add(a, b, name="add") y = tf.div(a, b, name="divide") with tf.Session() as sess: print("a =", sess.run(a)) print("b =", sess.run(b)) print("a + b =", sess.run(x)) print("a/b =", sess.run(y))
a = 5.0
b = 10.0
a + b = 15.0
a/b = 0.5
placeholder specifies a location, but the value in it is uncertain. A data type needs to be written in it.
During iteration, the data format is the same every time, but the value after each operation is changing. You can fix a data type and shape first and transfer data. The assignment is performed at the same time.
(similar to digging a pit and buying a radish of different sizes)
input1 = tf.placeholder(tf.float32) input2 = tf.placeholder(tf.float32) output = tf.multiply(input1, input2) with tf.Session() as sess: print(sess.run([output], feed_dict={input1:[7.], input2:[2.]}))
[array([ 14.], dtype=float32)]
3. Implement linear regression algorithm
Find the best line to fit the data in the data
3.1 generating samples
import numpy as np import tensorflow as tf import matplotlib.pyplot as plt # Randomly generate 1000 points around the line y=0.1x+0.3 num_points = 1000 vectors_set = [] for i in range(num_points): x1 = np.random.normal(0.0, 0.55) y1 = x1 * 0.1 + 0.3 + np.random.normal(0.0, 0.03) vectors_set.append([x1, y1]) # Generate some samples x_data = [v[0] for v in vectors_set] y_data = [v[1] for v in vectors_set] plt.scatter(x_data,y_data,c='r') plt.show()
3.2 training model
# Generate a 1dimensional W matrix, and the value is a random number between [ 1,1] W = tf.Variable(tf.random_uniform([1], 1.0, 1.0), name='W') # Generate a 1dimensional b matrix with an initial value of 0 b = tf.Variable(tf.zeros([1]), name='b') # The estimated value y is calculated y = W * x_data + b # Estimated value y and actual value y_ The mean square error between data is taken as the loss loss = tf.reduce_mean(tf.square(y  y_data), name='loss') # The gradient descent method is used to optimize the parameters optimizer = tf.train.GradientDescentOptimizer(0.5) # The training process is to minimize this error value train = optimizer.minimize(loss, name='train') sess = tf.Session() init = tf.global_variables_initializer() sess.run(init) # What are the initialized W and b print ("W =", sess.run(W), "b =", sess.run(b), "loss =", sess.run(loss)) # Perform 20 workouts for step in range(20): sess.run(train) # Output trained W and b print ("W =", sess.run(W), "b =", sess.run(b), "loss =", sess.run(loss)) #writer = tf.train.SummaryWriter("./tmp", sess.graph)
W = [ 0.96539688] b = [ 0.] loss = 0.297884
W = [ 0.71998411] b = [ 0.28193575] loss = 0.112606
W = [ 0.54009342] b = [ 0.28695393] loss = 0.0572231
W = [ 0.41235447] b = [ 0.29063231] loss = 0.0292957
W = [ 0.32164571] b = [ 0.2932443] loss = 0.0152131
W = [ 0.25723246] b = [ 0.29509908] loss = 0.00811188
W = [ 0.21149193] b = [ 0.29641619] loss = 0.00453103
W = [ 0.17901111] b = [ 0.29735151] loss = 0.00272536
W = [ 0.15594614] b = [ 0.29801565] loss = 0.00181483
W = [ 0.13956745] b = [ 0.29848731] loss = 0.0013557
W = [ 0.12793678] b = [ 0.29882219] loss = 0.00112418
W = [ 0.11967772] b = [ 0.29906002] loss = 0.00100743
W = [ 0.11381286] b = [ 0.29922891] loss = 0.000948558
W = [ 0.10964818] b = [ 0.29934883] loss = 0.000918872
W = [ 0.10669079] b = [ 0.29943398] loss = 0.000903903
W = [ 0.10459071] b = [ 0.29949448] loss = 0.000896354
W = [ 0.10309943] b = [ 0.29953739] loss = 0.000892548
W = [ 0.10204045] b = [ 0.29956791] loss = 0.000890629
W = [ 0.10128847] b = [ 0.29958954] loss = 0.000889661
W = [ 0.10075447] b = [ 0.29960492] loss = 0.000889173
W = [ 0.10037527] b = [ 0.29961586] loss = 0.000888927
plt.scatter(x_data,y_data,c='r') plt.plot(x_data,sess.run(W)*x_data+sess.run(b)) plt.show()
4.Mnist handwriting recognition data set
Datasets from tensorflow
import numpy as np import tensorflow as tf import matplotlib.pyplot as plt from tensorflow.examples.tutorials.mnist import input_data print ("Winner Winner Chicken Dinner")
Winner Winner Chicken Dinner
Download dataset
print ("Downloading~Don't rush") mnist = input_data.read_data_sets('data/', one_hot=True) print print (" Type is %s" % (type(mnist))) print (" Training data are %d" % (mnist.train.num_examples)) print (" Test data are %d" % (mnist.test.num_examples))
The label of the dataset is defined as an onehot encoding format. Under the 10 categories of 09, it is only 1 under the current dataset and 0 in other locations.
When doing classification tasks, the final result is the probability of different categories. The category with the highest probability of acquisition.
Batch
n. A batch; The amount of a batch of (food, medicine, etc.); Batch;
v. Batch processing;
[other] plural: batches
Take batch data and obtain batch data in the data set for training each time
5. Tensorflow logistic regression classification task
Import data
Set parameters, set the number of categories, specify the input format, specify the number of iterations, and specify the number of batch es for each iteration
placeholder specifies the size of x and y, and None specifies any data format
Parameter initialization, W1 represents the weight parameter matrix, which is the matrix of [784 * 10], and the matrix of B1 bit [10,]
Construction model
Construct the predicted value y of logistic regression_ pred
Judge the accuracy of training, and judge whether the prediction is correct by whether the position is the same
Iterative calculation
test result