前言

在上一篇文章：OSPF（六）OSPF特殊区域之Stub和Totally Stub区域详解及配置中，我们详细讲解了Stub区域的作用，以及配置，Stub区域消除了四类、五类LSA，Totally Stub区域更是将三类LSA也一并消除，只留下一条缺省的三类LSA。
本文主要介绍OSPF中的另外一种特殊区域：NSSA以及Totally NSSA区域。

Stub和Totally Stub区域存在的问题

如下图，当RTD和RTA同时连接到某一外部网络，RTA引入外部路由到OSPF域，RTD所在的Area 1为减小LSDB规模被设置为Stub或Totally Stub区域。这时，由于被配置了Stub或Totally Stub区域，RTD所有的数据都将从RTB走。
RTD访问外部网络的路径是“RTD->RTB->RTA->外部网络”，显然相对于RTD直接访问外部网络而言，这是一条次优路径。
OSPF规定Stub区域是不能引入外部路由的，这样可以避免大量外部路由对Stub区域设备资源的消耗。
对于既需要引入外部路由又要避免外部路由带来的资源消耗的场景，Stub和Totally Stub区域就不能满足需求了。

所以为了解决这一问题，我们就有了一个新的特殊区域：NSSA和Totally NSSA区域。

NSSA和Totally NSSA区域

NSSA

OSPF NSSA区域（Not-So-Stubby Area）是在原始OSPF协议标准中新增的一类特殊区域类型。
NSSA区域和Stub区域有许多相似的地方。两者的差别在于，NSSA区域能够将自治域外部路由引入并传播到整个OSPF自治域中，同时又不会学习来自OSPF网络其它区域的外部路由。

lNSSA LSA（七类LSA）：

七类LSA是为了支持NSSA区域而新增的一种LSA类型，用于描述NSSA区域引入的外部路由信息。
七类LSA由NSSA区域的ASBR产生，其扩散范围仅限于ASBR所在的NSSA区域。
缺省路由也可以通过七类LSA来产生，用于指导流量流向其它自治域。

七类LSA转换为五类LSA：

NSSA区域的ABR收到七类LSA时，会有选择地将其转换为五类LSA，以便将外部路由信息通告到OSPF网络的其它区域。
NSSA区域有多个ABR时，进行7类LSA与5类LSA转换的是Router ID最大的ABR。

配置

将Area 1区域设置成NSSA区域，只要将RTB、RTD路由器做配置即可。

命令如下：

RTB:

[RTB]ospf
[RTB-ospf-1]area 1
[RTB-ospf-1-area-0.0.0.1]nssa 

RTD:

[RTD]ospf
[RTD-ospf-1]area 1
[RTD-ospf-1-area-0.0.0.1]nssa 

查看RTD的LSDB：
发现RTD路由器只包含一类、二类、三类LSA，以及七类LSA：NSSA 192.168.6.0 192.168.4.4 78 36 80000001 1
NSSA 192.168.7.0 192.168.4.4 80 36 80000001 1
NSSA 0.0.0.0 192.168.2.2 259 36 80000001 1

[RTD]dis ospf lsdb

	 OSPF Process 1 with Router ID 192.168.4.4
		 Link State Database 

		         Area: 0.0.0.1
 Type      LinkState ID    AdvRouter          Age  Len   Sequence   Metric
 Router    192.168.4.4     192.168.4.4         70  48    80000008       1
 Router    192.168.2.2     192.168.2.2        207  36    80000005       1
 Network   192.168.4.4     192.168.4.4        204  32    80000002       0
 Sum-Net   192.168.5.0     192.168.2.2        259  28    80000001       3
 Sum-Net   192.168.3.0     192.168.2.2        259  28    80000001       2
 Sum-Net   192.168.2.0     192.168.2.2        259  28    80000001       1
 Sum-Net   192.168.1.0     192.168.2.2        259  28    80000001       2
 NSSA      192.168.6.0     192.168.4.4         78  36    80000001       1
 NSSA      192.168.7.0     192.168.4.4         80  36    80000001       1
 NSSA      0.0.0.0         192.168.2.2        259  36    80000001       1

