一、介绍
今天是这个系列《C++之 Opencv 入门到提高》得第五篇文章。这篇文章也不难，介绍如何图像的基本操作，比如：读取一张图片的像素值，如何修改一张图片中的像素值，如何读取一张图片，如何保存一张图片等等，这都是基础，为以后的学习做好铺垫。虽然操作很简单，但是背后有很多东西需要我们深究，才能做到知其然知其所以然。OpenCV 具体的简介内容，我就不多说了，网上很多，大家可以自行脑补。
OpenCV 的官网地址：
https://opencv.org/
，组件下载地址：
https://opencv.org/releases/
。
OpenCV 官网学习网站：
https://docs.opencv.ac.cn/4.10.0/index.html

我需要进行说明，以防大家不清楚，具体情况我已经罗列出来。
操作系统：Windows Professional 10（64位）
开发组件：OpenCV – 4.10.0
开发工具：Microsoft Visual Studio Community 2022 (64 位) - Current版本 17.8.3
开发语言：C++（VC16）

二、知识学习
这些都是图像的基本操作，所以并不会很难，但是这也是学好 openCV的基础。内容很简单，就不说过多的废话了，所有讲解都在代码的注释中。

1 #include <opencv2/opencv.hpp>
2 #include <iostream>
3 #include <math.h>
4 
5 using namespacestd;6 using namespacecv;7 
8 /// <summary>
9 ///图像的操作10 ///1、读写图像11 ///2、读写像素12 ///3、修改像素值13 /// </summary>
14 /// <returns></returns>
15 intmain()16 {17     //1、读写图像18     //1.1、imread 可以指定加载灰度或者 RGB 图像19     //1.2、imwrite 可以保存图像，类型由扩展名决定。
20 Mat src;21     src = imread("D:\\360MoveData\\Users\\Administrator\\Desktop\\TestImage\\demo-gril.png", IMREAD_UNCHANGED);22     if(src.empty())23 {24         cout << "图像加载失败！！！" <<endl;25         return -1;26 }27 
28     namedWindow("原图", WINDOW_AUTOSIZE);29     imshow("原图", src);30 
31     //2、读写像素32     //2.1、都一个灰度（Gray）像素的像素值（CV_8UC1）33     //Scalar intensity=src.at<uchar>(row,col);34     //Scalar intensity=src.at<uchar>(Point(row,col));35     // 
36     //2.2、读一个彩色（RGB）像素点的像素值。37     //Vec3f intensity=src.at<Vec3f>(row,col);38     //float blue=intensity.val[0];39     //float green=intensity.val[1];40     //float red=intensity.val[2];41     //
42     //Vec3f 就是 float 类型的 RGB 数据43     // 
44     //2.3、修改单通道灰度像素值45     //src.at<uchar>(row,col)=128;46     // 
47     //2.4、修改RGB 三通道像素值48     //src.at<Vec3b>(row,col)[0]=128;49     //src.at<Vec3b>(row,col)[1]=128;50     //src.at<Vec3b>(row,col)[2]=128;51     // 
52     //2.5、空白像素赋值53     //src=Scalar(0);54     // 
55     // 
56     //2.6、Vec3b 与 Vec3f57     //2.6.1、Vec3b 对应三通道的顺序是 blue,green,red 的 uchar 类型数据58     //2.6.2、Vec3f 对应三通道的顺序是 blue,green,red 的 float 类型数据59     //2.6.3、把 CV_8UC1 转换为 CV32F1 实现如下：src.convertTo(dst,CV_32F);60     // 
61     //2.1、读取单通道像素值，示例代码：
62 Mat graySrc;63     cvtColor(src, graySrc, COLOR_BGR2GRAY);//将彩色的 RGB 3 通道的转换为灰度单通道的图片。
64     namedWindow("单通道灰度图像", WINDOW_AUTOSIZE);65     imshow("单通道灰度图像", graySrc);66 
67     int width =graySrc.cols;68     int height =graySrc.rows;69 
70     for (int row = 0; row < height; row++)71 {72         for (int col = 0; col < width; col++)73 {74             //读取单通道、灰度的像素值
75             int gray = graySrc.at<uchar>(row, col);76             //修改单通道、灰度的像素值
77             graySrc.at<uchar>(row, col) = 255 -gray;78 }79 }80 
81     imshow("修改后单通道灰度图像", graySrc);//可以直接使用显示图像，他会自动创建显示图片的窗口。82 
83     //处理多通道、彩色的图像
84     width =src.cols;85     height =src.rows;86     int channes =src.channels();87 
88 Mat dst;89 dst.create(src.size(),src.type());90 
91     for (int row = 0; row < height; row++)92 {93         for (int col = 0; col < width; col++)94 {95             if (channes == 1)96 {97                 //读取单通道、灰度的像素值
98                 int gray = src.at<uchar>(row, col);99                 //修改单通道、灰度的像素值
100                 src.at<uchar>(row, col) = 255 -gray;101 }102             else
103 {104                 //读取多通道、彩色像素值。Vec3b 就是指具有3个通道的 BGR 的数据结构
105                 Vec3b myvalue=src.at<Vec3b>(row, col);106                 int b = myvalue.val[0];107                 int g = myvalue.val[1];108                 int r = myvalue.val[2];109 
110                 //修改多通道、彩色像素值,这是取反效果。
111                 /*dst.at<Vec3b>(row, col)[0] = 255 - b;112 dst.at<Vec3b>(row, col)[1] = 255 - g;113 dst.at<Vec3b>(row, col)[2] = 255 - r;*/
114 
115                 //修改多通道、彩色像素值,这是只包含蓝色和绿色，青就是色。
116                 /*dst.at<Vec3b>(row, col)[0] = b;117 dst.at<Vec3b>(row, col)[1] = g;118 dst.at<Vec3b>(row, col)[2] = 0;*/
119 
120                 //修改多通道、彩色像素值,这是只包含蓝色和红色，就是紫色。
121                 /*dst.at<Vec3b>(row, col)[0] = b;122 dst.at<Vec3b>(row, col)[1] = 0;123 dst.at<Vec3b>(row, col)[2] = r;*/
124 
125                 //修改多通道、彩色像素值,这是只包含绿色和红色，就是黄色。
126                 dst.at<Vec3b>(row, col)[0] = 0;127                 dst.at<Vec3b>(row, col)[1] =g;128                 dst.at<Vec3b>(row, col)[2] =r;129 
130                 //graySrc.at<uchar>(row, col) = min(r,min(b,g));取灰色第二个方法
131 }132 }133 }134 
135     imshow("修改后单、多通道图像", dst);//可以直接使用显示图像，他会自动创建显示图片的窗口。136     //imshow("单通道灰度图像", graySrc);137     //opencv 接口也可以实现这样反差的效果
138 bitwise_not(src, dst);139 
140     imshow("bitwise_not 修改后单、多通道图像", dst);//可以直接使用显示图像，他会自动创建显示图片的窗口。
141 
142     
143     waitKey(0);144 
145     system("pause");146     return 0;147 }

