跨模态神经搜索实践VCED Jina入门

1. Jina简介

1.1 Jina是什么

Jina是帮助您在云端构建跨模态和多模态系统的框架。借助 Jina，开发人员可以轻松地在生产环境中构建高性能云原生应用程序、服务和系统。

简单来说，Jina可以帮助快速把非结构化数据如图像、文档视频等，转化为向量数据。并结合Jina的其他组件设计，帮助快速的将向量数据利用起来，实现多模态的数据搜索。

1.2 Jina的三个基本概念

Jina包括三个基本概念：

• Document：基本的数据结构，它的作用是可以将非结构化数据与向量数据进行映射；
• Executor：可以理解为一个Python类，代表了Jina的算法单元，比如将图像编码为向量，对结果进行排序等算法都可以用Executor表述；
• Flow：可以将多个Executor连接起来，将它们协调成流水线（pipeline）。

Jina还包括其它概念，这里给出官方手册供参考。

1.3 安装Jina

在前文中讲过Jina的安装，有基于miniconda和docker的安装，这里给出对应命令：

# via pypi
pip install jina

# via conda
conda install jina -c conda-forge

# via docker
docker pull jinaai/jina:latest
1
2
3
4
5
6
7
8

1.4 启动方式

Jina有两种编码方式：

• 基于Python：所有的类（Flow和Executor）和实现都基于Python实现，通过Python启动相关服务
• 基于Yaml文件：Executor用Python编写，Flow通过YAML定义，整个服务通过jina flow --uses flow.yml启动

同时，以上两种方式可以很容易的转化

• 给出包含Yaml文件，使用Python启动的方式，只需要新增一个读取Yaml文件的类并启动即可，如下：

from jina import Flow

f = Flow.load_config('flow.yml')

with f:
    f.block()
1
2
3
4
5
6

• 将Python方式转换为Yaml文件：

from jina import Flow

Flow().add(uses=FooExec, replicas=3).add(uses=BarExec, replicas=2).save_config('flow.yml')
1
2
3

1.5 快速入门

Jina包括服务端和客户端，首先创建服务端

1.5.1 创建服务端

创建Executors，这里示例，在同一个文件创建多个Executor，文件名为test.py，代码内容如下：

# 创建 test.py 文件与 YAML 文件在同一目录下
# 导入 document、executor 和 flow 以及 requests 装饰器
from jina import DocumentArray, Executor, requests, Document

# 编写 FooExecutor 与 BarExecutor 类，类中定义了函数 foo 和 bar
# 该函数从网络请求接收 DocumentArray (先暂时不需要理解它是什么)，并在其内容后面附加 "foo was here" 与 "bar was here"
class FooExecutor(Executor):
    @requests  # 用于指定路由，类似网页访问 /index 和 /login 会被路由到不同的方法上是用样的概念，关于 request 下面会再进行详细介绍
    def foo(self, docs: DocumentArray, **kwargs):
        docs.append(Document(text='foo was here'))


