jina - 帮助开发者构建和部署多模态AI应用的开源框架

使用云原生技术构建多模态AI应用程序

Jina让你可以构建通过gRPC、HTTP和WebSockets进行通信的多模态AI服务和管道，然后将它们扩展并部署到生产环境。你可以专注于逻辑和算法，而不必担心基础设施的复杂性。

Jina为机器学习模型提供了从本地部署到高级编排框架（如Docker-Compose、Kubernetes或Jina AI Cloud）的一流Python体验。Jina使高级解决方案工程和云原生技术对每个开发者都变得易于访问。

为任何数据类型和任何主流深度学习框架构建和服务模型。
设计高性能服务，具有轻松扩展、双向客户端-服务器流、批处理、动态批处理、异步/非阻塞数据处理和任何协议。
流式传输输出时服务LLM模型。
通过Executor Hub进行Docker容器集成，OpenTelemetry/Prometheus可观测性。
通过Jina AI Cloud简化CPU/GPU托管。
使用我们的Kubernetes和Docker Compose集成部署到你的云或系统。

等等，Jina与FastAPI有什么不同？

Jina的价值主张似乎与FastAPI非常相似。然而，它们之间存在几个根本性的区别：

数据结构和通信协议

FastAPI的通信依赖于Pydantic，而Jina依赖于DocArray，使得Jina能够支持多种协议来公开其服务。gRPC协议的支持特别适用于数据密集型应用程序，例如嵌入服务，其中嵌入和张量可以更高效地序列化。

高级编排和扩展能力

Jina允许你轻松地将服务和模型容器化并编排，提供并发性和可扩展性。
Jina允许你部署由多个微服务组成的应用程序，这些微服务可以独立容器化和扩展。

云端之旅

Jina提供了从本地开发（使用DocArray）到本地服务（使用Deployment和Flow）的平滑过渡，最终通过使用Kubernetes的容器生命周期编排功能获得生产就绪的服务。
通过使用Jina AI Cloud，你可以通过一条命令访问可扩展的无服务器部署。

文档

安装

pip install jina

在Apple Silicon/Windows上找到更多安装选项。

入门

基本概念

Jina有三个基本层：

数据层：BaseDoc和DocList（来自DocArray）是Jina中的输入/输出格式。
服务层：Executor是一个Python类，用于转换和处理文档。通过简单地将你的模型包装到Executor中，你就可以让它们被Jina服务和扩展。Gateway是确保连接Flow中所有Executor的服务。
编排层：Deployment服务于单个Executor，而Flow则服务于链接到管道中的Executor。

这里解释了完整的术语表。

服务AI模型

让我们构建一个快速、可靠且可扩展的基于gRPC的AI服务。在Jina中，我们称之为**Executor。我们的简单Executor将包装来自Stability AI的StableLM LLM。然后我们将使用Deployment**来服务它。

让我们实现服务的逻辑：

`executor.py`
from jina import Executor, requests from docarray import DocList, BaseDoc from transformers import pipeline class Prompt(BaseDoc): text: str class Generation(BaseDoc): prompt: str text: str class StableLM(Executor): def __init__(self, kwargs): super().__init__(kwargs) self.generator = pipeline( 'text-generation', model='stabilityai/stablelm-base-alpha-3b' ) @requests def generate(self, docs: DocList[Prompt], **kwargs) -> DocList[Generation]: generations = DocList[Generation]() prompts = docs.text llm_outputs = self.generator(prompts) for prompt, output in zip(prompts, llm_outputs): generations.append(Generation(prompt=prompt, text=output)) return generations

executor.py

from jina import Executor, requests
from docarray import DocList, BaseDoc

from transformers import pipeline


class Prompt(BaseDoc):
    text: str


class Generation(BaseDoc):
    prompt: str
    text: str


class StableLM(Executor):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.generator = pipeline(
            'text-generation', model='stabilityai/stablelm-base-alpha-3b'
        )

    @requests
    def generate(self, docs: DocList[Prompt], **kwargs) -> DocList[Generation]:
        generations = DocList[Generation]()
        prompts = docs.text
        llm_outputs = self.generator(prompts)
        for prompt, output in zip(prompts, llm_outputs):
            generations.append(Generation(prompt=prompt, text=output))
        return generations

然后我们用Python API或YAML部署它：

Python API: deployment.py YAML: deployment.yml

Python API: `deployment.py`	YAML: `deployment.yml`
`from jina import Deployment from executor import StableLM dep = Deployment(uses=StableLM, timeout_ready=-1, port=12345) with dep: dep.block()`	`jtype: Deployment with: uses: StableLM py_modules: - executor.py timeout_ready: -1 port: 12345` 然后通过CLI运行YAML Deployment：`jina deployment --uses deployment.yml`

from jina import Deployment
from executor import StableLM

dep = Deployment(uses=StableLM, timeout_ready=-1, port=12345)

with dep:
    dep.block()

jtype: Deployment
with:
  uses: StableLM
  py_modules:
    - executor.py
  timeout_ready: -1
  port: 12345

然后通过CLI运行YAML Deployment：jina deployment --uses deployment.yml

使用Jina客户端向服务发送请求：