代码很简单，就不多说了。

效果如图：

以上就是图像修改后的效果图。


三、总结
这是 C++ 使用 OpenCV 的第五篇文章，其实也没那么难，感觉是不是还是很好入门的，那就继续。初见成效，继续努力。皇天不负有心人，不忘初心，继续努力，做自己喜欢做的，开心就好。

Jave Web是java面向web开发的相关技术，他是相关技术的统称，并不是指某一个单一的技术。
在我之前的博客中（Java网络编程----通过实现简易聊天工具来聊聊BIO模型 https://www.cnblogs.com/jilodream/p/17405923.htm），就已经写到过java可以作为一个服务器（如TCP/UDP），接收外部的请求。如使用TCP监听端口，然后直接用web页面请求该端口，那么服务器就会接收到相关的响应，接着做好业务处理，返回响应的请求即可。但是整个的业务流程太繁琐了。我们不但要处理业务流程，还要控制请求会话，还要控制各种业务分支的处理，显然这不是我们想要的。
于是聪明的开发者很快想到了-----解耦，业务人员只要编写相关的业务即可，不需要关心繁琐的网络细节处理，因此就诞生了servlet。开发人员只要实现servlet，而servlet和不同的路径绑定。web请求后，由系统直接转发到各自的Servlet，并由Servlet来处理相关业务即可。
那什么是servlet呢？servlet 是
Server Applet
（服务器应用程序）的简写，从名字我们就可以看出它是专门用来编写服务器端的应用程序。我们通常用它来处理服务器中http请求的处理和响应。
它是一项很古老的技术，随java诞生之初就已经问世，很多人甚至都不知Servlet是做什么。那么问题来了，我们为什么还要学习和掌握Servlet呢？这主要是由于Servlet是javaEE的重要组成，是java web开发的重要基石。我们现在项目中常用到的Jsp、Springmvc、Springboot等框架，在处理网络请求的核心技术，仍然是Servlet。我们虽然不需要再继续直面Servlet或更底层的技术进行开发，但是Servlet究竟是什么样的，如何执行，以及再新技术中承担什么样的角色，这个却是我们想要熟悉底层原理所必须要掌握的。

