一报还一报

1.硕2023-赵妍-20230429-周报

计划：

1.毕业论文初稿还有部分未完成，正在补充和修改。
2.完成北京理工大学嵩天python教学课程（慕课）-第1周Python基本语法元素课件学习，以及相关python习题练习

完成量：

补充：
1.这周大部分时间花在了我的毕业论文上。本科学校安排5.7论文查重，毕业答辩5.15日开始，5.20前结束（我的具体答辩日期未定），所以毕业论文和毕业答辩比较赶，最近一直在赶毕业论文和毕业答辩的事情，争取尽快完成毕业设计，然后补学习深度学习和python基础的进度。
2.这周花了小部分时间学习了北京理工大学嵩天python教学课程（慕课）-第1周Python基本语法元素课件学习，以及相关python习题练习。这部分比较基础，已安装python环境和pycharm工具平台，练习主要在pycharm上面练习。
学习笔记：

实例1：温度转换

温度转换公式： ①C = (F-32)/1.8 ② F = C*1.8+32

# TempConvert.py
TempStr = input("请输入带有符号的温度值：")
if TempStr[-1] in ['F', 'f']:
    C = (eval(TempStr[0:-1]) - 32) / 1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C', 'c']:
    F = 1.8 * eval(TempStr[0:-1]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

（1）不用像c语言和java语言一样需要定义变量，也不需要定义变量的类型。且if else if else 变为if elif else，且else if（）{}变为 elif ：，用“：”替代；且句子末尾不需要加“；”但是严格注意缩进。
（2）eval（）函数是去掉最外层侧的引号，eval('123')将字符串变为整数123。
（3）变量名[值]表示数据的位置。 如题中 TempStr[-1] ,表示TempStr字符串中的最后一个数字。TempStr[0:-1]，表示TempStr字符串中第1个字符开始到最后一个字符结束（不含最后一个字符）。
在python中，数据方式排列的有两种。一种是正向递增。如数据S=12345，S[0]为1，S[2]为2。另一种是逆向递减,S[-1]为5，S[-2]为4.
举一反三：[0:]指取所有数据，[:-1]指取除了最后一个数据的所有数据。
（4）python的注释有两种。一种是单行注释，如#注释内容。第二种是多行注释，如'''注释内容'''。（在pycharm中快捷键ctrl+？/仍然适用）
（5）in表示该数据是否匹配in之后的[ ]的数据。
（6）{:.2f}有两种含义，{}表示将format（f）一个占位符，而：.2f表示将该数据取两位小数保留。
练习题：
1.对于示例1：举一反三
1）标识改变放在温度数值之前：C82.F28
修改TempStr[-1]改为TempStr[0]；修改eval(TempStr[0:-1])改为eval(TempStr[1:])

# demo1.py
#input C82
TempStr = input("请输入带有符号的温度值：")
if TempStr[0] in ['F', 'f']:
    C = (eval(TempStr[1:]) - 32) / 1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[0] in ['C', 'c']:
    F = 1.8 * eval(TempStr[1:]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

2）标识改变放在温度数值之前：82Ce.28Fa
修改TempStr[-1]改为TempStr[-2:]；修改eval(TempStr[0:-1])改为eval(TempStr[0:-2])

# demo1.py
#input 82Ce
TempStr = input("请输入带有符号的温度值：")
if TempStr[-2:] in ["FA", "Fa", "fa"]:
    C = (eval(TempStr[0:-2]) - 32) / 1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-2:] in ["Ce", "ce", "CE"]:
    F = 1.8 * eval(TempStr[0:-2]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

2.根据半径r计算圆面积

#CalCircle.py
r = 25
area = 3.1415 * r * r
print(area)
print("{:.2f}".format(area))

3.绘制一个五角星

#StarDraw.py
from turtle import *

color('red', 'red')
begin_fill()
for i in range(5):
    fd(200)
    rt(144)
end_fill()
done()

4.绘制多个同切圆

#TangentCirclesDraw.py
import turtle

turtle.pensize(2)
turtle.circle(10)
turtle.circle(40)
turtle.circle(80)
turtle.circle(160)

2.硕2023-赵妍-20230506-周报

计划：

1.毕业论文初稿已定稿。
2.完成北京理工大学嵩天python教学课程（慕课）-第3周Python基本语法元素课件学习，以及相关python习题练习
3.《百度架构师手把手带你零基础实践深度学习》学习深度学习入门课程课节1：第一章：零基础入门深度学习（上）

完成量：

补充：
1.毕业论文:本科学校安排5.7论文查重，毕业答辩5.15日开始，5.20前结束（我的具体答辩日期未定），我已经提交了毕业论文初稿给指导老师，但是到目前为止，我还没有收到他的回复。此外我向去年的毕业设计同学询问了毕业设计的要求，了解到需要制作答辩PPT和答辩演示视频。然而，具体的要求还没有明确说明，大概下周才会告诉我们更细节的信息。
2.在深度学习框架中，通常包括数据处理、模型设计、训练配置、训练过程和模型保存这五个步骤。在本周的波士顿房价预测案例中，我们已经掌握了数据处理的方法。然而，对于后面的几个步骤，我还不是很明白。因此，下周我们打算结合零基础入门深度学习（中）课程中的梯度下降课程示例进行学习，并补充波士顿房价预测的学习笔记。
学习笔记：

1.人工智能、机器学习、深度学习的关系

人工智能是一种广义的概念，包括了许多技术和方法，机器学习是其中之一，而深度学习则是机器学习的一个分支。因此，深度学习是机器学习的一部分，而机器学习是人工智能的一部分。（分支分支）

2.一些基本概念的解释

(1)损失函数（损失Loss)：衡量模型预测值和真实值差距的评价函数
(2)神经网络的基本概念（如神经元、多层连接、前向计算、计算图）
①　神经元：经网络中每个节点称为神经元，由两部分组成：加权和：将所有输入加权求和；非线性变换（激活函数）：加权和的结果经过一个非线性函数变换，让神经元计算具备非线性的能力。
②　多层连接： 大量这样的节点按照不同的层次排布，形成多层的结构连接起来，即称为神经网络。
③　前向计算： 从输入计算输出的过程，顺序从网络前至后。
④　计算图： 以图形化的方式展现神经网络的计算逻辑又称为计算图，也可以将神经网络的计算图以公式的方式表达：
神经网络它的本质是一个含有很多参数的“大公式”。
(3)模型结构三要素（模型假设、评价函数和优化算法），下面示例中有具体用到，可参考，就可以知晓含义。

3.NumPy库中一些常用的数学函数和多维数组操作

导入包：import numpy as np
注：加粗表示在下面的波士顿房价预测的示例中有具体用到
功能 函数或方法

4.机器学习

举例：牛顿第二定律实验
(1)多次实验，给定多组 实验数据 ：作用力x，加速度y
(2)根据实验数据猜测y=x*w（w为待定参数，即为模型参数），即完成模型假设
(3)想要对猜测的关系式进行优化。寻找最优之前，我们需要先定义什么是最优，即评价一个Y~X关系的好坏的指标，即完成评价函数
(4)寻找最优解的方法，找到w=1/m，可能最接近即为优化算法
将以上步骤简化为三个阶段
(1)假设：通过观察加速度a和作用力F的观测数据，假设a和F是线性关系，即a=w⋅F
(2)评价：对已知观测数据上的拟合效果好，即w⋅F计算的结果要和观测的a尽量接近。
(3)优化：在参数w的所有可能取值中，发现w=1/m可使得评价最好（最拟合观测样本）。

5.深度学习

(1)深度学习相比传统的机器学习算法，两者在理论结构上是一致的，即模型假设、评价函数和优化算法，区别在于假设的复杂度。
(2)深度学习框架的出现，是指一类用于实现深度学习模型的软件库或工具包，其中包含了许多用于定义、训练和评估深度学习模型的函数、工具和接口。深度学习框架的出现，大大降低了深度学习模型的开发门槛，提高了开发效率和模型性能。
(3)常见的深度学习框架：

(4)不同场景的深度学习模型具备一定的通用性，五个步骤即可完成模型的构建和训练即数据处理、模型设计、训练配置、训练过程、模型保存。通过波士顿房价预测来举例描述以上步骤。

数据处理包含五个部分：数据导入、数据形状变换、数据集划分、数据归一化处理和封装load data函数。数据预处理后，才能被模型调用。
举例：波士顿房价预测
描述：波士顿房价预测是一个经典的机器学习任务，类似于程序员世界的“Hello World”。和大家对房价的普遍认知相同，波士顿地区的房价受诸多因素影响。该数据集统计了13种可能影响房价的因素和该类型房屋的均价，期望构建一个基于13个因素进行房价预测的模型。
①　假设：因为房价是一个连续值，所以房价预测显然是一个回归任务，可用简单的线性回归模型解决，预测y和x关系表达式如

②　评价：线性回归模型使用均方误差作为损失函数（Loss），用以衡量预测房价和真实房价的差异，公式如下：

五个步骤即数据处理、模型设计、训练配置、训练过程、模型保存。
1)数据处理（数据导入、数据形状变换、数据集划分、数据归一化处理和封装load data函数）
①　数据导入：从文件housing.data读出data数据

