0.3 alpha

Author: snowkylin

.gitignore

@@ -1,6 +1,9 @@
 .vscode
+book
 build
 reference
 teaching
 workspace.code-workspace
+source/.vscode
+source/_future
 source/_static/code/.idea

make_singlehtml.bat

@@ -0,0 +1 @@
+make singlehtml

source/_static/code/basic/eager/1plus1.py

@@ -0,0 +1,14 @@
+import tensorflow as tf
+tf.enable_eager_execution()
+
+a = tf.constant(1)
+b = tf.constant(1)
+c = tf.add(a, b)    # 也可以直接写 c = a + b，两者等价
+
+print(c)
+
+A = tf.constant([[1, 2], [3, 4]])
+B = tf.constant([[5, 6], [7, 8]])
+C = tf.matmul(A, B)
+
+print(C)

source/_static/code/basic/eager/grad.py

@@ -0,0 +1,17 @@
+import tensorflow as tf
+tf.enable_eager_execution()
+
+x = tf.get_variable('x', shape=[1], initializer=tf.constant_initializer(3.))
+with tf.GradientTape() as tape:     # 在 tf.GradientTape() 的上下文内，所有计算步骤都会被记录以用于求导
+    y = tf.square(x)
+y_grad = tape.gradient(y, x)        # 计算y关于x的导数
+print([y.numpy(), y_grad.numpy()])
+
+X = tf.constant([[1., 2.], [3., 4.]])
+y = tf.constant([[1.], [2.]])
+w = tf.get_variable('w', shape=[2, 1], initializer=tf.constant_initializer([[1.], [2.]]))
+b = tf.get_variable('b', shape=[1], initializer=tf.constant_initializer([1.]))
+with tf.GradientTape() as tape:
+    L = 0.5 * tf.reduce_sum(tf.square(tf.matmul(X, w) + b - y))
+w_grad, b_grad = tape.gradient(L, [w, b])        # 计算L(w, b)关于w, b的偏导数
+print([L.numpy(), w_grad.numpy(), b_grad.numpy()])

source/_static/code/basic/eager/regression.py

@@ -0,0 +1,19 @@
+import tensorflow as tf
+tf.enable_eager_execution()
+
+X = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+y = tf.constant([[10.0], [20.0]])
+
+w = tf.get_variable('w', shape=[3, 1], initializer=tf.zeros_initializer())
+b = tf.get_variable('b', shape=[1], initializer=tf.zeros_initializer())
+variables = [w, b]
+
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
+
+for i in range(100):
+    with tf.GradientTape() as tape:
+        y_pred = tf.matmul(X, w) + b
+        loss = tf.reduce_mean(tf.square(y_pred - y))
+    grads = tape.gradient(loss, variables)
+    optimizer.apply_gradients(grads_and_vars=zip(grads, variables))
+print(variables)

source/_static/code/basic/example/numpy.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+X_raw = np.array([2013, 2014, 2015, 2016, 2017])
+y_raw = np.array([12000, 14000, 15000, 16500, 17500])
+
+X = (X_raw - X_raw.min()) / (X_raw.max() - X_raw.min())
+y = (y_raw - y_raw.min()) / (y_raw.max() - y_raw.min())
+
+a, b = 0, 0
+
+num_epoch = 10000
+learning_rate = 1e-3
+for e in range(num_epoch):
+    # 手动计算损失函数关于自变量（模型参数）的梯度
+    y_pred = a * X + b
+    grad_a, grad_b = (y_pred - y).dot(X), (y_pred - y).sum()
+
+    # 更新参数
+    a, b = a - learning_rate * grad_a, b - learning_rate * grad_b
+
+print(a, b)

source/_static/code/basic/example/python.py

