AIGC时代算法工程师的面试秘籍（第二十七式2024.11.18-12.1） |【三年面试五年模拟】

文摘科技 2024-12-01 20:12 浙江

近期文章回顾（更多热门文章请关注公众号与知乎Rocky Ding哦）

写在前面

“
【三年面试五年模拟】旨在整理&挖掘AI算法工程师在实习/校招/社招时所需的干货知识点与面试经验，力求让读者在获得心仪offer的同时，增强技术基本面。
”

Rocky最新发布Stable Diffusion 3和FLUX.1系列模型的深入浅出全维度解析文章，点击链接直达干货知识：https://zhuanlan.zhihu.com/p/684068402

大家好，我是Rocky。

又到了定期学习《三年面试五年模拟》文章的时候了！本周期共更新了80多个AIGC面试高频问答，依旧干货满满！诚意满满！

《三年面试五年模拟》系列文章帮助很多读者获得了心仪的算法岗offer，收到了大家的很多好评，Rocky觉得很开心也很有意义。

在AIGC时代到来后，Rocky对《三年面试五年模拟》整体战略方向进行了重大的优化重构，在秉持着Rocky创办《三年面试五年模拟》项目初心的同时，增加了AIGC时代核心的版块栏目，详细的版本更新内容如下所示：

整体架构：分为AIGC知识板块和AI通用知识板块。
AIGC知识板块：分为AI绘画、AI视频、大模型、AI多模态、数字人这五大AIGC核心方向。
AI通用知识板块：包含AIGC、传统深度学习、自动驾驶等所有AI核心方向共通的知识点。

Rocky已经将《三年面试五年模拟》项目的完整版构建在Github上：https://github.com/WeThinkIn/Interview-for-Algorithm-Engineer/tree/main，本周期更新的80+AIGC面试高频问答已经全部同步到项目中了，欢迎大家star！

本文是《三年面试五年模拟》项目的第二十七式，考虑到易读性与文章篇幅，Rocky本次只从Github完整版项目中摘选了2024年11月18号-2024年12月1号更新的部分高频&干货面试知识点和面试问题，并配以相应的参考答案（精简版），供大家学习探讨。

在《三年面试五年模拟》版本更新白皮书，迎接AIGC时代中我们阐述了《三年面试五年模拟》项目在AIGC时代的愿景与规划，也包含了项目共建计划，感兴趣的朋友可以一起参与本项目的共建！

《三年面试五年模拟》系列将陪伴大家度过整个AI行业的职业生涯，并且让大家能够持续获益。

So，enjoy（与本文的BGM一起食用更佳哦）：

正文开始

目录先行

AI绘画基础：

AIGC面试中必考的Stable Diffusion系列模型版本有哪些？
AIGC面试中必考的AI绘画技术框架脉络是什么样的？

AI视频基础：

Sora的Text-Encoder模型架构是什么样的？
AI视频大模型的生成质量指标有哪些？

深度学习基础：

介绍一下PyTorch中.detach()、.clone()、requires_grad=True、torch.no_grad()的原理与作用
介绍一下CLIP-pooled-embedding的作用

机器学习基础：

什么是机器学习中的对比学习？
机器学习中训练集、验证集、测试集之间有哪些区别？

Python编程基础：

介绍一下Python中的sequence和mapping代表的数据结构
在AI服务中如何设置项目的base路径？

模型部署基础：

如何构建TensorRT模型的缓存机制？
AI模型的轻量化效果评价指标有哪些？

计算机基础：

介绍一下AI行业中API的原理与作用
计算机中http协议与ssh协议有哪些异同？

开放性问题：

AI算法工程师如何提升在AI行业中的影响力？
AI算法工程师如何破圈在社会中提升自己的影响力？

AI绘画基础

【一】AIGC面试中必考的Stable Diffusion系列模型版本有哪些？

当前AIGC时代的AI算法面试中，Stable Diffusion系列模型是一个必考模型，Rocky在这里为大家梳理其中的必考版本，大家需要深入了解：

Stable Diffusion 1.x版本，必考！
Stable Diffusion 2.x版本，可能考
Stable Diffusion XL版本，必考！
Stable Diffusion 3.x版本，必考！
FLUX.1版本，必考！

【二】AIGC面试中必考的AI绘画技术框架脉络是什么样的？

在进入AIGC时代后，大家在面试AIGC算法工程师时，面试官对于AI绘画技术的考察是面试的重中之重，因此Rocky总结梳理了AI绘画技术在工业界、投资界、学术界、竞赛界以及应用界的核心框架脉络，让大家能够有目标的进行技术学习与面试准备：

AI绘画核心大模型：以FLUX.1系列和Stable Diffusion系列模型的知识为主，再加上DaLL-E、Imagen、Playgrond等主流AI绘画大模型的考察。
AI绘画中的LoRA模型：LoRA模型相关知识的考察，包括SD LoRA模型、FLUX.1 LoRA、Dreambooth LoRA、Textual Inversion等。
AI绘画生成可控模型：ControlNet系列模型、IP-Adapter模型等。
AI绘画框架：ComfyUI、Stable Diffusion WebUI、Fooocus等。
AI绘画辅助模型：GAN、U-Net、SAM、Dino等。

Rcoky也在撰写与沉淀AI绘画技术框架脉络的相关干货文章，力求给大家全网最详细的讲解与分析：

深入浅出完整解析Stable Diffusion 3（SD 3）和FLUX.1系列核心基础知识深入浅出完整解析Stable Diffusion XL（SDXL）核心基础知识深入浅出完整解析Stable Diffusion（SD）核心基础知识深入浅出完整解析Stable Diffusion中U-Net的前世今生与核心知识深入浅出完整解析LoRA（Low-Rank Adaptation）模型核心基础知识深入浅出完整解析ControlNet核心基础知识深入浅出完整解析主流AI绘画框架（Stable Diffusion WebUI、ComfyUI、Fooocus）核心基础知识深入浅出完整解析AIGC时代中GAN（Generative Adversarial Network）系列模型核心基础知识

AI视频基础

【一】Sora的Text-Encoder模型架构是什么样的？

从Sora开源的技术报告中我们可以看到，Sora支持文本Promot和图像Prompt的输入，直观地来说，Sora可能配备了类似于CLIP的Text Encoder和Image Encoder来提取文本和图像两个模态的信息，并进行多模态信息特征的对齐。

【二】AI视频大模型的生成质量指标有哪些？

在AI视频大模型的生成质量评价指标中，我们可以使用自动化指标评估和人工评估两种方式。

在自动化评估指标方面，为了评估文本到视频生成的质量，我们可以使用VBench中的多个指标，如人类动作、场景、动态程度、外观风格等。同时还可以使用两个额外的视频评估工具：Devil 中的 Dynamic Quality （动态质量）和 Chrono-Magic 中的 GPT4o-MT Score，这些工具专注于视频的动态特性。动态质量是通过将各种质量指标与动态评分相结合来定义的，这种方法减少了视频动态性与视频质量之间的负相关性所带来的偏差，从而更全面地评估视频质量。

