qidao123.com技术社区-IT企服评测·应用市场

标题: AIGC时代算法工程师的面试秘籍(第二十五式2024.10.21-11.3) |【三年面试 [打印本页]

作者: 梦应逍遥    时间: 2024-11-14 05:55
标题: AIGC时代算法工程师的面试秘籍(第二十五式2024.10.21-11.3) |【三年面试
写在前面

   【三年面试五年模拟】旨在整理&挖掘AI算法工程师在练习/校招/社招时所需的干货知识点与面试履历,力求让读者在获得心仪offer的同时,加强技能根本面。
    欢迎大家关注Rocky的公众号:WeThinkIn
欢迎大家关注Rocky的知乎:Rocky Ding
AIGC算法工程师面试面经秘籍分享:WeThinkIn/Interview-for-Algorithm-Engineer欢迎大家Star~
获取更多AI行业的前沿资讯与干货资源
  WeThinkIn最新福利放送:大家只需关注WeThinkIn公众号,后台回复“简历资源”,即可获取包含Rocky独家简历模版在内的60套精选的简历模板资源,希望能给大家在AIGC时代带来资助。
Rocky最新发布Stable Diffusion 3和FLUX.1系列模型的深入浅出全维度解析文章,点击链接直达干货知识:https://zhuanlan.zhihu.com/p/684068402

大家好,我是Rocky。
又到了定期阅读《三年面试五年模拟》文章的时候了!本周期共更新了60多个AIGC面试高频问答,仍旧干货满满!诚意满满!
《三年面试五年模拟》系列文章资助很多读者获得了心仪的算法岗offer,收到了大家的很多好评,Rocky以为很开心也很有意义。
在AIGC时代到来后,Rocky对《三年面试五年模拟》整体战略方向进行了重大的优化重构,在秉持着Rocky创办《三年面试五年模拟》项目初心的同时,增加了AIGC时代核心的版块栏目,具体的版本更新内容如下所示:
Rocky已经将《三年面试五年模拟》项目的完整版构建在Github上:https://github.com/WeThinkIn/Interview-for-Algorithm-Engineer/tree/main,本周期更新的60+AIGC面试高频问答已经全部同步到项目中了,欢迎大家star!
本文是《三年面试五年模拟》项目的第二十五式,考虑到易读性与文章篇幅,Rocky本次只从Github完整版项目中摘选了2024年10月21号-2024年11月3号更新的部门高频&干货面试知识点和面试问题,并配以相应的参考答案(精简版),供大家学习探究。
在《三年面试五年模拟》版本更新白皮书,迎接AIGC时代中我们论述了《三年面试五年模拟》项目在AIGC时代的愿景与规划,也包含了项目共建计划,感爱好的朋友可以一起到场本项目的共建!
《三年面试五年模拟》系列将陪伴大家度过整个AI行业的职业生活,并且让大家可以大概连续获益。
So,enjoy(与本文的BGM一起食用更佳哦):
正文开始

     目录先行  

AI绘画基础:

深度学习基础:

机器学习基础:

Python编程基础:

模型部署基础:

计算机基础:

开放性问题:

     AI绘画基础  

【一】Midjourney迭代至今有哪些良好的特点?

Rocky认为Midjourney系列是AIGC时代AI绘画ToC产品的一个非常有价值的标杆,我们需要连续研究挖掘其价值与良好特点:
【二】Midjourney有哪些关键的参数?

Rocky认为,了解Midjourney的关键参数,可以大概从中挖掘出一些借鉴价值,并对其底层技能进行判定,好坏常有价值的事变。
Rocky也会连续补充更新Midjourney的最新关键参数。
1. 版本参数:--version 或 --v

作用:
指定利用 Midjourney 的模型版本。差别版本的模型在风格、细节和渲染结果上有所区别。
利用方法:
  1. --version <版本号>
  2. --v <版本号>
复制代码
示例:
  1. /imagine prompt: a serene landscape --v 6
复制代码
2. 风格化参数:--stylize 或 --s

作用:
控制天生图像的艺术风格程度。数值越大,图像越具艺术性;数值越小,图像越靠近于严酷按照提示天生。可以用数值范围是0-1000,默认值是100。
默认情况下,Midjourney会为图像加上100的–s参数数值。假如将数值调到低于100,那么画面的细节会变少、质感会更粗糙,图像整体质量会降落;而假如将数值调至高于100,那么画面的细节会更丰富、光影、纹理的质感也会更精致。如下图,随着–s数值的提升,树精灵的服装变得更华丽了,面部五官也更加可爱精致,与–s为0时有明显的区别。

利用方法:
  1. --stylize <数值>
  2. --s <数值>
复制代码
示例:
  1. /imagine prompt: a portrait of a cat --s 1000
复制代码
3. 宽高比参数:--aspect 或 --ar

作用:
指定天生图像的宽高比例。
=利用方法:
  1. --aspect <宽比>:<高比>
  2. --ar <宽比>:<高比>
复制代码
示例:
  1. /imagine prompt: a tall skyscraper --ar 9:16
复制代码
具体说明:

4. 质量参数:--quality 或 --q

作用:
控制图像天生的质量和渲染速度。较高的质量会产生更精致的图像,但需要更多的时间和资源。
利用方法:
  1. --quality <数值>
  2. --q <数值>
复制代码
示例:
  1. /imagine prompt: an intricate mechanical watch --q 2