查看OSPF路由表：

[RTD]dis ospf routing 

	 OSPF Process 1 with Router ID 192.168.4.4
		  Routing Tables 

 Routing for Network 
 Destination        Cost  Type       NextHop         AdvRouter       Area
 192.168.4.0/24     1     Transit    192.168.4.4     192.168.4.4     0.0.0.1
 192.168.7.0/24     1     Stub       192.168.7.4     192.168.4.4     0.0.0.1
 192.168.1.0/24     3     Inter-area 192.168.4.2     192.168.2.2     0.0.0.1
 192.168.2.0/24     2     Inter-area 192.168.4.2     192.168.2.2     0.0.0.1
 192.168.3.0/24     3     Inter-area 192.168.4.2     192.168.2.2     0.0.0.1
 192.168.5.0/24     4     Inter-area 192.168.4.2     192.168.2.2     0.0.0.1

 Routing for NSSAs
 Destination        Cost      Type       Tag         NextHop         AdvRouter
 0.0.0.0/0          1         Type2      1           192.168.4.2     192.168.2.2

 Total Nets: 7  
 Intra Area: 2  Inter Area: 4  ASE: 0  NSSA: 1 

我们还可通过tracert命令验证数据路径,发现现在RTD访问外部网络从最优路径通过（RTD->RTF)

[RTD]tracert 192.168.6.1

 traceroute to  192.168.6.1(192.168.6.1), max hops: 30 ,packet length: 40,press 
CTRL_C to break 

 1 192.168.7.6 20 ms  20 ms  20 ms 

 2 192.168.6.1 10 ms  10 ms  20 ms 

Totally NSSA

Totally NSSA与MSSA的区别：

• Totally NSSA不允许三类LSA在本区域内泛洪。（与Stub和Totally Stub的区别相同）

配置

在NSSA区域中的ARB（也就是图中RTB），追加上no-summary参数即可。

RTB:

[RTB]ospf
[RTB-ospf-1]area 1
[RTB-ospf-1-area-0.0.0.1]nssa no summary

查看RTD的LSDB：
发现三类LSA汇总成一条缺省LSASum-Net 0.0.0.0 192.168.2.2 49 28 80000001 1

[RTD]dis ospf lsdb

	 OSPF Process 1 with Router ID 192.168.4.4
		 Link State Database 

		         Area: 0.0.0.1
 Type      LinkState ID    AdvRouter          Age  Len   Sequence   Metric
 Router    192.168.4.4     192.168.4.4          5  48    80000014       1
 Router    192.168.2.2     192.168.2.2         12  36    80000008       1
 Sum-Net   0.0.0.0         192.168.2.2         49  28    80000001       1
 NSSA      192.168.6.0     192.168.4.4         78  36    80000001       1
 NSSA      192.168.7.0     192.168.4.4         80  36    80000001       1
 NSSA      0.0.0.0         192.168.2.2        259  36    80000001       1

整体实验配置过程及命令

步骤一：搭建拓扑

搭建拓扑，并分配好网段，建议标记下来，以免出错。

步骤二：配置路由器接口IP地址

根据分配好的网段，配置路由器所有接口的IP地址。以及PC的IP地址。

举个栗子：

[RTD]
[RTD]interface GigabitEthernet 0/0/0
[RTD-GigabitEthernet0/0/0]ip address 192.168.4.4 24

步骤三：OSPF区域以及邻居配置

注意：这里我们分了三个区域：Area 0、Area 1、Area 2。需要在不同的区域下宣告邻居。

宣告邻居命令：network [相邻网段] [反子网掩码]

举个栗子：
RTA：

[RTA]ospf	
[RTA]ospf 1
[RTA-ospf-1]area 0
[RTA-ospf-1-area-0.0.0.0]network 192.168.1.0 0.0.0.255  
[RTA-ospf-1-area-0.0.0.0]network 192.168.2.0 0.0.0.255
[RTA-ospf-1-area-0.0.0.0]network 192.168.3.0 0.0.0.255

