本项目能够经过你的文字描绘来自动识别视频中相符合的片段进行视频编排。该项目依据跨模态查找与向量检索技能搭建，经过前后端别离的形式，协助你快速的接触新一代查找技能。

Pycharm装置

本项目在Linux环境下运转，建议装置Pycharm（Linux）运转

装置办法

image.png

1. Jina 是什么

简略来说 Jina 能够协助你快速把非结构化数据例如图画，文档视频等，转换为向量数据。并结合 Jina 的其他组件规划，协助你快速的把向量数据利用起来，完成多模态的数据查找。

2. Jina 的三个根本概念

Document、Executor 和 Flow 是 Jina 的三个根本概念。

  • Document 是根本的数据类型，它的效果便是能够将非结构化数据与向量数据之间进行映射，详细细节会在 DocArray 一章中详细阐述。
  • Executor 能够了解为一个 Python 类，代表了 Jina 中的算法单元，比方把图画编码成向量、对成果进行排序等算法等都能够用 Executor 来表述。
  • Flow 能够将多个 Executor 衔接起来，将他们和谐成流水线(pipeline)。

3. 装置 Jina

装置 Jina 需求 Python3.7 及以上版别

# via pypi
pip install jina

4. 快速上手

咱们经过下面的比如来了解 Jina 的根本概念，首要咱们需求界说一个 YAML 文件，用于指定 Flow 依照什么逻辑履行

# 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

界说好 YAML 文件后咱们来界说详细的履行逻辑

# 创立 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'))

运转以下命令发动 grpc 服务：

jina flow --uses toy.yml

发动成功后，能够看到如下输出成果

发动.png

然后创立 client.py 文件，履行 python 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']" 字符串。

5. DocArray

5.1 界说

DocArray 是用于存储非结构化数据的数据结构工具包，是本次咱们做跨模态应用的根底。经过这个小而精的入口，能友好地带你走进多模态、跨模态的国际。

DocArray 的亮点在于 Hierarchy + Nested。DocArray 有不同的层级结构，分层存储，榜首层能够是一个全体的视频，第二层是该视频的不同镜头，第三层能够是镜头的某一帧。也能够是其他模态，比方第四层存储台词阶段，第五层存储 ….. 既能够经过某个画面的描绘查找，也能够经过台词的意思去查找，这样查找的颗粒度，结构的多样性和成果的丰厚度，都比传统文本检索好许多。

此外，DocArray 的规划关于 Python 用户来说十分直观，不需求学习新的语法。它融合了 Json、Pandas、Numpy、Protobuf 的长处，更适用于数据科学家和深度学习工程师。

5.2 三个根本概念

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

  • Document：一种表明嵌套非结构化数据的数据结构，是 DocArray 的根本数据类型。无论是处理文本、图画、视频、音频、3D、表格 或它们的嵌套或组合，都能够用 Document 来表明，然后使得各类数据的结构都十分规整，方便后续处理
  • DocumentArray：用于高效拜访、处理和了解多个文档的容器，能够保存多个 Document 的列表
  • Dataclass：用于直观表明多形式数据的高档API

5.3 装置

3.x 版别的 Jina 现已包含了 DocArray，假如你用的是 3.x 的 Jina，能够跳过此步骤。假如你不清楚自己装置的版别号，能够在命令行里输入jina -vf来检查 Jina版别。

因为本项目触及的是视频查找编排，所以这儿重点介绍文本、图画和视频在 Jina 中是怎么处理的。

6. 文本处理

6.1 创立文本

from jina import Document  # 导包
# 创立简略的文本数据
d = Document(text='hello, world.') 
print(d.text)  # 经过text获取文本数据
# 假如文本数据很大，或许自URI，能够先界说URI，然后将文本加载到文档中
d = Document(uri='https://www.w3.org/History/19921103-hypertext/hypertext/README.html')
d.load_uri_to_text()
print(d.text)
# 支持多语言
d = Document(text='👋	नमस्ते दुनिया!	你好国际！こんにちは国际！	Привет мир!')
print(d.text)

image.png

6.2 切割文本

from jina import Document  # 导包
d = Document(text='👋	नमस्ते दुनिया!	你好国际！こんにちは国际！	Привет мир!')
d.chunks.extend([Document(text=c) for c in d.text.split('!')])  # 按'!'分割
d.summary()

