风力发电机组机结构与原理，中国电力出版社，PDF版本。

大家好，今天我将给大家分享关于如何开发一个数据库系统的知识，将从0到1手把手带着一步步去开发这个项目，希望我的分享对大家的学习和工作有所帮助，如果有不足的地方还请大家多多指正。

一、什么是数据库系统
数据库系统一般由数据库、数据库管理系统（及其开发工具）、应用系统、数据库管理员构成 

二、数据库管理系统的主要功能包括
数据定义功能：DBMS提供数据定义语言（Data Definition Language，DDL），用户通过它可以方便地对数据库中的对象进行定义
数据组织、存储和管理：DBMS要分类组织、存储和管理各种数据，包括数据字典、用户数据、数据的存取路径等。
数据操纵功能：DBMS提-供数据操纵语言（Data Manipulation Language，DML），用户可以使用DML操纵数据，实现对数据库的基本操作，如查询、插入、删除和修改等
数据库的事务管理和运行管理：数据库在建立、运用和维护时由数据管理系统统一管理、统一控制，以保证数据的安全性、完整性、多用户对数据的并发使用以及发生故障后的系统恢复
数据库建立和维护功能：数据库初始数据的输入、转换功能，数据库的转储、恢复功能，数据库的重组织功能和性能监视、分析功能等。

三、数据库系统结构
1.1模式(概念模式或逻辑模式)
定义:数据库中全体数据的逻辑结构特征的描述，是所有用户的公用数据库结构。

特性:

一个数据库只有一个模式
模式与应用程序无关，只是数据的一个框架
1.2子模式(外模式或用户模式)
定义:数据库用户所见和使用的局部数据的逻辑结构和特征的描述，是用户所用的数据库结构

特性:

子模式是模式的子集
一个数据库有多个子模式，每个用户至少使用一个子模式
同一个用户可以使用不同的子模式，每个子模式可为不同的用户所用
1.3内模式(存储模式)
定义:是数据物理结构和存储方法的描述。它是整个数据库的最低层结构的表示。

特性:

一个数据库只有一个内模式，内模式对用户透明
一个数据库由多种文件组成，如用户数据文件，索引文件及系统文件
内模式设计直接影响数据库的性能

以下是开发流程：
在idea中构建如下几个子模块工程：
@PostMapping("/doLogin")
@ApiOperation(value = "一键注册登录接口", notes = "一键注册登录接口", httpMethod = "POST")
public GraceJSONResult doLogin(HttpServletRequest request,
                               HttpServletResponse response,
                               @RequestBody @Valid RegisterLoginBO registerLoginBO,
                               BindingResult result);
验证的字段上方可以写一些相关的注解，系统识别后会自动检查
RegisterLoginBO.java
public class RegisterLoginBO {

    @NotBlank(message = "手机号不能为空")
    private String mobile;
    @NotBlank(message = "短信验证码不能为空")
    private String smsCode;

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getSmsCode() {
        return smsCode;
    }

    public void setSmsCode(String smsCode) {
        this.smsCode = smsCode;
    }

    @Override
    public String toString() {
        return "RegisterLoginBO{" +
                "mobile='" + mobile + '\'' +
                ", smsCode='" + smsCode + '\'' +
                '}';
    }
}

如果校验有问题，那么可以直接获得并且放回给前端即可。
BaseController.java
/**
 * 验证beanBO中的字段错误信息
 * @param result
 * @return
 */
public Map<String, String> getErrors(BindingResult result) {
    Map<String, String> map = new HashMap<>();
    List<FieldError> errorList = result.getFieldErrors();
    for (FieldError error : errorList) {
        // 发生验证错误所对应的某一个属性
        String errorField = error.getField();
        // 验证错误的信息
        String errorMsg = error.getDefaultMessage();
        map.put(errorField, errorMsg);
    }
    return map;
}
一般来说，admin系统不会有主动注册功能，账号都是分配的，那么默认就会存在一个基本账户，这也是预先通过代码生成用户名和密码的。直接手动生成即可：
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