RTB：

[RTB]ospf
[RTB-ospf-1]areo 0
[RTB-ospf-1-area-0.0.0.0]network 192.168.2.0 0.0.0.255
[RTB-ospf-1-area-0.0.0.0]area 1
[RTB-ospf-1-area-0.0.0.1]network 192.168.4.0 0.0.0.255

步骤三：检测OSPF

配置好了OSPF之后，可以先不着急继续往下配置，我们可以先检测一下OSPF是否配置正确。

检测命令：

1. 可以用RTDpingRTE查看能否通信
2. 查看路由表：display ip routing-table
3. 查看OSPF路由表：display ospf routing

步骤四：引入外部路由

步骤1

将外部路由用RIP协议进行配置。

RTF：

[RTF]rip 
[RTF-rip-1]version 2    //版本2
[RTF-rip-1]network 192.168.6.0 
[RTF-rip-1]network 192.168.1.0
[RTF-rip-1]network 192.168.7.0

步骤2

重要！！！
路由引入之前需要在RTF上将192.168.1.0/24、192.168.7.0/24网段用OSPF协议宣告邻居。
同时将RTA上将192.168.1.0/24网段用RIP宣告。RTD上将192.168.7.0/24网段用RIP宣告。

RTF：
注意OSPF区域的变化

[RTF]ospf
[RTF-ospf-1]a 0
[RTF-ospf-1-area-0.0.0.0]network 192.168.1.0 0.0.0.255
[RTF-ospf-1]a 1
[RTF-ospf-1-area-0.0.0.1]network 192.168.7.0 0.0.0.255

RTA：

[RTA]rip 
[RTA-rip-1]v 2
[RTA-rip-1]network 192.168.1.0

RTD：

[RTD]rip 
[RTD-rip-1]v 2
[RTD-rip-1]network 192.168.7.0

步骤3

外部路由引入。（详细解释可查看文章：OSPF（五）OSPF外部路由

RTA、RTD：

[RTA]ospf
[RTA-ospf-1]import-route rip

RTF：

[RTF]rip 
[RTF-rip-1]
[RTF-rip-1]import-route ospf 

步骤五：检测外部路由是否引入成功

检测命令：

1. 可以用RTDpingRTE查看能否通信
2. 查看路由表：display ip routing-table
3. 查看OSPF路由表：display ospf routing

步骤六：配置NSSA、Totally NSSA

这部分实验可对照上文，这里不再赘述。

本篇博客思路：
对于OSPF的LSA信息泛洪问题-----
-划分区域-----
-在MA中解决LSA泛洪问题-----
-路由器承担不同角色-----
-不同的LSA信息进行介绍-----
-限制LSA数量------

OSPF区域划分

划分区域的作用是什么？为了解决什么问题？

对于在MA网络中如何解决LSA泛洪的问题呢？

区域划分为：

1）骨干区域：主要功能为快速、高效地传输IP分组的OSPF区域。骨干区域将其他类型的OSPF区域连接起来，通常没有终端用户。骨干区域也叫OSPF区域0，它是网络核心，其他区域都与它直接相连。

注意：在一些CISCO文档中，将骨干区域称为中转区域。然而在OSPF RFC中，中转区域是一个与虚链路相关的术语。虚链路在后续的文章中介绍。

2）常规（非骨干）区域：主要功能为连接用户和资源的OSPF区域。常规区域通常是根据职能或地理位置划分的。默认情况下，常规区域不允许另一个区域使用其连接将数据流传输到其他区域。默认情况下，来自其他区域的所有数据流都必须经过骨干区域0.常规区域又分为几类，包括标准区域、末节区域、完全末节区域和次末节区域（NSSA）和绝对末节NSSA。文章后续的文章中介绍这些区域类型。