复制代码
具体说明:

5. 种子参数:--seed

作用:
指定随机数天生的种子,以控制图像天生的随机性。利用相同的种子和提示,可以复现相似的图像。
利用方法:
  1. --seed <数值>
复制代码
示例:
  1. /imagine prompt: a mystical forest --seed 123456789
复制代码
具体说明:

6. 混乱度参数:--chaos

作用:
Chaos 是一种混沌值参数,可以缩写为 --c 添加在提示词之后,控制天生图像的随机性和不可预测性。较高的值会产生更意想不到的结果。可以用数值范围是0-100,默认值是0。
Midjourney对每组提示词返回的并非单张图像,而是4张,这让我们一次就能得到多张图像,提升了出图服从。在之前的版本中,每次天生的4张图像好坏常相似的,官方以为这倒霉于用户获取更多样的结果,于是在V6版本中调大了图像间的差别性,让4张图像在风格、构图、内容等方面有明显差别。
如下图,–c 数值达到 25 时,画面固然还能保持 “穿白色衣服,头戴桃子花环的男孩” 这一形象,但已经不再局限于 “3D、玩偶” 的风格范围了,拓展到真人、布偶、陶偶等范例上;而在数值达到 50 以及更高时,画面已经和最初的提示词关联度很低了,风格和内容都变得很随机。

利用方法:
  1. --chaos <数值>
复制代码
示例:
  1. /imagine prompt: abstract shapes and colors --chaos 80
复制代码
具体说明:

7. 图像提示参数:--image

作用:
提供一个参考图像,指导天生的图像风格或内容。本质上和Stable Diffusion系列的图生图功能是一样的。
利用方法:
  1. 在提示中上传图像或提供图像 URL
复制代码
示例:
  1. /imagine prompt: [上传的图片] + a sunset over the ocean
复制代码
具体说明:

8. 负面提示参数:--no

作用:
清除特定元素或特征,使天生的图像不包含指定内容。与Stable Diffusion系列的Negative Prompt结果划一。
利用方法:
  1. --no <不希望出现的元素>
复制代码
示例:
  1. /imagine prompt: a city street at night --no cars
复制代码
具体说明:

9. Tile 参数:--tile


作用:
天生可无缝平铺的图像,实用于纹理和配景设计。
利用方法:
  1. --tile
复制代码
示例:
  1. /imagine prompt: a floral pattern --tile
复制代码
具体说明:

10. UPBETA 参数:--UPBETA

作用:
提供更好的图像质量和细节,在图像的细节处置惩罚上有更好的表现,呈现出更精致的纹理和表面。与Stable Diffusion系列模型的精绘功能非常相似。
利用用法:
  1. /imagine prompt: <描述文本> --upbeta
复制代码
示例:
  1. /imagine prompt: a futuristic city skyline at sunset --upbeta
复制代码
     深度学习基础  

【一】什么是NewGELU激活函数?

NewGELU 是对传统 GELU (Gaussian Error Linear Unit) 的一种改进。GELU 本身在许多AI模型中表现优异(如 Transformer 系列模型),而 NewGELU 在保存 GELU 平滑特性的同时,进一步优化了计算服从和非线性特性,从而可以在一些AI任务中获得更好的表现。
一、GELU 激活函数的回顾

在了解 NewGELU 之前,我们先回顾一下 GELU 激活函数的定义和特点,以便更好地明确 NewGELU 的改进之处。
1. GELU 的数学定义

GELU 激活函数的数学表达式为:
                                         GELU                            (                            x                            )                            =                            x                            ⋅                            Φ                            (                            x                            )                                  \text{GELU}(x) = x \cdot \Phi(x)                     GELU(x)=x⋅Φ(x)
其中,                                    Φ                         (                         x                         )                              \Phi(x)                  Φ(x) 是标准正态分布的累积分布函数(CDF),定义为:
                                         Φ                            (                            x                            )                            =                                       1                               2                                                 (                               1                               +                               erf                                           (                                               x                                                   2                                                           )                                          )                                            \Phi(x) = \frac{1}{2} \left(1 + \text{erf}\left(\frac{x}{\sqrt{2}}\right)\right)                     Φ(x)=21​(1+erf(2                      ​x​))
由于累积分布函数的计算较为复杂,GELU 常利用以下近似表达式来加速计算:
                                         GELU                            (                            x                            )                            ≈                            0.5                            ⋅                            x                            ⋅                                       (                               1                               +                               tanh                               ⁡                                           (                                                             2                                        π                                                                        (                                     x                                     +                                     0.044715                                     ⋅                                                   x                                        3                                                  )                                              )                                          )                                            \text{GELU}(x) \approx 0.5 \cdot x \cdot \left(1 + \tanh\left(\sqrt{\frac{2}{\pi}} \left( x + 0.044715 \cdot x^3 \right)\right)\right)                     GELU(x)≈0.5⋅x⋅(1+tanh(π2​               ​(x+0.044715⋅x3)))
2. GELU 的特点


二、NewGELU 的引入

NewGELU 是一种对 GELU 的改进,其目标是:
三、NewGELU 激活函数的定义

1. 数学表达式

