面试篇大模型

大模型面试篇

0 基本术语

1 大模型微调的方法有哪些？

LORA：其原理如下图所示：对于一个预训练好的基座模型，保留其原有的权重矩阵W不变，仅微调训练更新部分，且这个更新权重矩阵被分解成A和B两个低秩矩阵。下图中A矩阵初始化为高斯分布矩阵，B矩阵初始化为0矩阵。

 有没有激活函数？

标准LoRA实现：在原始的LoRA论文和许多标准实现中，LoRA层的设计主要集中在通过低秩分解（如低秩矩阵分解）来高效地调整大型语言模型的权重参数。这些实现通常不引入额外的激活函数，因为它们的目标是尽可能保持原模型的结构和特性，而只是对权重进行适应性调整。

不排除有那种引入激活函数的以适应特定任务的。

import torch
import torch.nn as nn
import torch.nn.functional as F

class LoRALayer(nn.Module):
    def __init__(self, in_features, out_features, rank):
        super(LoRALayer, self).__init__()
        self.rank = rank
        
        # Initialize the low-rank matrices
        self.A = nn.Parameter(torch.randn(in_features, rank))
        self.B = nn.Parameter(torch.randn(rank, out_features))
        
        # Optional: Initialize the matrices with smaller values to avoid large initial weights
        nn.init.normal_(self.A, mean=0, std=0.02)
        nn.init.normal_(self.B, mean=0, std=0.02)
    
    def forward(self, x):
        # Compute the low-rank approximation
        return x @ self.A @ self.B

class SimpleLoRAModel(nn.Module):
    def __init__(self, input_dim, output_dim, lora_rank):
        super(SimpleLoRAModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)
        self.lora = LoRALayer(input_dim, output_dim, lora_rank)
    
    def forward(self, x):
        # Combine the original linear layer with the LoRA adaptation
        return self.linear(x) + self.lora(x)

# Example usage
input_dim = 10
output_dim = 5
lora_rank = 3

model = SimpleLoRAModel(input_dim, output_dim, lora_rank)
example_input = torch.randn(1, input_dim)
output = model(example_input)

print(output)

如果给lora加激活函数，你觉得用什么比较好，用了能不能收敛，为什么？

• ReLU和其变种（如Leaky ReLU、Parametric ReLU）在大多数情况下表现良好，收敛速度较快。
• 对于较深的网络，可能需要使用更复杂的激活函数（如Swish）来确保非线性的引入不导致梯度消失。
• 适当的权重初始化（如He初始化、Xavier初始化）对于确保带激活函数的网络能够收敛非常重要。

lora不同参数的影响？

 

RLHF:—种结合了人类反馈的强化学习方法。把人的判断引入其中。

prefix—tuning：添加前缀︰在模型的每个自注意力层和前馈网络层之前，插入一小组可学习的参数作为“前缀"。这些前缀在训练过程中与任务相关的数据一起学习，从而捕捉到新任务的特定信息。但是保持了预训练模型的参数。

传统人工设计模版中的真实token替换成可微的virtual token；该方法在输入token之前构造一段任务相关的virtual tokens作为Prefix；然后，在训练的时候只更新Prefix部分的参数，而 PLM 中的其他部分参数固定。

embedding层的表现力不够，将导致性能显著下降，因此，在每层都加了prompt的参数，改动较大。

Adapter Tuning：曾家微调结构

2 Langchain是什么？

LangChain提供了一个模块化的框架，使得开发者可以灵活地集成不同的语言模型和工具，以适应特定的应用需求。

3 gpt调用的参数又什么特点？

temputure penalty top等数值越大越容易生成不受控制新的词汇

4 语言模型如何提高？

one-shot/few-shot、one-shot-chain/few-shot-chain、LTM（拆分问题+提示问题答案的方式）

5 分词怎么进行分？

使用jieba，直接根据动词名词的此行进行分类

6 编码有哪些类型？