OSPF采用严格的两层区域结构。网络的底层物理连接必须与两层区域结构匹配，即所有非骨干区域都直接与区域0相连。

  特殊情况：如果OSPF只有一个区域，可以为任意的区域编号。

下篇 博客还会讲到对于OSPF的不规则区域的解决办法

OSPF路由器角色

OSPF路由器的类型决定了什么样的数据流能够进入和离开区域。

1）内部路由器：

所有接口都位于同一个区域中的路由器，同一个区域中所有内部路由器的LSDB都相同。

2）骨干路由器：

位于骨干区域0边缘的路由器，至少有一个接口与区域0相连。骨干路由器在维护OSPF路由信息时采用的步骤和算法与内部路由器相同。

3）区域边界路由器（ABR）：

连接多个区域的路由器，为其连接的每个区域维护一个LSDB，并路由器前往/来自其他区域的数据流。ABR将区域0连接到非骨干区域，因此是区域的出口，这意味着前往其他区域的路由信息必须经过当前区域的ABR。ABR将这些路由选择信息通告给骨干，骨干路由器再将其转发给其他的ABR。只能在ABR对其连接的区域的地址进行汇总（对其连接的区域的LSDB种的路由选择信息进行汇总）。ABR分离LSA泛洪区，还可能提供默认路由。一个区域肯能有一台或多台ABR。

理想的设计是只让每个ABR连接两个区域：
骨干区域和另一个区域。正如前面指出的，建议ABR最多不要连接3个以上的区域。

4）自治系统边界路由器（ASBR）：

至少有一个接口与其他域（如另一个OSPF自治区域系统或使用其他网络协议的域）相连。OSPF自治系统由所有OSPF区域及其中的路由器组成。ASBR可将外部路由重分发到OSPF域中，反之亦然。

注意：同一台路由器可属于多种类型。
例如，如果路由器同时连接区域0、区域1和一个非OSPF网络，
则它既是ABR又是ASBR。

对于它连接的每个区域，路由器都有一个独立的LSDB。因此，ABR有两个LSDB，一个针对的是区域0，另一个针对的是它连接的非骨干区域。属于同一区域的两台路由器中针对该区域的LSDB相同。

OSPF 七类LSA

LSA新旧比较

LSA总结列表：

限制LSA数量

1.区域划分

2.特殊区域

(1)stub末节区域

配置注意事项：

(2)Totally Stub完全末节区域

(3)NSSA 非完全末节区域

七类LSA介绍：

(4)Totally NSSA完全的非完全末节区域

3. LSA汇总

4.LSA过滤

OSPF不规则区域的处理

不规则区域的主要表现形式（数字代表区域编号）：
1023 非骨干区域为与area0相连接
123 没有骨干区域area0
010 存在多个骨干区域area0*

(1) 双向重发布

（2）virtual link 虚链路

（3）Tunnel 隧道

ospf FA地址解释

OSPF工作过程

启动配置完成后，本地默认组播发出hello包到所有邻居；若收到其他邻居的hello回复，邻居关系建立，生成邻居表;
邻居关系建立后，进行条件匹配，匹配失败将维持邻居关系，仅hello继续周期保活；若条件匹配成功，使用DBD来获取数据库目录，之后使用LSR/LSU/LSack来获取本地未知的LSA信息，生成完整的数据库表；
之后本地基于LSDB，启用SPF算法，生成导向图，再基于最短路径优先选择，将最佳路径加载于路由表中；
收敛完成，hello包周期保活，每30min周期进行数据库同步（比对，纠正）

    看RPN网络基本是从faster-RCNN来的。看的有点迷糊。后来看了几篇博客感觉有点懂了。记录下来防止自己忘了吧。尽量用大白话。了解RPN网络的整个应用流程。

1.明确输入输出：输入是CNN卷积后的特征图 输出是候选框图  如下图。知乎上盗了张图。 感觉这个是最形象的

                                                                                                          图1