话不多说，想要使用Servlet，我们需要做两步：

1、编写Servlet相关业务代码
2、将业务代码打包放置在Tomcat中，由Tomcat来加载这些Servlet

第一步，试着来编写一个Servlet
我们首先通过IDEA 新建一个web项目，此处我们选择采用maven部署，搭建好之后项目整体的结构就如下面的文件层级树一样
了

E:.

├─.idea

├─.smarttomcat

│  └─PureJaveServlet

│      └─conf

└─src

    └─main

        ├─java

        │  └─org

        │      └─example

        ├─resources

        └─webapp

其中：

resources 一般是我们填写的资源信息，如图片，业务配置文件等，
webapp则会放置html、css等渲染文件，还会放一些web组件（Servlet、Filter）的配置信息。我们这里只要知道作用即可。
src/main/java则是我们的业务代码。值得注意的是，我们要引入Servlet网络编程的相关依赖包，才能进行相关的web开发。默认的java SE是不包含这些开发包的。
在Servlet4.0之前，我们只使用javax相关的包，并且未来对接的是Tomcat 9.x及以下版本。(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )
在Servlet5.0之后，我们只使用javax相关的包，并且未来对接的是Tomcat 10.x及以后版本。
这里我们使用高版本来学习，即jakarta版本，未来tomcat也需要使用高版本。

接着编写POM文件：

1 <?xml version="1.0" encoding="UTF-8"?>
2 <projectxmlns="http://maven.apache.org/POM/4.0.0"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
5 <modelVersion>4.0.0</modelVersion>
6 
7 <groupId>org.example</groupId>
8 <artifactId>PureJaveServlet</artifactId>
9 <version>1.0-SNAPSHOT</version>
10 <name>PureJaveServlet</name>
11 <packaging>war</packaging>
12 
13 <properties>
14     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15     <maven.compiler.target>11</maven.compiler.target>
16     <maven.compiler.source>11</maven.compiler.source>
17 </properties>
18 
19 <dependencies>
20     <dependency>
21         <groupId>jakarta.servlet</groupId>
22         <artifactId>jakarta.servlet-api</artifactId>
23         <version>5.0.0</version>
24         <scope>provided</scope>
25     </dependency>
26 
27     <dependency>
28         <groupId>org.projectlombok</groupId>
29         <artifactId>lombok</artifactId>
30         <version>1.18.30</version>
31     </dependency>
32     <dependency>
33         <groupId>org.apache.commons</groupId>
34         <artifactId>commons-lang3</artifactId>
35         <version>3.13.0</version>
36     </dependency>
37     <!--http客户端-->
38     <!--fastjson-->
39     <dependency>
40         <groupId>com.alibaba</groupId>
41         <artifactId>fastjson</artifactId>
42         <version>1.2.83</version>
43     </dependency>
44 
45 
46     <dependency>
47         <groupId>com.fasterxml.jackson.core</groupId>
48         <artifactId>jackson-databind</artifactId>
49         <version>2.10.0</version>
50     </dependency>
51     <dependency>
52         <groupId>io.pebbletemplates</groupId>
53         <artifactId>pebble</artifactId>
54         <version>3.1.6</version>
55     </dependency>
56     <dependency>
57         <groupId>org.apache.maven.plugins</groupId>
58         <artifactId>maven-compiler-plugin</artifactId>
59         <version>3.10.1</version>
60     </dependency>
61 
62 </dependencies>
63 
64 <build>
65     <plugins>
66         <plugin>
67             <groupId>org.apache.maven.plugins</groupId>
68             <artifactId>maven-war-plugin</artifactId>
69             <version>3.3.2</version>
70         </plugin>
71         <plugin>
72             <groupId>org.apache.maven.plugins</groupId>
73             <artifactId>maven-compiler-plugin</artifactId>
74             <configuration>
75                 <compilerArgs>
76                     <arg>-parameters</arg>
77                 </compilerArgs>
78             </configuration>
79         </plugin>
80     </plugins>
81 </build>
82 </project>