同理，查询操作也是类似JPA的操作，再继承Repository后直接使用其内置api即可：
FriendLinkMngControllerApi.java
@PostMapping("getFriendLinkList")
@ApiOperation(value = "查询友情链接列表", notes = "查询友情链接列表", httpMethod = "POST")
public GraceJSONResult getFriendLinkList();
首先可以在数据库通过写sql脚本实现查询
SELECT
c.id as commentId,
c.father_id as fatherId,
c.article_id as articleId,
c.comment_user_id as commentUserId,
c.comment_user_nickname as commentUserNickname,
c.content as content,
c.create_time as createTime,
f.comment_user_nickname as quoteUserNickname,
f.content as quoteContent
FROM
comments c
LEFT JOIN
comments f
on
c.father_id = f.id
WHERE
c.article_id = '2006117B57WRZGHH'
order by
c.create_time
desc
目前我们所搭建的eureka是单机单实例的注册中心，如果挂了，那么整个微服务体系完全不可以，这是不应该的，所以为了实现eureka的高可用，我们可以搭建集群。
在进行集群构建之前，大家先参照目前的eureka再去构建一个一模一样的工程，可以取名为 springcloud-eureka-cluster。
为集群中各个eureka节点配置host
eureka:
  instance:
    hostname: eureka-cluster-${port:7001}    # 集群中每个eureka的名字都要唯一
  # 自定义eureka集群中另外的两个端口号
  other-node-port2: ${p2:7002}
  other-node-port3: ${p3:7003}
  client:
#    register-with-eureka: false
#    fetch-registry: false
    service-url:
      # 集群中的每个eureka单实例，都需要相互注册到其他的节点，在此填入集群中其他eureka的地址进行相互注册
      defaultZone: http://eureka-cluster-${eureka.other-node-port2}:${eureka.other-node-port2}/eureka/,http://eureka-cluster-${eureka.other-node-port3}:${eureka.other-node-port3}/eureka/
我们自己测试的时候时间可以设置为10秒内有10次，我认定非法请求，直接限制这个ip访问15秒，15秒后释放。（像有的网站会出现二维码让你扫描通过，或者手机验证码或者人机交互判断你当前是否是人还是机器，因为有可能是爬虫请求）
开发步骤：
首先在yml中设置基本参数：
@Override
public Object run() throws ZuulException {
    System.out.println("执行【IP黑名单】Zuul过滤器...");

    // 获得上下文对象requestContext
    RequestContext requestContext = RequestContext.getCurrentContext();
    HttpServletRequest request = requestContext.getRequest();

    // 获得ip
    String ip = IPUtil.getRequestIp(request);

    /**
     * 需求：
     * 判断ip在10秒内请求的次数是否超过10次，
     * 如果超过，则限制访问15秒，15秒过后再放行
     */
    final String ipRedisKey = "zuul-ip:" + ip;
    final String ipRedisLimitKey = "zuul-ip-limit:" + ip;

    // 获得剩余的限制时间
    long limitLeftTime = redis.ttl(ipRedisLimitKey);
    // 如果剩余时间还存在，说明这个ip不能访问，继续等待
    if (limitLeftTime > 0) {
        stopRequest(requestContext);
        return null;
    }

    // 在redis中累加ip的请求访问次数
    long requestCounts = redis.increment(ipRedisKey, 1);

    // 从0开始计算请求次数，初期访问为1，则设置过期时间，也就是连续请求的间隔时间
    if (requestCounts == 1) {
        redis.expire(ipRedisKey, timeInterval);
    }

    // 如果还能取得到请求次数，说明用户连续请求的次数落在10秒内
    // 一旦请求次数超过了连续访问的次数，则需要限制这个ip了
    if (requestCounts > continueCounts) {
        // 限制ip访问一段时间
        redis.set(ipRedisLimitKey, ipRedisLimitKey, limitTimes);

        stopRequest(requestContext);
    }

    return null;
}