同时我们还可以设置人工评估，比如CogVideoX论文中设计了一百个精心编写的Prompt，这些Prompt的特点是分布广泛、表述清晰、概念范围明确。用这些提示词生成视频，并让评估小组为视频进行打分，每个子项评分范围为0到1，整体总分则在0到5之间，得分越高表示视频质量越好。同时任何分数扣减的原因也被仔细记录。主要从下面四个角度进行人工打分：

感官质量（Sensory Quality）：主要关注生成的视频的感知质量，包括主体一致性、帧的连续性和稳定性。
指令遵循（Instruction Following）：主要关注生成的视频是否与输入Prompt对齐，包括主体的准确性、数量、元素和细节的正确性。
物理模拟（Physics Simulation）：主要关注生成的视频是否能够遵循物理世界的客观法则，例如光照效果、不同物体之间的交互以及流体动力学的逼真度。
封面质量（Cover Quality）：主要关注从单帧图像中可以评估的指标，包括美学质量、清晰度和逼真度。

深度学习基础

【一】介绍一下PyTorch中.detach()、.clone()、requires_grad=True、torch.no_grad()的原理与作用

在 PyTorch 中，.detach()、.clone()、requires_grad=True 和 torch.no_grad() 是涉及自动微分（autograd）和张量操作的核心概念。它们控制了张量是否参与计算图的构建、是否跟踪梯度，以及如何高效地操作张量。

1. `.detach()`

作用

.detach() 方法用于从当前的计算图中分离张量。分离后的张量与原张量共享相同的存储空间（数据），但不会再参与梯度计算。

原理

在 PyTorch 的自动微分机制中，每个操作都会在后台构建一个计算图，用于反向传播计算梯度。而 .detach() 会创建一个新的张量，分离计算图：

新的张量不跟踪梯度。
新张量的 requires_grad 属性为 False。

常见用法

避免梯度计算：

在反向传播中，有些中间结果不需要计算梯度时，使用 .detach() 避免冗余计算图构建。

进行无梯度的张量操作：

处理某些张量，只需要其值而不需要其与梯度计算的关系。

示例

import torch

# 创建张量并参与计算图
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x * 2

# 分离张量，y_detached 不再参与计算图
y_detached = y.detach()

# 检查 requires_grad 属性
print(y.requires_grad)       # True
print(y_detached.requires_grad)  # False

# 修改 y_detached 的值，不影响 y
y_detached[0] = 10
print(y)  # tensor([2., 4., 6.], grad_fn=<MulBackward0>)

2. `.clone()`

作用

.clone() 方法用于深复制一个张量，新张量的存储空间与原张量完全独立。

原理

.clone() 创建一个新的张量，具有与原张量相同的数据值和属性（如 requires_grad）。
如果原张量需要梯度，clone() 出的张量会继续参与梯度计算，且其计算图关系保持不变。

常见用法

创建独立的张量拷贝：

对原张量的修改不会影响到克隆后的张量。

操作过程中需要保留中间结果：

尤其在构建复杂的计算图时，使用 .clone() 可以保留独立状态。

示例

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 克隆张量
y = x.clone()
y[0] = 10  # 修改 y 不会影响 x

# 验证
print(x)  # tensor([1., 2., 3.], requires_grad=True)
print(y)  # tensor([10.,  2.,  3.], requires_grad=True)

# 克隆张量保持计算图
z = x * 2
z_clone = z.clone()
print(z.grad_fn)       # <MulBackward0 object>
print(z_clone.grad_fn) # <MulBackward0 object>

**3. `requires_grad=True`

作用

张量的 requires_grad 属性控制其是否需要计算梯度。如果设置为 True，该张量会参与计算图的构建，并在反向传播时计算和存储梯度。

原理

当 requires_grad=True：

张量会参与计算图，记录每一步的操作。
在反向传播时，PyTorch 会根据计算图，计算梯度并存储在 tensor.grad 属性中。

当 requires_grad=False：

张量不会记录操作，且节省内存和计算资源。

常见用法

训练模型时需要梯度：

对模型参数（如权重）设置 requires_grad=True，以便在反向传播中更新权重。

冻结梯度：

在推理阶段，或冻结某些层时，将 requires_grad=False。

示例

# 创建需要梯度的张量
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 操作
y = x * 2
z = y.sum()

# 反向传播
z.backward()

# 梯度
print(x.grad)  # tensor([2., 2., 2.])

# 冻结梯度
x.requires_grad_(False)
print(x.requires_grad)  # False

4. `torch.no_grad()`

作用

torch.no_grad() 是一个上下文管理器，临时禁用自动梯度计算。

原理

在 torch.no_grad() 块内：

所有操作都会被标记为不需要梯度。
不会构建计算图。
可以节省内存和计算资源。

注意：torch.no_grad() 是临时的，只在上下文块中生效。

常见用法

推理阶段：

在模型推理中，通常只需要前向传播，使用 torch.no_grad() 避免不必要的计算图构建。

冻结梯度操作：

修改模型权重或对张量进行操作时，不希望干扰现有计算图。

示例

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)

# 不使用 torch.no_grad
with torch.no_grad():
    y = x * 2
    print(y.requires_grad)  # False

# 离开 no_grad 块后
z = x * 2
print(z.requires_grad)  # True

总结与对比

功能	作用	是否构建计算图	是否跟踪梯度
`.detach()`	分离张量与计算图，不再跟踪梯度	否	否
`.clone()`	深复制张量，生成新张量（可继续跟踪梯度）	是（如需要）	是（如需要）
`requires_grad=True`	控制张量是否需要计算梯度	是	是
`torch.no_grad()`	上下文管理器，禁用梯度计算（节省资源）	否	否

使用建议

训练阶段：requires_grad=True 保证计算图的正确构建。
推理阶段：使用 torch.no_grad()，避免不必要的计算图构建。
冻结部分梯度：使用 .detach() 或设置 requires_grad=False。
深复制张量：使用 .clone() 确保独立性。

【二】介绍一下CLIP-pooled-embedding的作用

CLIP Pooled Embedding 的作用详细解析

CLIP（Contrastive Language-Image Pretraining）是强大的AI多模态模型，由 OpenAI 提出，用于将自然语言与图像相联系。CLIP 的核心是一个双塔结构，分别包含一个文本编码器和一个图像编码器，通过对比学习（contrastive learning）训练，使图像和文本在共享的嵌入空间中具有相似的表示。

其中，Pooled Embedding 是 CLIP 提供的一种高效的语义特征表示方法，主要用于提取文本或图像的全局特征，广泛用于AI多模态任务和下游应用。

什么是 Pooled Embedding？

在 CLIP 中：

图像编码器（如 ViT 或 ResNet）将图像输入转化为一组 token 的嵌入表示。
文本编码器（如 Transformer）将文本输入转化为一组 token 的嵌入表示。

这些编码器通常生成序列化的输出，表示输入的各个部分。但在很多任务中，我们需要一个全局的语义特征，这就是 Pooled Embedding 的作用。

生成 Pooled Embedding 的方法