from jina import Client
from docarray import DocList, BaseDoc


class Prompt(BaseDoc
```yaml
jtype: TextToImage
py_modules:
  - executor.py
metas:
  name: TextToImage
  description: 基于StableDiffusion的文字转图片生成执行器
  url:
  keywords: []

diffusers
accelerate
transformers

然后通过执行 jina hub push TextToImage 将执行器推送到Hub。

这将生成一个URL，您可以在 Deployment 和 Flow 中使用该URL来使用已推送的执行器容器。

jtype: Flow
with:
    port: 12345
executors:
  - uses: jinai+docker://<user-id>/StableLM
  - uses: jinai+docker://<user-id>/TextToImage

快速进入云原生

使用Kubernetes与Jina很容易：

jina export kubernetes flow.yml ./my-k8s
kubectl apply -R -f my-k8s

Docker Compose同样简单：

jina export docker-compose flow.yml docker-compose.yml
docker-compose up

注意您还可以将部署YAML导出到 Kubernetes 和 Docker Compose。

这还不是全部。我们还支持 OpenTelemetry, Prometheus, 和 Jaeger。

哪种云原生技术对您来说仍然具有挑战性？告诉我们，我们会处理复杂性并使其变得简单。

部署到JCloud

您还可以将Flow部署到JCloud，在那里您可以通过一个命令轻松享受自动扩展、监控等功能。

首先，通过指定资源需求并使用容器化的Hub执行器，将 flow.yml 文件转换为 JCloud兼容的YAML。

然后，使用 jina cloud deploy 命令部署到云端：

wget https://raw.githubusercontent.com/jina-ai/jina/master/.github/getting-started/jcloud-flow.yml
jina cloud deploy jcloud-flow.yml

警告

在完成本教程后，请确保删除/清理Flow以节省资源和积分。

阅读更多关于将Flow部署到JCloud 的信息。

为LLM提供流式服务

大型语言模型可以为从聊天机器人到助手和智能系统的广泛应用提供动力。然而，这些模型可能很庞大且运行缓慢，而用户希望系统既智能又快速！

大型语言模型通过将您的问题转化为标记（tokens），然后一个一个地生成新标记，直到模型决定停止生成为止。这意味着您需要流式传输由大型语言模型生成的输出标记到客户端。在本教程中，我们将讨论如何通过Jina中的流式端点实现这一目标。

服务架构

第一步是定义流式服务的架构，就像在任何其他服务框架中一样。服务的输入是提示和要生成的最大标记数量，而输出只是标记ID：

from docarray import BaseDoc

class PromptDocument(BaseDoc):
    prompt: str
    max_tokens: int

class ModelOutputDocument(BaseDoc):
    token_id: int
    generated_text: str

服务初始化

我们的服务依赖于一个大型语言模型。作为示例，我们将使用 gpt2 模型。这是您如何在执行器中加载此类模型：

from jina import Executor, requests
from transformers import GPT2Tokenizer, GPT2LMHeadModel
import torch

tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

class TokenStreamingExecutor(Executor):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.model = GPT2LMHeadModel.from_pretrained('gpt2')

实现流式端点

我们的流式端点接受 PromptDocument 作为输入，并流式传输 ModelOutputDocument。要将文档流式传输回客户端，在端点实现中使用 yield 关键字。因此，我们使用模型生成最多 max_tokens 个标记并逐个传输，直到生成停止：

class TokenStreamingExecutor(Executor):
    ...

    @requests(on='/stream')
    async def task(self, doc: PromptDocument, **kwargs) -> ModelOutputDocument:
        input = tokenizer(doc.prompt, return_tensors='pt')
        input_len = input['input_ids'].shape[1]
        for _ in range(doc.max_tokens):
            output = self.model.generate(**input, max_new_tokens=1)
            if output[0][-1] == tokenizer.eos_token_id:
                break
            yield ModelOutputDocument(
                token_id=output[0][-1],
                generated_text=tokenizer.decode(
                    output[0][input_len:], skip_special_tokens=True
                ),
            )
            input = {
                'input_ids': output,
                'attention_mask': torch.ones(1, len(output[0])),
            }

了解更多关于流式端点的信息，见 Executor 文档。

提供服务并发送请求

最后一步是提供执行器服务并使用客户端发送请求。要使用gRPC提供执行器服务：

from jina import Deployment

with Deployment(uses=TokenStreamingExecutor, port=12345, protocol='grpc') as dep:
    dep.block()

要从客户端发送请求：

import asyncio
from jina import Client

async def main():
    client = Client(port=12345, protocol='grpc', asyncio=True)
    async for doc in client.stream_doc(
        on='/stream',
        inputs=PromptDocument(prompt='法国的首都是什么？', max_tokens=10),
        return_type=ModelOutputDocument,
    ):
        print(doc.generated_text)

asyncio.run(main())

The
The capital
The capital of
The capital of France
The capital of France is
The capital of France is Paris
The capital of France is Paris.

支持

加入我们的 Discord社区，与其他社区成员交流想法。
订阅我们 YouTube频道上的最新视频教程。

加入我们

Jina由 Jina AI 支持，并根据 Apache-2.0 许可发布。