import numpy as np 
import json  # 读入训练数据 
datafile = './work/housing.data'
data = np.fromfile(datafile, sep=' ') 
data

注：关于np.fromfile()函数用法：
它是NumPy库中用于从二进制文件中读取数据的函数。该函数可以从文件中读取数据，并返回一个NumPy数组。具体用法如下：
np.fromfile()函数从名为'data.bin'的二进制文件中读取数据，数据类型为np.float32。读取的数据被存储在一个NumPy数组中，并输出了数组的形状和元素类型。

import numpy as np
# 从二进制文件中读取数据，返回一个NumPy数组
data = np.fromfile('data.bin', dtype=np.float32)
# 输出数组的形状和元素类型
print(data.shape, data.dtype)

②　数据形状变换：读入的数据是一维数据，对数据的形状进行转变

# 这里对原始数据做reshape，变成N x 14的形式 
feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE','DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ] 
feature_num = len(feature_names)  #结果：14 
data = data.reshape([data.shape[0] // feature_num, feature_num])

这行代码使用 NumPy 的 reshape() 函数将 data 数组从一维数组转换为二维数组->（有几组，每组几个）
注：data.reshape([data.shape[0] // feature_num, feature_num])
新数组：
第一个维度的长度是 data.shape[0] // feature_num，其中 // 是整数除法运算符。因为 data 数组中的每个数据项都包含多个特征，因此除以 feature_num 可以得到数据集中的样本数量。data.开始为一维数组，data.shape[0] 为全部数据数。
第二个维度的长度为 feature_num，即每个样本的特征数量。这样，data 数组就被重构为一个二维数组，其中每一行都包含一个样本的所有特征。

（补充：需要注意的是，此代码假定 data 数组的长度是特征数量 feature_num 的整数倍。如果数据文件的最后一行包含不完整的数据，或者数据文件的格式与代码所期望的格式不匹配，可能会导致该代码无法正确执行。因此，在使用此代码之前，需要检查数据文件的格式是否正确，并确保代码中使用的特征数量与数据文件中的特征数量相匹配。）
③　数据集划分
将数据集划分成训练集和测试集，其中训练集用于确定模型的参数，测试集用于评判模型的效果。
④　数据归一化处理
对每个特征进行归一化处理，使得每个特征的取值缩放到0~1之间。归一化可以使得不同特征之间的值处于同一数量级，避免了某些特征对模型训练的影响过大。

# 计算train数据集的最大值，最小值 
maximums, minimums = \ training_data.max(axis=0), \ training_data.min(axis=0) 
# 对数据进行归一化处理 
for i in range(feature_num): data[:, i] = (data[:, i] - minimums[i]) / (maximums[i] - minimums[i])

这段代码的主要作用是对数据进行归一化处理。在归一化过程中，首先计算了训练数据集中每个特征的最大值和最小值，然后对所有数据进行归一化。具体来说，对于数据矩阵 data 的每一列（即每个特征），都执行以下操作：
a.从矩阵中选出该特征的所有值，然后计算该特征的最小值和最大值。这里使用 NumPy 的 max() 和 min() 函数来计算最大值和最小值，其中 axis=0 参数指示对每列进行操作。
b.对于该特征的每个数据点，将其减去最小值，再除以最大值和最小值的差，即可将数据归一化到 [0, 1] 的范围内。这里使用 NumPy 的广播机制来实现对所有数据点的操作。
⑤　封装load data函数

def load_data(): 
# 从文件导入数据 
datafile = './work/housing.data' 
data = np.fromfile(datafile, sep=' ') 

# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数 
feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \ 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ] 
feature_num = len(feature_names) 

# 将原始数据进行Reshape，变成[N, 14]这样的形状
data = data.reshape([data.shape[0] // feature_num, feature_num]) 

# 将原数据集拆分成训练集和测试集 
# 这里使用80%的数据做训练，20%的数据做测试
ratio = 0.8 
offset = int(data.shape[0] * ratio)
training_data = data[:offset]

 # 计算训练集的最大值，最小值 
maximums, minimums = training_data.max(axis=0), training_data.min(axis=0)

 # 对数据进行归一化处理
for i in range(feature_num): 
data[:, i] = (data[:, i] - minimums[i]) / (maximums[i] - minimums[i]) 

# 训练集和测试集的划分比例
training_data = data[:offset] 
test_data = data[offset:]
return training_data, test_data

2)模型设计
模型设计是深度学习模型关键要素之一，也称为网络结构设计，相当于模型的假设空间，即实现模型“前向计算”（从输入到输出）的过程。
3)训练配置
模型设计完成后，需要通过训练配置寻找模型的最优值，即通过损失函数来衡量模型的好坏。
4)训练过程
训练过程是深度学习模型的关键要素之一，其目标是让定义的损失函数Loss尽可能的小，也就是说找到一个参数解w和b，使得损失函数取得极小值。
梯度下降法（盲人下坡）：这种情况特别类似于一位想从山峰走到坡谷的盲人，他看不见坡谷在哪（无法逆向求解出Loss导数为0时的参数值），但可以伸脚探索身边的坡度（当前点的导数值，也称为梯度）。那么，求解Loss函数最小值可以这样实现：从当前的参数取值，一步步的按照下坡的方向下降，直到走到最低点。
5)模型保存
6.python的数据运算函数

3.硕2023-赵妍-20230508汇报（入组考核）

ppt：

稿子：

总结：
1.从人工智能、机器学习、深度学习的关系入手，深入了解了这些概念之间的联系
2.介绍机器学习课程例子——牛顿第二定律实验，引出机器学习的三个概念
3.介绍深度学习的入门例子——波士顿房价预测实验五个步骤
全文：
大家好，我叫赵妍，以下是我的一周学习汇报。
上周，我专注于学习深度学习的入门课程。从人工智能、机器学习、深度学习的关系入手，深入了解了这些概念之间的联系，这让我对深度学习有了更为全面和深刻的认识。通过机器学习课程例子——牛顿第二定律实验，学习了机器学习的过程，了解了机器学习中使用的一些重要概念。
接着，我进一步学习了深度学习的入门例子——波士顿房价预测实验。在这个实验中，通过五个步骤即可完成模型的构建和训练即数据处理、模型设计、训练配置、训练过程、模型保存，以及学会了使用python计算工具包-numpy。
首先，从人工智能、机器学习和深度学习三者关系出发。人工智能是一种广义的概念，包括了许多技术和方法，机器学习是其中之一，而深度学习则是机器学习的一个分支。因此，深度学习是机器学习的一部分，而机器学习是人工智能的一部分。理解它们之间的关系有助于我们更好地理解这些概念的本质和应用。
基于机器学习过程，根据牛顿第二定律实验的多组数据，我们得到了一个假设，即力F和加速度a可能存在线性关系，具体来说，F可能等于m乘以a。但是这也引发了我们的思考，为什么质量m和a的关系一定是线性的呢？为什么F和a的关系不会是类似于F等于a的正弦函数或者F等于a的平方函数之类的复杂关系呢？
这样的关系当然可以被假设，因为世界上存在着无数可能的关系。但是，漫无目的地尝试不同的Y和X之间的关系显然是非常低效的。因此，假设空间首先限定了一个模型能够表达的可能关系，如浅蓝色圆圈所示。机器学习的任务就是在这个假设圆圈内寻找最优的YX关系，即确定参数w。
那么，如何确定最优的YX关系呢？这就引入了机器学习中的重要概念——评价函数，也被称为损失函数。评价函数的作用是衡量模型预测值与真实值之间的差距，即Loss值越小，差距也就越小。因此，在假设圈定的范围内，寻找使损失函数最小的Y~X关系，这个寻找最优解的方法被称为优化算法。
从上述过程可以得出，机器学习的过程与学习牛顿第二定律的过程基本相同，都分为模型假设、评价函数和优化算法三个阶段。
深度学习和传统机器学习算法的理论结构基本相同，但两者的区别在于所假设的模型复杂度不同。深度学习引入了神经网络模型，使其可以处理更复杂的问题，如计算机视觉、自然语言处理和语音识别等。因此，深度学习在这些领域中的表现比传统机器学习算法更为优秀，这也是深度学习的诞生原因。
同样，在不同的场景中使用深度学习模型时，有着一定的通用性，包含五个主要步骤。包含数据处理、模型设计、训练配置、训练过程、模型保存。
波士顿房价预测实验是一个经典的机器学习任务，旨在通过建立一个基于13个因素进行房价预测的模型来预测波士顿地区的房价。由于房价是一个连续值，所以房价预测显然是一个回归任务。在这个任务中，我们使用线性回归模型来建立预测模型，其中，y表示房价，x表示13个因素的值，w是模型的权重，b是模型的偏置。
为了确定模型的权重和偏置，我们需要定义一个损失函数来评估模型的预测值与实际值之间的误差。常用的损失函数为均方误差函数，其中，n表示样本数量，y则表示实际房价和模型的预测房价。我们的目标是找到最优的权重w和偏置b，使得损失函数的值最小化，即让模型的预测结果尽可能地接近真实值。
根据深度学习的五个步骤，首先需要进行数据处理，其中数据处理可以分为五个模块。
第一步是读入数据，可以使用NumPy库中的fromfile()函数，该函数可以从二进制文件中读取数据，并返回一个NumPy数组。
第二步是进行数据形状变换，因为原始数据是1维的，所以需要使用NumPy的reshape()函数将数据数组从一维数组转换为二维数组，从而形成一个2维的矩阵。其中，reshape()函数的第一个参数代表矩阵的行数，第二个参数代表矩阵的列数。
第三步是将数据集划分为训练集和测试集，其中训练集用于确定模型的参数，测试集用于评估模型的效果。
第四步是对每个特征进行数据归一化处理，使得每个特征的取值都缩放到0~1之间。归一化处理可以使得不同特征之间的值处于同一数量级，避免某些特征对模型训练的影响过大。在这一步中，可以使用NumPy的max()和min()函数来计算每列数据的最大值和最小值，其中axis=0参数表示对每列进行操作。使用NumPy的广播机制，可以将数据归一化处理到[0, 1]的范围内，实现对所有数据点的操作。
最后一步是将上述数据处理操作封装成load data函数，以便下一步模型的调用。
根据深度学习的五个步骤，其次是进行模型设计。前面我们提到，波士顿房价预测实验使用了线性回归模型。现在我们需要根据w、b和影响因素值x，来生成预测房价y。其中，权重w和偏置b是模型的参数，需要通过训练来确定。在这个示例中，我们使用了random函数来生成随机的初始权重w的值，以上是他的一些使用方法，然后使用了dot函数来实现点乘积运算，并将该计算方法封装成了forward函数。
根据深度学习的五个步骤，接下来是进行训练配置。线性回归模型一般使用均方误差函数作为损失函数。在前面的步骤中，我们已经使用forward函数计算了房价的预测值。现在需要计算损失值，可以使用numpy库中的mean函数计算数组的平均值。以下是mean函数的一些常见用法示例。
在深度学习的五个步骤中，下一步是训练过程。训练过程是通过反向传播算法来更新模型参数，以最小化损失函数的过程。在这个过程中，通常使用一种叫做随机梯度下降的优化算法来更新参数。随机梯度下降算法可以看做是盲人下坡法的一种应用。
在随机梯度下降算法中，每个训练样本都可以看作是山上的一个点，而损失函数就是山的高度。我们需要通过梯度的方向来判断下一步应该往哪个方向更新参数，就像盲人根据脚下的坡度来判断下一步该往哪个方向走一样。因为每个训练样本的梯度都不同，所以我们每次只使用一个样本来更新参数，而不是使用所有样本的平均梯度。
总结来说，深度学习的过程包括数据处理、模型设计、训练、验证和模型保存等五个步骤。数据处理和模型设计的目的是为了获得更好的输入数据和更适合任务的模型，而训练的目的是寻找合适的参数使得损失函数最小化，这也是深度学习最重要的一步。总体来说，深度学习和机器学习的过程有很多相似之处，但深度学习通过深层次的神经网络可以更好地处理复杂的数据和任务。
以上是我本周的学习汇报，感谢聆听。

4.硕2023-赵妍-20230513-周报

计划：

1.毕业论文定稿且查重已通过、毕设答辩ppt已完成、毕设演示视频已完成。
2.《百度架构师手把手带你零基础实践深度学习》学习深度学习入门课程课节2：第一章：零基础入门深度学习（中）+课节3：第一章：零基础入门深度学习（下）
3.科技论文课学习笔记

完成量：

补充：
1.这周大部分时间花在了我的毕业论文上。本科学校安排5.7论文查重，毕业答辩5.15日开始，5.20前结束（我的具体答辩日期未定），所以毕业论文和毕业答辩比较赶，最近一直在赶毕业论文和毕业答辩的事情，争取尽快完成毕业设计，然后补学习深度学习和python基础的进度。
2.这周花了小部分时间学习了北京理工大学嵩天python教学课程（慕课）-第1周Python基本语法元素课件学习，以及相关python习题练习。这部分比较基础，已安装python环境和pycharm工具平台，练习主要在pycharm上面练习。
学习笔记：
1.北京理工大学嵩天python教学课程（慕课）的基础课程最近看了第三章后就基本上没在看了，主要花时间在学习深度学习的课程，但深度学习课程内出现的python知识点基本上也能看懂。本周和下周（周三前）可能还得花点时间在毕设答辩上，之后再把北京理工大学嵩天python教学课程（慕课）的基础课程这些补上。
2.在上周林华同学的组会上，他分享了关于最近论文中单词积累方面的学习。毕设答辩结束后，我计划学习有关英文论文表达的相关方面。虽然目前我还没有具体安排时间，但我会在后续尽快安排时间进行学习。
本周学习笔记主要如下：

1.波士顿房价预测实验

前情回顾：
描述：波士顿房价预测是一个经典的机器学习任务，类似于程序员世界的“Hello World”。和大家对房价的普遍认知相同，波士顿地区的房价受诸多因素影响。该数据集统计了13种可能影响房价的因素和该类型房屋的均价，期望构建一个基于13个因素进行房价预测的模型。
①　假设：因为房价是一个连续值，所以房价预测显然是一个回归任务，可用简单的线性回归模型解决，预测y和x关系表达式如

②　评价：线性回归模型使用均方误差作为损失函数（Loss），用以衡量预测房价和真实房价的差异，公式如下：

不同场景的深度学习模型具备一定的通用性，五个步骤即可完成模型的构建和训练即数据处理、模型设计、训练配置、训练过程、模型保存。通过波士顿房价预测来举例描述以上步骤。

本周内容：
1)数据处理（在上周周报）
补：
归一化目的？
特征输入归一化后，不同参数输出的Loss是一个比较规整的曲线，学习率可以设置成统一的值 ；
特征输入未归一化时，不同特征对应的参数所需的步长不一致，尺度较大的参数需要大步长，尺寸较小的参数需要小步长，导致无法设置统一的学习率。