CLS Token（[CLS] 标记）：

在 Transformer 架构中（例如 BERT 或 CLIP 的文本编码器），通常会在输入前加入一个特殊的 [CLS] 标记。
编码完成后，CLS 的嵌入被视为全局语义表征。
CLIP 文本编码器会直接使用该 CLS Token 的嵌入作为文本的 Pooled Embedding。

Global Average Pooling（全局平均池化）：

对于图像编码器（如 ViT 或 ResNet），CLIP 通常使用全局平均池化操作，将图像的每个 token 的嵌入取平均值，生成单一向量表示，作为图像的 Pooled Embedding。

Pooled Embedding 的作用

1. 全局语义表征

Pooled Embedding 提供了输入（文本或图像）的全局语义信息，适合于需要整体语义理解的任务。

文本：表示整段文字的语义。
图像：表示整张图片的视觉语义。

2. 对比学习中的对齐

CLIP 的训练目标是将相关的图像-文本对拉近，而将不相关的对拉远。

文本和图像分别通过其编码器生成 Pooled Embedding。
通过对比学习（Contrastive Loss），CLIP 在高维空间中优化，使图像和对应文本的 Pooled Embedding 尽可能接近。

3. 下游任务的输入特征

Pooled Embedding 是许多下游任务的基础特征，常用于：

分类任务：提取图像或文本的嵌入后，输入分类器。
检索任务：用于图像到文本、文本到图像的检索匹配。
多模态任务：如视觉问答（VQA）和视觉-文本生成，使用 Pooled Embedding 作为全局上下文。

4. 高效表征

Pooled Embedding 通过一个固定大小的向量（如 512 维）表示输入，能够大幅简化计算，适合后续的处理和存储。

Pooled Embedding 的计算过程

图像编码器（Image Encoder）

假设图像编码器使用的是 ViT（Vision Transformer）：

输入图像被分成固定大小的 patch。
每个 patch 转换为 token，输入到 Transformer。
输出的 token 是一个序列，其中包括了 [CLS] token。
CLIP 使用全局平均池化（Global Average Pooling）对所有 token 取平均值，得到图像的 Pooled Embedding。

文本编码器（Text Encoder）

假设文本编码器使用的是 Transformer：

输入文本被分解为 token（如单词或子词）。
特殊的 [CLS] token 被添加到输入序列的开头。
Transformer 输出序列的表示，其中 [CLS] token 的嵌入被用作文本的 Pooled Embedding。

应用场景

1. 多模态检索

通过 Pooled Embedding，可以实现图像与文本的相互检索：

将图像的 Pooled Embedding 与文本的 Pooled Embedding 在共享空间中匹配。
相似度较高的嵌入被认为是相关的。

2. 分类任务

提取图像的 Pooled Embedding，作为输入特征传递给分类器。
可用于物体分类、情感分析等任务。

3. 内容生成

在生成任务中（如文本生成、图像生成），Pooled Embedding 可以作为条件输入，指导生成过程。

4. 语义搜索

使用文本 Pooled Embedding，快速进行语义相关内容的检索。
如基于文本描述搜索图像。

优点与局限性

优点

简洁高效：Pooled Embedding 是固定大小的向量，便于存储和后续计算。
语义丰富：对输入的全局语义有良好概括。
适用广泛：适合检索、分类等多种任务。

局限性

上下文丢失：对于复杂输入，可能丢失部分局部细节。
固定长度限制：特征向量维度固定，可能不足以表达某些复杂场景的全部信息。

机器学习基础

【一】什么是机器学习中的对比学习？

对比学习（Contrastive Learning）的核心概念

对比学习（Contrastive Learning）是一种无监督学习方法，其核心目标是通过对比数据样本之间的相似性与差异性，学习出高质量的特征表示。在机器学习和深度学习中，对比学习被广泛用于生成语义丰富的表示，特别是在视觉、自然语言处理（NLP）和多模态任务中。

1. 对比学习的核心思想

对比学习的关键在于：

将相似的数据样本拉近：对语义相似或共享上下文的样本，学到的表示应该在高维嵌入空间中接近。
将不相似的数据样本拉远：对于语义无关或无上下文关系的样本，其嵌入表示应该远离。

通过这一拉近和拉远的机制，模型可以在没有明确监督信号（如标签）的情况下，学习到语义上有意义的特征。

2. 对比学习的基本构造

(1) 正样本对（Positive Pair）

正样本对是语义相似的两个数据样本。
通常通过数据增强生成，例如对一张图像应用不同的增强方法（裁剪、翻转、变换等）。

(2) 负样本对（Negative Pair）

负样本对是语义上不相关的两个数据样本。
通常在一个小批量数据中，将不同样本视为负样本。

(3) 对比损失函数（Contrastive Loss）

对比学习通过设计损失函数，使正样本对在嵌入空间中更接近，负样本对更远离。
常用的对比损失包括：

是正样本对的嵌入表示。
表示相似度函数（如余弦相似度）。
是温度参数，用于调节分布平滑性。
表示小批量中的样本数。
是样本对的欧几里得距离。
表示样本对的标签（1 为正样本对，0 为负样本对）。
是一个距离的阈值。
基于欧几里得距离的对比损失：
InfoNCE 损失：

3. 对比学习的实现框架

(1) 数据增强

对比学习的正样本对通常通过数据增强生成，常用的方法包括：

图像任务：随机裁剪、旋转、翻转、颜色扰动。
文本任务：同义词替换、删除、句子重组。
时间序列任务：时间窗裁剪、噪声添加。

(2) 嵌入空间的设计

使用神经网络将数据样本映射到高维嵌入空间：

使用主干模型（如 ResNet、Transformer）提取特征。
加入投影头（Projection Head）将特征映射到嵌入空间，用于对比学习。

(3) 小批量采样

在每个小批量中，生成多个正样本对和负样本对：

正样本对：同一数据的增强视图。
负样本对：其他样本的视图。

4. 对比学习的优势

无需标签：

通过无监督学习，大幅减少对人工标注的依赖。

语义相关性：

嵌入空间的表示保留了语义信息，可以用在分类、检索等任务中。

泛化能力强：

学到的特征可以迁移到不同的下游任务。

【二】机器学习中训练集、验证集、测试集之间有哪些区别？

在机器学习中，数据集的划分是非常关键的一步，通常将数据划分为训练集、验证集和测试集。

训练集是模型学习的依据；
验证集是模型优化的工具；
测试集是评估模型性能的标准。

正确地划分和使用这些数据子集是确保模型性能和泛化能力的关键。

1. 训练集 (Training Set)

定义

训练集是用于训练模型的数据子集。模型通过训练集中的样本学习输入特征和目标输出之间的关系，调整模型的参数（如权重和偏置）以最小化预测误差。

特点

模型训练的主要依据：训练集是用来优化模型的，模型会直接接触这些数据并从中学习。
数据量通常是最多的，以保证模型有足够的样本来学习数据分布。
通常用在监督学习中，训练集包括输入特征和对应的目标标签。

目的