Servlet类

1 packageorg.example;2 
3 
4 importjakarta.servlet.ServletException;5 importjakarta.servlet.annotation.WebServlet;6 importjakarta.servlet.http.HttpServlet;7 importjakarta.servlet.http.HttpServletRequest;8 importjakarta.servlet.http.HttpServletResponse;9 
10 importjava.io.IOException;11 importjava.io.PrintWriter;12 
13 
14 @WebServlet(urlPatterns = "/nihao")15 public class HiServlet extendsHttpServlet {16 @Override17     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throwsIOException {18         String name = req.getParameter("name");19         resp.setContentType("text/html");20         PrintWriter out =resp.getWriter();21         out.println("<html><body>");22         out.println(String.format("<h1>Hello, %s </h1>", name));23         out.println("</body></html>");24 out.flush();25 }26 }

1 packageorg.example;2 
3 importjakarta.servlet.annotation.WebServlet;4 importjakarta.servlet.http.HttpServlet;5 importjakarta.servlet.http.HttpServletRequest;6 importjakarta.servlet.http.HttpServletResponse;7 
8 importjava.io.IOException;9 importjava.io.PrintWriter;10 
11 /**
12 * @discription13  */
14 @WebServlet(urlPatterns = "/bye")15 public class ByeServlet extendsHttpServlet {16 @Override17     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throwsIOException {18         String name = req.getParameter("name");19         resp.setContentType("text/html");20         PrintWriter out =resp.getWriter();21         out.println("<html><body>");22         out.println(String.format("<h1>bye bye, %s </h1>", name));23         out.println("</body></html>");24 out.flush();25 }26 }

代码部分就结束了，我们观察代码可以发现两点：
1、所有的Sevlet都要继承自HttpServlet。HttpServlet是一个抽象类，我们需要复写抽象类中的抽象方法，以保证未来Tomcat等web服务器在加载Servlet时，可以按照统一的规范查找，执行。
我们在Servlet中重写了doGet() 方法，表示处理该servlet路径下的get请求，同理还可以重写doPost doDelete doPut等方法，来处理对应的请求类型。
这里我们很简单，直接返回一段响应的html。
2、我们并没有写main方法，而是在Pom中标记我们的工程需要打包成一个war包。
第二步，配置tomcat
没有main方法，我们如何启动我们的java程序呢？我们通常是将其配置到tomcat的指定路径中，启动tomcat后，tomcat会加载war包中servlet的相关类，进行处理。
因此我们会将tomcat这样的web服务器称之为Servlet容器。
我们首先从tomcat官网上（https://tomcat.apache.org/whichversion.html）下载一个与我们对应的servlet版本匹配的tomcat版本。

