精华内容
下载资源
问答
  • Transformer代码详解

    2021-03-20 17:38:10
    理论部分请看其他教程,本文详解代码。 Embedding Embedding很好理解,vocab表示词表大小,d_model表示embedding大小。至于返回值为什么乘上sqrt(self.d_model) 目前还不是很理解。 class Embeddings(nn.Module): ...

    本教程适用于对Transformer理论有一定理解的朋友。理论部分请看其他教程,本文详解代码。

    Embedding

    Embedding很好理解,vocab表示词表大小,d_model表示embedding大小。至于返回值为什么乘上sqrt(self.d_model) 目前还不是很理解。

    class Embeddings(nn.Module):
        def __init__(self, d_model, vocab):
            super(Embeddings, self).__init__()
            self.lut = nn.Embedding(vocab, d_model)
            self.d_model = d_model
    
        def forward(self, x):
            return self.lut(x) * math.sqrt(self.d_model)
    

    位置编码

    因为子注意力机制在算注意力权重的时候,并没有考虑到词语前后关系,而是考虑了整体的上下文,因此需要加入位置编码。主要的数学公式如下所示:
    在这里插入图片描述
    pos可以理解成每个字符在一句话的位置,i可以理解为在embedding向量的位置。这里假设betch_size设置为1,那么一句话的矩阵表达就是:[seq_len, d_model]。在我们一开始得到了embedding后的矩阵,需要再加上PositionalEncoding矩阵,它的维度也是[seq_len, d_model],下面让我们看看如何得到这个矩阵。

    # 位置编码
    class PositionalEncoding(nn.Module):
        def __init__(self, d_model, dropout, max_len=5000):
            super(PositionalEncoding, self).__init__()
            self.dropout = nn.Dropout(dropout)
            self.pe = torch.zeros(max_len, d_model)
            # [man_len, 1]
            position = torch.arange(0, max_len).unsqueeze(1)
            # (d_model/2, )
            div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
            # pe: [max_len, d_model]  矩阵的扩充运算
            self.pe[:, 0::2] = torch.sin(position * div_term)
            self.pe[:, 1::2] = torch.cos(position * div_term)
            # pe : [1, max_len, d_model] 第一个维度是batch_size
            self.pe = self.pe.unsqueeze(0)
    
        def forward(self, x):
            # 输入的x维度: [batch_size, seq_len, d_model]
            # 因为输入的句子的长度会比设定的max_len小,因为需要切片操作
            x = x + self.pe[:, :x.size(1)]
            return self.dropout(x)
    

    画出图形看一下形状:

    import matplotlib.pyplot as plt
    plt.figure(figsize=(15,5))
    model = PositionalEncoding(20, 0)
    x = torch.zeros(1, 100, 20)
    plt.plot(range(100), model(x)[0,:, 4:8])
    plt.show()
    

    可以看到周期性的变化,这让每个位置的值都有了自己的position
    在这里插入图片描述

    展开全文
  • java贪吃蛇源代码详解

    千次阅读 2021-02-12 09:59:45
    描述1、本代码主要功能为实现贪吃蛇游戏,GUI界面做到尽量简洁和原游戏相仿。目前版本包含计分,统计最高分,长度自动缩短计时功能。2、运行时请把.java文件放入default package 即可运行。a)文件位置b)进入游戏c) ...

    描述

    1、本代码主要功能为实现贪吃蛇游戏,GUI界面做到尽量简洁和原游戏相仿。目前版本包含计分,统计最高分,长度自动缩短计时功能。

    2、运行时请把.java文件放入default package 即可运行。

    a)文件位置

    22060acf5ec533343d5167d4de383372.png

    b)进入游戏

    876592f56d3c6722eb5a5413bdaaed1a.png

    c) 游戏进行中

    02a4b577ecad1bda4b5c9eb63d4b3868.png

    JAVA实现代码

    ALL RIGHTS RESERVED 3 import java.awt.*;

    import java.awt.event.*;

    importstatic java.lang.String.format; import java.util.*;

    import java.util.List; import javax.swing.*;

    Publicclass Snakeextends JPanel implements Runnable {

    enum Dir {

    up(0, -1), right(1, 0), down(0, 1), left(-1, 0);

    Dir(intx, inty) { this.x = x; this.y = y;

    }

    finalintx, y;

    }

    staticfinal Random rand = new Random();

    staticfinalintWALL = -1;

    staticfinalintMAX_ENERGY = 1500;

    volatilebooleangameOver = true;

    Thread gameThread; intscore, hiScore; intnRows = 44;

    intnCols = 64;

    Dir dir; intenergy;

    int[][] grid;

    List《Point>snake, treats;

    Font smallFont;

    public Snake() {

    setPreferredSize(new Dimension(640, 440));

    setBackground(Color.white);

    setFont(new Font(“SansSerif”, Font.BOLD, 48));

    setFocusable(true);

    smallFont = getFont().deriveFont(Font.BOLD, 18);

    initGrid();

    addMouseListener(new MouseAdapter() {

    @Override

    publicvoid mousePressed(MouseEvent e) {

    if (gameOver) {

    startNewGame();

    repaint();

    }

    }

    });

    addKeyListener(new KeyAdapter() {

    @Override

    publicvoid keyPressed(KeyEvent e) {

    switch (e.getKeyCode()) {

    case KeyEvent.VK_UP: if (dir != Dir.down) dir = Dir.up; break;

    case KeyEvent.VK_LEFT: if (dir != Dir.right) dir = Dir.left; break;

    case KeyEvent.VK_RIGHT: if (dir != Dir.left) dir = Dir.right; break;

    case KeyEvent.VK_DOWN: if (dir != Dir.up) dir = Dir.down; break;

    }

    repaint();

    }

    });

    }

    void startNewGame() { gameOver = false;

    stop();

    initGrid();

    treats = new LinkedList<>();

    dir = Dir.left;

    energy = MAX_ENERGY;

    if (score>hiScore) hiScore = score; score = 0;

    snake = new ArrayList<>(); for (intx = 0; x< 7; x++) snake.add(new Point(nCols / 2 + x, nRows / 2));

    do addTreat(); while(treats.isEmpty());

    (gameThread = new Thread(this)).start();

    }

    void stop() {

    if (gameThread != null) {

    Thread tmp = gameThread; gameThread = null; tmp.interrupt();

    }

    }

    void initGrid() { grid = newint[nRows][nCols]; for (intr = 0;

    r《nRows; r++) { for (intc = 0; cif (c == 0 || c == nCols - 1 || r == 0 || r == nRows - 1) grid[r][c] = WALL;

    }

    }

    }

    @Override

    publicvoid run() {

    while (Thread.currentThread() == gameThread) { try { Thread.sleep(Math.max(75 - score, 25));

    } catch (InterruptedException e) {

    return;

    } if (energyUsed() || hitsWall() || hitsSnake()) {

    gameOver();

    } else {

    if (eatsTreat()) { score++; energy = MAX_ENERGY;

    growSnake();

    }

    moveSnake();

    addTreat();

    }

    repaint();

    }

    } boolean energyUsed() { energy -= 10;

    returnenergy<= 0;

    }

    boolean hitsWall() {

    Point head = snake.get(0);

    intnextCol = head.x + dir.x;

    intnextRow = head.y + dir.y;

    returngrid[nextRow][nextCol] == WALL;

    }

    boolean hitsSnake() {

    Point head = snake.get(0);

    intnextCol = head.x + dir.x;

    intnextRow = head.y + dir.y;

    for (Point p : snake) if (p.x == nextCol&&p.y == nextRow) returntrue; returnfalse;

    }

    boolean eatsTreat() {

    Point head = snake.get(0);

    intnextCol = head.x + dir.x; intnextRow = head.y + dir.y; for (Point p : treats) if (p.x == nextCol&&p.y == nextRow) { returntreats.remove(p);

    }

    returnfalse;

    } void gameOver() { gameOver = true;

    stop();

    } void moveSnake() {

    for (inti = snake.size() - 1; i> 0; i--) {

    Point p1 = snake.get(i - 1);

    Point p2 = snake.get(i); p2.x = p1.x;

    p2.x = p1.x; p2.y = p1.y;

    }

    Point head = snake.get(0); head.x += dir.x; head.y += dir.y;

    }

    void growSnake() {

    Point tail = snake.get(snake.size() - 1); intx = tail.x + dir.x; inty = tail.y + dir.y; snake.add(new Point(x, y));

    } void addTreat() { if (treats.size() 《 3) {

    if (rand.nextInt(10) == 0) { // 1 in 10 if (rand.nextInt(4) != 0) { // 3 in 4 intx, y; while (true) {

    x = rand.nextInt(nCols);

    y = rand.nextInt(nRows); if (grid[y][x] != 0) continue;

    Point p = new Point(x, y);

    if (snake.contains(p) || treats.contains(p)) continue;

    treats.add(p); break;

    }

    }

    elseif (treats.size() > 1) treats.remove(0);

    }

    }

    }

    void drawGrid(Graphics2D g) { g.setColor(Color.lightGray);

    for (intr = 0; r}

    }

    }

    void drawSnake(Graphics2D g) { g.setColor(Color.blue); for (Point p : snake) g.fillRect(p.x * 10, p.y * 10, 10, 10);

    g.setColor(energy< 500 ? Color.red : Color.orange);

    Point head = snake.get(0);

    g.fillRect(head.x * 10, head.y * 10, 10, 10);

    }

    void drawTreats(Graphics2D g) {

    g.setColor(Color.green); for (Point p : treats) g.fillRect(p.x * 10, p.y * 10, 10, 10);}

    void drawStartScreen(Graphics2D g) { g.setColor(Color.blue);

    g.setFont(getFont());

    g.drawString(“Snake”, 240, 190);

    g.setColor(Color.orange); g.setFont(smallFont);

    g.drawString(“(click to start)”, 250, 240);

    }

    void drawScore(Graphics2D g) { inth = getHeight();

    g.setFont(smallFont);

    g.setColor(getForeground());

    String s = format(“hiscore %d score %d”, hiScore, score);

    g.drawString(s, 30, h - 30);

    g.drawString(format(“energy %d”, energy), getWidth() - 150, h - 30);

    }

    @Override

    publicvoid paintComponent(Graphics gg) { super.paintComponent(gg);

    Graphics2D g = (Graphics2D) gg;

    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

    drawGrid(g);

    if (gameOver) {

    drawStartScreen(g);

    } else {

    drawSnake(g);

    drawTreats(g);

    drawScore(g);

    }

    }

    publicstaticvoid main(String[] args) {

    SwingUtilities.invokeLater(() -> {

    JFrame f = new JFrame();

    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    f.setTitle(“Snake”);

    f.setResizable(false);

    f.add(new Snake(), BorderLayout.CENTER);

    f.pack();

    f.setLocationRelativeTo(null);

    f.setVisible(true);

    });

    }

    }

    打开APP阅读更多精彩内容

    点击阅读全文

    展开全文
  • LSTM实践(代码详解)(一) 首先学习LSTM的目的:对时序数据有一个更深层次的挖掘,对比深度学习方法和机器学习方法在特征提取上的优劣。 文章目录LSTM实践(代码详解)(一)一、LSTM博文推荐二、代码详解先贴...

    LSTM实践(代码详解)(一)


    首先学习LSTM的目的:对时序数据有一个更深层次的挖掘,对比深度学习方法和机器学习方法在特征提取上的优劣。

    一、LSTM博文推荐

    这里先推荐一本教材 《TensorFlow深度学习》 。首先学习Tensorflow对LSTM实战是有帮助的。这里不对LSTM进行过多原理解释,给出几个大佬的博文供大家学习:
    博文一 :系列好文!!!大佬主要讲解了原理部分和Kears实现部分,建议有程序基础的小伙伴可以学习一下。

    博文二 :关于Tensorflow的系列好文,解释通俗易懂,想学习基础部分的小伙伴可以移步查看。

    知乎三 :这篇知乎回答可以帮助小伙伴更好的理解LSTM原理部分。

    二、代码详解

    先贴代码再解释

    代码如下:

    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns
    from sklearn import metrics
    from sklearn.model_selection import train_test_split
    from keras.models import Model
    from keras.layers import LSTM, Activation, Dense, Dropout, Input, Embedding
    from keras.optimizers import RMSprop
    from keras.callbacks import EarlyStopping
    from keras import Sequential
    
    
    # 查看数据 ===>索引、编号、标签、序列sequence
    df = pd.read_csv(r'E:\feature.csv',index_col='INDEX')
    df.drop(['ID'],axis=1,inplace=True)
    
    
    # 划分训练集测试集
    X = df.iloc[:,1:]
    Y = df.DR
    X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.15)
    
    '''
    实现方法1:模型法
    '''
    Seq_len = 100
    def RNN():
        inputs = Input(name='inputs',shape=[Seq_len])
        layer = Embedding(100,50,input_length=Seq_len)(inputs)
        layer = LSTM(64)(layer)
        layer = Dense(64,name='FC1')(layer)
        layer = Activation('relu')(layer)
        layer = Dropout(0.5)(layer)
        layer = Dense(1,name='out_layer')(layer)
        layer = Activation('sigmoid')(layer)
        model = Model(inputs=inputs,outputs=layer)
        return model
    
    model = RNN()
    model.summary()
    model.compile(loss='binary_crossentropy',optimizer=RMSprop(),metrics=['accuracy'])
    
    model.fit(X_train,Y_train,batch_size=10,epochs=100,
              validation_split=0.2,callbacks=[EarlyStopping(monitor='val_loss',min_delta=0.0001)])
    
    '''
    实现方法2:序列法
    '''
    # model = Sequential()
    # inputs = Input(name='inputs',shape=[max_len])
    # model.add(Embedding(max_words,50,input_length=max_len))
    # model.add(LSTM(5))
    # model.add(Dense(1))
    # model.add(Activation( 'sigmoid' ))
    
    
    # model.compile(optimizer= 'sgd' , loss= 'mse' ,  metrics=[ 'accuracy' ])
    # model.fit(X_train,Y_train, batch_size=10, epochs=20,callbacks=[EarlyStopping(monitor='loss',min_delta=0.0001)])
    
    
    
    accr = model.evaluate(X_test,Y_test)
    print('Test set\n  Loss: {:0.3f}\n  Accuracy: {:0.3f}'.format(accr[0],accr[1]))
    
    y_pre = model.predict(X_test)
    print(y_pre)
    y_pred = []
    for y in y_pre:
        if y > 0.5:
            y_pred.append(1)
        else:
            y_pred.append(0)
    print(y_pred)
    print(Y_test)
    
    # 查看混淆矩阵(预测值和真实值的各类情况统计矩阵)
    confusion_matrix_result = metrics.confusion_matrix(y_pred, Y_test)
    print('The confusion matrix result:\n', confusion_matrix_result)
    
    

    总结

    这里先对代码进行一个整理以及备份,没有做过多解释以及分析,想交流学习的小伙伴可以评论区回复,然后我会及时更新。

    展开全文
  • YOLOv1损失函数代码详解

    千次阅读 2021-11-22 21:30:40
    损失函数:

    V1损失函数:

     

       1、标注图像某位置有目标,预测为有==>计算not response loss 未响应损失以及box框的坐标等的信息对应蓝色框红色框

    其代码为:

    
    # # # # # # # # # # # # # # # # 本来有 预测有的损失# # # # # # # # # # # # # # # # 
            #计算包含obj损失  即本来有,预测有  和  本来有,预测无
            coo_response_mask = torch.cuda.ByteTensor(box_target.size())
            coo_response_mask.zero_()
            coo_not_response_mask = torch.cuda.ByteTensor(box_target.size())
            coo_not_response_mask.zero_()
            # 选择最好的IOU 2个box选1个吧 
            for i in range(0,box_target.size()[0],2):
                # 预测框 2个
                box1 = box_pred[i:i+2]
                box1_xyxy = Variable(torch.FloatTensor(box1.size()))
                box1_xyxy[:,:2] = box1[:,:2] -0.5*box1[:,2:4]# 左上角
                box1_xyxy[:,2:4] = box1[:,:2] +0.5*box1[:,2:4]# 右下角
                #  标注框 1个
                box2 = box_target[i].view(-1,5)
                box2_xyxy = Variable(torch.FloatTensor(box2.size()))
                box2_xyxy[:,:2] = box2[:,:2] -0.5*box2[:,2:4]
                box2_xyxy[:,2:4] = box2[:,:2] +0.5*box2[:,2:4]
                iou = self.compute_iou(box1_xyxy[:,:4],box2_xyxy[:,:4]) #[2,1]
                max_iou,max_index = iou.max(0)
                max_index = max_index.data.cuda()
                coo_response_mask[i+max_index]=1 # 最大iou对应的mask 值为1 否则为0
                coo_not_response_mask[i+1-max_index]=1# 非最大iou对应的mask 值为1 否则为0
                
            # 1.response loss响应损失,即本来有,预测有   有相应 坐标预测的loss  (x,y,w开方,h开方)参考论文loss公式
            # box_pred [144,5]   coo_response_mask[144,5]   box_pred_response:[72,5]
            # 选择IOU最好的box来进行调整  负责检测出某物体
            box_pred_response = box_pred[coo_response_mask].view(-1,5)# 最佳box坐标提出来其对应的预测值
            box_target_response = box_target[coo_response_mask].view(-1,5)# 最佳box坐标剔除来其对应的真值
            # box_pred_response:[72,5]     计算预测 有物体的概率误差,返回一个数  
            # 存在可信度计算  box_target_response[:,4]的值为1  想让box_pred_response[:,4]存在的可能性越大越好
                               
            contain_loss=F.mse_loss(
    box_pred_response[:,4],box_target_response[:,4],size_average=False)   
            # 计算(x,y,w开方,h开方)参考论文loss公式
            # 坐标可信度计算 
            loc_loss = F.mse_loss(
    box_pred_response[:,:2],box_target_response[:,:2],size_average=False) + F.mse_loss
    (torch.sqrt(box_pred_response[:,2:4]),torch.sqrt(box_target_response[:,2:4]),size_average=False)
    

    contain_loss是计算预测为有目标的网格的confidence与真值的confidence的平方误差作为loss判定。只是两个值的计算对应红色框

    loc_loss是计算蓝色框的内容

    2、标注图像某位置有目标,预测为无==>计算response loss响应损失,对应代码为:

    # # # # # # # # # # # # # 本来有 预测无的损失# # # # # # # # # # # # # # # # 
            # 2.not response loss 未响应损失,即本来有,预测无   未响应
            box_pred_not_response = box_pred[coo_not_response_mask].view(-1,5)
            box_target_not_response = box_target[coo_not_response_mask].view(-1,5)
            box_target_not_response[:,4]= 0
            #存在可信度计算   loss的目的是让box_pred_not_response越小越好。就是想让不存在的可能性越小越好
            not_contain_loss = F.mse_loss(box_pred_response[:,4],box_target_response[:,4],size_average=False)
    

    not_contain_loss是计算预测为无的网格confidence与真值的confidence的平方误差作为loss判定,也只是两个值的计算对应红色框。       可见红色框是分了两部分计算的

    3、标注图像某位置无目标,预测为有==>计算不包含obj损失  只计算第4,9位的有无物体概率的loss :对应橙色框

    
    # # # # # # # # # 本来无 预测有的损失# # # # # # # # # # # #  对应橙框
            # 计算不包含obj损失  即本来无,预测有 
            # 在预测结果中拿到真实无物体的网格,并改变形状为(xxx,30)  xxx代表一个batch的图片上的不存在物体的网格总数    30代表2*5+20   例如:[1496,30]
            # 根据noo_mask给出的0 1 信息来提取对应网格  一条数据代表一个网格的信息  noo_mask为 1 说明此网格真实无物体
            noo_pred = pred_tensor[noo_mask].view(-1,30)  
            #提取出标签图像上真实无物体的网格标签内容
            noo_target = target_tensor[noo_mask].view(-1,30)      # 例如:[1496,30]
            # ByteTensor:8-bit integer (unsigned)
            noo_pred_mask = torch.cuda.ByteTensor(noo_pred.size())   # 例如:[1496,30]
            noo_pred_mask.zero_()   #初始化全为0
            # 将第4、9  即将无obj的confidence置为1
            noo_pred_mask[:, 4] = 1
            noo_pred_mask[:, 9] = 1
            # 拿到第4列和第9列里面的值(即拿到真实无物体的网格中,网络预测这些网格有物体的概率值) 一行有两个值(第4和第9位) 
            # 例如noo_pred_c:2992  noo_target_c:2992   如果有obj存在就不会取这个值
            noo_pred_c = noo_pred[noo_pred_mask]
            # 拿到第4列和第9列里面的值  真值为0,表示真实无obj(即拿到真实无物体的网格中,这些网格有物体的概率值,为0)
            noo_target_c = noo_target[noo_pred_mask]
            # 均方误差    如果 size_average = True,返回 loss.mean()。    例如noo_pred_c:2992        noo_target_c:2992
            # nooobj_loss 一个标量  那么这个损失函数目标就是让noo_pred_c无限接近于真值0 这个loss就能无限接近最小值0 损失函数目的达到
            # 想让存在的可能性越小越好
            nooobj_loss = F.mse_loss(noo_pred_c,noo_target_c,size_average=False)
    

    noo_mask记录的是所有网格在真实图像上目标存在与否的标签。

    noo_pred是根据noo_mask标签取出的实际不含目标的预测网格的向量。其向量4,,9位置的值是预测值。

    noo_target是根据noo_mask标签取出的实际不含目标的真值网格的向量。其向量第4 ,9位置值是0。

    nooobj_loss只计算了这个些网格30维向量的4,9位置的损失值,其他位置都没用。对应上图中的橙色框。这样此部分的loss函数目标就是让预测值越接近0越好。符合了loss的目的了。

    4、标注图像某位置无目标,预测为无==>无损失(不计算)

    5、类别的损失函数计算,代码如下:

    class_loss = F.mse_loss(class_pred, class_target, size_average=False)

    class_loss计算的是类别的损失函数,是网格向量的后20个数据做最小平方误差来构建loss函数的。对应图中紫色框

    参考:

    【目标检测系列】yolov1的损失函数详解(结合pytorch代码)_gbz3300255的博客-CSDN博客

    PyTorch——YOLOv1代码学习笔记_柯南道尔的春天的博客-CSDN博客

    展开全文
  • 知识拓展——伪代码详解

    千次阅读 2021-02-23 12:52:31
    知识拓展——伪代码详解代码代码的基本控制结构伪代码实例:伪代码的特点 伪代码代码是一种介于自然语言和形式化语言之间的半形式化语言,是一种用于描述功能模块的算法设计和加工细节的语言,也称为程序...
  • 比ResNet更强的RepVGG代码详解

    千次阅读 多人点赞 2021-03-27 12:43:55
    RepVGG的PaddlePaddle复现 Hi Guy!...AI Studio有大佬复现过RepVGG,但是没有给出推理模型的转换,本文代码更全,配合代码讲解,更容易理解 论文解读:https://github.com/lmk123568/RepVGG_Tutorial/
  • 【C语言】贪吃蛇小游戏代码详解

    千次阅读 多人点赞 2021-02-08 18:13:27
    初始化游戏边界和小蛇 这个没什么难度,就是循环打印,直接放代码。 /* * 绘制游戏区域边界 */ void DrawMap(void) { int x, y; for (x = 0; x ; x += 2) { y = 0; gotoxy(x, y); printf("■"); y = ...
  • MeanTeacher 本博客仅做算法流程疏导,具体细节...代码详解 train_transform = data.TransformTwice(transforms.Compose([ data.RandomTranslateWithReflect(4), transforms.RandomHorizontalFlip(), transforms.T
  • java代码详解

    2021-03-10 05:34:06
    publicstaticStringgetDoGetURL2(Stringurl,Stringcharset)throwsException{HttpClienthttpClient=newHttpClient();httpClient.getHttpConnectionManager().getParams().... } 每一行代码的意思,谢谢! 展开
  • 俄罗斯方块——java源代码提供import java.awt.*; import java.awt.event.*; //俄罗斯方块类 public class ERS_Block extends Frame{ public static boolean isPlay=false; public .我写俄罗斯方块的时候,添加键盘...
  • 这是公众号【3D视觉工坊】出品的第一门课,视觉三维重建,基于colmap框架,保姆级教程,详细内容请见大纲,课程购买链接:彻底搞透视觉三维重建:原理剖析、代码讲解、及优化改进; 介绍 视觉三维重建 = 定位定姿 + ...
  • ORB-SLAM2代码详解01: ORB-SLAM2代码运行流程

    千次阅读 多人点赞 2021-05-14 11:24:27
    ORB-SLAM2代码详解01: ORB-SLAM2代码运行流程运行官方Demo阅读代码之前你应该知道的事情变量命名规则理解多线程为什么要使用多线程?多线程中的锁SLAM主类`System`构造函数跟踪函数 运行官方Demo 以TUM数据集为例,...
  • Python阶乘求和的代码详解发布时间:2020-09-09 05:59:45来源:脚本之家阅读:86作者:angryTomPython阶乘求和的方法题目描述:获得用户输入的整数n,输出 1!+2!+…+n!的值。如果输入数值为0、负数、非数字或非整数...
  • yolov5检测代码详解

    千次阅读 2021-02-24 16:06:05
    import argparse import time from pathlib import Path import cv2 import torch import torch.backends.cudnn as cudnn from numpy import random from models.experimental import attempt_load ...
  • 文章目录main.coled.coled.h main.c #include "led.h" #include "delay.h" #include "sys.h" #include "usart.h" #include "oled.h" int main(void) { ... NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);...
  • 粒子群PSO优化算法Matlab代码详解

    千次阅读 2021-05-20 21:45:17
    PSO算法代码详解 前期文章介绍了PSO算法的基本原理,来帮助同学们去了解PSO算法的流程。因为篇幅的问题呢,就没有在前期文章附上代码详解,为了弥补遗憾,我把代码解释作为独立的一篇博客发表,方便不同需求的同学...
  • 因为一段代码的可读性阅读他后期的维护成本也就越高。 设计模式是可以帮助你改善代码 很多时候你写出来的 ifelse 都是没有考虑使用设计模式优化,就像;同类服务的不同接口适配包装、同类物料不同组合的建造、多种...
  • } } } } } 附官方详解:http://doc.java.sun.com/DocWeb/api/javax.print.PrintService 大小: 16.4 KB 大小: 12.9 KB 大小: 8.7 KB 大小: 19.5 KB 分享到: 2012-03-03 21:08 浏览 2983 论坛回复 / 浏览 (5 / 45534...
  • DDPG算法代码详解

    2021-10-21 10:24:46
    无人机辅助移动边缘计算的计算卸载优化:一种深度确定性策略梯度方法贡献DDPG框架代码详解ActorCritic经验回放池神经网络参数更新存经验训练 参考论文: [1] Wang Y , Fang W , Ding Y , et al. Computation ...
  • 工作流审批业务代码详解(一)

    多人点赞 热门讨论 2021-09-29 14:17:36
    1.源码结构 下载好源码后,只需要关注flowable这个包,其他功能有兴趣可以自己查看。 有关于api的介绍请参考前文。 其中有几个通用的方法,为架构封装 ResponseFactory:将api提供的实体对象转为符合前台的对象 ...
  • 针对文章,有不同意见,欢迎评论区交流中文解读代码讲解,针对部分函数train.pyprocessing.pyGKT+Dense的初始图构建models.pylayers.py代码中不懂记录 中文解读 代码讲解,针对部分函数 train.py 其中的train函数 ...
  • ECCV 2020 Best Paper: RAFT 光流检测代码详解

    千次阅读 热门讨论 2021-03-19 14:30:45
    github上放出的代码也写得非常清晰,为了方便更多小伙伴了解这篇工作,下面结合原文中画的模型图对主要代码进行解释。 首先,简单介绍一下 RAFT 的整体框架。输入为连续的两帧图像,Feature Encoder(权值共享)提
  • 工作流审批业务代码详解(四)

    多人点赞 热门讨论 2021-10-15 09:52:07
    10.任务节点/TaskController 1.查询所有任务 查询所有的任务节点,主要调用historyService API提供的方法,详细逻辑见注释。 @GetMapping(value = "/list") public Result list(TaskQueryVo taskQueryVo) { ...
  • 超级好的Deep Sort的代码详解:Deep Sort的代码详解
  • BP神经网络预测matlab代码讲解与实现步骤

    千次阅读 多人点赞 2021-12-07 12:47:16
    matlab代码编写4. BP代码运行结果4.1 预测值和真实值的误差计算(MAE、MSE、MRSE)4.2 BP网络训练的性能分析图像5. 结语6. MATLAB代码 1. BP神经网络的简介和结构参数 神经网络是机器学习中一种常见的数学模型,...
  • 目标追踪---deepsort代码讲解

    千次阅读 2021-09-13 20:16:11
    目录 一、目标追踪整体代码 二、主要功能 2.1 Configs文件目录下...下面对目标追踪的重要代码的功能进行一个讲解 首先代码分为三个部分: 目标追踪的相关代码和权重 目标检测相关代码和权重,这里用的是yolov...
  • 工作流审批业务代码详解(二)

    万次阅读 多人点赞 2021-10-15 09:55:43
    5.流程定义ProcessDefinitionController 1.查询流程列表 使用repositoryService提供的API。同模型查询同理。详细逻辑见注释。 @GetMapping(value = "/list") public Result list(ProcessDefinitionQueryVo ...
  • 内容简介: 目前主流的目标跟踪算法都是基于Tracking by Detection策略,即根据目标检测结果进行目标跟踪,... 本次代码讲解主要遵循由上而下的方式,先讲总体后讲细节。 代码目录结构如下: data/2DMOT2...
  • 2021SC@SDUSC 因为brpc使用的是epoll的边缘触发,所以将fd设置为非阻塞,然后设置socket的send,recv buffer大小,然后将当前fd加入到event_dispatcher 在GetGlobalEventDispatcher中,会只进行一次初始化...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,423,385
精华内容 569,354
关键字:

代码讲解

友情链接: MFC4pic.rar