one-hot：第一次出现就写1 加上顺序来一个个写01

doc2bow：按照词频，忽略顺序（语法和句子结构）

TF-IDF：加权后的搭配的词频

LDA：按照一定概率来及得到不同主题词的分布

word2vec/docvec：类似pca，变成多维特征分布

在transformer里面需要位置编码：

BERT使用的位置编码是正弦余弦位置编码（Sine-Cosine Positional Encoding）。

• -周期性：正弦和余弦函数具有周期性，可以为不同位置产生不同的编码，并且在超出已知序列长度的位置上也能产生合理的编码。

• -连续性：正弦和余弦函数的连续性使得它们能够提供平滑的位置表示，有利于模型学习长距离依赖关系

正余弦位置编码指的是绝对位置编码，rope指的是相对位置编码：

有什么缺点？

不稳定，容易消失

7 常见的语言网络和区别？

textcnn：

1 通俗易懂的TextCNN-CSDN博客 主要是与训练权重里面可以训练embedding也可以不联系随机取得

2 embedding得到的vocab_size, embed_dim 前者是总数多少个字符，后者指的是特征维度

RNN:循环神经网络，LSTM网络

8 LN,bn，RNSNORM有什么不同？

LN是chananel上进行归一化，BN指的是batchsize归一化 RNORM没有算标准差只计算平均值。

9 大模型语言模型有哪些有什么区别？

gpt：训练过程：预训练无监督模型+有监督的微调 结构上是transfomer的单向decoder +生成式模型。

llama：使用Rnsnorm+swiglue+repr位置编码（采用RoPE位置编码，即苏神提出的RoPE，现在基本是大模型必备的位置编码方式）feedForward不同, 三层全连接。

llama2：和llama一样只是，多头注意力换了。