NewGELU 激活函数的近似表达式为:
                                         NewGELU                            (                            x                            )                            =                            0.5                            ⋅                            x                            ⋅                                       (                               1                               +                               tanh                               ⁡                                           (                                                             2                                        π                                                           ⋅                                  (                                  x                                  +                                  0.0356774                                  ⋅                                               x                                     3                                              )                                  )                                          )                                            \text{NewGELU}(x) = 0.5 \cdot x \cdot \left(1 + \tanh\left(\sqrt{\frac{2}{\pi}} \cdot (x + 0.0356774 \cdot x^3)\right)\right)                     NewGELU(x)=0.5⋅x⋅(1+tanh(π2​               ​⋅(x+0.0356774⋅x3)))
与 GELU 的近似表达式对比:
                                         GELU                            (                            x                            )                            ≈                            0.5                            ⋅                            x                            ⋅                                       (                               1                               +                               tanh                               ⁡                                           (                                                             2                                        π                                                                        (                                     x                                     +                                     0.044715                                     ⋅                                                   x                                        3                                                  )                                              )                                          )                                            \text{GELU}(x) \approx 0.5 \cdot x \cdot \left(1 + \tanh\left(\sqrt{\frac{2}{\pi}} \left( x + 0.044715 \cdot x^3 \right)\right)\right)                     GELU(x)≈0.5⋅x⋅(1+tanh(π2​               ​(x+0.044715⋅x3)))
2. 公式的简化

NewGELU 的公式与 GELU 非常相似,但将常数 0.044715 改为 0.0356774。这一小小的改动,使得 NewGELU 在计算上更加高效,且在某些任务中表现略优于标准 GELU。
四、NewGELU 的特性

1. 更高的计算服从


2. 平滑的非线性


3. 自适应性


五、总结


【二】CNN+Transformer组合的架构有哪些优势?

在AI行业中,CNN(卷积神经网络)Transformer结合的架构将 CNN 的局部特征提取能力和 Transformer 的全局特征捕获能力相结合,具备多个显著优势。
1. 局部和全局特征的有效结合


2. 计算服从和模型性能的均衡


3. 提高模型的鲁棒性和泛化能力


4. 多模态任务中的优势


     机器学习基础  

【一】机器学习中将余弦相似度作为损失函数有哪些优势?

在机器学习中,余弦相似度(Cosine Similarity)是一种用于衡量两个向量之间相似度的常用方法,尤其实用于高维空间的特征向量。将余弦相似度作为损失函数(通常转化为余弦相似度损失)具有多个优势,特别是在文本、图像特征和推荐系统等任务中。
1. 余弦相似度的定义与计算

余弦相似度的公式如下:
                                         Cosine Similarity                            =                            cos                            ⁡                            (                            θ                            )                            =                                                                A                                     ⃗                                              ⋅                                               B                                     ⃗                                                                  ∣                                  ∣                                               A                                     ⃗                                              ∣                                  ∣                                  ⋅                                  ∣                                  ∣                                               B                                     ⃗                                              ∣                                  ∣                                                       \text{Cosine Similarity} = \cos(\theta) = \frac{\vec{A} \cdot \vec{B}}{||\vec{A}|| \cdot ||\vec{B}||}                     Cosine Similarity=cos(θ)=∣∣A                     ∣∣⋅∣∣B                     ∣∣A                     ⋅B                     ​
其中:

余弦相似度的取值范围为 ([-1, 1])

余弦相似度损失通常是将余弦相似度取负值,或利用 (1 - \text{Cosine Similarity}),使得两个向量越相似,损失越小。
2. 余弦相似度作为损失函数的优势

2.1 忽略向量的模长,专注于方向


2.2 实用于高维稀疏数据


2.3 对特征进行归一化,有助于稳固训练


2.4 更符合间隔度量的直观意义


3. 余弦相似度损失的实际应用场景

3.1 文本相似度任务

在自然语言处置惩罚(NLP)中,余弦相似度广泛用于衡量文本相似度,如句子嵌入的比力。在这种场景中:

3.2 图像特征匹配

在图像处置惩罚任务(如人脸识别、图像检索)中,余弦相似度损失用于比力差别图像的嵌入表示:

3.3 推荐系统中的用户与物品匹配

在推荐系统中,可以将用户与物品的特征向量转换为相同的嵌入空间:

总结

总的来说,我们利用余弦相似度作为损失函数的优势总结如下:
因此,余弦相似度损失在文本相似度、图像特征匹配、推荐系统等范畴得到了广泛应用,可以大概有效提升模型在这些任务中的表现。
【二】先容一下机器学习中的L2损失函数

在机器学习中,L2损失函数(也称为均方误差损失,Mean Squared Error, MSE)是一种用于评估模型预测值与真实值之间差别的常见损失函数。L2损失函数广泛应用于回归问题中,因为它具有较好的数值稳固性,且对于较大的误差给予更大的处罚。
1. L2损失函数的定义

假设我们有一个模型,给定输入                                              x                            i                                       x_i                  xi​ 可以输出预测值                                                         y                               ^                                      i                                       \hat{y}_i                  y^​i​ ,并且我们知道目标值                                              y                            i                                       y_i                  yi​ 。L2损失函数的定义如下:
                                                    L                                           L                                  2                                                 =                                       1                               n                                                 ∑                                           i                                  =                                  1                                          n                                      (                                                   y                                  ^                                          i                                      −                                       y                               i                                                 )                               2                                            L_{L2} = \frac{1}{n} \sum_{i=1}^n (\hat{y}_i - y_i)^2                     LL2​=n1​i=1∑n​(y^​i​−yi​)2
