预备知识
tf.where(条件语句，A，B)
条件语句真返回A，假返回B
import tensorflow as tf
a=tf.constant([1,2,3,1,1])
b=tf.constant([0,1,3,4,5])
c=tf.where(tf.greater(a,b),a,b)
print(c)
运行结果：
tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)
np.random.RandomState.rand(维度)
返回一个[0,1）之间的随机数，维度为空返回标量
import numpy as np
rdm=np.random.RandomState(seed=1)
a=rdm.rand()
b=rdm.rand(2,3)
print(a)
print(b)
运行结果：
0.417022004702574
[[7.20324493e-01 1.14374817e-04 3.02332573e-01]
[1.46755891e-01 9.23385948e-02 1.86260211e-01]]
np.vstack(数组1，数组2)
将两个数组按垂直方向叠加
import numpy as np
a=np.array([1,2,3])
b=np.array([4,5,6])
c=np.vstack(（a,b）)
print(c)
运行结果：
[[1 2 3]
[4 5 6]]
np.mgrid[] .ravel() np.c_[]
np.mgrid[起始值：结束值：步长，起始值：结束值：步长，...]【起始值，结束值）
x.ravel()将x变为一维数组
np.c_[数组1，数组2，...]使返回的间隔数值点配对
import numpy as np
x,y=np.mgrid[1:3:1,2:4:0.5]
grid=np.c_[x.ravel(),y.ravel()]
print(x)
print(y)
print(grid)
运行结果：
[[1. 1. 1. 1.]
[2. 2. 2. 2.]]
[[2. 2.5 3. 3.5]
[2. 2.5 3. 3.5]]
[[1. 2. ]
[1. 2.5]
[1. 3. ]
[1. 3.5]
[2. 2. ]
[2. 2.5]
[2. 3. ]
[2. 3.5]]
复杂度学习率
神经网络复杂度
空间复杂度：
层数=隐藏层的层数+1个输出层（输入层不算）
总参数=总w+总b
时间复杂度：
乘加运算次数（权重线个数）
学习率
指数衰减学习率
可以先用较大的学习率，快速得到较优解，然后逐步减小学习率，使模型在训练后期稳定
指数衰减学习率=初始学习率×学习率衰减率^(当前轮数/多少轮衰减一次)
; 激活函数
首选relu激活函数；
学习率设置较小值；
输入特征标准化（让输入特征满足以0为均值，1为标准差的正态分布）；
初始参数中心化（让随机生成的参数满足以0为均值，sqrt(2/当前层输入特征个数)为标准差的正态分布）。
sigmoid函数
tf.nn.sigmoid(x)
; Tanh函数
tf.nn.tanh(x)
Relu函数
tf.nn.relu(x)
避免产生过多负特征
; Leaky Relu函数
tf.nn.leaky_relu(x)
损失函数
预测值（y）与已知答案（y_）的差距
优化目标：损失最小
均方误差
mse:tf.reduce_mean(tf.square(y_-y))
自定义损失函数
交叉熵损失函数CE（cross entropy）
表征两个概率分布之间的距离（分类）
tf.losses.categorical_crossentropy(y_,y)
softmax与交叉熵结合
输出先过softmax函数，再计算y与y_的交叉熵损失函数
tf.nn.softmax_cross_entropy_with_logits(y_,y)
缓解过拟合
; 欠拟合解决方法
增加输入特征项
增加网络参数
减少正则化参数
过拟合解决方法
数据清洗
增大训练集
采用正则化
增大正则化参数
正则化缓解过拟合
正则化在损失函数中引入模型复杂度指标，利用给W加权值，弱化了训练数据的噪声。
loss=loss(y与y_)+regularizer×loss(w)
正则化的选择
L1（|w|,tf.nn.l1_loss(w)）正则化大概率会使很多参数变为零，因此该方法可通过稀疏参数，即减少参数的数量，降低复杂度
L2(|w^2|,tf.nn.l2_loss(w))正则化会使参数很接近零但不为零，因此该方法可通过减小参数值的大小降低复杂度
优化器
神经网络参数优化器
待优化参数w，损失函数loss，学习率lr，每次迭代一个batch，t表示当前batch迭代的总次数：
- 计算t时刻损失函数关于当前参数的梯度gt=dloss/dwt
- 计算t时刻一阶动量（与梯度相关的函数）mt和二阶动量（与梯度平方相关的函数）Vt
- 计算t时刻下降梯度nt=lr×mt/sqrt(Vt)
- 计算t+1时刻参数：wt+1=wt-nt=wt-lr×mt/sqrt(Vt)
SGD(无momentum),常用的梯度下降法
w1.assign_sub(lr*grads[0])
b1.assign_sub(lr*grads[1])
SGDM(含momentum的SGD)，在SGD基础上增加一阶动量
m_w,m_b=0,0
beta=0.9
m_w=beta*m_w+(1-beta)*grads[0]
m_b=beta*m_b+(1-beta)*grads[1]
w1.assign_sub(lr*m_w)
b1.assign_sub(lr*m_b)
Adagrad，在SGD基础上增加二阶动量
v_w,v_b=0,0
v_w+=tf.square(grads[0])
v_b+=tf.square(grads[1])
w1.assign_sub(lr*grads[0]/tf.sqrt(v_w))
b1.assign_sub(lr*grads[1]/tf.sqrt(v_b))
RMSProp,SGD基础上增加二阶动量
v_w,v_b=0,0
beta=0.9
v_w=beta*v_w+(1-beta)*tf.square(grads[0])
v_b=beta*v_b+(1-beta)*tf.square(grads[1])
w1.assgn_sub(lr*grads[0]/tf.sqrt(v_w))
b1.assign_sub(lr*grads[1]/tf.sqrt(v_b))
Adam,同时结合SGDM一阶动量和RMSProp二阶动量
import tensorflow as tf
from sklearn import datasets
from matplotlib import pyplot as plt
import numpy as np
import time
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]
x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
lr = 0.1
train_loss_results = []
test_acc = []
epoch = 500
loss_all = 0
m_w, m_b = 0, 0
v_w, v_b = 0, 0
beta1, beta2 = 0.9, 0.999
delta_w, delta_b = 0, 0
global_step = 0
now_time = time.time()
for epoch in range(epoch):
for step, (x_train, y_train) in enumerate(train_db):
global_step += 1
with tf.GradientTape() as tape:
y = tf.matmul(x_train, w1) + b1
y = tf.nn.softmax(y)
y_ = tf.one_hot(y_train, depth=3)
loss = tf.reduce_mean(tf.square(y_ - y))
loss_all += loss.numpy()
grads = tape.gradient(loss, [w1, b1])
m_w = beta1 * m_w + (1 - beta1) * grads[0]
m_b = beta1 * m_b + (1 - beta1) * grads[1]
v_w = beta2 * v_w + (1 - beta2) * tf.square(grads[0])
v_b = beta2 * v_b + (1 - beta2) * tf.square(grads[1])
m_w_correction = m_w / (1 - tf.pow(beta1, int(global_step)))
m_b_correction = m_b / (1 - tf.pow(beta1, int(global_step)))
v_w_correction = v_w / (1 - tf.pow(beta2, int(global_step)))
v_b_correction = v_b / (1 - tf.pow(beta2, int(global_step)))
w1.assign_sub(lr * m_w_correction / tf.sqrt(v_w_correction))
b1.assign_sub(lr * m_b_correction / tf.sqrt(v_b_correction))
print("Epoch {}, loss: {}".format(epoch, loss_all / 4))
train_loss_results.append(loss_all / 4)
loss_all = 0
total_correct, total_number = 0, 0
for x_test, y_test in test_db:
y = tf.matmul(x_test, w1) + b1
y = tf.nn.softmax(y)
pred = tf.argmax(y, axis=1)
pred = tf.cast(pred, dtype=y_test.dtype)
correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_correct += int(correct)
total_number += x_test.shape[0]
acc = total_correct / total_number
test_acc.append(acc)
print("Test_acc:", acc)
print("--------------------------")
total_time = time.time() - now_time
print("total_time", total_time)
plt.title('Loss Function Curve')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.plot(train_loss_results, label="$Loss$")
plt.legend()
plt.show()
plt.title('Acc Curve')
plt.xlabel('Epoch')
plt.ylabel('Acc')
plt.plot(test_acc, label="$Accuracy$")
plt.legend()
plt.show()
Original: https://blog.csdn.net/weixin_44918105/article/details/122843093
Author: JoengGaap
Title: Tensorflow2（2）
相关阅读
Title: 关系数据模型（三）——关系演算
目录
一、关系演算概述
1、集合的表示
列举法
描述法
2、关系的谓词表示
3、关系演算
4、元组关系演算
5、元组关系演算公式
二、关系演算——与关系代数的等价性
三、用元组关系演算实现查询
四、本讲小结
关系数据模型是目前大多数DBMS所采用的数据模型，包括关系数据结构、关系操作和关系完整性三个方面。
关系模型的数据结构非常简单，只包含单一的数据结构——关系。在用户看来，关系模型中数据的逻辑结构可用一张扁平的二维表来形象地表示。关系模型的数据结构虽然简单却能够表达丰富的语义，描述实体以及实体之间的各种联系。也就是说，在关系模型中，实体以及实体之间的联系均用单一的结构类型即关系来表示。
关系操作可用关系代数和关系演算来表达。关系代数是用对关系的运算来表达查询要求的和实现数据更新的。关系代数操作的一个序列构成一个关系代数表达式，其结果还是一个关系，来表示对数据库操作的结果。关系操作可以分为传统的集合运算和专门的关系运算，传统的集合运算主要包括：并、差、交、广义笛卡尔积，专门的关系运算主要包括：投影、选择、连接、除。其中选择、投影、并、差、广义笛卡尔积是五种基本操作，其他操作是可以用基本操作来定义和导出的。关系演算是用查询得到的元组应满足的谓词条件来表达查询要求的。根据参与运算的变元的不同，关系演算又分为元组关系演算和域关系演算。
关系操作的特点是集合操作方式，即操作的对象和结果都是集合，这种操作方式也称一次一集合（set-at-a-time）的方式。相应地，非关系数据模型的数据操作方式则为一次一记录（record-at-a-time）的方式。
关系模型的完整性规则是对关系的某种约束，也是关系的值随着时间变化时应该满足的一些约束条件。关系模型中有三类完整性约束：实体完整性，参照完整性，用户定义的完整性。
因此与其他数据模型相比，关系模型呈现如下突出的优点：
1．关系模型提供单一的数据结构形式，具有高度的简明性和精确性。各类用户都能很容易地掌握和运用基于关系数据模型的数据库系统，使得数据库应用开发的效率显著提高。
2．关系模型的逻辑结构和相应的操作完全独立于数据存储方式，具有高度的数据独立性。用户不必关心数据的物理存储细节。
3．关系模型使数据库理论的研究建立在坚实的数理逻辑基础上。关系运算的完备性和规范化设计理论为数据库技术的成熟奠定了基础。
4．关系数据库语言与谓词逻辑的内在联系，为以关系数据库为基础的推理系统和知识库系统的研究提供了方便，并成为新一代数据库技术不可缺少的基础。
Original: https://blog.csdn.net/L_zhai/article/details/118626970
Author: 冯诺依曼阿贝尔
Title: 关系数据模型（三）——关系演算