bert：双向transformer编码器+MLM随即编码器+NSP(预测一个句子） 但是相对的参数量太大

ELMo：双向的LSTM+思想就是根据当前上下文对word embedding进行动态调整的语言模型.

ChatGLM：qkv合并成一个权重convert时不是concat在一起的。

羊驼：缩小版的llama模型

qwen：FeedForward和Llama一致, 三个dense层。除了qkv有bias, 其余均没有bias

llama3：分词器比llama2大了很多128k，原来是32k。分组查询注意力：GQA在处理注意力时，不再对每个查询进行全局计算，而是将查询分成多个组，并在组内进行计算。数据过滤：高质量的数据过滤不仅减少了噪音和偏见，还确保了模型在各种应用场景中的安全性和可靠性

为什么都是解码器：

简化模型架构 生成任务的适配性  高效处理长文本

10 大模型多模态模型幻觉问题是什么？

1 数据层面：数据不均衡，并且任务量太少（例如数据量一部分很多一部分很少）

2 图片：输入图片的太小：224的基本上。Clip 训练是⽤⽂本和图像的 contrastive learning，会focus 在显著的物体，丢失⼀些细节

3 Modality Aligning：结构过于简单，图像token数量的限制

4 llm：不充分的信息融合，只关注部分 上下⽂信息，对图像的token关 注少

11 解决方法有哪些？

1 数据方面减少噪声，数据更加多样化

2 输入图片尽量分辨率大一点此外tokens可以BLIP2 32tokens -> QwenVL 256 tokens

3 结合不同的vit模型来进行提取特征

4 引入一些图像的辅助信息，例如分割和检测

5 都是试图通过输⼊不确定的视觉信息放⼤原始的LLM的先验知识⽽减少幻觉

12 qwen-vl的问题总结

基本知识点：以Qwen-7B的预训练模型作为语言模型的初始化，中间加入单层随机初始化的cross-attention，经过约1.5B的图文数据训练得到，最终图像输入分辨率为448。

语言编码器：Qwen-VL的大型语言模型使用了来自Qwen-7B模型的预训练权重。

视觉编码器：Openclip的ViT-bigG模型

视觉语言适配器：一层的crossattention的.这个机制将视觉特征序列压缩到固定长度的256。文本信息当成q

训练过程：一阶段冻结qwenlm，三阶段冻结vit

训练任务：

• 图像描述（Captioning）

• 视觉问答（VQA）

• 定位任务（Grounding）

• 参考定位和定位描述的双重任务（Ref Grounding 和 Grounded Cap.）

• 光学字符识别（OCR）

• 文本生成（Text Generation）

为了增强模型对细节的理解和定位能力，Qwen-VL的训练过程中涵盖了哪些数据形式？这些数据形式与传统的图像-文本任务有何不同？

我感觉因为1 图片分辨率是448 text token是256 2 任务量token变得很大 

13 clip问题的集合

概念：CLIP不仅是一个Zero-shot的图像分类模型，更是打开了图像和文本直接的桥梁，实现了文本-图像的预训练。

添加图片注释，不超过 140 字（可选）

编码器输出一样的序列，然后生成一个矩阵，这个矩阵和label进行余弦相似度计算

纬度变化：其实就是embediing维度都64*128✖️一起变成64*64 接着变成labels的64

几个函数 info-nce-loss：输入维度都是一样的，乘机变成了N*N，最后和N一起

def info_nce_loss(image_features, text_features, temperature=0.07):
    """
    计算InfoNCE损失。
    参数:
    - image_features: 图像特征，维度为(N, feature_dim)
    - text_features: 文本特征，维度为(N, feature_dim)
    - temperature: 温度参数，控制softmax的软度
    返回:
    - loss: 计算得到的损失值
    """
    # 计算图像和文本之间的相似度矩阵
    import ipdb;
    ipdb.set_trace()
    logits = torch.mm(image_features, text_features.t()) / temperature
    # 对角线元素是正样本的相似度
    labels = torch.arange(logits.shape[0], device=logits.device)
    # 使用交叉熵损失计算InfoNCE损失 其实就是相乘得到类别的矩阵进行交叉函数
    loss_i2t = F.cross_entropy(logits, labels)
    loss_t2i = F.cross_entropy(logits.t(), labels)
    # 返回图像到文本和文本到图像损失的平均值
    return (loss_i2t + loss_t2i) / 2

clip得原理+参数量 

余弦相似度：

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

余弦相似度是文本与图像特征之间，infonceloss是文本与图像特征和label之间的关系

14 blip问题的集合

blip1

添加图片注释，不超过 140 字（可选

​交叉注意力（CA）指的是什么：query_text 代表从文本模态编码后的特征，key_image 和 value_image 代表从图像模态编码后的特征。通过交叉注意力机制，模型能够基于图像特征来增强文本的表示，这在图像和文本的联合理解任务中非常关键。

对于itc函数：就是info函数，参照clip

添加图片注释，不超过 140 字（可选）

15 bilp2知识点合集

添加图片注释，不超过 140 字（可选）

训练：

Q-Former训练第一步：联合视觉编码器训练

Q-Former 训练的第一步，作者将 Q-Former 连接到冻结参数的图像编码器，并使用图像-文本对进行预训练，那么这一步的目标是训练好 Q-Former，以便 Queries 可以学习到如何更好地结合文本提取图片信息。

1. 图文对比学习（Image-Text Contrastive Learning，ITC）QT都遮挡 

2. 图文匹配任务（Image-Text Matching，ITM）都不遮挡

3. 基于图像的文本生成（Image-Grounded Text Generation，ITG）右上角的qt遮挡一下

Q-Former训练第二步：联合视觉编码器和大型语言模型训练在生成预训练的阶段，作者把 Q-Former 和冻结参数的 LLM 连接起来，以利用 LLM 的文本生成能力

添加图片注释，不超过 140 字（可选）

16 Llava的知识点合集

使用了感觉还是数据更加细节了，输入更多的细节数据 把检测的一些位置放进去进行学习了

​

17 CogVLM​

ViT编码器：在 CogVLM-17B 中，采用预训练的 EVA2-CLIP-E

CogVLM-17B 采用 Vicuna-7B-v1.5 进行进一步训练

视觉专家模块：在每层添加一个视觉专家模块，以实现深度的视觉 - 语言特征对齐。在每个transformer层中，图像特征使用与文本特征不同的QKV矩阵和MLP层（都是可训练的 

18 扩散模型

DDPM

AIGC系列之：DDPM原理解读（简单易懂版）-CSDN博客

总体结构

AIGC系列之：DDPM原理解读（简单易懂版）_ddpm中的unet-CSDN博客

https://juejin.cn/post/7251391372394053691

AIGC专栏2——Stable Diffusion结构解析-以文本生成图像（文生图，txt2img）为例-CSDN博客

​编辑 其实模型就是unet里面加了很多的attention

Stable Diffusion

Stable Diffusion 超详细讲解-CSDN博客

我感觉就是qkv变了一下，把q换成了我们需要的文本信息而已哦

对着噪声进行交叉熵损失

DDIM：ddim是ddpm的非马尔可夫变体

 ddpm和ddim之间的区别主要在于它们如何逆转噪声添加过程。ddpm通过许多小步骤来完成，而ddim通过更少、更大的步骤来完成。这使得ddimm能够更快地从噪声中生成清晰的图像，因为它们可以走捷径，而不需要经过每一个小步骤就能获得清晰的图像。

 dreambooth

 用于在少量镜头设置中微调文本到图像的扩散模型，同时保留模型在主题类上的语义知识。

 

 ControlNet

将原始网络的模型复制一份，称之为trainable copy，在其上进行操作施加控制条件。然后将施加控制条件之后的结果和原来模型的结果相加获得最终的输出。

不训练零卷积就是不动的，训练就会改变了 

19 分布式训练

1 PDD和PD区别

DP

基本：它通过在多个GPU上复制模型来实现数据并行性，所有操作都在一个进程中进行。只能在一台机器上的多个GPU上运行，不能跨多台机器。

工作原理：

• 将模型复制到每个GPU。
• 将输入数据分发到每个GPU。
• 每个GPU执行前向和后向传播。
• 汇总所有GPU的梯度到主设备（通常是GPU 0）。
• 主设备更新模型参数。
• 只能单机多卡

DDP

基本：提供的用于多机多GPU分布式训练的模块.能够跨多台机器进行训练，适用于大规模分布式训练任务。

• 每个进程控制一个GPU，并在该GPU上维护一个模型副本。
• 每个进程独立加载数据，并执行前向和后向传播。
• 通过分布式通信同步每个GPU的梯度。
• 每个GPU使用同步后的梯度更新模型参数。
• 可以多机多卡

举个栗子 ：4台机器(每台机器8张卡)进行分布式训练
通过 init_process_group() 对进程组进行初始化
初始化后 可以通过 get_world_size() 获取到 world_size
在该例中为32， 即有32个进程，其编号为0-31,即rank的取值范围， 可以通过 get_rank() 函数可以进行获取。 在每台机器上，local rank均为0-8，这是 local_rank 与 rank 的区别， local_rank 会对应到实际的 GPU ID 上
(单机多任务的情况下注意CUDA_VISIBLE_DEVICES的使用
控制不同程序可见的GPU devices)

注意事项：

分布式模型部署，引入SyncBN，将普通BN替换成SyncBN。

Pytorch 分布式训练（DP/DDP）_pytorch分布式训练-CSDN博客

scaler = GradScaler()
   # 反向传播和梯度缩放
    scaler.scale(loss).backward()
    
    # 调整梯度并更新参数
    scaler.step(optimizer)
    
    # 更新梯度缩放器
    scaler.update()

​

import os
import sys
import json
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data.distributed import DistributedSampler
from torchvision import transforms, datasets
from tqdm import tqdm
from model import resnet34
import torch.multiprocessing as mp
import torch.distributed as dist
# 新增导入 GradScaler 和 autocast
from torch.cuda.amp import GradScaler, autocast

def main_worker(rank, world_size):
    dist.init_process_group(backend='nccl', init_method='env://', world_size=world_size, rank=rank)
    torch.cuda.set_device(rank)
    
    device = torch.device("cuda", rank)
    print(f"using {device} device on rank {rank}.")

    data_transform = {
        "train": transforms.Compose([
            transforms.RandomResizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        "val": transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])
    }

    data_root = os.path.abspath(os.getcwd())
    image_path = os.path.join(data_root, "flower_data")
    assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    
    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
                                         transform=data_transform["train"])
    train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank)
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=16, shuffle=False,
                                               num_workers=8, pin_memory=True,
                                               sampler=train_sampler)
    
    validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
                                            transform=data_transform["val"])
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=16, shuffle=False,
                                                  num_workers=8, pin_memory=True)
    
    print("using {} images for training, {} images for validation.".format(len(train_dataset), len(validate_dataset)))
    
    net = resnet34()
    net.to(device)
    net = torch.nn.parallel.DistributedDataParallel(net, device_ids=[rank])

    loss_function = nn.CrossEntropyLoss()
    params = [p for p in net.parameters() if p.requires_grad]
    optimizer = optim.Adam(params, lr=0.0001)

    # 新增 GradScaler 实例
    scaler = GradScaler()

    epochs = 3
    best_acc = 0.0
    save_path = './resNet34.pth'
    train_steps = len(train_loader)
    for epoch in range(epochs):
        net.train()
        running_loss = 0.0
        train_sampler.set_epoch(epoch)
        train_bar = tqdm(train_loader, file=sys.stdout)
        
        for step, data in enumerate(train_bar):
            images, labels = data
            optimizer.zero_grad()
            
            # 使用 autocast 上下文管理器
            with autocast():
                logits = net(images.to(device))
                loss = loss_function(logits, labels.to(device))
            
            # 使用 scaler 进行反向传播和优化
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()
            
            running_loss += loss.item()
            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1, epochs, loss)
        
        net.eval()
        acc = 0.0
        with torch.no_grad():
            val_bar = tqdm(validate_loader, file=sys.stdout)
            for val_data in val_bar:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1]
                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
                val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1, epochs)
        
        val_accurate = acc / len(validate_dataset)
        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' % (epoch + 1, running_loss / train_steps, val_accurate))
        
        if val_accurate > best_acc:
            best_acc = val_accurate
            if rank == 0:
                torch.save(net.state_dict(), save_path)
    
    print('Finished Training')