其中:

这个公式表示的是每个样本的预测误差平方的平均值,也被称为均方误差(Mean Squared Error, MSE)
2. L2损失的性子

3. L2损失函数的梯度

在机器学习模型训练过程中,我们通常利用梯度降落方法来最小化损失函数。为此,需要计算损失函数相对于模型参数的梯度。对 L2 损失函数的每一个预测值                                                         y                               ^                                      i                                       \hat{y}_i                  y^​i​ 来说,它的梯度为:
                                                                ∂                                               L                                                   L                                        2                                                                               ∂                                                             y                                        ^                                                  i                                                             =                                       2                               n                                      (                                                   y                                  ^                                          i                                      −                                       y                               i                                      )                                  \frac{\partial L_{L2}}{\partial \hat{y}_i} = \frac{2}{n} (\hat{y}_i - y_i)                     ∂y^​i​∂LL2​​=n2​(y^​i​−yi​)
这表明:

4. L2损失的应用场景

L2损失函数实用于以了局景:
5. 优势与劣势

优势

劣势

     Python编程基础  

【一】先容一下Python中的继续(Inheritance)头脑

继续是面向对象编程(OOP)的一个核心概念,它允许一个类(称为子类或派生类)从另一个类(称为父类或基类)继续属性和方法。子类可以继续父类的特性,并且可以在此基础上添加自己的新特性,从而实今世码的重用和扩展。Python 作为一门支持面向对象编程的语言,提供了强大的继续机制。
Python中继续的优势:
一、继续的根本概念

1. 父类(基类)


2. 子类(派生类)


3. 继续的目的


二、Python 中的继续实现

1. 根本语法

在 Python 中,继续通过在类定义时指定父类来实现。
  1. class 子类名(父类名):
  2.     # 类的定义
复制代码
2. 示例

父类:
  1. class Animal:
  2.     def __init__(self, name):
  3.         self.name = name
  4.     def speak(self):
  5.         pass
复制代码
子类:
  1. class Dog(Animal):
  2.     def speak(self):
  3.         return f"{self.name} says Woof!"
  4. class Cat(Animal):
  5.     def speak(self):
  6.         return f"{self.name} says Meow!"
复制代码
利用子类:

  1. dog = Dog("Buddy")
  2. cat = Cat("Kitty")
  3. print(dog.speak())  # 输出: Buddy says Woof!
  4. print(cat.speak())  # 输出: Kitty says Meow!
复制代码
三、继续的范例

1. 单继续


2. 多重继续


3. 多层继续


四、方法重写(Override)


示例:

  1. class Vehicle:
  2.     def move(self):
  3.         print("The vehicle is moving.")
  4. class Car(Vehicle):
  5.     def move(self):
  6.         print("The car is driving on the road.")
  7. vehicle = Vehicle()
  8. car = Car()
  9. vehicle.move()  # 输出: The vehicle is moving.
  10. car.move()      # 输出: The car is driving on the road.
复制代码
五、调用父类的方法


示例:

  1. class Person:
  2.     def __init__(self, name):
  3.         self.name = name
  4. class Employee(Person):
  5.     def __init__(self, name, employee_id):
  6.         super().__init__(name)  # 调用父类的构造函数
  7.         self.employee_id = employee_id
  8. employee = Employee("Alice", "E123")
  9. print(employee.name)         # 输出: Alice
  10. print(employee.employee_id)  # 输出: E123
复制代码
六、继续中的特别方法

1. __init__ 构造函数


示例:
  1. class Parent:
  2.     def __init__(self):
  3.         print("Parent init")
  4. class Child(Parent):
  5.     def __init__(self):
  6.         super().__init__()  # 调用父类的构造函数
  7.         print("Child init")
  8. child = Child()
  9. # 输出:
  10. # Parent init
  11. # Child init
复制代码
2. __str__ 和 __repr__ 方法


示例:
  1. class Animal:
  2.     def __str__(self):
  3.         return "This is an animal."
  4. class Dog(Animal):
  5.     def __str__(self):
  6.         return "This is a dog."
  7. dog = Dog()
  8. print(dog)  # 输出: This is a dog.
复制代码
七、继续的注意事项

1. 访问权限


2. 方法解析顺序(MRO)


示例:

  1. class A:
  2.     pass
  3. class B(A):
  4.     pass
  5. class C(A):
  6.     pass
  7. class D(B, C):
  8.     pass
  9. print(D.mro())
  10. # 输出: [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
复制代码
【二】先容一下Python中的多态(Polymorphism)头脑

多态(Polymorphism) 是面向对象编程(OOP)的核心概念之一,指的是同一操纵作用于差别对象时,可以大概产生差别的解释和行为。简朴来说,多态允许我们在不考虑对象具体范例的情况下,对差别范例的对象实行相同的操纵。在 Python 中,多态性通过动态范例和灵活的对象模型得以实现。
一、什么是多态?

1. 定义


2. 多态的范例


二、Python 中的多态实现

1. 动态范例和鸭子范例


示例:
  1. class Dog:
  2.     def speak(self):
  3.         return "Woof!"
  4. class Cat:
  5.     def speak(self):
  6.         return "Meow!"
  7. class Duck:
  8.     def speak(self):
  9.         return "Quack!"
  10. def animal_speak(animal):
  11.     return animal.speak()
  12. animals = [Dog(), Cat(), Duck()]
  13. for animal in animals:
  14.     print(animal_speak(animal))