损失函数用均方误差的好处？
a.平方使得曲线的最低点是可导的
b.越接近最低点，曲线的坡度逐渐放缓，有助于通过当前的梯度来判断接近最低点的程度（是否逐渐减少步长，以免错过最低点）。
2)模型设计
模型设计是深度学习模型关键要素之一，也称为网络结构设计，相当于模型的假设空间，即实现模型“前向计算”（从输入到输出）的过程。
即根据

线性回归模型公式，通过写一个forward函数（代表“前向计算”）完成上述计算过程。
①　函数：

def forward(self, x):
z = np.dot(x, self.w) + self.b
return z

②　调用：

net = Network(13)
x1 = x[0]
z = net.forward(x1)

3)训练配置
模型设计完成后，需要通过训练配置寻找模型的最优值，即通过损失函数来衡量模型的好坏。即根据

均方误差公式，通过写一个loss函数完成上述计算过程。
①　函数：

def loss(self, z, y):
   error = z - y
   cost = error * error
   cost = np.mean(cost)
   return cost

②　调用：

netnet = Network(13)
x1 = x[0:3]
y1 = y[0:3]
z = net.forward(x1)
loss = net.loss(z, y1)

4)训练过程
训练过程是深度学习模型的关键要素之一，其目标是让定义的损失函数Loss尽可能的小，也就是说找到一个参数解w和b，使得损失函数取得极小值。
梯度下降法（盲人下坡）：这种情况特别类似于一位想从山峰走到坡谷的盲人，他看不见坡谷在哪（无法逆向求解出Loss导数为0时的参数值），但可以伸脚探索身边的坡度（当前点的导数值，也称为梯度）。那么，求解Loss函数最小值可以这样实现：从当前的参数取值，一步步的按照下坡的方向下降，直到走到最低点。
①　得出计算梯度公式：gradient_w = (z1 - y1) * x1