优化模型的性能，使其能够尽可能准确地预测训练数据中的目标值。
学习数据的模式和规律。

2. 验证集 (Validation Set)

定义

验证集是用于评估模型性能并调整超参数的数据子集。模型通过验证集来评估在未见数据上的表现，从而指导模型的超参数调节和选择最佳模型。

特点

模型优化的工具：验证集用来调节超参数（如学习率、正则化强度、神经网络的层数等），而不直接影响模型的权重。
验证集中的样本不用于训练，因此它能更好地反映模型在未知数据上的表现。
数据量一般比训练集少，但必须足够大以保证评估的可靠性。

目的

避免模型过拟合（overfitting）或欠拟合（underfitting）。
帮助选择最佳的模型结构或超参数。

注意

如果超参数调节过多，验证集实际上可能成为一种“隐式训练数据”，从而降低模型对真正未知数据的泛化能力。

3. 测试集 (Test Set)

定义

测试集是用于最终评估模型性能的数据子集。这些数据在模型训练和验证过程中是完全未见的，目的是对模型的真实泛化能力进行客观评估。

特点

最终性能的衡量标准：模型在测试集上的表现代表了它对完全未知数据的预测能力。
测试集数据不能用于模型的训练或优化。
数据量一般比训练集和验证集更少，但应足够大以确保评估的可靠性。

目的

提供对模型在生产环境中真实表现的估计。
检测模型是否有过拟合的迹象（即在训练集和验证集上表现良好，但在测试集上表现差）。

三者的区别总结

特性	训练集	验证集	测试集
用途	训练模型、调整权重	调整超参数，选择最佳模型	最终评估模型性能
模型接触方式	模型直接接触，权重被更新	模型间接接触，用于优化超参数	模型完全不可见，仅用于测试
数据量	最大	中等	最小
影响阶段	训练阶段	优化阶段	评估阶段
能否调整参数	是	是（调整超参数）	否（仅用于测试）

数据划分比例

根据数据集大小的不同，训练集、验证集和测试集的划分比例也会有所不同。以下是常见的划分比例：

常规情况：训练集 : 验证集 : 测试集 = 6:2:2 或 8:1:1。
小数据集：由于数据量少，可以采用交叉验证（Cross-Validation）代替单一验证集。
大数据集：可以划分出更多比例的数据作为测试集或验证集。

验证集和测试集的特别注意点

验证集的动态性：

在训练过程中，验证集可能会多次用来评估模型。
如果过度依赖验证集调整超参数，可能导致模型在验证集上表现较好但对真正未知数据（测试集）表现较差。

测试集的隔离性：

测试集必须完全独立，不能用于调参，否则会失去衡量模型真实性能的意义。
如果多个模型使用同一个测试集进行评估，可能会导致数据泄漏或过度拟合。

Python编程基础

【一】介绍一下Python中的sequence和mapping代表的数据结构

在 Python 中，**Sequence** 和 Mapping 是两种核心的数据结构抽象类型，定义了不同的行为模式和用途。这些抽象类型在 collections.abc 模块中被定义，表示 Python 中通用的序列和映射行为。

Sequence 是按位置组织的有序数据结构，适合需要通过索引访问数据的场景。
Mapping 是键值对组织的无序数据结构，适合通过键快速查找值的场景。

Python 提供了丰富的内置类型和扩展类型，使得 Sequence 和 Mapping 能满足各种编程需求。了解它们的特性有助于选择合适的数据结构进行AI项目的高效开发。

Sequence

Sequence 是一种线性排列的有序数据结构，允许通过整数索引访问元素。序列支持切片和迭代操作，是最常见的容器之一。

常见的 Sequence 类型

**list**：可变序列，可以动态修改内容。
**tuple**：不可变序列，内容一旦定义就无法修改。
**str**：表示文本的不可变序列，每个元素是字符。
**range**：表示整数序列的不可变对象。
**collections.deque**：双端队列，可高效地在两端插入或删除元素。

Sequence 的特点

有序性：元素按照插入顺序排列。
支持索引：可以使用整数索引访问元素。
支持切片：可以通过切片操作获取子序列。
支持迭代：可以使用 for 循环遍历元素。

Sequence 的常用操作

以下是序列支持的一些通用操作：

操作	描述	示例
`obj[index]`	获取指定索引的元素	`my_list[0]`
`obj[start:end]`	切片操作，获取子序列	`my_list[1:3]`
`len(obj)`	获取序列长度	`len(my_list)`
`in`/`not in`	检查元素是否存在	`3 in my_list`
`+`/`*`	连接或重复序列	`[1, 2] + [3, 4]` 或 `[1] * 3`
`for x in obj`	遍历序列的每个元素	`for x in my_list: print(x)`

示例代码

from collections.abc import Sequence

# 定义不同类型的 Sequence
my_list = [1, 2, 3]       # list
my_tuple = (4, 5, 6)      # tuple
my_str = "hello"          # string

# 检查是否为 Sequence 类型
print(isinstance(my_list, Sequence))  # True
print(isinstance(my_tuple, Sequence)) # True
print(isinstance(my_str, Sequence))   # True

# 使用序列操作
print(my_list[0])         # 1
print(my_tuple[-1])       # 6
print(my_str[1:4])        # "ell"

Mapping

Mapping 是一种键值对（key-value）结构，表示元素的无序集合。它允许通过键（key）快速访问对应的值（value）。

常见的 Mapping 类型

**dict**：Python 内置的字典类型，支持哈希表操作。
**collections.OrderedDict**：保留插入顺序的字典。
**collections.defaultdict**：提供默认值的字典。
**collections.Counter**：计数器，统计元素出现次数。

Mapping 的特点

键值对存储：每个元素是 key: value 形式。
键的唯一性：每个键必须唯一，不能重复。
无序性：普通字典中，键值对的排列无序（从 Python 3.7 开始，dict 保留插入顺序）。
快速查找：通过键可以快速找到对应的值。

Mapping 的常用操作

以下是映射支持的一些通用操作：

操作	描述	示例
`obj[key]`	获取指定键的值	`my_dict["name"]`
`obj[key] = value`	设置或更新键对应的值	`my_dict["age"] = 25`
`del obj[key]`	删除指定键的键值对	`del my_dict["name"]`
`key in obj`	检查键是否存在	`"name" in my_dict`
`obj.keys()`	返回所有键	`my_dict.keys()`
`obj.values()`	返回所有值	`my_dict.values()`
`obj.items()`	返回所有键值对	`my_dict.items()`
`len(obj)`	返回映射的键值对个数	`len(my_dict)`

示例代码

from collections.abc import Mapping

# 定义不同类型的 Mapping
my_dict = {"name": "Alice", "age": 30}        # dict
from collections import defaultdict
my_defaultdict = defaultdict(int)            # defaultdict

# 检查是否为 Mapping 类型
print(isinstance(my_dict, Mapping))          # True
print(isinstance(my_defaultdict, Mapping))   # True