2.先形象解释一下：左侧是特征图 ，立方体厚度决定于特征图维度。右侧红框就是经过该网络后提取出的感兴趣ROI区域。  这个特征图生成方法很多了，例如 ZF，VGG ,Resnet 什么的都可以。这里就不细说了。RPN不关注具体目标是啥，是车，是人或者狗，楼房都可以。它只是将框内认为是目标，框外认为是背景，做了个二分类。至于框内目标具体是啥，最终是交给分类网络去做。结果会略显潦草，后面会对边框进行提炼。

3.具体做法：以ZF网络计算的特征图作为输入来说吧（不同网络体现在输入上是特征图的尺寸不同，RPN实现都是一致的），当然不同网络的检测结果差异是网络本身决定的了。

3.1.计算RPN的输入特征图（又见无耻的盗图....） 对应于图1的最左侧

                                                                                                                   图2

首先输入图像大小是224*224*3。 然后开始各种卷积 池化。卷积核大小，个数，步长，填充参数都在图上可见。最终，rpn是选择conv5的结果作为其输入，也就是13*13*256这个特征图是RPN网络的输入。具体这个卷积流程去参考其他文章即可。本文重点介绍RPN的处理流程。

3.2.生成Anchors   对应于图1的中间部分

    首先牢记：特征图上的每个点生成一个Anchors，特征图大小与Anchors对应。文中是用9个锚点。所谓Anchors 就理解成9个不同的框好了（框的属性自然就是长宽了，再进一步就是四个点的坐标喽），特征图上的每个点对应于一个Anchors。这九个不同的框按大小，比例生成的，论文中有介绍。这个框的数据（框的左上角坐标（x0，y0），右下角坐标（x1，y1）这四个值都是对应于原图的）对应于原图，就是图1右侧那个红框。下面这个就是原图，红色点就是特征图上的点对应于原图的位置。（接着盗图）。它部署 9 个锚点框：3 个不同宽高比 * 3 个不同大小的锚点框 = 9个锚点框。每一个位置使用 9 个锚点，每个位置会生成 2×9 个目标分数和 4×9 个坐标分数。显然，通过一个中心定义9个不同的框，就是为实现多尺度这个想法。当然这样做获得检测框很不准确，后面会做2次bounding box regression修正检测框位置。

                                                                                                                   图3

下面是卷积的具体过程。

先上总图                

                                                                                                             图4

a.conv fetaure map到 intermediate layer的卷积过程：

    在特征图上用sliding window 3*3的窗口滑动。这个窗口提出来的图 conv feature map大小是3*3*256，上面那个图只显示了1通道的，在它下面还有255层。那么对于特征图上某个点来说，就要用256个大小为3*3*256的卷积核对这个窗口进行卷积，卷积过程显然是对应通道（256channel）卷积，获得1*256维的向量，然后累加获得1*1向量，卷积核有256个，这样的向量就有256个最终结果就是1*256（这个256是卷积核个数）。结果对应于下图intermediate layer。整张特征图卷积结果如下图

（卷积函数 输入通道数决定卷积核的通道数，卷积核的个数决定输出通道数）

b.intermediate layer的256维向量后面对应两条分支：

    cls layer分支是目标和背景的二分类（classification），因为k等于9，所以通过1×1×256×18的卷积核得到 2*9 = 18个分数，分别是目标和背景的评分。这次卷积总的流程如下图。最右侧的18层中，每两层代表了某个anchor的特征图上所有点的前景背景概率值。

    reg layer分支。如果候选框是目标区域，就去判断该目标区域的候选框位置在哪，这个时候另一条分支就过1×1×256×36的卷积得到4*9个值，每个框包含4个值（x，y，w，h），就是9个候选区域对应的框应该偏移的具体位置Δxcenter,Δycenter,Δwidth,Δheight。如果候选框不是目标区域，就直接将该候选框去除掉，不再进行后续位置信息的判断操作。这里预测的值都是通过模型不断训练得到的。显然最右侧的18层中，每4层代表了某个anchor的特征图上所有点的偏移量的值。