#计算w的梯度
z = net.forward(x)
gradient_w = (z - y) * x
gradient_w = np.mean(gradient_w, axis=0)
gradient_w = gradient_w[:, np.newaxis]
gradient_w
#计算b的梯度
gradient_b = (z - y)
gradient_b = np.mean(gradient_b)
# 此处b是一个数值，所以可以直接用np.mean得到一个标量
gradient_b

②　梯度更新
只要沿着梯度反方向走一小步，下一个点的损失函数就会减少了。即
net.w = net.w- eta * gradient_w
a.相减：参数需要向梯度的反方向移动。
b.eta：控制每次参数值沿着梯度反方向变动的大小，即每次移动的步长，又称为学习率。
并由梯度下降法的概念引入随机梯度下降法。一个合理的解决方案是每次从总的数据集中随机抽取出小部分数据来代表整体，基于这部分数据计算梯度和损失来更新参数，这种方法被称作随机梯度下降法（Stochastic Gradient Descent，SGD），核心概念如下：
a.mini-batch：每次迭代时抽取出来的一批数据被称为一个mini-batch。
b.batch_size：一个mini-batch所包含的样本数目称为batch_size。
c.epoch：当把整个数据集都遍历到了的时候，则完成了一个epoch。
因为分成了一组一组，所以需要将这些组打乱，引入np.random.shuffle函数。
注：关于np.random.shuffle()函数用法：

