自动驾驶是高安全型应用，需要高性能和高可靠的深度学习模型，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()
}
让我知道你喜欢今天的内容