复制代码
输出:
  1. Woof!
  2. Meow!
  3. Quack!
复制代码

2. 继续和方法重写


示例:
  1. class Animal:
  2.     def speak(self):
  3.         raise NotImplementedError("Subclasses must implement this method.")
  4. class Dog(Animal):
  5.     def speak(self):
  6.         return "Woof!"
  7. class Cat(Animal):
  8.     def speak(self):
  9.         return "Meow!"
  10. def animal_speak(animal):
  11.     return animal.speak()
  12. animals = [Dog(), Cat()]
  13. for animal in animals:
  14.     print(animal_speak(animal))
复制代码
输出:
  1. Woof!
  2. Meow!
复制代码

3. 运算符重载


示例:
  1. class Vector:
  2.     def __init__(self, x, y):
  3.         self.x = x
  4.         self.y = y
  5.     # 重载加法运算符
  6.     def __add__(self, other):
  7.         return Vector(self.x + other.x, self.y + other.y)
  8.     # 重载字符串表示
  9.     def __str__(self):
  10.         return f"Vector({self.x}, {self.y})"
  11. v1 = Vector(2, 3)
  12. v2 = Vector(5, 7)
  13. v3 = v1 + v2
  14. print(v3)
复制代码
输出:
  1. Vector(7, 10)
复制代码

三、鸭子范例详解

1. 概念


示例:
  1. class Bird:
  2.     def fly(self):
  3.         print("Bird is flying.")
  4. class Airplane:
  5.     def fly(self):
  6.         print("Airplane is flying.")
  7. class Fish:
  8.     def swim(self):
  9.         print("Fish is swimming.")
  10. def lift_off(entity):
  11.     entity.fly()
  12. bird = Bird()
  13. plane = Airplane()
  14. fish = Fish()
  15. lift_off(bird)   # 输出: Bird is flying.
  16. lift_off(plane)  # 输出: Airplane is flying.
  17. # lift_off(fish)  # AttributeError: 'Fish' object has no attribute 'fly'
复制代码

四、多态性的长处

1. 提高代码的灵活性


2. 加强代码的可扩展性


3. 代码重用


五、抽象基类(Abstract Base Class)


示例:

  1. from abc import ABC, abstractmethod
  2. class Shape(ABC):
  3.     @abstractmethod
  4.     def area(self):
  5.         pass
  6. class Rectangle(Shape):
  7.     def __init__(self, width, height):
  8.         self.width = width
  9.         self.height = height
  10.     def area(self):
  11.         return self.width * self.height
  12. class Circle(Shape):
  13.     def __init__(self, radius):
  14.         self.radius = radius
  15.     def area(self):
  16.         return 3.1416 * self.radius ** 2
  17. shapes = [Rectangle(3, 4), Circle(5)]
  18. for shape in shapes:
  19.     print(f"Area: {shape.area()}")
复制代码
输出:
  1. Area: 12
  2. Area: 78.53999999999999
复制代码

六、Python 中不支持方法重载


示例:

  1. class MathOperations:
  2.     def multiply(self, x, y, z=None):
  3.         if z is not None:
  4.             return x * y * z
  5.         else:
  6.             return x * y
  7. math_ops = MathOperations()
  8. print(math_ops.multiply(2, 3))       # 输出: 6
  9. print(math_ops.multiply(2, 3, 4))    # 输出: 24
复制代码

七、方法解析顺序(MRO)在多态中的作用


示例:

  1. class A:
  2.     def do_something(self):
  3.         print("Method from A")
  4. class B:
  5.     def do_something(self):
  6.         print("Method from B")
  7. class C(B, A):
  8.     pass
  9. c = C()
  10. c.do_something()
  11. print(C.mro())