# 使用映射操作
print(my_dict["name"])                       # "Alice"
my_dict["age"] = 35                          # 更新值
my_dict["gender"] = "Female"                 # 添加新键值对
print(my_dict.keys())                        # 返回所有键

Sequence vs Mapping

特性	Sequence	Mapping
数据结构	有序	无序
访问方式	通过索引访问	通过键访问
数据存储	按位置存储元素	键值对存储
可迭代性	可以迭代元素	可以迭代键、值或键值对
示例类型	`list`, `tuple`, `str`	`dict`, `defaultdict`, `OrderedDict`

【二】在AI服务中如何设置项目的base路径？

在 AI 服务中设置 Base Path 是一个关键步骤，它能够统一管理项目中的相对路径，确保代码在开发和部署环境中都可以正确运行。

1. 常见 Base Path 设置方案

(1) 使用项目根目录作为 Base Path

项目根目录是最常见的 Base Path 选择，适合组织良好的代码结构，所有文件和资源相对于根目录存放。

代码实现

在入口脚本中设置项目根目录：

import os

# 设置项目根目录
BASE_PATH = os.path.dirname(os.path.abspath(__file__))

# 示例：构造文件路径
config_path = os.path.join(BASE_PATH, "config", "settings.yaml")
print(config_path)

**os.path.abspath(__file__)**：获取当前脚本的绝对路径。
**os.path.dirname()**：提取文件所在目录。
优势：简单易用，适合大多数开发场景。

(2) 使用当前工作目录作为 Base Path

当前工作目录（Current Working Directory, CWD）是运行脚本时所在的目录。

代码实现

import os

# 获取当前工作目录
BASE_PATH = os.getcwd()

# 示例：构造文件路径
model_path = os.path.join(BASE_PATH, "models", "model.pt")
print(model_path)

适用场景：

项目运行时始终从固定目录启动，例如通过 cd /path/to/project 再运行脚本。

注意：如果脚本从不同目录运行，可能导致路径解析错误。

(3) 使用环境变量设置 Base Path

通过环境变量配置 Base Path，适合多环境部署，能够动态调整路径。

设置环境变量

Linux/Mac：
```
export BASE_PATH=/path/to/project
```
Windows（命令提示符）：
```
set BASE_PATH=C:\path\to\project
```

代码实现

在代码中读取环境变量：

import os

# 获取环境变量设置的 Base Path
BASE_PATH = os.getenv("BASE_PATH", os.getcwd())

# 示例：构造文件路径
data_path = os.path.join(BASE_PATH, "data", "dataset.csv")
print(data_path)

**os.getenv()**：读取环境变量，第二个参数是默认值。
优势：适合不同环境配置（开发、测试、生产）。

(4) 使用配置文件指定 Base Path

通过配置文件集中管理路径信息，方便维护。

配置文件示例

config.yaml：

base_path: "/path/to/project"

代码实现

使用 PyYAML 读取配置文件：

import os
import yaml

# 读取配置文件
with open("config.yaml", "r") as f:
    config = yaml.safe_load(f)
BASE_PATH = config["base_path"]

# 示例：构造文件路径
log_path = os.path.join(BASE_PATH, "logs", "service.log")
print(log_path)

优势：路径配置集中化，易于管理。
注意：需要额外依赖 PyYAML 或其他配置解析工具。

(5) 使用路径管理模块

封装路径管理逻辑到单独模块，例如 folder_paths.py，便于多脚本共享。

`folder_paths.py` 示例

import os

# 定义 Base Path
BASE_PATH = os.path.dirname(os.path.abspath(__file__))

# 目录路径
models_dir = os.path.join(BASE_PATH, "models")
data_dir = os.path.join(BASE_PATH, "data")
logs_dir = os.path.join(BASE_PATH, "logs")

# 获取完整路径
def get_full_path(sub_dir, file_name):
    return os.path.join(BASE_PATH, sub_dir, file_name)

在其他脚本中使用

import folder_paths

# 使用路径管理模块获取路径
model_path = folder_paths.get_full_path("models", "model.pt")
print(model_path)

# 使用预定义的路径
print(folder_paths.models_dir)

优势：集中路径逻辑，减少重复代码。

2. 选择 Base Path 的策略

开发阶段

使用项目根目录作为 Base Path，便于在本地开发和调试。
使用 os.path.abspath(__file__) 确保路径与代码结构一致。

部署阶段

推荐使用环境变量或配置文件管理 Base Path，支持灵活调整路径。
确保环境变量和配置文件在不同环境中正确设置。

模型部署基础

【一】如何构建TensorRT模型的缓存机制？

在TensorRT架构中，模型运行主要依赖GPU，因此直接支持将整个TensorRT引擎从GPU移动到CPU并非直接内置的功能。但是我们可以通过一些技巧，将TensorRT引擎对象序列化到CPU（或者磁盘），并在需要时反序列化加载到GPU，可以有效管理显存，特别是在多模型推理或资源有限的场景下。这种方法实现了类似“缓存”的机制，能够动态加载模型到GPU，同时释放未使用的GPU资源，从而提高硬件资源的利用效率。

1. 基本思路

TensorRT模型（即引擎）在推理时需要加载到GPU中运行。如果需要将模型“缓存”到CPU，可以通过以下方法：

序列化引擎：

在推理完成后，将引擎序列化为二进制数据并存储在CPU内存中（甚至可以存储到磁盘）。

反序列化引擎：

在需要推理时，将二进制数据反序列化为TensorRT引擎，并加载到GPU中执行推理。

这种方法模拟了将模型缓存到CPU的过程，因为TensorRT本身无法直接在CPU上运行。

2. 实现步骤

1. 加载模型并创建TensorRT引擎

首先我们加载ONNX模型或已有的TensorRT引擎，并创建可用于推理的引擎。

import tensorrt as trt

# 加载 TensorRT Logger
logger = trt.Logger(trt.Logger.WARNING)

# 创建 TensorRT Builder 和 Network
builder = trt.Builder(logger)
network = builder.create_network(flags=1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))

# 加载 ONNX 文件
onnx_file = "model.onnx"
with trt.OnnxParser(network, logger) as parser:
    with open(onnx_file, 'rb') as f:
        parser.parse(f.read())

# 构建引擎
config = builder.create_builder_config()
config.max_workspace_size = 1 << 30  # 设置最大工作空间
engine = builder.build_engine(network, config)

2. 将引擎序列化到CPU

使用 TensorRT 的序列化功能，将引擎对象保存为二进制数据。

# 序列化引擎
serialized_engine = engine.serialize()

# 将序列化后的引擎保存到 CPU 内存（或者存储到文件）
cached_engine_on_cpu = serialized_engine  # 模拟缓存到 CPU

3. 在需要时重新加载引擎到 GPU

使用 TensorRT 的反序列化功能，将缓存的引擎加载回 GPU。

# 反序列化引擎
runtime = trt.Runtime(logger)
engine_from_cpu = runtime.deserialize_cuda_engine(cached_engine_on_cpu)

# 创建执行上下文
context = engine_from_cpu.create_execution_context()

4. 推理流程

构造输入和输出张量，并执行推理。