private void stopRequest(RequestContext requestContext){
    // 停止继续向下路由，禁止请求通信
    requestContext.setSendZuulResponse(false);
    requestContext.setResponseStatusCode(200);
    String result = JsonUtils.objectToJson(
            GraceJSONResult.errorCustom(
                    ResponseStatusEnum.SYSTEM_ERROR_BLACK_IP));
    requestContext.setResponseBody(result);
    requestContext.getResponse().setCharacterEncoding("utf-8");
    requestContext.getResponse().setContentType(MediaType.APPLICATION_JSON_VALUE);
}
上面这些都是通过不同key要执行多次才能得到结果，一般来说我们会使用es的aggs功能做聚合统计，会更好。
通过一个脚本来统计男女数量：
POST http://192.168.1.203:9200/fans/_doc/_search
{
    "size": 0,
    "query":{
        "match":{
            "writerId":"201116760SMSZT2W"
        }
    },
    "aggs": {
        "counts": {
            "terms": {
                "field": "sex"
            }
        }
    }
}

以下就是数据库系统开发的整个流程讲解，感谢大家的阅读

今天给大家分享一下关于SpringBoot开发双11商品服务系统的整个流程，我将深度还原大厂实习期技术成长全流程，让你收获大厂项目开发全流程与实战经验，具备应对大流量场景问题的解决能力，全面助力提升实习/转正/跳槽表现力与成功率。


Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

目的
让大家更容易使用 spring，更容易集成各种常用的中间件、开源软件。
SpringBoot 基于 Spring 开发, SpringBoot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。
SpringBoot 不是用来替代 spring 的解决方案，而是和 spring 框架紧密结合提升 spring 开发者体验的工具。

准备测试数据
我们先导入准备好的测试数据，这个测试数据是一份商品数据。

字段包含商品id，name（商品名）
last_month_sales（最近一个月的销量）
favorites（收藏数）这几个字段，我们主要是通过商品名来搜索。
首先我先先创建一个商品索引
PUT goods
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0
  },
  "mappings": {
    "properties": {
      "id": {
        "type": "keyword",
        "doc_values": false,
        "norms": false,
        "similarity": "boolean"
      },
      "name": {
        "type": "text"
      },
        "price": {
        "type": "double"
      },
      "last_month_sales": {
        "type": "long"
      },
      "favorites": {
        "type": "long"
      },
      "year":{
        "type": "short"
      }
    }
  }
}
千里之行，始于足下。想要舒舒服服地使用Spring框架，就要把它的开发环境配置好，这对它好，也对我好。