def main():
    world_size = torch.cuda.device_count()
    mp.spawn(main_worker, args=(world_size,), nprocs=world_size, join=True)

if __name__ == '__main__':
    main()

20 混合精度 

21  Attention 和 self-attention 有什么区别？transformer复杂度是多少

attention就是一种机制动态分配不同的权重给序列不同的位置

self-attention指的是Self-attention机制会计算序列中每个位置与其他位置之间的关联程度，然后使用这些关联程度来调整每个位置的表示。这样，每个位置的表示将受到整个序列的影响，而不仅仅是局部的上下文信息。

Transformer 模型的时间复杂度通常是 O(N^2)。

22 量化与反量化问题 

23 map计算过程与map的不足之处 

如何计算map？

 

 

如何求的召回率和精度呢？在不同的置信度阈值下的排序

 

24 cnn与transformer有什么区别？ 

Transformer 通过自注意力机制捕捉全局依赖关系，适用于长序列处理和语言理解，而 CNN 通过卷积操作高效提取局部特征，适用于图像和视频处理。随着研究的进展，这两种架构的应用领域也在不断扩展，并在一些任务中相互融合，提升了模型的性能。

一个适合于全局依赖关系，适合语言理解和长序列处理，一个适合于提取局部特征

25 为什么cnn是一种特殊的自注意力机制？