# 新建一个array
a = np.array([1,2,3,4,5,6,7,8,9,10,11,12])
print('before shuffle', a) #[ 1  2  3  4  5  6  7  8  9 10 11 12]
np.random.shuffle(a)
print('after shuffle', a)#[ 7  2 11  3  8  6 12  1  4  5 10  9]

他虽然会打乱数据，但是它之打乱第0维。
5)模型保存
Numpy提供了save接口，可直接将模型权重数组保存为.npy格式的文件。

np.save('w.npy', net.w)
np.save('b.npy', net.b)

6)最终代码实现

import numpy as np

class Network(object):
    def __init__(self, num_of_weights):
        # 随机产生w的初始值
        # 为了保持程序每次运行结果的一致性，此处设置固定的随机数
        self.w = np.random.randn(num_of_weights, 1)
        self.b = 0.
        
    def forward(self, x):#前向计算
        z = np.dot(x, self.w) + self.b
        return z
    
    def loss(self, z, y):#均方误差计算
        error = z - y
        num_samples = error.shape[0]
        cost = error * error
        cost = np.sum(cost) / num_samples
        return cost
    
    def gradient(self, x, y):#计算梯度
        z = self.forward(x)
        N = x.shape[0]
        gradient_w = 1. / N * np.sum((z-y) * x, axis=0)
        gradient_w = gradient_w[:, np.newaxis]
        gradient_b = 1. / N * np.sum(z-y)
        return gradient_w, gradient_b
    
    def update(self, gradient_w, gradient_b, eta = 0.01):#更新梯度方向
        self.w = self.w - eta * gradient_w
        self.b = self.b - eta * gradient_b
                       
    def train(self, training_data, num_epochs, batch_size=10, eta=0.01):#训练
        n = len(training_data)
        losses = []
        for epoch_id in range(num_epochs):
            # 在每轮迭代开始之前，将训练数据的顺序随机打乱
            # 然后再按每次取batch_size条数据的方式取出
            np.random.shuffle(training_data)
            # 将训练数据拆分，每个mini_batch包含batch_size条的数据
            mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
            for iter_id, mini_batch in enumerate(mini_batches):
                #print(self.w.shape)
                #print(self.b)
                x = mini_batch[:, :-1]
                y = mini_batch[:, -1:]
                a = self.forward(x)
                loss = self.loss(a, y)
                gradient_w, gradient_b = self.gradient(x, y)
                self.update(gradient_w, gradient_b, eta)
                losses.append(loss)
                print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.
                                 format(epoch_id, iter_id, loss))
        
        return losses