1. jdk 的配置       
使用 IDEA 进行开发，在 IDEA 中配置 jdk 的方式很简单，打开 File->Project Structure选择 SDKs。
在 JDK home path 中选择本地 jdk 的安装目录。
在 Name 中为 jdk 自定义名字通过以上三步骤，即可导入本地安装的 jdk。如果是使用 STS 或者 eclipse 可以通过两步骤添加：
window->preference->java->Instralled JRES 来添加本地 jdk。
window-->preference-->java-->Compiler 选择 jre，和 jdk 保持一致。
PUT test_index/_doc/1
{
  "string_field":"imooc",
  "int_field": 100,
  "float_field":3.14,
  "bool_field":true,
  "date_field":"2022/03/16",
  "obj_field":{"key1":"value1","key2":100},
  "array_field1":[100,3.14],
  "array_field2":[100,"200"],
  "array_field3":["2022/03/16","100"],
  "array_field4":["100","2022/03/16"],
  "null_field":null
  }
  创建 Spring Boot 项目后需要进行 maven 配置。打开 File->settings，搜索 maven，配置一下本地的 maven 信息。在 Maven home directory 中选择本地 Maven 的安装路径；在 User settings file 中选择本地 Maven 的配置文件所在路径。在配置文件中配置一下国内阿里的镜像，这样在下载 maven 依赖时，速度会变得很快。
{
  "test_index" : {
    "mappings" : {
      "properties" : {
        "array_field" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "bool_field" : {
          "type" : "boolean"
        },
        "date_field" : {
          "type" : "date",
          "format" : "yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis"
        },
        "float_field" : {
          "type" : "float"
        },
        "int_field" : {
          "type" : "long"
        },
        "obj_field" : {
          "properties" : {
            "key1" : {
              "type" : "text",
              "fields" : {
                "keyword" : {
                  "type" : "keyword",
                  "ignore_above" : 256
                }
              }
            },
            "key2" : {
              "type" : "long"
            }
          }
        },
        "string_field" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

从以上结果中，我们可以看到 Spring Boot 通过MVN方式自动为项目配置了对应的 springframework、logging、jackson 以及 Tomcat 等依赖，而这些正是我们在开发 Web 项目时所需要的。

那么细心的同学可能会发现一个问题，即在以上 pom.xml 的配置中，引入依赖 spring-boot-starter-web 时，并没有指明其版本（version），但在依赖列表中，我们却看到所有的依赖都具有版本信息，那么这些版本信息是在哪里控制的呢？ 
{
  "_index" : "test_index",
  "_id" : "1",
  "_version" : 1,
  "_seq_no" : 0,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "string_field" : "Chan",
    "int_field" : 100,
    "int_string_field" : "100",
    "float_field" : 3.14,
    "bool_field" : true,
    "date_field" : "2022/03/16",
    "obj_field" : {
      "key1" : "value1",
      "key2" : 100
    },
    "array_field" : [
      "value1",
      "100"
    ],
    "null_field" : null
  }
}
spring-boot-starter-parent 是所有 Spring Boot 项目的父级依赖，它被称为 Spring Boot 的版本管理中心，可以对项目内的部分常用依赖进行统一管理。

<parent>    

        <groupId>org.springframework.boot</groupId>    

        <artifactId>spring-boot-starter-parent</artifactId>    

        <version>2.5.6</version>    

        <relativePath/> 

</parent>

Spring Boot 项目可以通过继承 spring-boot-starter-parent 来获得一些缺省的配置内容，它主要提供了以下特性：

默认 JDK 版本（Java 8）

默认字符集（UTF-8）

依赖管理功能

资源过滤

默认插件配置识别 

application.properties 或 application.yml 类型的配置文件
DELETE test_index

PUT test_index
{
  "mappings": {
    "dynamic":false 
  }
}
GET test_index/_search
{
  "query": {
   "term": {
     "field1.field2": {
       "value": "imooc ES"
     }
   }
  }
}

GET test_index/_doc/4

DELETE test_index

PUT test_index
{
  "mappings": {
    "dynamic":"strict" 
  }
}


POST test_index/_doc/2
{
  "field1":{
   "field2":"imooc ES" 
  }
}

GET test_index/_search
{
  "query": {
   "term": {
     "field1.field2": {
       "value": "imooc ES"
     }
   }
  }
}

GET test_index/_doc/4

以下就是本文的全部内容，感谢大家观看

14、小电流贴片共模电感更换需要注意些什么.

RadarSensors_ARS408-21_cn数据手册

ASCB1 系列智能微型断路器是安科瑞电气股份有限公司全新推出的智慧用电产品，产品由智能微型断路器与智能网关两部分组成，可用于对用电线路的关键电气因素，如电压、电流、功率、温度、漏电、能耗等进行实时监测，具有远程操控、预警保护、短路保护、电能计量统计、故障定位等功能，应用于户内建筑物及类似场所的工业、商业、民用建筑及基础设施等领域低压终端配电网络。

RadarSensors_ARS404-21_cn数据手册

结合某地下污水厂项目，从结构、系统组成、系统功能、控制要求、场景模式等方面介绍了地下污水厂智能照明控制系统，探索了一套适用于地下污水厂的智能照明控制策略，以确保地下污水厂正常运行的照明需求。

RadarSensors_ARS308-21_cn数据手册

电子书为扫描版本，自己手动添加书签作为目录供参考

TI出的一个经验文档，讲的很不错

自动驾驶是高安全型应用，需要高性能和高可靠的深度学习模型，Vision Transformer是理想的选摔。现在主流的自动驾驶感知算法基本都使用了Vision Transformer相关技术，比如分割、2D/3D检测，以及最近大火的大模型 (如SAM)，Vision Transformer在自动驾驶领域的落地方面遍地开花。5一方面，在自动驾驶或图像处理相关算法岗位的面试题中，Vision Transformer是必考题，需要对其理论知识有深入理解，并且在项目中真实的使用过相关技术。

Transformer出自于Google于2017年发表的论文《Attention is all you need》，最开始是用于机器翻译，并且取得了非常好的效果。但是自提出以来，Transformer不仅仅在NLP领域大放异彩，并且在CV、RS等领域也取得了非常不错的表现。尤其是2020年，绝对称得上是Transformer的元年，比如在CV领域，基于Transformer的模型横扫各大榜单，完爆基于CNN的模型。为什么Transformer模型表现如此优异？它的原理是什么？它成功的关键又包含哪些？本文将简要地回答一下这些问题。

我们知道Transformer模型最初是用于机器翻译的，机器翻译应用的输入是某种语言的一个句子，输出是另外一种语言的句子。
var i *int = nil
fmt.Println("i.size:", unsafe.Sizeof(i)) //8

var i8 *int8 = nil
fmt.Println("i8.size:", unsafe.Sizeof(i8)) //8

var s *string = nil
fmt.Println("s.size:", unsafe.Sizeof(s)) //8

var ps *struct{} = nil
fmt.Println("ps.size:", unsafe.Sizeof(ps)) //8

var si []int = nil
var si1 []int = nil
fmt.Println("si.size:", unsafe.Sizeof(si)) //24

var ii interface{} = nil
fmt.Println("ii.size:", unsafe.Sizeof(ii)) //16
我们以生成我，爱，机器，学习，翻译成<bos>,i，love，machine，learning,<eos>这个例子做生成过程来解释。
训练：

把“我/爱/机器/学习”embedding后输入到encoder里去，最后一层的encoder最终输出的outputs [10, 512]（假设我们采用的embedding长度为512，而且batch size = 1),此outputs 乘以新的参数矩阵，可以作为decoder里每一层用到的K和V；
将<bos>作为decoder的初始输入，将decoder的最大概率输出词向量A1和‘i’做cross entropy（交叉熵）计算error。
将<bos>，“i” 作为decoder的输入，将decoder的最大概率输出词 A2 和‘love’做cross entropy计算error。
将<bos>，“i”，“love” 作为decoder的输入，将decoder的最大概率输出词A3和’machine’ 做cross entropy计算error。
将<bos>，“i”，"love "，“machine” 作为decoder的输入，将decoder最大概率输出词A4和‘learning’做cross entropy计算error。
将<bos>，“i”，"love "，“machine”，“learning” 作为decoder的输入，将decoder最大概率输出词A5和终止符做cross entropy计算error。
那么并行的时候是怎么做的呢，我们会有一个mask矩阵在这叫seq mask，因为他起到的作用是在decoder编码我们的target seq的时候对每一个词的生成遮盖它之后的词的信息。
func main() {
s := []string{"a", "b", "c"}
fmt.Println("s:origin", s)
changes1(s)
fmt.Println("s:f1", s)

changes2(s)
fmt.Println("s:f2", s)

changes3(s)
fmt.Println("s:f3", s)
}

func changes1(s []string) {
var tmp = []string{"x", "y", "z"}
s = tmp
}

func changes2(s []string) {
// item只是一个副本，不能改变s中元素的值
for i, item := range s {
item = "d"
fmt.Printf("item=%s;s[%d]=%s", item, i, s[i])
}
}

func changes3(s []string) {
for i := range s {
s[i] = "d"
}
}

首先我们需要为每个输入向量(也就是词向量)创建3个向量，分别叫做Query、Key、Value。那么如何创建呢？我们可以对输入词向量分别乘上3个矩阵来得到Q、K、V向量，这3个矩阵的参数在训练的过程是可以训练的。注意Q、K、V向量的维度是一样的，但是它们的维度可以比输入词向量小一点，比如设置成64，其实这步也不是必要的，这样设置主要是为了与后面的Mulit-head注意力机制保持一致（当使用8头注意力时，单头所处理的词向量维度为512/8=64，此时Q、K、V向量与输入词向量就一致了）。我们假设输入序列为英文的"Thinking Machines"
想要深度理解Attention机制，就需要了解一下它产生的背景、在哪类问题下产生，以及最初是为了解决什么问题而产生。

首先回顾一下机器翻译领域的模型演进历史：

机器翻译是从RNN开始跨入神经网络机器翻译时代的，几个比较重要的阶段分别是: Simple RNN, Contextualize RNN,Contextualized RNN with attention, Transformer(2017)，下面来一一介绍。

「Simple RNN」 ：这个encoder-decoder模型结构中，encoder将整个源端序列(不论长度)压缩成一个向量(encoder output)，源端信息和decoder之间唯一的联系只是: encoder output会作为decoder的initial states的输入。这样带来一个显而易见的问题就是，随着decoder长度的增加，encoder output的信息会衰减。
func main(){
var c = make(chan int)
fmt.Printf("c.pointer=%p\n", c) //c.pointer=0xc000022180
go func() {
c <- 1
addChannel(c)
close(c)
}()

for item := range c {
//item: 1
//item: 2
fmt.Println("item:", item)
}
}

func addChannel(done chan int) {
done <- 2
fmt.Printf("done.pointer=%p\n", done) //done.pointer=0xc000022180
}
在测试模型的时候，Test：decoder没有label，采用自回归一个词一个词的输出，要翻译的中文正常从encoder并行输入（和训练的时候一样）得到每个单词的embedding，然后decoder第一次先输入bos再此表中的id，得到翻译的第一个单词，然后自回归，如此循环直到预测达到eos停止标记
type visit struct {
a1  unsafe.Pointer
a2  unsafe.Pointer
typ Type
}

func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
if !v1.IsValid() || !v2.IsValid() {
return v1.IsValid() == v2.IsValid()
}
if v1.Type() != v2.Type() {
return false
}

// We want to avoid putting more in the visited map than we need to.
// For any possible reference cycle that might be encountered,
// hard(v1, v2) needs to return true for at least one of the types in the cycle,
// and it's safe and valid to get Value's internal pointer.
hard := func(v1, v2 Value) bool {
switch v1.Kind() {
case Pointer:
if v1.typ.ptrdata == 0 {
// not-in-heap pointers can't be cyclic.
// At least, all of our current uses of runtime/internal/sys.NotInHeap
// have that property. The runtime ones aren't cyclic (and we don't use
// DeepEqual on them anyway), and the cgo-generated ones are
// all empty structs.
return false
}
fallthrough
case Map, Slice, Interface:
// Nil pointers cannot be cyclic. Avoid putting them in the visited map.
return !v1.IsNil() && !v2.IsNil()
}
return false
}

if hard(v1, v2) {
// For a Pointer or Map value, we need to check flagIndir,
// which we do by calling the pointer method.
// For Slice or Interface, flagIndir is always set,
// and using v.ptr suffices.
ptrval := func(v Value) unsafe.Pointer {
switch v.Kind() {
case Pointer, Map:
return v.pointer()
default:
return v.ptr
}
}
addr1 := ptrval(v1)
addr2 := ptrval(v2)
if uintptr(addr1) > uintptr(addr2) {
// Canonicalize order to reduce number of entries in visited.
// Assumes non-moving garbage collector.
addr1, addr2 = addr2, addr1
}

// Short circuit if references are already seen.
typ := v1.Type()
v := visit{addr1, addr2, typ}
if visited[v] {
return true
}

// Remember for later.
visited[v] = true
}

switch v1.Kind() {
case Array:
for i := 0; i < v1.Len(); i++ {
if !deepValueEqual(v1.Index(i), v2.Index(i), visited) {
return false
}
}
return true
case Slice:
if v1.IsNil() != v2.IsNil() {
return false
}
if v1.Len() != v2.Len() {
return false
}
if v1.UnsafePointer() == v2.UnsafePointer() {
return true
}
// Special case for []byte, which is common.
if v1.Type().Elem().Kind() == Uint8 {
return bytealg.Equal(v1.Bytes(), v2.Bytes())
}
for i := 0; i < v1.Len(); i++ {
if !deepValueEqual(v1.Index(i), v2.Index(i), visited) {
return false
}
}
return true
case Interface:
if v1.IsNil() || v2.IsNil() {
return v1.IsNil() == v2.IsNil()
}
return deepValueEqual(v1.Elem(), v2.Elem(), visited)
case Pointer:
if v1.UnsafePointer() == v2.UnsafePointer() {
return true
}
return deepValueEqual(v1.Elem(), v2.Elem(), visited)
case Struct:
for i, n := 0, v1.NumField(); i < n; i++ {
if !deepValueEqual(v1.Field(i), v2.Field(i), visited) {
return false
}
}
return true
case Map:
if v1.IsNil() != v2.IsNil() {
return false
}
if v1.Len() != v2.Len() {
return false
}
if v1.UnsafePointer() == v2.UnsafePointer() {
return true
}
for _, k := range v1.MapKeys() {
val1 := v1.MapIndex(k)
val2 := v2.MapIndex(k)
if !val1.IsValid() || !val2.IsValid() || !deepValueEqual(val1, val2, visited) {
return false
}
}
return true
case Func:
if v1.IsNil() && v2.IsNil() {
return true
}
// Can't do better than this:
return false
case Int, Int8, Int16, Int32, Int64:
return v1.Int() == v2.Int()
case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
return v1.Uint() == v2.Uint()
case String:
return v1.String() == v2.String()
case Bool:
return v1.Bool() == v2.Bool()
case Float32, Float64:
return v1.Float() == v2.Float()
case Complex64, Complex128:
return v1.Complex() == v2.Complex()
default:
// Normal equality suffices
return valueInterface(v1, false) == valueInterface(v2, false)
}
}
这便是encoder的整体计算流程图了，Transformer模型中堆叠了多个这样的encoder，无非就是输出连接输入罢了，常规操作。
最后再附上一个Transformer的代码实现，读者有兴趣可以跟着自己复现一下Transformer模型的代码。
   package main

   import (
       "log"
       "sync"
   )

   func init() {
       log.SetFlags(log.Lshortfile)
   }
   func main() {
       lock := sync.Mutex{}

       //Go 1.18 新增，是一种非阻塞模式的取锁操作。当调用 TryLock() 时，
       //该函数仅简单地返回 true 或者 false，代表是否加锁成功
       //在某些情况下，如果我们希望在获取锁失败时，并不想停止执行，
       //而是可以进入其他的逻辑就可以使用TryLock()
       log.Println("TryLock：", lock.TryLock())
       //已经通过TryLock（）加锁，不能再次加锁
       lock.Lock()

   }

注释EN55014-1

CS5511是一个将DP/eDP输入转换为LVDS信号的桥接芯片，此外，CS5511可以用作在DP/eDP输入到DP/eDP输出场景中桥接芯片