@@ -0,0 +1,38 @@
+a = 0
+b = 0
+
+def f(x):
+    y_pred = a * x + b
+    return y_pred
+
+def loss(x, y):
+    l = (a * x + b - y) ** 2
+    return l
+
+def gradient_loss(x, y):
+    g_a = 2 * (a * x + b - y) * x
+    g_b = 2 * (a * x + b - y)
+    return g_a, g_b
+
+X_raw = [2013, 2014, 2015, 2016, 2017]
+Y_raw = [12000, 14000, 15000, 16500, 17500]
+x_pred_raw = 2018
+X = [(x - min(X_raw)) / (max(X_raw) - min(X_raw)) for x in X_raw]
+Y = [(y - min(Y_raw)) / (max(Y_raw) - min(Y_raw)) for y in Y_raw]
+
+num_epoch = 10000
+learning_rate = 1e-3
+for e in range(num_epoch):
+    for i in range(len(X)):
+        x, y = X[i], Y[i]
+        g_a, g_b = gradient_loss(x, y)
+        a = a - learning_rate * g_a
+        b = b - learning_rate * g_b
+print(a, b)
+for i in range(len(X)):
+    x, y = X[i], Y[i]
+    print(f(x), y)
+x_pred = (x_pred_raw - min(X_raw)) / (max(X_raw) - min(X_raw))
+y_pred = f(x_pred)
+y_pred_raw = y_pred * (max(Y_raw) - min(Y_raw)) + min(Y_raw)
+print(x_pred_raw, y_pred_raw)

source/_static/code/basic/example/tensorflow.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+X_raw = np.array([2013, 2014, 2015, 2016, 2017])
+y_raw = np.array([12000, 14000, 15000, 16500, 17500])
+
+X = (X_raw - X_raw.min()) / (X_raw.max() - X_raw.min())
+y = (y_raw - y_raw.min()) / (y_raw.max() - y_raw.min())
+
+import tensorflow as tf
+
+# 定义数据流图
+learning_rate_ = tf.placeholder(dtype=tf.float32)
+X_ = tf.placeholder(dtype=tf.float32, shape=[5])
+y_ = tf.placeholder(dtype=tf.float32, shape=[5])
+a = tf.get_variable('a', dtype=tf.float32, shape=[], initializer=tf.zeros_initializer)
+b = tf.get_variable('b', dtype=tf.float32, shape=[], initializer=tf.zeros_initializer)
+
+y_pred = a * X_ + b
+loss = tf.constant(0.5) * tf.reduce_sum(tf.square(y_pred - y_))
+
+# 反向传播，手动计算变量（模型参数）的梯度
+grad_a = tf.reduce_sum((y_pred - y_) * X_)
+grad_b = tf.reduce_sum(y_pred - y_)
+
+# 梯度下降法，手动更新参数
+new_a = a - learning_rate_ * grad_a
+new_b = b - learning_rate_ * grad_b
+update_a = tf.assign(a, new_a)
+update_b = tf.assign(b, new_b)
+
+train_op = [update_a, update_b] 
+# 数据流图定义到此结束
+# 注意，直到目前，我们都没有进行任何实质的数据计算，仅仅是定义了一个数据图
+
+num_epoch = 10000
+learning_rate = 1e-3
+with tf.Session() as sess:
+    # 初始化变量a和b
+    tf.global_variables_initializer().run()
+    # 循环将数据送入上面建立的数据流图中进行计算和更新变量
+    for e in range(num_epoch):
+        sess.run(train_op, feed_dict={X_: X, y_: y, learning_rate_: learning_rate})
+    print(sess.run([a, b]))