# 获取数据
train_data, test_data = load_data()
# 创建网络
net = Network(13)
# 启动训练
losses = net.train(train_data, num_epochs=50, batch_size=100, eta=0.1)

# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

2.使用飞桨实现波士顿房价预测任务（部分）

(1)飞桨支持两种深度学习建模编写方式
更方便调试的动态图模式和性能更好并便于部署的静态图模式。
①　动态图模式（命令式编程范式，类比Python）：解析式的执行方式。
②　静态图模式（声明式编程范式，类比C++）：先编译后执行的方式。
(2)导入必要的包

import paddle #核心框架
import paddle.fluid as fluid#paddle框架
import paddle.fluid.dygraph as dygraph#动态模式
from paddle.fluid.dygraph import Linear#导入全连接
import os#系统库，主要用于文件操作
import random
import numpy as np
from matplotlib import pyplot as plt

(3)数据导入

def load_data_s(datafile,feature_num,n):
    '''
    导入数据
    datafile(数据文件路径)
    feature_num(特征数量)
    n(划分比率)
    '''
    #导入数据
    data=np.fromfile(datafile,sep=' ')
    #改变数据的形状(N,14)
    data=data.reshape(data.shape[0]//feature_num,feature_num)
    #数据归一化
    maxnums=data.max(axis=0)
    minnums=data.min(axis=0)
    avgs = data.sum(axis=0)/data.shape[0]
    #定义全局变量
    global max_values
    global min_values
    global avg_values
    max_values=maxnums
    min_values=minnums
    avg_values = avgs
    
    for i in range(feature_num):
        data[:,i]=(data[:,i]-minnums[i])/(maxnums[i]-minnums[i])
    #数据集的划分(训练集和测试集)
    offset=int(data.shape[0]*n)
    train_data=data[:offset]
    test_data=data[offset:]

    return train_data,test_data

(4)模型设计、训练配置、训练过程、保存模型（下周补充）

3.科技论文笔记

(1)分区介绍

(2)论文结构

Title->Abstract->Introduction->Relate ->work->Methodology->Experiments->Conclusions
1)标题（Title）
例子：A knowledge-guide hierarchical learning method for long-tailed image classification
研究内容：A knowledge-guide hierarchical learning method
核心技术：knowledge-guide hierarchical
适用场景：long-tailed image classification
2)摘要（Abstract）