下载到本地之后解压即可。
接着我们为了方便在IDEA中下载一个smart tomcat的组件，将该组件关联好servlet代码和tomcat服务器即可。
关键配置如下：
Tomcat server: 选择我们下载好的tomcat服务器，如果没有下拉选项就选择"Congure..."手动加一下。
Deployment dirctory：部署文件夹，(防盗连接：本文首发自http://www.cnblogs.com/jilodream/ )该配置指向前文项目结构树种的webapp。
Use classpath of module：选择当前项目
Context path：选择上下文路径（其实就是url的前缀路径），按照url规则随便填，我这里叫填的是/biubiubiu
server port：Servlet的服务器端口，默认填8080
admin port：tomcat的管理端口 默认填8005，一般就是用于停掉tomcat（其实一般也不用）。
之后我们通过IDEA：拉起tomcat，加载servlet相关类和资源。

命令行输入如下：

....
15-Nov-2024 10:34:38.099 信息 [main] org.apache.coyote.AbstractProtocol.start 开始协议处理句柄["http-nio-8080"]15-Nov-2024 10:34:39.831 信息 [main] org.apache.catalina.startup.Catalina.start [4858]毫秒后服务器启动

http://localhost:8080/biubiubiu

执行效果如下：

有人会觉得通过下载并配置tomcat有点麻烦，我们如果想debug代码的话，就更麻烦了，有没有简单点的办法：
其实除了下载tomcat，我们还可以通过代码的形式直接拉起tomcat。思路如下：
首先通过maven加载对应tomcat依赖，然后在main方法中创建tomcat实例，并且指定tomcat所需要的配置信息，如资源和class路径。然后通过start()方法启动tomcat实例就可以了。
代码如下：

新搭建一个java web项目，Servlet类和工程结构我们保持不变还是和原来一样

POM文件

1 <?xml version="1.0" encoding="UTF-8"?>
2 <projectxmlns="http://maven.apache.org/POM/4.0.0"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
5     <modelVersion>4.0.0</modelVersion>
6 
7     <groupId>com.example</groupId>
8     <artifactId>demotom</artifactId>
9     <version>1.0-SNAPSHOT</version>
10     <name>demotom</name>
11     <packaging>war</packaging>
12 
13     <properties>
14         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15         <maven.compiler.target>11</maven.compiler.target>
16         <maven.compiler.source>11</maven.compiler.source>
17         <tomcat.version>10.0.0</tomcat.version>
18     </properties>
19 
20     <dependencies>
21 
22 
23         <dependency>
24             <groupId>org.apache.tomcat.embed</groupId>
25             <artifactId>tomcat-embed-core</artifactId>
26             <version>${tomcat.version}</version>
27             <scope>provided</scope>
28         </dependency>
29         <dependency>
30             <groupId>org.apache.tomcat.embed</groupId>
31             <artifactId>tomcat-embed-jasper</artifactId>
32             <version>${tomcat.version}</version>
33             <scope>provided</scope>
34         </dependency>
35     </dependencies>
36 
37     <build>
38         <plugins>
39             <plugin>
40                 <groupId>org.apache.maven.plugins</groupId>
41                 <artifactId>maven-war-plugin</artifactId>
42                 <version>3.3.2</version>
43             </plugin>
44         </plugins>
45     </build>
46 </project>

主类：

1 packagecom.example.demotom;2 
3 importorg.apache.catalina.Context;4 importorg.apache.catalina.LifecycleException;5 importorg.apache.catalina.WebResourceRoot;6 importorg.apache.catalina.startup.Tomcat;7 importorg.apache.catalina.webresources.DirResourceSet;8 importorg.apache.catalina.webresources.StandardRoot;9 
10 importjava.io.File;11 
12 /**
13 * @discription14  */
15 public classTomMain {16     public static void main(String[] args) throwsLifecycleException {17         Tomcat tomcat = newTomcat();18         tomcat.setPort(Integer.getInteger("port", 8080));19 tomcat.getConnector();20         String docBase = new File("src/main/webapp").getAbsolutePath();21         Context ctx = tomcat.addContext("", docBase);22         WebResourceRoot resources = newStandardRoot(ctx);23         String base = new File("target/classes").getAbsolutePath();24         resources.addJarResources(new DirResourceSet(resources, "/WEB-INF/classes", base, "/"));25 ctx.setResources(resources);26 tomcat.start();27 tomcat.getServer().await();28 }29 }

启动后控制台输出如下，我们可以看到8080端口已经被监听：

"C:\Program Files\Java\jdk-11\bin\java.exe" -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:51854,suspend=y,server=n -Dfile.encoding=UTF-8 -classpath ....

Connected to the target VM, address: '127.0.0.1:51854', transport: 'socket'

11月 15, 2024 10:47:54 上午 org.apache.coyote.AbstractProtocol init

信息: Initializing ProtocolHandler ["http-nio-8080"]

11月 15, 2024 10:47:54 上午 org.apache.catalina.core.StandardService startInternal

信息: Starting service [Tomcat]

11月 15, 2024 10:47:54 上午 org.apache.catalina.core.StandardEngine startInternal

信息: Starting Servlet engine: [Apache Tomcat/10.0.0]

11月 15, 2024 10:47:56 上午 org.apache.catalina.util.SessionIdGeneratorBase createSecureRandom

警告: Creation of SecureRandom instance for session ID generation using [SHA1PRNG] took [1,753] milliseconds.

11月 15, 2024 10:47:56 上午 org.apache.coyote.AbstractProtocol start

信息: Starting ProtocolHandler ["http-nio-8080"]

在深度学习的领域中，前向传播、反向传播和损失函数是构建和训练神经网络模型的三个核心概念。今天，小编将通过一个简单的实例，解释这三个概念，并展示它们的作用。

前向传播：神经网络的“思考”过程

前向传播是神经网络计算的基础步骤，它涉及将输入数据逐层传递，通过神经网络的权重和激活函数，最终输出预测结果。这个过程包含
“样本数据输入、算法模型、输出”
这几个步骤。

我们来举个简单的例子，比如给一个小宝宝看一张图片，然后问他：“这上面画的是什么？”他就会用他的小脑袋瓜去“思考”这张图片，然后告诉你答案。前向传播就像是这个过程，只不过小宝宝换成了神经网络。

  • 样本数据输入
    ：这一步将图像、文字、语音等样本数据转换为我们电脑能识别的数字输入。就像小宝宝看到图片，神经网络也接收到一张图片，这张图片被转换成一串数字。
  • 算法模型
    ：简单来说，就是一些数学计算，主要包含线性层+规则化层+激活，线性层负责做线性函数的拟合；规则化层负责把我们的线性拟合规则化，方便后面的计算；激活层负责的是变成非线性化，因为我们的现实世界是非线性的。所以整个过程就是：我们输入的样本是非线性的，我们通过这样一堆数学公式，去拟合非线性的样本数据。
  • 输出层
    ：也是一些数学运算，比如Linear或者Conv，负责将模型的输出转换为预测结果输出。

这个过程可以用下面的数学公式表示：
image

损失函数：告诉神经网络它错了多少

损失函数是衡量模型预测结果与真实标签之间差距的依据，它的核心作用是告诉我们模型的预测结果“错”得有多离谱。通俗来说，
损失函数就像是一个裁判，它给模型的预测结果打分，分数越低，说明模型的预测结果越接近真实情况，模型的性能就越好
。损失函数是为了让我们反向传播起作用的。就像如果小宝宝猜错了，你会告诉他：“不对哦，这是数字8，不是3。”损失函数就像是这句话，它告诉神经网络：“嘿，你的答案有点偏差。”

下面是几种常用的损失函数：

L1 Loss（MAE）
：平均绝对误差，对异常值的容忍性更高，但当梯度下降恰好为0时无法继续进行。就像是你告诉小宝宝：“你的答案差了多远。”这个距离就是损失值。
image

L2 Loss（MSE）
：均方误差，连续光滑，方便求导，但易受到异常值的干扰。这就像是你告诉小宝宝：“你的答案差了多少个单位。”这个单位的平方和就是损失值。
image

Smooth L1 Loss
：处理异常值更加稳健，同时避免了L2 Loss的梯度爆炸问题。就像是你告诉小宝宝：“你的答案差了多远，但我不会因为你猜得特别离谱就惩罚你。”这个损失函数对极端错误更宽容。
image

反向传播：神经网络的“自我修正”过程

反向传播是利用损失函数的梯度来更新网络参数的过程。它从输出层开始，逆向通过网络，利用链式法则计算每个参数对损失函数的梯度。包含这几个过程：

  • 计算输出层误差梯度
    ：首先计算输出层的误差梯度，这是损失函数对输出层权重的敏感度。
  • 逐层反向传播
    ：然后从输出层开始，逆向通过网络，逐层计算误差梯度。
  • 更新权重和偏置
    ：使用梯度下降算法，根据计算出的梯度更新网络中每一层的权重和偏置。

所以前向传播、反向传播、损失函数之间的关系是这样的：

他们都是深度学习训练过程中的核心。
前向传播
负责生成预测结果，
损失函数
负责量化预测结果与真实标签之间的差异，而
反向传播
则负责利用这些差异来更新模型参数，以减少损失函数的值。

通过三者的结合，我们可以构建、训练并优化深度学习模型，使其能够从数据中学习复杂的模式，并在各种任务如图像识别、自然语言处理和预测分析中做出准确的预测。

前向传播、反向传播、损失函数属于机器学习领域中的核心概念，在AI全体系课程中，是理解其他更复杂机器学习算法的基础，掌握这几个概念对于深入学习机器学习、理解更高级的算法以及在实际应用中设计和优化模型都具有重要的意义。通过理解前向传播、反向传播和损失函数，学习者能够更好地把握机器学习模型的工作原理，为进一步探索深度学习和其他高级机器学习技术打下坚实的基础。

我们在进行页面跳转时，很多情况下都得考虑登录状态问题，比如进入个人信息页面，下单交易页面等等。在这些场景下，通常在页面跳转前，会先判断下用户是否已经登录，若已登录，则跳转到相应的目标页面，若没有登录，则先跳转到登录页面，然后等着获取登录状态，若登录页面关闭时，能获取到已登录，则继续跳转到目标页，若用户取消了登录，则终止后面的行为。这样的处理通常会存在一些问题，例如很多页面都与登录状态相关，这样需要在大量的入口处增加登录逻辑判断。即使封装成一个方法，也需要关心是否登录成功，增加了逻辑的复杂性，而且登录页面先关闭，再打开新页面，页面切换动画也很不协调。

那么我们有没有一种更好的方案来处理登录鉴权问题呢？首先我们先梳理一下我们想要的效果，我们的目的是要跳转到相应的目标页，目标页是否需要先登录，我们是不太愿意关注的，最好是内部自己处理掉，，若没有登录，就先进行登录，登录成功后，继续后面的行为，外面使用的地方尽量做到无感知。总结一下就是进行页面跳转时，内部先判断一下状态，然后再进行后续的行为，而这恰好是Navigation拦截器的功能。

NavPathStack提供了setInterception方法，用于设置Navigation页面跳转拦截回调。该方法需要传一个NavigationInterception对象，该对象包含三个回调函数willShow，didShow和modeChange，我们在willShow页面即将显示时，进行拦截处理。先判断是否登录，没有登录，就重定向到登录页面，若已登录，则继续后续行为，不做拦截。示例如下

@Entry
@ComponentV2
struct Index {
  nav: NavPathStack = new NavPathStack()
  isLogin: boolean = false

  aboutToAppear(): void {
    this.nav.setInterception({
      willShow: (from: NavDestinationContext | NavBar, to: NavDestinationContext | NavBar,
        operation: NavigationOperation, isAnimated: boolean) => {
        if (typeof to === 'object') {
          if (isLogin) {
            AppRouter.popPage()
            AppRouter.jumpPage('login', undefined)
          }
        }
      }
    })
  }

  build() {
    Navigation(this.nav)
    .hideToolBar(true)
    .hideTitleBar(true)
    .height('100%')
    .width('100%')
  }
}

拦截器细节优化

如何判断是否需要进行拦截

在拦截器中，虽然我们可以进行拦截重定向跳转，但需要考虑的一个问题是什么情况下进行拦截，也就是哪些页面跳转时需要先判断下登录状态。首先想到的是弄一个数组，所有需要登录校验的页面都放到这个数组中。页面跳转时，我们只需要判断下目标页是否在数组中，就可以知道是否需要进行拦截校验登录了。其实思想是对的，只是我们有更简单的实现方式。在系统路由表中，有一个data字段，可以在这个字段中增加一个字段，是否需要登录，在拦截器中先获取目标页中这个参数，只要所有需要登录的页面，都添加了这个字段就可以了。我们以用户信息页为例，配置如下

{
  "routerMap": [
    {
      "name": "login",
      "pageSourceFile": "src/main/ets/pages/login/LoginPage.ets",
      "buildFunction": "loginBuilder"
    },
    {
      "name": "user_info",
      "pageSourceFile": "src/main/ets/pages/user/UserInfoPage.ets",
      "buildFunction": "userInfoBuilder",
      "data": {
        "needLogin": "1"
      }
    }
  ]
}

拦截器中获取该字段的方式如下

this.nav.setInterception({
  willShow: (from: NavDestinationContext | NavBar, to: NavDestinationContext | NavBar,
    operation: NavigationOperation, isAnimated: boolean) => {
    if (typeof to === 'object') {
      const data = (to as NavDestinationContext).getConfigInRouteMap()?.data
      if (data !== undefined && (data as object)['needLogin'] === '1' && !AppConstant.hasLogin) {
        AppRouter.popPage()
        AppRouter.jumpPage(Pages.login, undefined)
      }
    }
  }
})

登录成功后如何获取目标页和页面参数

登录成功后，我们如何知道要跳转到哪个目标页，以及跳转到目标页时所需要的参数呢？我们在跳转到登录页时可以增加2个参数targetPage和targetParam，分别表示要处理的目标页以及相应的参数，若targetPage的值为undefined，则说明登录成功后没有后续操作，若有值，则跳转到这个页面并把相应的参数传过去。在拦截器中，可以通过to.pathInfo.name获取到目标页的名称name以及通过to.pathInfo.param获取到目标页所需要的参数，并把它们赋值给登录页面的targetPage和targetParam就行了。

我们可以发现使用拦截器这种方式，完全符合我们最初的设想，外部调用时不用考虑是否要校验登录状态，由拦截器内部自己处理。登录后也是直接跳转到目标也，没有页面关闭效果。而且是否需要判断登录，只需配置一个字段就行了，非常方便。

汇编中，加法指令很重要，因为它是执行其他很多指令的基础。

同时，加法指令也会影响
NZCV
标志。有关
NZCV
的介绍，可以参看《一文搞懂 ARM 64 系列: ADC》。

ARM64
汇编中，
ADD
指令有
3
种形式，这里介绍第一种形式，也就是与
立即数
相加。

1 指令语法

ADD <Xd|SP>, <Xn|Sp>, #imm{, shift}

{}
里的内容表示是可选的。

shift
表示
LSL(逻辑左移)
的位数，有
2
个取值，一个是
0
，一个是
12
。
0
是其默认值。

所谓
LSL(逻辑左移)
，是指将数值整体向左移动，低位补
0
。如果高位被移出去，直接丢弃。

image

2 指令语义

整个指令就是将源寄存器
<Xn|SP>
，与立即数
imm
(如果有必要，需要进行
LSL
)相加，将结果写入目的寄存器
<Xd|SP>
。

注意
，这条指令不影响
NZCV
标志。

(<Xd|SP>, _) = <Xn|Sp> + imm << shift

3 NZCV 如何受影响

虽然这条指令最终不影响
NZCV
标志，但是搞清楚
NZCV
如何受影响，还是很有必要的。

1
将源寄存器的值
<Xn|SP>
和
imm << shift
都当成
无符号整型数
，两数相加，得到一个
无符号整型数
的结果，记作
u_result
。此时计算时不考虑溢出:

<Xn|SP> = 0xffffffffffffffff // 64 bit 全 1
(imm << shift) = 1
u_result = 0xffffffffffffffff + 1 = 0x10000000000000000 // 2^64，而不是 0

2
将源寄存器的值
<Xn|SP>
和
imm << shift
都当成
有符号整型数
，两数相加，得到一个
有符号整型数
的结果，记作
s_result
。此时计算时不考虑溢出:

<Xn|SP> = 0xffffffffffffffff // 64 bit 全 1，此时当成 -1 看待
(imm << shift) = 0x8000000000000000 // 64 bit 最小负整数 -9223372036854775808
s_result = -1 + (-9223372036854775808) = -9223372036854775809 // 而不是 0x7fffffffffffffff

3
从
u_result
中取
(63~0)
共
64bit
，记作
result
;

4
如果
result
的最高位是
1
，那么
N = 1
;

5
如果
result = 0
，那么
Z = 1
;

6
如果把
result
当成
无符号整型数
，它的值等于
u_result
，那么
C = 0
；如果不等于，那么
C = 1
，也就是在进行加法运算时，发生了进位。

7
如果把
result
当成
有符号整型数
，它的值等于
s_result
，那么
V = 0
；如果不等于，那么
V = 1
，也就是说在进行加法运算，发生了溢出。

  1. 1
  2. ...
  3. 24
  4. 25
  5. 26
  6. 27
  7. 28
  8. 29
  9. 30
  10. ...
  11. 1512