import numpy as np
import pycuda.driver as cuda
import pycuda.autoinit  # 初始化 CUDA 上下文

# 创建输入和输出缓冲区
input_shape = (1, 3, 224, 224)  # 示例输入维度
output_shape = (1, 1000)  # 示例输出维度

# 在 GPU 上分配内存
d_input = cuda.mem_alloc(np.prod(input_shape) * np.float32().nbytes)
d_output = cuda.mem_alloc(np.prod(output_shape) * np.float32().nbytes)

# 创建主机上的输入数据
input_data = np.random.rand(*input_shape).astype(np.float32)
cuda.memcpy_htod(d_input, input_data)

# 执行推理
bindings = [int(d_input), int(d_output)]
context.execute_v2(bindings)

# 从 GPU 拷贝结果到主机
output_data = np.empty(output_shape, dtype=np.float32)
cuda.memcpy_dtoh(output_data, d_output)

print("Inference result:", output_data)

3. 注意事项

1. 数据传输开销

序列化和反序列化是额外的开销，因此在高频推理任务中可能导致性能下降。
如果模型较大，序列化和反序列化的时间会显著增加。

2. GPU 资源管理

每次加载引擎到 GPU 时，需要确保 GPU 上有足够的显存。
在释放 GPU 资源后，可以通过 cuda.Context.synchronize() 确保设备状态一致。

3. 磁盘与内存存储选择

如果缓存到 CPU 的模型较大，可以选择将其保存到磁盘（如 .plan 文件），并在需要时从磁盘加载。

4. TensorRT 的版本兼容性

序列化的引擎仅在相同的 TensorRT 版本、CUDA 版本和 GPU 硬件架构上兼容。如果环境变化，需要重新生成引擎。

【二】AI模型的轻量化效果评价指标有哪些？

AI模型轻量化的效果评价指标主要用于衡量模型在资源使用效率、性能表现和实际应用适应性之间的平衡。下面是Rocky总结的主流轻量化效果评价指标及其适用场景：

1. 模型大小

指标定义

模型文件大小：模型的总存储体积，通常以 MB（兆字节）或 GB（千兆字节）为单位。
参数数量（Parameter Count）：模型的可训练参数总数，通常以百万（M）或十亿（B）级别表示。

意义

存储成本：模型越小，占用的存储空间越少，更适合在资源受限的设备（如移动设备、物联网设备）上部署。
传输效率：在边缘设备与服务器之间传输模型时，小模型能够显著降低网络延迟。

评估方式

比较模型轻量化前后的文件大小或参数数量的变化，例如：
示例：一个 100MB 的模型压缩到 20MB，压缩率为 5x。

2. 推理速度

指标定义

延迟（Latency）：单次推理所需的时间，通常以毫秒（ms）为单位。
吞吐量（Throughput）：单位时间内模型能够处理的输入数量（例如 FPS 或样本/秒）。

意义

实时性：延迟低的模型适合实时应用场景，如在线翻译、视频分析。
处理效率：吞吐量高的模型适合批量处理任务，例如大规模数据预测。

评估方式

延迟：测量模型在给定硬件（如 CPU、GPU 或专用加速器）上的单次推理时间。
吞吐量：在一定时间窗口内运行模型，计算处理的输入数量。
示例：模型轻量化后推理速度提升了 3x，意味着延迟降低到 1/3。

3. 能耗

指标定义

功耗（Power Consumption）：模型推理时所需的能量消耗，通常以瓦特（W）或焦耳（J）为单位。
能效比（Energy Efficiency Ratio）：每单位功耗下模型处理的样本数量（如 FPS/W）。

意义

设备续航：低功耗模型更适合部署在电池供电设备（如手机、无人机）上。
绿色计算：节能模型更符合环保要求，尤其在数据中心部署时可以降低运营成本。

评估方式

使用硬件能耗监测工具，测量模型运行过程中的能耗，并比较轻量化前后的变化。
示例：轻量化后，模型每秒功耗从 20W 降低到 8W。

4. 精度

指标定义

模型性能指标：

生成任务：图像生成质量、对话准确度等
分类任务：准确率（Accuracy）、召回率（Recall）、F1 分数等。
回归任务：均方误差（MSE）、均绝对误差（MAE）等。
检测任务：平均精度均值（mAP）。
分割任务：交并比（IoU）。

轻量化引起的精度变化：

意义

平衡点：评估轻量化后模型性能是否显著下降，以确保模型在目标任务中的实用性。

评估方式

比较轻量化前后的模型在相同数据集上的性能表现。
示例：轻量化模型的分类准确率从 95% 下降到 94.5%，性能下降了 0.5%。

5. 内存使用

指标定义

显存占用（GPU Memory Usage）：模型推理时在 GPU 上占用的显存，通常以 MB 或 GB 为单位。
RAM 使用量（CPU Memory Usage）：模型推理时在 CPU 上占用的内存，通常以 MB 或 GB 为单位。

意义

硬件适配性：轻量化模型应能够在低资源设备（如嵌入式系统）上运行。
并发能力：占用内存越少，单一硬件上同时运行的实例数越多。

评估方式

使用监控工具（如 NVIDIA 的 nvidia-smi 或 PyTorch/TensorFlow 的内存分配监控 API）测量内存占用。
示例：轻量化后显存占用从 6GB 降低到 2GB。

6. 模型压缩比

指标定义

模型压缩比（Compression Ratio）：

意义

存储效率：高压缩比意味着模型占用的存储空间显著减少。

评估方式

计算模型在量化、剪枝或知识蒸馏后的大小变化。
示例：一个 500MB 的模型压缩到 50MB，压缩比为 10x。

7. 参数稀疏度

指标定义

稀疏率（Sparsity Ratio）：模型权重中为零的参数所占的比例。

意义

计算效率：稀疏模型在部署到支持稀疏优化的硬件（如专用加速器）时，可以显著提升推理速度和降低功耗。

评估方式

检查轻量化后的权重矩阵，计算零值权重的比例。
示例：模型稀疏率从 0% 增加到 50%。

8. 部署难易度

指标定义

模型兼容性：轻量化后的模型是否能直接运行在目标硬件（如移动设备、嵌入式设备）上。
转换成本：从开发框架到部署框架的转换复杂度（如从 PyTorch 转换到 TensorRT）。

意义

工程效率：易部署的模型可以快速投入生产环境。

评估方式

测试轻量化后的模型在目标硬件或框架（如 TensorRT、ONNX）上的兼容性。

9. 用户体验

指标定义

响应时间（Response Time）：模型在用户交互中的实际响应时间。
体验流畅度：在应用中（如手机或 AR/VR 环境），模型轻量化后是否对体验流畅性有所改善。

意义

实际效果：轻量化的最终目标是提升用户体验，这往往比单纯的性能指标更重要。

评估方式

测量轻量化模型在实际应用场景中的响应速度和流畅度。
示例：语音助手模型响应时间从 500ms 降低到 200ms。

10. 通用性和适应性

指标定义