image.png

6.3 text、ndarray 互转

from jina import DocumentArray, Document  # 导包
# DocumentArray 相当于一个 list，用于寄存 Document
da = DocumentArray([Document(text='hello world'), 
                    Document(text='goodbye world'),
                    Document(text='hello goodbye')])
vocab = da.get_vocabulary()  # 输出：{'hello': 2, 'world': 3, 'goodbye': 4}
# 转为ndarray
for d in da:
    d.convert_text_to_tensor(vocab, max_length=10)  # 转为tensor向量，max_length为向量最大值，可不设置
    print(d.tensor) 
 # 输出成果：
 [0 0 0 0 0 0 0 0 2 3] #用这种办法简略将字符串转为向量
 [0 0 0 0 0 0 0 0 4 3]
 [0 0 0 0 0 0 0 0 2 4]
 # ndarray
 for d in da:
    d.convert_tensor_to_text(vocab)
    print(d.text)
# 输出成果：
hello world
goodbye world
hello goodbye

6.4 Demo: 简略的文本匹配

from jina import Document, DocumentArray
d = Document(uri='https://www.gutenberg.org/files/1342/1342-0.txt').load_uri_to_text() # 链接是傲慢与偏见的电子书，此处将电子书内容加载到 Document 中
da = DocumentArray(Document(text=s.strip()) for s in d.text.split('\n') if s.strip()) # 依照换行进行分割字符串
da.apply(lambda d: d.embed_feature_hashing())
q = (
    Document(text='she entered the room') # 要匹配的文本
    .embed_feature_hashing()  # 经过 hash 办法进行特征编码
    .match(da, limit=5, exclude_self=True, metric='jaccard', use_scipy=True) # 找到五个与输入的文本最相似的语句
)
print(q.matches[:, ('text', 'scores__jaccard')]) # 输出对应的文本与 jaccard 相似性分数
# 输出成果：
[['staircase, than she entered the breakfast-room, and congratulated', 
'of the room.', 
'She entered the room with an air more than usually ungracious,', 
'entered the breakfast-room, where Mrs. Bennet was alone, than she', 
'those in the room.'], 
[{'value': 0.6, 'ref_id': 'f47f7448709811ec960a1e008a366d49'}, 
{'value': 0.6666666666666666, 'ref_id': 'f47f7448709811ec960a1e008a366d49'}, 
{'value': 0.6666666666666666, 'ref_id': 'f47f7448709811ec960a1e008a366d49'}, 
{'value': 0.6666666666666666, 'ref_id': 'f47f7448709811ec960a1e008a366d49'}, 
{'value': 0.7142857142857143, 'ref_id': 'f47f7448709811ec960a1e008a366d49'}]]

image.png

7. 图画处理

图画部分需求提前装置 Pillow 和 matplotlib 包。首要以下图为例，进行图画部分的介绍：

apple.png

7.1 读取图片并转为 tensor

d = Document(uri='apple.png')
d.load_uri_to_image_tensor()
print(d.tensor, d.tensor.shape)

image.png

7.2 进行简略的图画处理

from jina import Document
d = (
    Document(uri='apple.png')
    .load_uri_to_image_tensor()
    .set_image_tensor_shape(shape=(224, 224))  # 设置shape
    .set_image_tensor_normalization()  # 标准化
    .set_image_tensor_channel_axis(-1, 0)  # 更改通道
)
print(d.tensor, d.tensor.shape)
# 你能够运用 save_image_tensor_to_file 将 tensor 转为图画。当然，因为做了预处理，图片回来时损失了许多信息。
d.save_image_tensor_to_file('apple-proc.png', channel_axis=0)  # 因为前面进行了预处理，channel_axis应该设为0

image.png

7.3 读取图画集

from jina import DocumentArray
da = DocumentArray.from_files('Downloads/*.jpg')  # 从Downloads文件夹中读取一切的jpg文件，在这儿你应该依据自己的路径设置
da.plot_image_sprites('sprite-img.png')  # 运用 plot_image_sprites 绘制图片集图片

image.png

7.4 切割大型图画

因为大型杂乱图画包含了太多的元素和信息，难以界说查找问题，因此很难对其进行查找。

以下图为例，假如要对图画进行剖析，首要就需求切割图画。这儿运用滑动窗口来切割图画。

