第一个小例子：

import tensorflow as tf
import numpy as np

## 创建测试数据
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3

###----------创建结构开始----------###
# 搭建模型
Weights = tf.Variable(tf.random_uniform([1],-1,1.0))
biases = tf.Variable(tf.zeros([1]))

y = x_data * Weights + biases

# 计算误差
loss = tf.reduce_mean(tf.square(y-y_data))

# 反向传递，优化权重和偏置
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

###----------创建结构结束----------###

# 初始化结构
init = tf.global_variables_initializer()
# 获取Session
sess = tf.Session()
# 用Session进行初始化
sess.run(init)

# 开始训练
for step in range(201):
    sess.run(train)
    # 每20步输出权重和偏置
    if step%20 == 0:
        print(step,sess.run(Weights),sess.run(biases))

第二个例子：

import tensorflow as tf

# 定义两个常量
matrix1 = tf.constant([[3,3]])
matrix2 = tf.constant([[2],[2]])

# 乘法操作
product = tf.matmul(matrix1,matrix2)

# 方式1
sess = tf.Session()
result = sess.run(product)
print(result)
sess.close()

# 方式2
# with tf.Session() as sess:
# result = sess.run(product)
# print(result)

第三个例子：

import tensorflow as tf

# 定义一个变量，初始化是0
state = tf.Variable(0,name='content')

# 定义一个常量
one = tf.constant(1)

# 定义加法步骤
new_value = tf.add(state,one)

# 将state 更新成 new_value
update = tf.assign(state,new_value)

# 初始化所定义的变量
init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    for step in range(3):
        sess.run(update)
        print(sess.run(state))

第四个例子：

import tensorflow as tf

#在 Tensorflow 中需要定义 placeholder 的 type ，一般为 float32 形式
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

# mul = multiply 是将input1和input2 做乘法运算，并输出为 output
ouput = tf.multiply(input1,input2)

with tf.Session() as sess:
    print(sess.run(ouput,feed_dict={input1:[7.],input2:[2.]}))

第五个例子

import tensorflow as tf

#在 Tensorflow 中需要定义 placeholder 的 type ，一般为 float32 形式
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

# mul = multiply 是将input1和input2 做乘法运算，并输出为 output
ouput = tf.multiply(input1,input2)

with tf.Session() as sess:
    print(sess.run(ouput,feed_dict={input1:[7.],input2:[2.]}))

第六个例子

import tensorflow as tf
import numpy as np

# 添加神经层封装函数
def add_layer(inputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_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

# 构建所需的数据
x_data = np.linspace(-1,1,300, dtype=np.float32)[:, np.newaxis]
noise = np.random.normal(0, 0.05, x_data.shape).astype(np.float32)
y_data = np.square(x_data) - 0.5 + noise

# 定义占位符输入变量
xs = tf.placeholder(tf.float32, [None, 1])
ys = tf.placeholder(tf.float32, [None, 1])

############### 搭建网络 ###############

# 输入层1个，隐藏层10个，激励函数relu
l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)

# 输输入层10个，输出层1个，无激励函数
prediction = add_layer(l1, 10, 1, activation_function=None)

# 计算预测值prediction和真实值的误差，对二者差的平方求和再取平均。
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                     reduction_indices=[1]))

# 接下来，是很关键的一步，如何让机器学习提升它的准确率。
# tf.train.GradientDescentOptimizer()中的值通常都小于1，
# 这里取的是0.1，代表以0.1的效率来最小化误差loss。
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# 初始化
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

# 比如这里，我们让机器学习1000次。机器学习的内容是train_step,
# 用 Session 来 run 每一次 training 的数据，逐步提升神经网络的预测准确性。
# (注意：当运算要用到placeholder时，就需要feed_dict这个字典来指定输入。)
for i in range(1000):
    # training
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
        # 每50步我们输出一下机器学习的误差。
        print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))