复制代码
输出:
  1. Method from B
  2. [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
复制代码

     模型部署基础  

【一】如何将ONNX模型从GPU切换到CPU中进行缓存?

在AI行业中,在算法服务推理运行结束后,将ONNX模型从GPU切换到CPU中进行缓存,是经典的高性能算法服务的一环。 ONNX Runtime 中,可以很方便地将模型从 GPU 切换到 CPU 上。通过 ONNX Runtime 提供的 providers 参数或 set_providers 方法,可以方便地在 GPU 和 CPU 之间切换模型的运行设备。只需指定 "CPUExecutionProvider" 就可以让模型在 CPU 上进行缓存。
方法一:在创建 InferenceSession 时指定 CPUExecutionProvider

ONNX Runtime 的 InferenceSession 支持多个计算提供者(Execution Providers),可以通过指定提供者将模型从 GPU 切换到 CPU。只需要在创建 InferenceSession 时将 providers 参数设置为 ["CPUExecutionProvider"],就会强制模型在 CPU 上运行。
  1. import onnxruntime as ort
  2. # 指定使用 CPU 运行
  3. session = ort.InferenceSession("model.onnx", providers=["CPUExecutionProvider"])
复制代码
假如之前在利用 GPU(如 "CUDAExecutionProvider")运行模型,将 providers 参数改为 "CPUExecutionProvider" 就可以切换到 CPU 上。
方法二:通过 set_providers 方法动态切换到 CPU

假如已经创建了利用 GPU 的 InferenceSession,可以通过 set_providers 方法动态切换到 CPU 而不重新加载模型。
  1. # 假设已有一个使用 GPU 的 session
  2. session.set_providers(["CPUExecutionProvider"])
复制代码
这样可以在同一个 InferenceSession 上切换到 CPU。
方法三:通过 providers 属性检查当前的计算提供者

可以利用 session.get_providers() 来查看当前可用的计算提供者,并确认是否成功切换到 CPU。
  1. print(session.get_providers())  # 输出当前会话使用的提供者
复制代码
假如输出包含 "CPUExecutionProvider",则表示会话已经在 CPU 上运行。
示例:完整流程

  1. import onnxruntime as ort
  2. # 创建一个使用 GPU 的 session
  3. session = ort.InferenceSession("model.onnx", providers=["CUDAExecutionProvider"])
  4. # 进行推理
  5. outputs = session.run(None, {"input_name": input_data})
  6. # 切换到 CPU
  7. session.set_providers(["CPUExecutionProvider"])
  8. # 确认提供者已切换到 CPU
  9. print("Current providers:", session.get_providers())
复制代码
【二】先容一下Base64编码图像的原理

Base64 编码是一种用于将二进制数据转换为文本字符串的编码方法。在许多网络传输和存储应用中,Base64 编码可以使二进制数据(如图像、文件)以文本形式嵌入到 JSON、XML 或 HTML 等格式中,而不会被粉碎。以下是具体先容 Base64 编码图像的原理、工作流程、应用场景以及解码过程。
一、为什么要利用 Base64 编码图像?

二、Base64 编码的原理

Base64 的核心头脑是将任意二进制数据表示为可打印的 ASCII 字符串,具体步骤如下:
Base64 字符表

三、图像的 Base64 编码过程

1. 获取二进制数据

图像文件本质上是一个包含像素值和元数据的二进制文件。可以通过打开图像文件并读取二进制数据的方式来获取图像的原始数据。
2. 将二进制数据编码为 Base64 字符串

将图像的二进制数据进行 Base64 编码。以 Python 为例:
  1. import base64
  2. # 打开图像文件并读取二进制数据
  3. with open("example.jpg", "rb") as image_file:
  4.     binary_data = image_file.read()
  5. # 将二进制数据编码为 Base64
  6. base64_data = base64.b64encode(binary_data).decode('utf-8')
  7. print(base64_data)
复制代码
这里的 base64.b64encode 函数将二进制数据转换为 Base64 编码的字节对象,利用 decode('utf-8') 将其转为字符串。
3. 天生 Base64 数据 URI

为了在 HTML 中嵌入图像,可以将 Base64 编码的字符串封装为 data URI 格式:
  1. <img src="data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/..." />
复制代码
其中,data:image/jpeg;base64, 表示 MIME 范例为 JPEG 格式的图像,紧随厥后的 Base64 字符串就是图像数据。
四、Base64 解码图像的过程

将 Base64 字符串还原成图像的步骤如下:
Python 示例

  1. import base64
  2. # 假设 base64_data 是从 Base64 字符串中提取的图像数据
  3. base64_data = "..."  # 这里应该是实际的 Base64 字符串
  4. # 解码 Base64 数据
  5. image_data = base64.b64decode(base64_data)
  6. # 将解码后的数据保存为图像文件
  7. with open("decoded_image.jpg", "wb") as file:
  8.     file.write(image_data)
复制代码
五、优缺点

长处


缺点


     计算机基础  

Rocky从工业界、学术界、竞赛界以及应用界角度出发,总结归纳AI行业所需的计算机基础干货知识。这些干货知识不仅能在面试中资助我们,还能让我们在AI行业中提高工作服从
【一】先容一下Gunicorn的原理,并举例其在AI行业的作用

Gunicorn(Green Unicorn) 是一个被广泛应用的 Python Web 服务器网关接口(WSGI)HTTP 服务器,实用于 UNIX 系统。它以简朴、高效、轻量级著称,可以大概兼容多种 Web 框架,如 Django、Flask、Pyramid 等。
在 AI 行业,模型的部署和服务化是关键环节之一。Gunicorn 作为成熟的 Python WSGI 服务器,为 AI 模型的服务化部署提供了稳健、高性能的办理方案。通过与各种 Web 框架和异步工作类的结合,Gunicorn 可以大概满意 AI 应用对高并发、低耽误和稳固性的要求。在 AI 行业的实际应用中,公道地设置和利用 Gunicorn,可以有效提升模型服务的性能和可靠性。
一、Gunicorn 的原理详解

1. WSGI 概述


2. Gunicorn 的架构

Gunicorn 接纳了 预分叉(Pre-fork) 的工作模式,其架构主要包罗:

3. Gunicorn 的工作原理

4. Worker 范例

Gunicorn 支持多种 Worker 范例,以满意差别的并发需求:

5. 设置与定制


二、Gunicorn 的优势

三、Gunicorn 在 AI 行业的作用

1. AI 模型的服务化部署

在 AI 应用中,将训练好的模型部署为 Web 服务,供客户端调用是常见需求。Gunicorn 在这一过程中提供了可靠的服务器环境。

2. 实例:利用 Flask 部署预测服务

  1. # app.py
  2. from flask import Flask, request, jsonify
  3. import joblib
  4. app = Flask(__name__)
  5. model = joblib.load('model.pkl')
  6. @app.route('/predict', methods=['POST'])
  7. def predict():
  8.     data = request.json
  9.     prediction = model.predict([data['features']])
  10.     return jsonify({'prediction': prediction.tolist()})
  11. if __name__ == '__main__':
  12.     app.run()
复制代码
利用 Gunicorn 启动服务:
  1. gunicorn app:app --workers 4
复制代码

利用 Gunicorn 和 UvicornWorker 启动服务:
  1. gunicorn main:app --workers 2 --worker-class uvicorn.workers.UvicornWorker
复制代码

四、Gunicorn在AI服务部署中的优势

【二】先容一下Uvicorn的原理,并举例其在AI行业的作用

Uvicorn 是一个基于 Python 的高速、轻量级 ASGI(Asynchronous Server Gateway Interface)服务器,接纳了基于事故循环的异步编程模型。它以高性能和低资源消耗著称,实用于部署基于异步框架(如 FastAPI、Starlette)的 Python Web 应用。
在 AI 行业,实时性和高并发能力对于模型服务化部署尤为重要。Uvicorn 作为今世化的高性能 ASGI 服务器,在 AI 行业的应用越来越广泛。它的高并发、低耽误和对异步协议的支持,使得 AI 应用可以大概满意实时性和高吞吐量的要求。通过与异步框架的结合,Uvicorn 为 AI 模型的部署和服务化提供了强大的支持。
一、Uvicorn 的原理详解

1. ASGI 概述


2. Uvicorn 的架构

Uvicorn 接纳了今世化的异步编程技能,基于 uvloophttptools,提供了高性能的网络 I/O 和 HTTP 处置惩罚。

3. Uvicorn 的工作原理




Uvicorn 接受客户端哀求,创建 Scope,并调用 ASGI 应用的入口点,将 scope、receive、send 传递给应用步伐。

4. Uvicorn 的特点


二、Uvicorn 的优势

三、Uvicorn 在 AI 行业的作用

1. 实时推理服务

AI 应用常常需要提供实时的预测和推理服务,如聊天机器人、语音识别、实时推荐等。Uvicorn 的高并发和低耽误特性使其成为部署此类服务的理想选择。
示例:利用 FastAPI 部署实时预测服务
  1. # main.py
  2. from fastapi import FastAPI
  3. import asyncio
  4. import torch
  5. app = FastAPI()
  6. model = torch.load('model.pt')
  7. @app.post("/predict")
  8. async def predict(data: dict):
  9.     input_tensor = torch.tensor(data['input'])
  10.     result = await asyncio.to_thread(model_predict, input_tensor)
  11.     return {"result": result.tolist()}
  12. def model_predict(input_tensor):
  13.     with torch.no_grad():
  14.         output = model(input_tensor)
  15.     return output
复制代码
启动命令:
  1. uvicorn main:app --host 0.0.0.0 --port 8000
复制代码

1. 利用多进程模式

示例:
  1. uvicorn main:app --host 0.0.0.0 --port 8000
  2. --workers 4
复制代码

2. 与 Gunicorn 结合

示例:
  1. gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker
复制代码

2. 异步数据处置惩罚

在一些需要处置惩罚高吞吐量数据的 AI 应用中,如日志分析、实时监控等,Uvicorn 可以与异步框架结合,实现高效的数据吸收和处置惩罚。
示例:实时数据吸收与处置惩罚
  1. # main.py
  2. from fastapi import FastAPI, WebSocket
  3. from some_async_data_processing_library import process_data
  4. app = FastAPI()
  5. @app.websocket("/ws")
  6. async def websocket_endpoint(websocket: WebSocket):
  7.     await websocket.accept()
  8.     while True:
  9.         data = await websocket.receive_text()
  10.         result = await process_data(data)
  11.         await websocket.send_text(result)
复制代码
启动命令:
  1. uvicorn main:app --host 0.0.0.0 --port 8000
复制代码

3. 部署异步机器学习服务

一些机器学习任务,如异步训练、在线学习等,需要异步的处置惩罚方式。Uvicorn 可以大概支持这些异步任务的部署。
示例:异步任务队列
  1. # main.py
  2. from fastapi import FastAPI, BackgroundTasks
  3. import asyncio
  4. app = FastAPI()
  5. @app.post("/train")
  6. async def train_model(data: dict, background_tasks: BackgroundTasks):
  7.     background_tasks.add_task(async_train, data)
  8.     return {"message": "Training started"}
  9. async def async_train(data):
  10.     await asyncio.sleep(10)  # 模拟长时间训练任务
  11.     # 执行训练逻辑
复制代码

4. 与 AI 框架的集成


四、Uvicorn在AI部署中的优势

     开放性问题  

Rocky从工业界、学术界、竞赛界以及应用界角度出发,思索总结AI行业的干货开放性问题,这些问题不仅可以大概用于面试官的提问,也可以用作面试者的提问,在面试的末了阶段让面试双方进入深度的探究与交换。
与此同时,这些开放性问题也是贯穿我们职业生活的本诘责题,需要我们连续的思索感悟。这些问题没有标准答案,Rocky相信大家心中都有自己对于AI行业的认知与判定,欢迎大家在留言区分享与评论。
【一】AI算法工程师从纯技能到技能管理的差别是什么?

Rocky认为这是一个非常有价值的问题,不管是AIGC范畴、传统深度学习范畴还是自动驾驶范畴,从技能到技能管理,都需要我们大刀阔斧的提升行业认知、加强思维全面性以及拔高能力根本面
【二】AI公司的各个部门如何减小信息传递的损耗率?

在AI范畴,如何有效的将价值信息传达到每个部门,并降低损耗率,是AI产品和AI算法办理方案成败的关键,也是整个业务团队服从提升的关键一招。
推荐阅读

1、加入AIGCmagic社区知识星球!

AIGCmagic社区知识星球差别于市面上其他的AI知识星球,AIGCmagic社区知识星球是国内首个以AIGC全栈技能与商业变现为主线的学习交换平台,涉及AI绘画、AI视频、大模型、AI多模态、数字人以及全行业AIGC赋能等100+应用方向。星球内部包含海量学习资源、专业问答、前沿资讯、内推招聘、AI课程、AIGC模型、AIGC数据集和源码等干货
那该如何加入星球呢?很简朴,我们只需要扫下方的二维码即可。知识星球原价:299元/年,前200名限量活动价,终身优惠只需199元/年。大家只需要扫描下面的星球优惠卷即可享受初始住民的最大优惠:


2、Sora等AI视频大模型的核心原理,核心基础知识,网络布局,经典应用场景,从0到1搭建利用AI视频大模型,从0到1训练自己的AI视频大模型,AI视频大模型性能测评,AI视频范畴未来发展等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
Sora等AI视频大模型文章地址:https://zhuanlan.zhihu.com/p/706722494
3、Stable Diffusion 3和FLUX.1核心原理,核心基础知识,网络布局,从0到1搭建利用Stable Diffusion 3和FLUX.1进行AI绘画,从0到1上手利用Stable Diffusion 3和FLUX.1训练自己的AI绘画模型,Stable Diffusion 3和FLUX.1性能优化等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
Stable Diffusion 3和FLUX.1文章地址:https://zhuanlan.zhihu.com/p/684068402
4、Stable Diffusion XL核心基础知识,网络布局,从0到1搭建利用Stable Diffusion XL进行AI绘画,从0到1上手利用Stable Diffusion XL训练自己的AI绘画模型,AI绘画范畴的未来发展等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
Stable Diffusion XL文章地址:https://zhuanlan.zhihu.com/p/643420260
5、Stable Diffusion 1.x-2.x核心原理,核心基础知识,网络布局,经典应用场景,从0到1搭建利用Stable Diffusion进行AI绘画,从0到1上手利用Stable Diffusion训练自己的AI绘画模型,Stable Diffusion性能优化等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
Stable Diffusion文章地址:https://zhuanlan.zhihu.com/p/632809634
6、ControlNet核心基础知识,核心网络布局,从0到1利用ControlNet进行AI绘画,从0到1训练自己的ControlNet模型,从0到1上手构建ControlNet商业变现应用等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
ControlNet文章地址:https://zhuanlan.zhihu.com/p/660924126
7、LoRA系列模型核心原理,核心基础知识,从0到1利用LoRA模型进行AI绘画,从0到1上手训练自己的LoRA模型,LoRA变体模型先容,优质LoRA推荐等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
LoRA文章地址:https://zhuanlan.zhihu.com/p/639229126
8、Transformer核心基础知识,核心网络布局,AIGC时代的Transformer新内在,各AI范畴Transformer的应用落地,Transformer未来发展趋势等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
Transformer文章地址:https://zhuanlan.zhihu.com/p/709874399
9、最全面的AIGC面经《手把手教你成为AIGC算法工程师,斩获AIGC算法offer!(2024年版)》文章正式发布!

码字不易,欢迎大家多多点赞:
AIGC面经文章地址:https://zhuanlan.zhihu.com/p/651076114
10、50万字大汇总《“三年面试五年模拟”之算法工程师的求职面试“独孤九剑”秘籍》文章正式发布!

码字不易,欢迎大家多多点赞:
算法工程师三年面试五年模拟文章地址:https://zhuanlan.zhihu.com/p/545374303
《三年面试五年模拟》github项目地址(希望大家能多多star):https://github.com/WeThinkIn/Interview-for-Algorithm-Engineer
11、Stable Diffusion WebUI、ComfyUI、Fooocus三大主流AI绘画框架核心知识,从0到1搭建AI绘画框架,从0到1利用AI绘画框架的保姆级教程,深入浅出先容AI绘画框架的各模块功能,深入浅出先容AI绘画框架的高阶用法等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
AI绘画框架文章地址:https://zhuanlan.zhihu.com/p/673439761
12、GAN网络核心基础知识,网络架构,GAN经典变体模型,经典应用场景,GAN在AIGC时代的商业应用等全维度解析文章正式发布!

码字不易,欢迎大家多多点赞:
GAN网络文章地址:https://zhuanlan.zhihu.com/p/663157306
13、其他

Rocky将YOLOv1-v7全系列大解析文章也制作成相应的pdf版本,大家可以关注公众号WeThinkIn,并在后台 【精华干货】菜单大概回复关键词“YOLO” 进行取用。
Rocky一直在运营技能交换群(WeThinkIn-技能交换群),这个群的初心主要聚焦于技能话题的讨论与学习,包罗但不限于算法,开发,竞赛,科研以及工作求职等。群里有很多人工智能行业的大牛,欢迎大家入群一起学习交换~(请添加小助手微信Jarvis8866,拉你进群~)

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。




欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/) Powered by Discuz! X3.4