卷积可以看作是一种“局部”的自注意力机制，它在数据的每个小块区域内提取特征，而不是像自注意力机制那样考虑整个输入的全局信息

26 小目标检测的方法 

增大图像的分辨率 增大模型的输出尺寸 数据增强

改变检测头的输出尺寸 

27 Transformer的Q  K  V是指什么，优缺点、改进，为什么需要更多的训练数据？self-attention中为什么除以根号dk？头数可以不断扩大吗？

Q、K、V分别表示查询(Query)、键(Key)和值(Value)，是侧重不同语义特征的权重矩阵，是自注意力机制的核心组成部分。

优点：

(1)并行计算：Q、K、V的计算可以高度并行化，使得Transformer模型具有较高的计算效率。

(2)捕捉长距离依赖：自注意力机制能够有效地捕捉输入序列中的长距离依赖关系。

(3)适用于不定长序列：Transformer模型不受输入序列长度的限制，可以处理不定长的序列输入。

缺点：

(1)参数量大：由于每个位置的Q、K、V都是通过矩阵乘法计算得到的，因此参数量较大，导致模型相对较大。

(2)计算复杂度高：虽然并行计算提高了效率，但仍然需要对输入序列中的每个位置进行计算，导致计算复杂度较高。

(3)注意力权重可解释性差：由于注意力权重是通过Q、K之间的点积计算得到的，因此在一定程度上缺乏可解释性，不易理解模型的决策过程。