3.3获得最终结果： 对应于图1的右侧部分

    先上个图。里面绿色框就是标注框，是我们样本中框好的，代表了飞机的真实存在框范围，红色框可以看成是候选框的初值，针对特征图上的某个点，这样的框有9个。

                                                                                                                   图5

首先是分类问题，简而言之就是存在与否问题。上面红色就是此次认为红色框中存在灰机了。对应于cls layer层的某个锚点的某种形状的框，其判断为目标的概率非常大。我们训练模型，让cls layer更好的区分前景（灰机），背景（非灰机）。在训练之初我们先对前景和远景分别用正样本(1)和负样本(0)进行标签工作

 正样本标签： 与某一个GT有最高的IOU重叠的Anchor box。与任意一个GT的IOU重叠部分大于0.7的Anchor box 。

 负样本标签： 给与所有GT包围盒的IOU重叠部分都小于0.3的Anchor box。

    然后通过损失函数softmax loss（cross entropy loss）进行计算，这里的监督标签就是GT（1，0)，它不断告诉训练出的结果对还是不对。就这样训练到最后我们的RPN分类训练完成。这个步骤获得了红色框

然后是回归问题，简而言之就是修正边框而已。上面的蓝色就是在红色框基础上去修正得来的，对应于reg layer层。我们通过不断训练它，让其得到的四个值，x,y,w,h能与真实的GT坐标不断靠拢，能更接近真实目标的坐标。看上面那个飞机图，Region Porposal 是我们RPN给出的一个候选区域初值。把上面红色框图的信息给下一次最终的分类模块,它可能识别不出飞机。因为框的太少了。 所以在训练的时候，就需要尽可能的使我们的Anchor box的框与真实的GT的框接近。但是我们知道想让A-box=GT,是不太现实的，因为我们没法做到100%。

                                                                                                           图6

所以如上图所示，我们的目标就是希望从现有的原始红色的Region  Proposal最终得到蓝色的预测GT，而这个蓝色GT其实与绿色的真实的标定GT非常接近了已经。总而言之，我们如果得到了预测GT，那么目标就达成了。这个步骤对红色框估计获得了蓝色框、这个框显然就是图1中那几个红色的框框了。

多边框回归的参考文献列在下面了。详情见它。简而言之就是已经有个初始框，但是它不准，不准的因素有4个， x，y方向的偏移，x，y方向的缩放比例。然后就用神经网络去训练。让红色框与绿色框尽可能接近，那么对应的这4个参数就是需要训练的值呗

RPN具体的pytorch代码如下。可对照代码和上面理论去对应。

from __future__ import absolute_import
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

from model.utils.config import cfg
from .proposal_layer import _ProposalLayer
from .anchor_target_layer import _AnchorTargetLayer
from model.utils.net_utils import _smooth_l1_loss

import numpy as np
import math
import pdb
import time