1.研究内容和应用领域
2.However：指出不足，
3.In this paper：提出本文的方法
4.对比实验
3)引言（Introduction）
1.第一段：研究内容和现状
2.第二段：介绍已有方法（国内外研究现状），引出本文的方法
3.第三段：介绍本文方法 （Firstly Secondly Finally）
4.第四段：本文所做出的贡献（逐点给出）
5.第五段：本文接下来的介绍
4)相关工作（Relate work）
是摘要中国内外研究现状的扩展版，与引言中有相并进行拓展
5)模型方法（Methodology）
1.构造层次超类树（Constructing Hierarchical Superclass Tree）
2.分层学习模型（Hierarchical-learning model）
3.学习策略（Learning strategy）
6)实验（Experiments）
1、实验数据集（Datasets）
介绍数据集，介绍了几种数据集，并给出表格直观体现。
2、对比方法（Comparison methods）
3、评估指标（Evaluation metrics）
4、实验设置（Experimental setups）
5、主要结果（Main results）
6、消融实验（Ablation study）
消融实验（Ablation Study）是一种常用于研究领域的实验方法，通常用于评估模型中每个组成部分的贡献，或者通过排除某些组成部分来确定其对系统性能的影响。
在消融实验中，研究者会对一个系统或模型进行多次实验，每次实验都会移除系统中的某个组成部分或修改某个参数，然后比较这些实验的结果，以确定每个组成部分的贡献以及哪些部分对系统性能的影响最大。
通过消融实验，研究者可以更深入地了解系统或模型的内部结构和机制，进一步优化系统或模型的设计，并提高其性能。
7、超类的效能（Effect of superclasses）
8、深入分析（Further analysis）
7)结论（Conclusions）
本文工作+实验结果+未来工作
8)参考文献

(3)其他笔记

在科技论文中，公式通常是作为一个完整的句子或一段话的一部分出现的，因此，公式后面应该加上逗号或句号，使文章更加完整。具体要看公式所在的上下文和语境来决定是否需要逗号或句号，一般而言：
如果公式是在一句话的结尾，那么应该在公式后面加上逗号。
例如：
我们的模型可以表示为：
f(x) = Wx + b,
如果公式是一个完整的句子，则应在公式后面加上句号。
例如：由此，我们可以得到以下公式：
P(A|B) = P(B|A)P(A) / P(B).
请注意，这只是一般规则，具体情况还需要根据上下文和语境来判断。在论文写作中，尽量避免使用过多的公式，以免影响文章的可读性。

5.硕2023-赵妍-20230520-周报

计划：

完成量：

补充：

学习笔记：