为什么除以根号dk

多头 

28 Global attention与self-attention的区别

主要是一个是序列外部一个是序列内部

区别总结：

(1)计算范围不同：Self-attention 在序列内部进行计算，每个位置只与序列内其他位置相关；而 Global attention 在序列与序列之间进行计算，每个位置都与序列内所有位置相关。

(2)计算复杂度不同：由于计算范围不同，Global attention 的计算复杂度通常较高，特别是在处理长序列时。

(3)适用场景不同：Self-attention 适用于序列内部的长距离依赖关系建模，如文本序列；而 Global attention 适用于序列到序列的任务，需要考虑序列间的关系，如机器翻译。

29 扩散模型的损失函数是什么

30 目标检测的标签匹配

31 对prompt设置的一些感悟，在什么情况下怎么设置是最好的 

1 明确提出的要求 2 提供上下文 3 多一些信息 4 思维链方式，few-shot方式

32 sam知识点

image-encoder 用了一个MAE预训练的ViT。

prompt-encoder  指的是对于mask类型的提示，文中使用卷积讲mask转为embedding；points使用位置编码（别的论文的编码方式，详见原文）；box使用一对位置编码（左上角和右下角）；text提示直接使用CLIP的text-encoder。

mask-decoder

 设置的任务

1 单点验证图像中的掩码（通过单点来识别区域）

2 进行边缘检测

3 生成物体的区域（检测）

4 实力分割

 标注阶段通常包括三个主要阶段：

1 模型辅助标注

2 半自动标注

3 全自动标注

prompt的提示有哪些

 33 旋转90度的方法

 

 34 有哪些轻量化网络

MobileNet发展史：

MobileNet V1：使用了深度可分离卷积

MobileNet V2：MobileNet V2同样借鉴了ResNet，采用了残差结构，将输出与输入相加，但是ResNet中的残差结构是先降维卷积再升维，而MobileNet V2则是先升维卷积再降维

MobileNet V3：将原来的avg前移了

 EfficientNet：就是分别找到宽度、深度和分辨率的最佳系数，然后将它们组合起来一起放入原本的网络模型中，对每一个维度都有所调整。

主要特点是：

复合缩放： EfficientNet 在不同的网络维度（深度、宽度、分辨率）上进行统一的缩放，以获得更好的性能。
深度可扩展： 通过增加网络深度，可以捕获更丰富的特征表达。
宽度可扩展： 增加网络通道数可以提升网络的特征表示能力。
分辨率可扩展： 使用不同分辨率的输入图像可以适应不同任务和需求。
复合缩放参数： 通过复合缩放参数来平衡深度、宽度和分辨率的权衡。