class BarExecutor(Executor):
    @requests
    def bar(self, docs: DocumentArray, **kwargs):
        docs.append(Document(text='bar was here'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

创建flow.yml，内容如下：

# toy.yml
# 运行以下命令启动 grpc 服务：
# jina flow --uses toy.yml≈≈
jtype: Flow
with:
  port: 51000
  protocol: grpc
executors:
  - uses: FooExecutor
    name: foo
    py_modules:
      - test.py
  - uses: BarExecutor
    name: bar
    py_modules:
      - test.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

执行jina flow --uses toy.yml启动Jina服务，如下图表示启动成功：

1.5.3 创建客户端

创建client.py，代码如下：

# 从 Jina 中导入连接的客户端与 Document
from jina import Client, Document

c = Client(host='grpc://0.0.0.0:51000')  # 如果运行提示失败，可尝试使用localhost
result = c.post('/', Document())  # 将一个空的 Document 传到服务端执行
print(result.texts)  # ['', 'foo was here', 'bar was here']
1
2
3
4
5
6

执行即可发现输出相关内容：['', 'foo was here', 'bar was here']

2. DocArray

DocArray是一个嵌套的、非结构化的、多模式的数据传输库，包括文本、图像、音频、视频、3D网格等。它允许使用者以Python风格的API高效地处理、嵌入、搜索、推荐、存储和传输多模式数据。

DocArray 的亮点在于 Hierarchy + Nested。DocArray 有不同的层级结构，分层存储，第一层可以是一个整体的视频，第二层是该视频的不同镜头，第三层可以是镜头的某一帧。也可以是其他模态，比如第四层存储台词段落，第五层存储 … 既可以通过某个画面的描述搜索，也可以通过台词的意思去搜索，这样搜索的颗粒度，结构的多样性和结果的丰富度，都比传统文本检索好很多。

此外，DocArray 的设计对于 Python 用户来说非常直观，不需要学习新的语法。它融合了 Json、Pandas、Numpy、Protobuf 的优点，更适用于数据科学家和深度学习工程师。

2.1 三个基本概念

DocArray由三个简单的概念组成：

• Document：一种表示嵌套非结构化数据的数据结构，是 DocArray 的基本数据类型。无论是处理文本、图像、视频、音频、3D、表格 或它们的嵌套或组合，都可以用 Document 来表示，从而使得各类数据的结构都非常规整，方便后续处理；
• DocumentArray：用于高效访问、处理和理解多个文档的容器，可以保存多个Document的列表；
• Dataclass：用于直观表示多模式数据的高级API

2.2 安装

3.x 版本的 Jina 已经包含了 DocArray，如果你用的是 3.x 的 Jina，可以跳过此步骤。如果你不清楚自己安装的版本号，可以在命令行里输入jina -vf来查看 Jina版本。

2.3 DocArray使用

这里主要介绍其中的文本、视频和图像在Jina中的使用

2.3.1 文本处理

• 创建文本
• 切割文本
• text、ndarray互转
• 简单的文本匹配

2.3.2 图像处理

• 读取图片并转为tensor
• 简单的图像处理
• 读取图像集
• 切割大型图像

2.3.3 视频处理

• 视频导入和切分
• 关键帧提取
• 张量转存为视频

3. Executor

Executor用于在DocumentArray上执行一系列任务，在Executor中可以将具体的业务逻辑封装得到一个服务，除了直接方法的调用，还提供了路由的方式来帮助不需要知道服务的具体逻辑就可以调用，类似于前后端分离的网站，前端可以通过路由来对后端访问。在Jina中通过requests装饰器实现。如下：

class MyExecutor(Executor):
    @requests
    def foo(self, **kwargs):
        print(kwargs)

    @requests(on='/index')
    def bar(self, **kwargs):
        print(kwargs)
1
2
3
4
5
6
7
8

4. Flow

一个 Flow 可以理解为一系列任务的协调器，通过 add 方法可以将多个 Executor 串成一套执行逻辑。

from jina import Document, DocumentArray, Flow, Executor, requests

class FooExecutor(Executor):
    @requests
    def foo(self, docs: DocumentArray, **kwargs):
        docs.append(Document(text='foo was here'))


class BarExecutor(Executor):
    @requests
    def bar(self, docs: DocumentArray, **kwargs):
        docs.append(Document(text='bar was here'))


f = (
    Flow()
    .add(uses=FooExecutor, name='fooExecutor')
    .add(uses=BarExecutor, name='barExecutor')
)  # 创建一个空的 Flow

with f:  # 启动 Flow
    response = f.post(
        on='/'
    ) # 向 flow 发送一个请求
    print(response.texts)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

除了上面我们用 grpc 进行通信外，我们还可以使用纯 python 的方式对 Flow 进行调用，例如在上面我们定义了两个 Executor，分别是 FooExecutor 与 BarExecutor，并将这两个 Executor 添加到了同一个 Flow 中，通过 with 方法启动 Flow 并用 post 方法对 Flow 发送一个请求，最终程序会返回 ['foo was here', 'bar was here']。

但是通过 YAML 方式将 Executor 和 Flow 分开有以下优点：

• 服务器上的数据流是非阻塞和异步的，当 Executor 处于空闲状态时，会立即处理新的请求。
• 必要时会自动添加负载平衡，以确保最大吞吐量。

References

1. Jina