complicated-image.jpeg

from jina import Document
d = Document(uri='complicated-image.jpeg')
d.load_uri_to_image_tensor()
print(d.tensor.shape)
d.convert_image_tensor_to_sliding_windows(window_shape=(64, 64))  # 运用 64*64 的滑窗切割原图画，切分出 12*15=180 个图画张量
print(d.tensor.shape)
# 能够经过 as_chunks=True，使得上述 180 张图片张量增加到 Document 块中。
# PS：运转这行代码时，需求从头 load image tensor，否则会报错。
d.convert_image_tensor_to_sliding_windows(window_shape=(64, 64), as_chunks=True)
print(d.chunks)
d.chunks.plot_image_sprites('simpsons-chunks.png')  # 运用 plot_image_sprites 将各个 chunk 绘制成图片集图片

image.png

因为采用了滑动窗口扫描整个图画，运用了默许的 stride，切分后的图画不会有重叠，所以从头绘制出的图和原图不同不大。你也能够经过设置 strides 参数进行过采样。

d.convert_image_tensor_to_sliding_windows(window_shape=(64, 64), strides=(10, 10), as_chunks=True)
d.chunks.plot_image_sprites('simpsons-chunks-stride-10.png')

image.png

8. 视频处理

8.1 视频导入和切分

视频需求依赖 av 包。首要，运用 load_uri_to_video_tensor 导入视频。

from jina import Document
d = Document(uri='toy.mp4')
d.load_uri_to_video_tensor()
print(d.tensor.shape)

相较于图画，视频是一个 4 维数组，榜首维表明视频帧 id 或是视频的时刻，剩下的三维则和图画一致。

举个比如，假设 d.tensor.shape=（250，176，320，3），视频总长度 10s。阐明视频巨细为 176×320，包含 250 帧。然后推断出，帧速率约为 250/10=25fps。

能够运用 append 办法将 Document 放入 chunk 中：

for b in d.tensor:
    d.chunks.append(Document(tensor=b))
d.chunks.plot_image_sprites('mov.png')

8.2 关键帧提取

咱们从视频中提取的图画，许多都是冗余的，能够运用 only_keyframes 这个参数来提取关键帧：

from docarray import Document
d = Document(uri='toy.mp4')
d.load_uri_to_video_tensor(only_keyframes=True)
print(d.tensor.shape)

8.3 张量转存为视频

能够运用 save_video_tensor_to_file 进行视频的保存

from docarray import Document
d = (
    Document(uri='toy.mp4')
    .load_uri_to_video_tensor()  # 读取视频
    .save_video_tensor_to_file('60fps.mp4', 60)  # 将其保存为60fps的视频
)

9. Executor

前面咱们说到 Executor 能够看作一个 python 类，用于在 DocumentArray 上履行一系列使命，如第 4 节快速开始中咱们运用的办法相同，在 Executor 中咱们能够将详细的业务逻辑进行封装得到一个服务。除了直接办法办法的调用，Executor 供给了路由的办法来协助你不需求知道服务的详细逻辑就能够调用，类似于前后端别离的网站，前端经过 /index 这种形式对后端接口进行拜访，后端程序收到恳求后对其进行解析，并依据路由规则将该恳求传递到指定的办法中履行。在 Jina 中是经过 requests 装饰器完成的。

class MyExecutor(Executor):
    @requests
    def foo(self, **kwargs):
        print(kwargs)
    @requests(on='/index')
    def bar(self, **kwargs):
        print(kwargs)

上面的比如中便是一个 request 装饰器的比如，在一个 Executor 的办法中默许能够指定 @request(on="") 参数，其中 on 后边接的字符串便是该办法绑定的路由，并且能够看到在 foo 办法中并没有 on 这个参数，此时便是默许路由，当恳求找不到对应的路由时会履行该办法。

10. 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)

除了上面咱们用 grpc 进行通讯外，咱们还能够运用纯 python 的办法对 Flow 进行调用，例如在上面咱们界说了两个 Executor，分别是 FooExecutor 与 BarExecutor，并将这两个 Executor 增加到了同一个 Flow 中，经过 with 办法发动 Flow 并用 post 办法对 Flow 发送一个恳求，最终程序会回来 ['foo was here', 'bar was here']。

可是经过 YAML 办法将 Executor 和 Flow 分隔有以下长处：

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