任务迁移性能：轻量化模型在多个任务上的性能是否保持一致。
硬件适应性：模型是否能在多种硬件（如 GPU、TPU、CPU）上高效运行。

意义

可扩展性：轻量化模型应具备更广泛的适应性，而不仅仅针对单一任务或设备优化。

评估方式

在不同任务、设备上的性能测试，衡量其通用性。
示例：模型在移动设备上的推理速度提升 3x，同时在服务器上的精度几乎无损。

总结

指标类别	具体指标	意义
资源效率	模型大小、内存使用、推理速度、能耗	衡量轻量化模型在资源受限设备上的表现。
性能表现	精度、稀疏率、压缩比	确保轻量化后模型的任务性能和计算效率的平衡。
适用性与体验	部署难易度、响应时间、任务迁移性能	评估轻量化模型在实际场景中的应用和适配能力。

计算机基础

Rocky从工业界、学术界、竞赛界以及应用界角度出发，总结归纳AI行业所需的计算机基础干货知识。这些干货知识不仅能在面试中帮助我们，还能让我们在AI行业中提高工作效率。

【一】介绍一下AI行业中API的原理与作用

AI服务中的API概念详解

在AI行业中，API（Application Programming Interface，应用程序接口）是一种用于连接不同系统或服务的标准化接口。它允许开发者通过简单的请求与复杂的AI服务进行交互，而不需要深入了解服务的底层实现。API 是 AI 服务中的关键桥梁，使得复杂的 AI 模型可以以一种简单、可复用的方式被开发者调用，并将人工智能融入到各种项目中。

1. 什么是API？

定义： API 是一种定义好的通信协议，允许一个软件程序与另一个软件程序进行交互。在 AI 服务中，API 通常用来提供对 AI 模型或服务的访问接口。
作用：

将复杂的 AI 功能封装起来，通过简单的接口提供给开发者。
提供标准化的调用方式，使得开发者可以方便地集成到自己的应用中。

2. API在AI服务中的作用

2.1 模型调用

AI 服务提供商（如 OpenAI、Google Cloud AI、AWS）通过 API 暴露模型功能。
用户可以通过 API 调用模型执行特定任务，例如文本生成、图片识别或语音合成。

2.2 数据传输

API 用于在客户端（调用者）和服务端（AI 模型）之间传递输入数据和返回输出结果。

输入数据：如图片、文本、语音文件。
输出结果：如分类标签、生成的内容、分析报告。

2.3 抽象复杂性

AI 模型的训练和运行可能涉及复杂的算法和硬件部署。
API 将这些复杂性屏蔽，对外提供简单的调用接口，开发者无需关心底层实现。

2.4 易用性和集成

API 提供标准化的调用方式（如 HTTP 请求），可以方便地集成到各种编程语言和框架中。

3. 常见的AI服务API类型

3.1 基础类型API

AIGC：

提供图像生成、视频生成、文本对话等功能。
示例：Stable Diffusion API、ChatGPT API、Sora API等。

计算机视觉：

提供图像分类、目标检测、OCR（光学字符识别）等功能。
示例：Google Vision API、AWS Rekognition。

自然语言处理（NLP）：

提供语言生成、情感分析、翻译等功能。
示例：OpenAI GPT API、Azure Cognitive Services Text Analytics。

语音处理：

提供语音识别（ASR）、语音合成（TTS）等功能。
示例：Google Speech-to-Text API、Amazon Polly。

3.2 多模态API

处理多模态数据（如图像和文本的组合）：

示例：Stable Diffusion API（根据文本生成图片）、OpenAI DALL·E API。

3.3 定制模型API

提供用户上传数据的能力，用于定制模型或微调预训练模型。

示例：Hugging Face Hub API、Azure Custom Vision。

4. API的工作原理

4.1 请求-响应模式

客户端向服务端发送一个请求（Request），服务端处理后返回响应（Response）。
常用协议：HTTP/HTTPS。

4.2 RESTful API

REST（Representational State Transfer）是最常用的 API 架构风格。
特点：

使用标准的 HTTP 方法（如 GET、POST、PUT、DELETE）。
数据格式通常是 JSON 或 XML。
URL 用于标识资源，参数携带操作指令。

4.3 API结构

Endpoint（端点）：

图像分类 API 的端点：https://api.example.com/v1/image-classify
文本生成 API 的端点：https://api.example.com/v1/text-generate
每个服务提供的功能对应一个唯一的 URL。例如：

请求头（Headers）：

包含认证信息（如 API 密钥）。

请求体（Body）：

提供输入数据，如文本、图片或音频文件。

响应体（Response Body）：

服务返回的结果数据。

4.4 示例请求

以下是一个常见的 RESTful API 调用示例：

import requests

