sigmoid+交叉熵为什么更好，这是困扰了我大半天的问题，网上所有的教程都直接给出了最后一步的结果，我手推了好久，终于醒悟，下面附上详细的推导过程：
我们定义并简化一下公式：

1、网络的最后一层输出为：$z=(Wx^{}+b)$其中W为权重，b为偏置，严格来说里面的参数都是矩阵，不过我们计算就当作单独的参数，过程是一样的。

2、我们需要在输出后面加上sigmoid损失函数：

$a = g(z)=Sigmoid(z)=\frac{1}{1+e^{-z}}$

3、上式的a就是我们最终的输出值，与期望的输出值y，也就是真实值，共同计算损失函数。这里我们使用交叉熵损失函数：

$L=CE(a,y)=-[y\ln a+(1-y)\ln(1-a)]$
好了，这就是正向传播的一个输出，我们目的是反向传播得到W和b的梯度$\frac{\partial L}{\partial W}$,$\frac{\partial L}{\partial b}$由于$\frac{\partial L}{\partial W}=\frac{\partial L}{\partial z}*x$ ,$\frac{\partial L}{\partial b}=\frac{\partial L}{\partial z}$，所以我们就直接求$\frac{\partial L}{\partial z}$。
首先，把z代入最后的损失函数里面,式中g(z)就是sigmoid激活函数：$L=CE(g(z),y)=-[y\ln g(z)+(1-y)\ln(1-g(z))]$

对z求偏导：

$\frac{\partial L}{\partial z}=-[\frac{y*g'(z)}{g(z)}+\frac{-(1-y)*g'(z)}{(1-g(z))}]$

里面两项合并：

$\frac{\partial L}{\partial z}=-[\frac{y*g'(z)*(1-g(z))-(1-y)*g'(z)*g(z))}{g(z)*(1-g(z))}]$

展开，合并之后，得到：

$\frac{\partial L}{\partial z}=\frac{(g(z)-y)*g'(z)}{g(z)*(1-g(z))}$

之前推到这一步，就进展不下去了。但是sigmoid还有一个重要的性质，那就是sigmoid函数的导数,$Sigmoid'(x)=Sigmoid(x)*(1-Sigmoid(x))$，我们这里的g(z)函数就是Sigmoid，仔细看一下，这个式子的分母，$g(z)*(1-g(z))=g'(z)$

所以最后得到的公式为：$\frac{\partial L}{\partial z}=g(z)-y$

使用sigmoid+交叉熵的计算过程，就可以完全省去计算Sigmoid梯度这一步，从而避免了Sigmoid本身弥散的致命缺点。

损失函数求最小，求方差的最小，和求均方差的最小应该都是一个作用吧。为啥用sum就得不到结果呢，用mean就可以。不理解

import tensorflow.compat.v1 as tf
import numpy as np

# 使用 NumPy 生成假数据(phony data), 总共 100 个点.
x_data = np.float32(np.random.rand(2, 100)) # 随机输入
y_data = np.dot([0.100, 0.200], x_data) + 0.300

# 构造一个线性模型
#
b = tf.Variable(tf.zeros([1]))
W = tf.Variable(tf.random.uniform([1, 2], -1.0, 1.0))
y = tf.matmul(W, x_data) + b

# 最小化方差
loss = tf.reduce_mean(tf.square(y - y_data)) #这里，为什么用mean呢，用sum就出不来结果，得到很多[nan]

optimizer = tf.train.GradientDescentOptimizer(0.2)
train = optimizer.minimize(loss)

# 初始化变量
init = tf.global_variables_initializer()

# 启动图 (graph)
sess = tf.Session()
sess.run(init)

# 拟合平面
for step in range(0, 201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(W), sess.run(b))

数据库查询数据，在使用聚集函数时，代码中执行之后即使没有数据，rs中也会有数据，注：在数据库中执行该sql时是没有数据的，不知道为什么在java代码中会有，我当时使用的聚集函数是sum(),没有数据的部分都显示为0，也就是有了数据。所以用rs.next()判断时就一直为真，导致程序运行出错。

为什么要用async/await

单纯地使用promise对象+then的形式顺序执行，代码使用起来并不优雅，需要一种更接近传统语法的形式
异步请求axios的API都是返回的promise对象

基本用法

async 关键字用于函数上（async函数的返回值是Promise实例对象所以要用then得到返回值）
await 关键字用于async函数当中，接在promise对象前面可以得到reslove或者reject的结果

        var sum=0
        function time(num){
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    sum=sum+num
                    resolve(sum)
                }, 1000);
            })
        }
        async function test() {
            var num1 = await time(2)
            var num2 = await time(num1)
            var num3 = await time(num2)
            console.log(num3);
        }
        test()
    // 结果
    // 8


可以看到通过await可以不用then直接的得到Promise对象resolve的结果
同时代码是从上往下执行更符合传统的语法更优雅
如果想要得到async函数return的结果

var sum=0
        function time(num){
            return new Promise(function (resolve, reject) {
                setTimeout(function () {
                    sum=sum+num
                    resolve(sum)
                }, 1000);
            })
        }
        async function test() {
            var num1 = await time(2)
            var num2 = await time(num1)
            var num3 = await time(num2)
            return num3
        }
        console.log(test());
        // 结果
        // Promise {<pending>}


可以看到打印还是promise对象，所以要用then得到结果

test().then(function(res){
            console.log(res);
        })
        // 结果
        // 8

总结

async/await更像是promise对象的语法糖