source/_static/code/basic/example/tensorflow_autograd.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+X_raw = np.array([2013, 2014, 2015, 2016, 2017])
+y_raw = np.array([12000, 14000, 15000, 16500, 17500])
+
+X = (X_raw - X_raw.min()) / (X_raw.max() - X_raw.min())
+y = (y_raw - y_raw.min()) / (y_raw.max() - y_raw.min())
+
+import tensorflow as tf
+
+learning_rate_ = tf.placeholder(dtype=tf.float32)
+X_ = tf.placeholder(dtype=tf.float32, shape=[5])
+y_ = tf.placeholder(dtype=tf.float32, shape=[5])
+a = tf.get_variable('a', dtype=tf.float32, shape=[], initializer=tf.zeros_initializer)
+b = tf.get_variable('b', dtype=tf.float32, shape=[], initializer=tf.zeros_initializer)
+
+y_pred = a * X_ + b
+loss = tf.constant(0.5) * tf.reduce_sum(tf.square(y_pred - y_))
+
+# 反向传播，利用TensorFlow的梯度下降优化器自动计算并更新变量（模型参数）的梯度
+train_op = tf.train.GradientDescentOptimizer(learning_rate=learning_rate_).minimize(loss)
+
+num_epoch = 10000
+learning_rate = 1e-3
+with tf.Session() as sess:
+    tf.global_variables_initializer().run()
+    for e in range(num_epoch):
+        sess.run(train_op, feed_dict={X_: X, y_: y, learning_rate_: learning_rate})
+    print(sess.run([a, b]))

source/_static/code/basic/example/tensorflow_eager.py

@@ -0,0 +1,32 @@
+import tensorflow as tf
+import tensorflow.contrib.eager as tfe
+tfe.enable_eager_execution()
+import numpy as np
+
+X_raw = np.array([2013, 2014, 2015, 2016, 2017], dtype=np.float32)
+y_raw = np.array([12000, 14000, 15000, 16500, 17500], dtype=np.float32)
+
+X = (X_raw - X_raw.min()) / (X_raw.max() - X_raw.min())
+y = (y_raw - y_raw.min()) / (y_raw.max() - y_raw.min())
+
+X = tf.constant(X)
+y = tf.constant(y)
+
+a = tfe.Variable(0., name='a')
+b = tfe.Variable(0., name='b')
+
+num_epoch = 10000
+learning_rate = 1e-3
+for e in range(num_epoch):
+    # 前向传播
+    y_pred = a * X + b
+    loss = 0.5 * tf.reduce_sum(tf.square(y_pred - y)) # loss = 0.5 * np.sum(np.square(a * X + b - y))
+
+    # 反向传播，手动计算变量（模型参数）的梯度
+    grad_a = tf.reduce_sum((y_pred - y) * X)
+    grad_b = tf.reduce_sum(y_pred - y)
+
+    # 更新参数
+    a, b = a - learning_rate * grad_a, b - learning_rate * grad_b
+
+print(a, b)

source/_static/code/basic/example/tensorflow_eager_autograd.py

@@ -0,0 +1,31 @@
+import numpy as np
+import tensorflow as tf
+import tensorflow.contrib.eager as tfe
+tf.enable_eager_execution()
+
+X_raw = np.array([2013, 2014, 2015, 2016, 2017], dtype=np.float32)
+y_raw = np.array([12000, 14000, 15000, 16500, 17500], dtype=np.float32)
+
+X = (X_raw - X_raw.min()) / (X_raw.max() - X_raw.min())
+y = (y_raw - y_raw.min()) / (y_raw.max() - y_raw.min())
+
+X = tf.constant(X)
+y = tf.constant(y)
+
+a = tf.get_variable('a', dtype=tf.float32, shape=[], initializer=tf.zeros_initializer)
+b = tf.get_variable('b', dtype=tf.float32, shape=[], initializer=tf.zeros_initializer)
+variables = [a, b]
+
+num_epoch = 10000
+optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-3)
+for e in range(num_epoch):
+    # 使用tf.GradientTape()记录损失函数的梯度信息
+    with tf.GradientTape() as tape:
+        y_pred = a * X + b
+        loss = 0.5 * tf.reduce_sum(tf.square(y_pred - y))
+    # TensorFlow自动计算损失函数关于自变量（模型参数）的梯度
+    grads = tape.gradient(loss, variables)
+    # TensorFlow自动根据梯度更新参数
+    optimizer.apply_gradients(grads_and_vars=zip(grads, variables))
+
+print(a, b)

