自己开发了一个股票智能分析软件，功能很强大，需要的点击下面的链接获取：
https://www.cnblogs.com/bclshuai/p/11380657.html
1.1 tensorflow2.x自动求导
1.1.1 自动求导GradientTape类
GradientTape的作用就是用于自动求导，需要有自变量x和因变量y，调用gradient（y，x）就可以求导，在GradientTape定义的上下文中，会默认观察自变量x，并进行记录，需要占用内存等资源，所以可以精确指定观察变量，减少资源。自变量可以是多个，gradient（y，[x,p,g]） ,计算的结果就是多个变量的张量组合。也可以通过嵌套的方式实现高阶求导。
1.1.2 GradientTape类定义
class GradientTape(object):
（1）初始化构造函数
def __init__(self, persistent=False, watch_accessed_variables=True):
#persistent变量，默认情况下，调用一次求导之后，GradientTape所持有的资源就会被释放，不能再执行，如果需要持续求导，persistent默认为False,，也就是g只能调用一次，如果指定persistent为true，则可以多次求导。
#watch_accessed_variables，是否要指定观察的变量，默认为True，默认观察并记录上下文中的自变量，g.watch(x)可以不写，自动观察求导中的变量。如果要对监视变量进行精细控制，可以通过将watch_accessed_variables = False传递给tape，手动指定观察变量，避免全部观察记录，减少不必要的资源消耗。
实例
x = tf.Variable(2.0)
w = tf.Variable(5.0)
with tf.GradientTape(
watch_accessed_variables=False, persistent=True) as tape:
tape.watch(x)
y = x ** 2 # Gradients will be available for `x`.
z = w ** 3 # No gradients will be available as `w` isn't being watched.
dy_dx = tape.gradient(y, x)
print(dy_dx)
# No gradients will be available as `w` isn't being watched.
dz_dy = tape.gradient(z, w)
print(dz_dy)
（2）进入和退出函数
输入一个上下文，在该上下文中将操作记录在此tape上
def __enter__(self):
退出记录上下文，不再跟踪其他操作
def __exit__(self, typ, value, traceback):
（3）观察变量函数
指定观察变量，默认自动观察求导自变量，watch_accessed_variables = False时才需要手动指定。
def watch(self, tensor):
（1） 停止在tape上记录操作
暂时停止在该tape上进行记录操作。此上下文管理器处于活动状态时执行的操作不会记录在tape上。这对于减少通过跟踪所有计算而使用的内存很有用。
def stop_recording(self):
实例：
import tensorflow as tf
x = tf.Variable(4.0)
with tf.GradientTape(persistent=True) as tape:
y = tf.pow(x, 2)
z=tape.gradient(y,x)
#with tape.stop_recording():# The gradient computation below is not traced, saving memory.
y+=x
dy_dx = tape.gradient(y, x)
print(z)
print(dy_dx)
输出结果：
tf.Tensor(8.0, shape=(), dtype=float32)
tf.Tensor(9.0, shape=(), dtype=float32)
如果加上stop_recording
import tensorflow as tf
x = tf.Variable(4.0)
with tf.GradientTape(persistent=True) as tape:
y = tf.pow(x, 2)
z=tape.gradient(y,x)
with tape.stop_recording():# The gradient computation below is not traced, saving memory.
y+=x
dy_dx = tape.gradient(y, x)
print(z)
print(dy_dx)
输出结果为
tf.Tensor(8.0, shape=(), dtype=float32)
None
可见stop_recording作用是停止记录变量的计算，不记录结果。求导结果为None；
（2） 重置求导记录函数
清除此tape中存储的所有信息。等效于退出并重新进入tape上下文管理器。
def reset(self):
import tensorflow as tf
x=tf.Variable(initial_value=[1.,2.,3,])
with tf.GradientTape() as t:
loss = tf.pow(x,2)
with tf.GradientTape() as t:
loss += x;
z=t.gradient(loss, x) # Only differentiates other_loss_fn, not loss_fn
print(z)
# The following is equivalent to the above
with tf.GradientTape() as t:
loss = tf.pow(x,2)#调用了reset，这里的记录会被清除
#t.reset()注释，loss=x*x+x,不注释，会将x*x的记录清除，loss=x
loss += x
z=t.gradient(loss, x) # Only differentiates other_loss_fn, not loss_fn
print(z)
输出结果
tf.Tensor([1. 1. 1.], shape=(3,), dtype=float32)# 调用reset清除记录x*x
tf.Tensor([3. 5. 7.], shape=(3,), dtype=float32)# 不清除x*x
（6）返回观察的变量
该函数监视要求导的变量，可以是一个tensor[x]，也可以是多个参数组成的列表[x,y],如果watch_accessed_variables定义为True，则可以不调用该函数，可以自动求导。
def watched_variables(self):
（7）求导函数
def gradient(self,
target,# 求导的函数y,可以理解为要求导的因变量y
sources,# 要对哪一个自变量x求导，可以是多个组合
output_gradients=None,求导后输出结果乘以的系数
unconnected_gradients=UnconnectedGradients.NONE):# 它是一个可选参数，有两个值，“none”和“zero”，none是它的默认值，表示当我们的target（因变量y）与sources（自变量x）之间没有关系时，返回NONE
（8）雅克比矩阵
在向量微积分中，雅可比矩阵是一阶偏导数以一定方式排列成的矩阵。
def jacobian(self,
target, #求导的函数y,可以理解为要求导的因变量y
sources,自变量x，维度大于等于2的张量
unconnected_gradients=UnconnectedGradients.NONE,
parallel_iterations=None,# 控制并行调度的迭代次数，可以用来控制总的内存使用量
experimental_use_pfor=True):
实例
with tf.GradientTape() as g:
x = tf.constant([[1., 2.], [3., 4.]], dtype=tf.float32)
g.watch(x)
y = x * x#一阶导数是2*x
batch_jacobian = g.batch_jacobian(y, x)
# batch_jacobian is [[[2, 0], [0, 4]], [[6, 0], [0, 8]]]
1.1.3 自动求导的步骤
（1）创建一个GradientTape对象：g=tf.GradientTape()
（2）监视watch要求导的变量：g.watch(x)
（3）对函数进行求导：g.gredient(y,x)
1.1.4 自动求导实例
（1）高阶导数嵌套实例
先初始化一个变量，然后定义变量的函数，然后用tf.GradientTape()求一阶导数和二阶导数。
import tensorflow as tf
#定义并初始化变量
x=tf.Variable(initial_value=[[1.,2.,3.],[4.,5.,6.]])
#创建GradientTape对象
with tf.GradientTape() as g1:
#指定观察变量
# g1.watch(x)
with tf.GradientTape(persistent=True) as g2:#嵌套高阶求导
# g2.watch(x)
y=x*x
z=tf.sqrt(y+1)
y1=g2.gradient(y,x)#一阶导数
z1x=g2.gradient(z,x)#z对于x的导数，因为g2的persistent参数设置为true，所以可以调用两次，否则报错。
y2=g1.gradient(y1,x)#二阶导数
print(y)
print(y1)
print(y2)
print(z1x)
输出结果：
tf.Tensor(
[[ 1. 4. 9.]
[16. 25. 36.]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[ 2. 4. 6.]
[ 8. 10. 12.]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[2. 2. 2.]
[2. 2. 2.]], shape=(2, 3), dtype=float32)
tf.Tensor(
[[0.70710677 0.8944272 0.94868326]
[0.97014254 0.9805807 0.9863939 ]], shape=(2, 3), dtype=float32)
（2）多变量和输出系数求导实例
import tensorflow as tf
x = tf.Variable(initial_value=[1.0, 2.0, 3.0])
y = tf.Variable(initial_value=[2.0, 4.0, 6.0])
with tf.GradientTape(persistent=True) as g:
g.watch(x)
g.watch(y)
z = tf.pow(x, 2) + tf.pow(y, 2)
output_gradients = tf.Variable([0.2, 0.6, 0.2])#输出结果相乘的系数
dz = g.gradient(z, [x, y], output_gradients=output_gradients) # 给每一个元素施加不同的权重
print(dz)
'''运行结果为：
[<tf.Tensor: id=64, shape=(3,), dtype=float32, numpy=array([0.4, 2.4, 1.2],
dtype=float32)>,
<tf.Tensor: id=40, shape=(3,), dtype=float32, numpy=array([0.8, 4.8, 2.4],
dtype=float32)>]
'''
'''
本来的结果是dz_dx=[2,4,6], 分别乘以权重[0.2,0.6,0.2]之后，得到[0.4,2.4,1.2]
本来的结果是dz_dy=[4,8,12],分别乘以权重[0.2,0.6,0.2]之后，得到[0.8,4.8,2.4]
'''
1.1.5 参考文献
https://dengbocong.blog.csdn.net/article/details/108044938
https://blog.csdn.net/qq_27825451/article/details/89556703
https://tensorflow.google.cn/api_docs/python/tf/GradientTape#reset