class _RPN(nn.Module):
    """ region proposal network """
    def __init__(self, din):
        super(_RPN, self).__init__()
        
        self.din = din  # get depth of input feature map, e.g., 256 FT
        self.anchor_scales = cfg.ANCHOR_SCALES
        self.anchor_ratios = cfg.ANCHOR_RATIOS
        self.feat_stride = cfg.FEAT_STRIDE[0]

        # define the convrelu layers processing input feature map
        self.RPN_Conv = nn.Conv2d(self.din, 256, 3, 1, 1, bias=True)

        # define bg/fg classifcation score layer
        self.nc_score_out = len(self.anchor_scales) * len(self.anchor_ratios) * 2 # 2(bg/fg) * 9 (anchors)
        self.RPN_cls_score = nn.Conv2d(256, self.nc_score_out, 1, 1, 0)

        # define anchor box offset prediction layer
        self.nc_bbox_out = len(self.anchor_scales) * len(self.anchor_ratios) * 4 # 4(coords) * 9 (anchors)
        self.RPN_bbox_pred = nn.Conv2d(256, self.nc_bbox_out, 1, 1, 0)

        # define proposal layer
        self.RPN_proposal = _ProposalLayer(self.feat_stride, self.anchor_scales, self.anchor_ratios)

        # define anchor target layer
        self.RPN_anchor_target = _AnchorTargetLayer(self.feat_stride, self.anchor_scales, self.anchor_ratios)

        self.rpn_loss_cls = 0
        self.rpn_loss_box = 0

    @staticmethod
    def reshape(x, d):
        input_shape = x.size()
        x = x.view(
            input_shape[0],
            int(d),
            int(float(input_shape[1] * input_shape[2]) / float(d)),
            input_shape[3]
        )
        return x

    def forward(self, base_feat, im_info, gt_boxes, num_boxes):

        batch_size = base_feat.size(0)

        # return feature map after convrelu layer
        rpn_conv1 = F.relu(self.RPN_Conv(base_feat), inplace=True)
        # get rpn classification score
        rpn_cls_score = self.RPN_cls_score(rpn_conv1)

        rpn_cls_score_reshape = self.reshape(rpn_cls_score, 2)
        rpn_cls_prob_reshape = F.softmax(rpn_cls_score_reshape, 1)
        rpn_cls_prob = self.reshape(rpn_cls_prob_reshape, self.nc_score_out)

        # get rpn offsets to the anchor boxes
        rpn_bbox_pred = self.RPN_bbox_pred(rpn_conv1)

        # proposal layer
        cfg_key = 'TRAIN' if self.training else 'TEST'

        rois = self.RPN_proposal((rpn_cls_prob.data, rpn_bbox_pred.data,
                                 im_info, cfg_key))

        self.rpn_loss_cls = 0
        self.rpn_loss_box = 0

        # generating training labels and build the rpn loss
        if self.training:
            assert gt_boxes is not None

            rpn_data = self.RPN_anchor_target((rpn_cls_score.data, gt_boxes, im_info, num_boxes))

            # compute classification loss
            rpn_cls_score = rpn_cls_score_reshape.permute(0, 2, 3, 1).contiguous().view(batch_size, -1, 2)
            rpn_label = rpn_data[0].view(batch_size, -1)

            rpn_keep = Variable(rpn_label.view(-1).ne(-1).nonzero().view(-1))
            rpn_cls_score = torch.index_select(rpn_cls_score.view(-1,2), 0, rpn_keep)
            rpn_label = torch.index_select(rpn_label.view(-1), 0, rpn_keep.data)
            rpn_label = Variable(rpn_label.long())
            self.rpn_loss_cls = F.cross_entropy(rpn_cls_score, rpn_label)
            fg_cnt = torch.sum(rpn_label.data.ne(0))

            rpn_bbox_targets, rpn_bbox_inside_weights, rpn_bbox_outside_weights = rpn_data[1:]

            # compute bbox regression loss
            rpn_bbox_inside_weights = Variable(rpn_bbox_inside_weights)
            rpn_bbox_outside_weights = Variable(rpn_bbox_outside_weights)
            rpn_bbox_targets = Variable(rpn_bbox_targets)

            self.rpn_loss_box = _smooth_l1_loss(rpn_bbox_pred, rpn_bbox_targets, rpn_bbox_inside_weights,
                                                            rpn_bbox_outside_weights, sigma=3, dim=[1,2,3])

        return rois, self.rpn_loss_cls, self.rpn_loss_box

参考的文章太多了，哎   就厚着脸皮写个原创吧 哈哈。
参考文献：

1.https://blog.csdn.net/w437684664/article/details/104238521

2.https://www.jianshu.com/p/468e08f739bd

3.https://www.jianshu.com/p/643cdcf674fc

4.https://blog.csdn.net/YZXnuaa/article/details/79221189

5.https://blog.csdn.net/qq_36269513/article/details/80421990

6.https://blog.csdn.net/zijin0802034/article/details/77685438/ 边框回归的

7.https://blog.csdn.net/wangwei19871103/article/details/100929543 VGG主干网络与RPN的结合 基于keras的