source/_static/code/basic/graph/1plus1.py

@@ -0,0 +1,10 @@
+import tensorflow as tf
+
+# 定义一个“计算图”
+a = tf.constant(1)  # 定义一个常量Tensor（张量）
+b = tf.constant(1)
+c = a + b  # 等价于 c = tf.add(a, b)，c是张量a和张量b通过Add这一Operation（操作）所形成的新张量
+
+sess = tf.Session()     # 实例化一个Session（会话）
+c_ = sess.run(c)        # 通过Session的run()方法对计算图里的节点（张量）进行实际的计算
+print(c_)

source/_static/code/basic/graph/AmatmulB.py

@@ -0,0 +1,9 @@
+import tensorflow as tf
+
+A = tf.ones(shape=[2, 3])   # tf.ones(shape)定义了一个形状为shape的全1矩阵
+B = tf.ones(shape=[3, 2])
+C = tf.matmul(A, B)
+
+sess = tf.Session()
+C_ = sess.run(C)
+print(C_)

source/_static/code/basic/graph/aplusb.py

@@ -0,0 +1,12 @@
+import tensorflow as tf
+
+a = tf.placeholder(dtype=tf.int32)  # 定义一个占位符Tensor
+b = tf.placeholder(dtype=tf.int32)
+c = a + b
+
+a_ = input("a = ")  # 从终端读入一个整数并放入变量a_
+b_ = input("b = ")
+
+sess = tf.Session()
+c_ = sess.run(c, feed_dict={a: a_, b: b_})  # feed_dict参数传入为了计算c所需要的张量的值
+print("a + b = %d" % c_)

source/_static/code/basic/graph/grad.py

@@ -0,0 +1,10 @@
+import tensorflow as tf
+
+x = tf.Variable(initial_value=1.)
+y = tf.square(x)    # y = x ^ 2
+y_grad = tf.gradients(y, x)
+
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+y_, y_grad_ = sess.run([y, y_grad])
+print([y_, y_grad_])

source/_static/code/basic/graph/variable.py

@@ -0,0 +1,13 @@
+import tensorflow as tf
+
+a = tf.get_variable(name='a', shape=[])
+initializer = tf.assign(a, 0)   # tf.assign(x, y)返回一个“将张量y的值赋给变量x”的操作
+a_plus_1 = a + 1    # 等价于 a + tf.constant(1)
+plus_one_op = tf.assign(a, a_plus_1)
+
+sess = tf.Session()
+sess.run(initializer)
+for i in range(5):
+    sess.run(plus_one_op)                   # 对变量a执行加一操作
+    a_ = sess.run(a)                        # 获得变量a的值并存入a_
+    print(a_)

source/_static/code/basic/graph/variable_with_initializer.py

@@ -0,0 +1,12 @@
+import tensorflow as tf
+
+a = tf.get_variable(name='a', shape=[], initializer=tf.zeros_initializer)   # 指定初始化器为全0初始化
+a_plus_1 = a + 1
+plus_one_op = tf.assign(a, a_plus_1)
+
+sess = tf.Session()
+sess.run(tf.global_variables_initializer()) # 初始化所有变量
+for i in range(5):
+    sess.run(plus_one_op)
+    a_ = sess.run(a)
+    print(a_)

source/_static/code/extended/gpu/main.py

@@ -0,0 +1,16 @@
+import tensorflow as tf
+import os
+
+config = tf.ConfigProto()
+# config.gpu_options.allow_growth = True
+config.gpu_options.per_process_gpu_memory_fraction = 0.4
+tf.enable_eager_execution(config=config)
+
+A = tf.constant([[1, 2], [3, 4]])
+B = tf.constant([[5, 6], [7, 8]])
+C = tf.matmul(A, B)
+
+print(C)
+
+os.system('pause')
+