url = "https://api.example.com/v1/text-generate"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}
data = {
    "prompt": "Write a story about AI",
    "max_tokens": 100
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

5. API的关键特性

5.1 可扩展性

AI 服务提供的 API 通常支持多种输入大小、批量处理能力等，便于扩展应用。

5.2 异步支持

部分 API 支持异步调用，适合长时间运行的任务（如视频分析）。

5.3 认证和授权

使用 API 通常需要身份认证，常见方式包括：

API Key：最常见，开发者通过密钥调用服务。
OAuth：更安全的授权方式，允许第三方应用安全访问用户资源。

5.4 速率限制（Rate Limiting）

为防止滥用，API 通常限制每分钟或每小时的调用次数。例如：

每分钟最多调用 60 次。

5.5 数据安全性

API 通信通常使用 HTTPS，确保数据在传输中加密。
AI 服务提供商对上传数据和结果数据的隐私保护至关重要。

6. API的优点

快速集成：开发者无需训练模型，只需调用 API 即可实现功能。
降低门槛：非 AI 专业开发者也能利用复杂的 AI 技术。
灵活性：支持多种编程语言和框架，适用于各种项目需求。
成本优化：通过云端服务节省硬件和运维成本。

【二】计算机中http协议与ssh协议有哪些异同？

HTTP 和 SSH 协议是计算机网络中两种常见的协议，虽然它们有不同的应用场景，但在某些方面也有相似之处。HTTP 更专注于数据传输和信息展示，而 SSH 则强调安全性和远程控制。在实际应用中，选择使用哪种协议需要根据具体AI需求而定。如果追求快速、高效的数据传输，HTTP 是首选；如果需要安全的远程通信或文件传输，SSH 是不二之选。

一、HTTP 协议

定义

HTTP（HyperText Transfer Protocol，超文本传输协议）是一个无状态的、基于请求-响应模式的应用层协议，主要用于客户端和服务器之间传输超文本数据（如 HTML 文件、图片等）。

应用场景

浏览网页（通过浏览器与服务器交互）
数据传输（如 RESTful API 的数据请求）
前后端通信

技术特点

协议层：HTTP 是基于 TCP/IP 的应用层协议。
端口号：默认使用 80 端口（HTTPS 使用 443 端口）。
无状态：HTTP 本身不记录会话状态，依赖于 Cookies 或 Session 等机制实现会话管理。
通信模式：采用明文通信，数据安全性较低（除非通过 HTTPS 加密）。
扩展性：支持通过 HTTP/2 和 HTTP/3 协议进行优化，提升速度和性能。

二、SSH 协议

定义

SSH（Secure Shell Protocol，安全外壳协议）是一种为网络服务提供加密通信的协议，主要用于远程登录和其他安全网络服务。

应用场景

远程服务器登录和管理
传输文件（通过 SCP 或 SFTP）
执行远程命令
隧道代理和端口转发

技术特点

协议层：SSH 是一个基于 TCP/IP 的应用层协议。
端口号：默认使用 22 端口。
安全性：通过对数据进行加密（对称加密、非对称加密、散列算法），确保数据传输的保密性和完整性。
状态保持：SSH 是一个基于会话的协议，会在会话期间保持状态。
认证机制：支持基于密码和基于公钥的双重认证机制。

三、HTTP 和 SSH 的相同点

基于 TCP/IP 协议：

两者都工作在 TCP/IP 协议栈的应用层，依赖于 TCP 进行可靠的数据传输。

跨平台：

HTTP 和 SSH 协议都可以在多种操作系统上使用，并且都是应用广泛的标准协议。

客户端-服务器架构：

HTTP：浏览器作为客户端向 Web 服务器发送请求。
SSH：本地计算机作为客户端远程连接到 SSH 服务器。
两者都采用客户端与服务器的交互模式，例如：

扩展性：

HTTP 支持通过 HTTP/2、HTTP/3 和扩展头实现功能增强。
SSH 支持多种附加功能，如文件传输（SCP/SFTP）和端口转发。
两者都支持功能扩展。例如：

四、HTTP 和 SSH 的不同点

特性	HTTP 协议	SSH 协议
主要用途	传输超文本数据，主要用于网页浏览和前后端通信	安全远程登录和管理服务器，提供安全的命令执行和数据传输
安全性	HTTP 是明文传输（除非通过 HTTPS 加密）	SSH 默认启用加密，确保数据传输的保密性和完整性
默认端口	80（HTTP）或 443（HTTPS）	22
状态管理	无状态协议，通过外部机制（如 Cookie/Session）实现状态管理	基于会话的协议，会在整个会话期间保持连接状态
认证机制	一般无需身份认证，依赖于服务器开放的资源访问	需要身份验证（基于密码或公钥的认证机制）
通信方式	请求-响应模式，客户端发起请求，服务器返回响应	持续会话模式，客户端和服务器可以双向通信
数据内容	主要用于传输网页内容、文本数据和媒体文件	主要用于命令交互、远程文件传输和加密隧道通信
典型工具	浏览器（如 Chrome、Firefox）	SSH 客户端（如 OpenSSH、PuTTY）
传输效率	明文传输效率高，HTTPS 的加密可能稍慢，但对静态资源非常高效	数据加密增加了开销，但适合需要高安全性的通信场景

五、应用场景对比

HTTP 应用场景：

访问网页内容：如浏览器请求网页、获取图片、播放视频等。
API 调用：前端与后端的数据通信。
传输静态资源：如 HTML、CSS 和 JavaScript 文件。

SSH 应用场景：

管理服务器：远程登录到服务器执行管理任务。
传输文件：使用 SCP 或 SFTP 协议上传或下载文件。
构建安全隧道：通过 SSH 隧道代理访问内部网络或加密不安全的通信。

六、适用场景中的融合

尽管 HTTP 和 SSH 的用途不同，但在某些场景中可以结合使用。例如：

通过 SSH 加密 HTTP 流量：可以使用 SSH 隧道将 HTTP 请求加密后传输，提升数据的安全性。
远程管理 HTTP 服务：使用 SSH 连接远程服务器，部署和维护运行 HTTP 服务的 Web 服务器。

开放性问题

Rocky从工业界、学术界、竞赛界以及应用界角度出发，思考总结AI行业的干货开放性问题，这些问题不仅能够用于面试官的提问，也可以用作面试者的提问，在面试的最后阶段让面试双方进入深度的探讨与交流。

与此同时，这些开放性问题也是贯穿我们职业生涯的本质问题，需要我们持续的思考感悟。这些问题没有标准答案，Rocky相信大家心中都有自己对于AI行业的认知与判断，欢迎大家在留言区分享与评论。

【一】AI算法工程师如何提升在AI行业中的影响力？

Rocky认为这是一个AI行业从业者要思考的本质问题，不管是AIGC领域、传统深度学习领域还是自动驾驶领域，我们都需要在自己的职业生涯中持续思考与总结。

【二】AI算法工程师如何破圈在社会中提升自己的影响力？

Rocky认为这不仅仅是AI行业从业者要思考的本质问题，也是所有行业从业者要思考的本质问题，这是一个非常有价值的核心问题。

AIGC时代算法工程师的面试秘籍（第二十七式2024.11.18-12.1） |【三年面试五年模拟】

写在前面

正文开始

目录先行

AI绘画基础：

AI视频基础：

深度学习基础：

机器学习基础：

Python编程基础：

模型部署基础：

计算机基础：

开放性问题：

AI绘画基础

【一】AIGC面试中必考的Stable Diffusion系列模型版本有哪些？

【二】AIGC面试中必考的AI绘画技术框架脉络是什么样的？

AI视频基础

【一】Sora的Text-Encoder模型架构是什么样的？

【二】AI视频大模型的生成质量指标有哪些？

深度学习基础

【一】介绍一下PyTorch中.detach()、.clone()、requires_grad=True、torch.no_grad()的原理与作用

1. .detach()

作用

原理

常见用法

示例

2. .clone()

作用

原理

常见用法

示例

**3. requires_grad=True

作用

原理

常见用法

示例

4. torch.no_grad()

作用

原理

常见用法

示例

总结与对比

使用建议

【二】介绍一下CLIP-pooled-embedding的作用

CLIP Pooled Embedding 的作用详细解析

什么是 Pooled Embedding？

生成 Pooled Embedding 的方法

Pooled Embedding 的作用

1. 全局语义表征

2. 对比学习中的对齐

3. 下游任务的输入特征

4. 高效表征

Pooled Embedding 的计算过程

图像编码器（Image Encoder）

文本编码器（Text Encoder）

应用场景

1. 多模态检索

2. 分类任务

3. 内容生成

4. 语义搜索

优点与局限性

优点

局限性

机器学习基础

【一】什么是机器学习中的对比学习？

对比学习（Contrastive Learning）的核心概念

1. 对比学习的核心思想

2. 对比学习的基本构造

(1) 正样本对（Positive Pair）

(2) 负样本对（Negative Pair）

(3) 对比损失函数（Contrastive Loss）

3. 对比学习的实现框架

(1) 数据增强

(2) 嵌入空间的设计

(3) 小批量采样

4. 对比学习的优势

【二】机器学习中训练集、验证集、测试集之间有哪些区别？

1. 训练集 (Training Set)

定义

特点

目的

1. `.detach()`

2. `.clone()`

**3. `requires_grad=True`

4. `torch.no_grad()`

`folder_paths.py` 示例