35 detr原理 

【深入理解DETR】DETR的原理与算法实现-CSDN博客

利用了端到端的测试流程

position embing这个指的是高宽的位置编码，就是图片特征的位置编码

输出时候是（bs，100，92）（bs，100，4）意思是 92个类别 4个bbox 100个物体检测框

query的初始值是0，(100,256)，object query也是(100,256)，encoder的输出包含了图像提取的全局信息，通过两个检测头得到预测框的坐标和类别 

loss是分类损失+bbox损失（l1损失+giou损失）

 

36 为什么不用 T5

任务限制+模型太大

36 opencv

例如一个步骤：对图像进行矫正：比如我要做一个证件矫正你可以用传统图像处理的方法或者模型也行，提供点思路去解决这个问题?不需要考虑图像质量、是否能成功，只需要单纯的提供思路

 

总结一下：

1 检测：灰度图+去噪——边缘检测——轮廓检测（圆、方形） ——透视变换——图像裁剪

2 分割：灰度图+去噪——直方图均衡——阈值分割

37 swin transformer比VIT好在哪

 1 swin滑动窗口  vit是固定窗口 2效率好，减少模型计算内存

38 dataset与dataloder有什么区别 

 39 Linux什么命令可以查询当前文件夹下所有文件的文件数量并解释一下

40 深度可分离卷积,参数量减少了多少，怎么推导的

41 关于LSTM与RNN问题 

RNN

对于RNN来说：为了建模序列问题，RNN引入了隐状态h（hidden state）的概念，隐状态h可以对序列形的数据提取特征，接着再转换为输出。

 问题：关键字单词间隔不断增大时，RNN会丧失学习到连接如此远的信息的能力。

LSTM

 tanh：引入新信息进行迭代。

sigmoid：引入旧信息并筛选。

第一，sigmoid层称“输入门层”决定什么值我们将要更新；
第二，一个tanh层引入新信息

为什么可以解决长序列问题？

1 引入了记忆单元——根据simoid还更新重要的内容

2 引入了三个门来控制流动：保证输入多少已有的信息

能够保留关键信息跨越多个时间步，使得模型能够更好地捕捉和学习长期依赖关系。

这样更少出现训练中的数值不稳定现象。

42 解决文本长序列你用什么方法吗

1 Lstm的遗忘门，输入们，细胞更新等，加入simoid

2 Longformer中的三类方法

Sliding Window Attention：

是一种局部注意力机制，它仅仅允许每个位置的token与其附近的若干个token进行注意力计算，而不是与整个序列中的所有token进行注意力计算。线性时间复杂度（O(n)），而不是标准Transformer中的平方时间复杂度（O(n2)）

空洞滑窗机制:

旨在捕捉更广泛的依赖关系。在这种机制中，注意力窗口之间有间隔（称为膨胀系数或dilation），即每个token与其周围的token进行注意力计算

融合全局信息的滑窗机制

Sliding Window Attention处理局部依赖，大幅降低了模型的计算复杂度；而Global Attention则使得模型可以在需要时捕捉全局信息。这种组合有效平衡了模型的计算效率和能力，使得Longformer能够在处理长文本时仍然具有强大的表现。

3 对于Linear Transformers

43 算子优化 

1 低精度计算（Mixed Precision）：使用低精度的数据类型（如FP16）进行计算，可以减少内存占用并加速计算，同时在一定程度上保持模型的精度。

2 融合操作（Operator Fusion）：将多个算子合并为一个算子，减少中间数据的传输和存储开销，从而提高计算效率。例如，将卷积和激活函数的操作进行融合。

3 自定义算子（Custom Kernels）：针对特定硬件（如GPU、TPU）编写自定义算子，以充分利用硬件的并行计算能力和内存带宽。

4 perchannel量化

44 交叉熵与平方损失函数

45 NMS的意义