如何开始使用 Milvus

<p>现在，每个人都知道混合搜索提高了<a href="https://zilliz.com/learn/Retrieval-Augmented-Generation">RAG</a>（检索增强生成）搜索的质量。虽然<a href="https://zilliz.com/learn/sparse-and-dense-embeddings">密集 Embeddings</a>搜索在捕捉查询和文档之间的深层语义关系方面表现出了令人印象深刻的能力，但它仍有明显的局限性。这些限制包括缺乏可解释性，以及在处理长尾查询和稀有术语时性能不佳。</p>
<p>许多 RAG 应用之所以举步维艰，是因为预先训练的模型往往缺乏特定领域的知识。在某些情况下，简单的 BM25 关键字匹配就能胜过这些复杂的模型。这就是混合搜索的优势所在，它将密集向量检索的语义理解与关键词匹配的精确性结合在一起。</p>
<h2 id="Why-Hybrid-Search-is-Complex-in-Production" class="common-anchor-header">为什么混合搜索在生产中很复杂<button data-href="#Why-Hybrid-Search-is-Complex-in-Production" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>虽然像<a href="https://zilliz.com/learn/LangChain">LangChain</a>或<a href="https://zilliz.com/learn/getting-started-with-llamaindex">LlamaIndex</a>这样的框架可以轻松构建概念验证型混合检索器，但将其扩展到大规模数据集的生产却具有挑战性。传统的架构需要单独的向量数据库和搜索引擎，这导致了几个关键的挑战：</p>
<ul>
<li><p>高昂的基础设施维护成本和操作复杂性</p></li>
<li><p>跨多个系统的数据冗余</p></li>
<li><p>数据一致性管理困难</p></li>
<li><p>跨系统的安全和访问控制复杂</p></li>
</ul>
<p>市场需要一种统一的解决方案，既能支持词法和语义搜索，又能降低系统复杂性和成本。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/elasticsearch_vs_milvus_5be6e2b69e.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<h2 id="The-Pain-Points-of-Elasticsearch" class="common-anchor-header">Elasticsearch 的痛点<button data-href="#The-Pain-Points-of-Elasticsearch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Elasticsearch 是过去十年中最具影响力的开源搜索项目之一。它基于 Apache Lucene 构建，凭借其高性能、可扩展性和分布式架构而广受欢迎。虽然它在 8.0 版中增加了向量 ANN 搜索，但生产部署仍面临几个关键挑战：</p>
<p><strong>高更新和索引成本：</strong>Elasticsearch 的架构不能完全解耦写入操作、索引构建和查询。这导致在写操作过程中，尤其是批量更新时，CPU 和 I/O 开销巨大。索引和查询之间的资源争用会影响性能，成为高频更新场景的主要瓶颈。</p>
<p><strong>实时性差：</strong>作为一种 "接近实时 "的搜索引擎，Elasticsearch 在数据可见性方面引入了明显的延迟。对于 Agents 系统等人工智能应用来说，这种延迟尤其成问题，因为在这些应用中，高频率的交互和动态决策需要即时的数据访问。</p>
<p><strong>分片管理困难：</strong>虽然 Elasticsearch 使用分片来实现分布式架构，但分片管理带来了巨大挑战。缺乏动态分片支持造成了两难境地：小数据集中的分片过多会导致性能低下，而大数据集中的分片过少则会限制可扩展性并造成数据分布不均。</p>
<p><strong>非云原生架构：</strong>Elasticsearch 是在云原生架构流行之前开发的，其设计将存储和计算紧密结合在一起，限制了它与公共云和 Kubernetes 等现代基础架构的集成。资源扩展需要同时增加存储和计算资源，从而降低了灵活性。在多副本场景中，每个分片都必须独立建立索引，从而增加了计算成本，降低了资源效率。</p>
<p><strong>向量搜索性能差：</strong>虽然 Elasticsearch 8.0 引入了向量 ANN 搜索，但其性能明显落后于 Milvus 等专用向量引擎。基于 Lucene 内核，其索引结构在处理高维数据时效率低下，难以满足大规模向量搜索的要求。在涉及标量过滤和多租户的复杂情况下，其性能尤其不稳定，这使其难以支持高负荷或多样化的业务需求。</p>
<p><strong>资源消耗过大：</strong>Elasticsearch 对内存和 CPU 的要求极高，尤其是在处理大规模数据时。其对 JVM 的依赖性要求频繁调整堆大小和调整垃圾收集，严重影响了内存效率。向量搜索操作需要密集的 SIMD 优化计算，而 JVM 环境远非理想。</p>
<p>随着企业扩展其人工智能基础架构，这些基本限制变得越来越成问题，这使得 Elasticsearch 对于要求高性能和高可靠性的现代人工智能应用来说尤其具有挑战性。</p>
<h2 id="Introducing-Sparse-BM25-Reimagining-Lexical-Search" class="common-anchor-header">引入 Sparse-BM25：重塑词法搜索<button data-href="#Introducing-Sparse-BM25-Reimagining-Lexical-Search" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://milvus.io/blog/introduce-milvus-2-5-full-text-search-powerful-metadata-filtering-and-more.md">Milvus 2.5</a>在 2.4 版推出的混合搜索功能基础上，通过 Sparse-BM25 引入了本地词法搜索支持。这一创新方法包括以下关键组件：</p>
<ul>
<li><p>通过 Tantivy 进行高级标记化和预处理</p></li>
<li><p>分布式词汇和词频管理</p></li>
<li><p>使用语料库 TF 和查询 TF-IDF 生成稀疏向量</p></li>
<li><p>使用 WAND 算法支持反索引（Block-Max WAND 和图索引支持正在开发中）</p></li>
</ul>
<p>与 Elasticsearch 相比，Milvus 在算法灵活性方面具有显著优势。其基于向量距离的相似性计算可实现更复杂的匹配，包括实施基于 "端到端查询术语加权 "研究的 TW-BERT（术语加权 BERT）。这种方法在域内和域外测试中都表现出了卓越的性能。</p>
<p>另一个关键优势是成本效益。通过利用倒排索引和密集嵌入压缩，Milvus 实现了五倍的性能提升，而召回率下降不到 1%。通过尾端剪枝和向量量化，内存使用量减少了 50%以上。</p>
<p>长查询优化是 Milvus 的一大优势。传统的 WAND 算法在处理长查询时非常吃力，而 Milvus 则通过将稀疏嵌入与图索引相结合，在高维稀疏向量搜索场景中实现了十倍的性能提升。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/document_in_and_out_b84771bec4.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<h2 id="Milvus-The-Ultimate-Vector-Database-for-RAG" class="common-anchor-header">Milvus：RAG 的终极向量数据库<button data-href="#Milvus-The-Ultimate-Vector-Database-for-RAG" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 功能全面，是 RAG 应用程序的首选。主要优势包括</p>
<ul>
<li><p>丰富的元数据支持，具有动态 Schema 功能和强大的过滤选项</p></li>
<li><p>企业级多租户，通过 Collections、分区和分区 Key 实现灵活隔离</p></li>
<li><p>业内首创的磁盘向量索引支持，提供从内存到 S3 的多层存储</p></li>
<li><p>云原生可扩展性，支持从 10M 到 1B+ 向量的无缝扩展</p></li>
<li><p>全面的搜索功能，包括分组、范围和混合搜索</p></li>
<li><p>与 LangChain、LlamaIndex、Dify 和其他人工智能工具的深度生态系统集成</p></li>
</ul>
<p>系统的多种搜索功能包括分组、范围和混合搜索方法。与 LangChain、LlamaIndex 和 Dify 等工具的深度集成，以及对众多人工智能产品的支持，使 Milvus 成为现代人工智能基础设施生态系统的中心。</p>
<h2 id="Looking-Forward" class="common-anchor-header">展望未来<button data-href="#Looking-Forward" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着人工智能从 POC 过渡到生产，Milvus 将继续发展。我们专注于使向量搜索更易于使用、更具成本效益，同时提高搜索质量。无论您是初创公司还是企业，Milvus 都能降低人工智能应用开发的技术壁垒。</p>
<p>对可访问性和创新的承诺使我们又向前迈进了一大步。虽然我们的开源解决方案仍是全球成千上万应用的基础，但我们认识到，许多企业需要一个完全托管的解决方案，以消除操作开销。</p>
<h2 id="Zilliz-Cloud-The-Managed-Solution" class="common-anchor-header">Zilliz Cloud：托管解决方案<button data-href="#Zilliz-Cloud-The-Managed-Solution" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在过去三年中，我们在 Milvus 的基础上构建了完全托管的向量数据库服务<a href="https://zilliz.com/cloud">Zilliz Cloud</a>。通过对 Milvus 协议的云原生重新实施，它提供了更高的可用性、成本效率和安全性。</p>
<p>借鉴我们维护全球最大向量搜索集群和支持数千名人工智能应用开发人员的经验，与自托管解决方案相比，Zilliz Cloud 大大降低了操作符和成本。</p>
<p>准备好体验向量搜索的未来了吗？立即开始免费试用，无需信用卡，最高可获得 200 美元积分。</p>


Elasticsearch 已死，词法搜索万岁

使用 Milvus 2.5 开始混合语义/全文搜索

介绍 Milvus 2.5：全文搜索、更强大的元数据过滤功能和可用性改进！

语义搜索与全文搜索：我要在 Milvus 2.5 中选择哪一个？

利用 Milvus 设计多租户 RAG：可扩展企业知识库的最佳实践

如何为 Milvus 做贡献：开发人员快速入门指南

Getting Started with HNSWlib

HNSWlib 入门

<p>我们很高兴为 Milvus 用户推出每周办公时间，让他们在<a href="https://zilliz.com/learn/what-is-vector-database">向量数据库</a>项目中获得实际支持！加入我们的专家团队，参加 20 分钟的一对一会议，获取见解、指导和问题解答。无论您是刚刚开始使用，还是需要特定问题的帮助，我们都会帮助您充分利用 Milvus。</p>
<p><strong>在这里预订您的办公时间会议<a href="https://meetings.hubspot.com/chloe-williams1/milvus-office-hours">:https://meetings.hubspot.com/chloe-williams1/milvus-office-hours</a></strong></p>
<h2 id="Why-Book-a-Session" class="common-anchor-header">为什么要预约？<button data-href="#Why-Book-a-Session" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>以下是预订办公时间的几个重要原因：</p>
<ul>
<li><p><strong>优化 Milvus 性能：</strong>获取调整配置以提高数据库性能的技巧。</p></li>
<li><p><strong>数据模式设计建议：</strong>了解数据 Schema 和索引类型的最佳实践，以最适合您的使用情况。</p></li>
<li><p><strong>扩展 Milvus 部署：</strong>获取有关管理和扩展 Milvus 以适应更大数据量的建议。</p></li>
<li><p><strong>排除特定问题：</strong>遇到错误或异常行为？我们可以帮助排查和解决。</p></li>
<li><p><strong>集成协助：</strong>在使用 Milvus 与其他集成框架（如 LangChain、LlamaIndex、Spark 或您的数据处理管道）时需要指导？</p></li>
<li><p><strong>了解新功能：</strong>了解 Milvus 的最新功能，以及这些功能如何使您的项目受益。</p></li>
</ul>
<p>千万不要错过这个在专家指导下提升您的 Milvus 实施水平的机会。</p>
<p>如果您无法参加我们的现场活动，请不要担心，您仍有很多途径获得支持！Milvus 社区在<a href="https://discord.com/invite/8uyFbECzPX">Discord</a>和<a href="https://github.com/search?q=milvus&amp;type=discussions"> GitHub Discussions</a> 上非常活跃，随时准备为您提供帮助。无论您喜欢即时聊天还是异步讨论，这些平台都是您提问、分享知识以及与 Milvus 其他用户和贡献者联系的好地方。</p>


加入 Milvus 办公时间，获得向量 DB 专家的支持！

What are Matryoshka Embeddings?

Matryoshka Embeddings：多尺度的细节

如何使用 Milvus 备份工具：分步指南

在 Kubernetes 上部署 Milvus：Kubernetes 用户分步指南

如何在亚马逊 EKS 上部署开源 Milvus 向量数据库

<p><a href="https://milvus.io/intro">Milvus</a>是专为人工智能应用设计的开源向量数据库。无论您是在进行机器学习、深度学习还是其他任何人工智能相关项目，Milvus 都能为您提供处理大规模向量数据的强大而高效的方法。</p>
<p>现在，通过 Milvus 的 Python SDK PyMilvus 中的<a href="https://milvus.io/docs/embeddings.md">模型模块集成</a>，添加 Embeddings 和 Rerankers 模型变得更加容易。这种集成简化了将数据转化为可搜索向量或重新排名结果的过程，从而获得更准确的结果，例如在<a href="https://zilliz.com/learn/Retrieval-Augmented-Generation">检索增强生成（RAG）</a>中。</p>
<p>在本博客中，我们将回顾密集嵌入模型、稀疏嵌入模型和重排序器，并演示如何使用<a href="https://milvus.io/blog/introducing-milvus-lite.md">Milvus Lite</a>（Milvus 的轻量级版本，可在您的 Python 应用程序中本地运行）在实践中使用它们。</p>
<h2 id="Dense-vs-Sparse-Embeddings" class="common-anchor-header">密集嵌入与稀疏嵌入<button data-href="#Dense-vs-Sparse-Embeddings" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在介绍如何使用我们的集成之前，我们先来了解一下向量嵌入的两大类。</p>
<p><a href="https://zilliz.com/glossary/vector-embeddings">向量嵌入</a>通常分为两大类：<a href="https://zilliz.com/learn/sparse-and-dense-embeddings"><strong>密集嵌入</strong></a>（<a href="https://zilliz.com/learn/sparse-and-dense-embeddings"><strong>Dense Embeddings</strong></a>）<a href="https://zilliz.com/learn/sparse-and-dense-embeddings">和<strong>稀疏嵌入（Sparse Embeddings</strong></a>）。</p>
<ul>
<li><p>密集嵌入（Dense Embeddings）是高维向量，其中大部分或所有元素都不为零，因此非常适合编码文本语义或模糊含义。</p></li>
<li><p>稀疏嵌入（Sparse Embeddings）是高维向量，其中有很多零元素，更适合编码精确或相邻的概念。</p></li>
</ul>
<p>Milvus 支持这两种类型的嵌入，并提供混合搜索。<a href="https://zilliz.com/blog/hybrid-search-with-milvus">混合搜索</a>允许你在同一个 Collections 中跨各种向量场进行搜索。这些向量可以代表数据的不同方面，使用不同的嵌入模型，或采用不同的数据处理方法，使用重新排序器组合结果。</p>
<h2 id="How-to-Use-Our-Embedding-and-Reranking-Integrations" class="common-anchor-header">如何使用我们的 Embeddings 和 Rerankers 集成<button data-href="#How-to-Use-Our-Embedding-and-Reranking-Integrations" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在下面的章节中，我们将演示使用我们的集成生成嵌入和进行向量搜索的三个实际示例。</p>
<h3 id="Example-1-Use-the-Default-Embedding-Function-to-Generate-Dense-Vectors" class="common-anchor-header">示例 1：使用默认嵌入函数生成密集向量</h3><p>要使用 Milvus 的嵌入和 Rerankers 功能，必须安装<code translate="no">pymilvus</code> 客户端和<code translate="no">model</code> 软件包。</p>
<pre><code translate="no">pip install <span class="hljs-string">&quot;pymilvus[model]&quot;</span>
<button class="copy-code-btn"></button></code></pre>
<p>这一步将安装<a href="https://milvus.io/docs/quickstart.md">Milvus Lite</a>，允许你在 Python 应用程序中本地运行 Milvus。它还包含模型子包，其中包括 Embeddings 和 Rerankers 的所有实用程序。</p>
<p>模型子包支持各种嵌入模型，包括来自 OpenAI、<a href="https://zilliz.com/learn/Sentence-Transformers-for-Long-Form-Text">Sentence Transformers</a>、<a href="https://zilliz.com/learn/bge-m3-and-splade-two-machine-learning-models-for-generating-sparse-embeddings">BGE-M3</a>、BM25、<a href="https://zilliz.com/learn/bge-m3-and-splade-two-machine-learning-models-for-generating-sparse-embeddings">SPLADE</a> 和 Jina AI 预训练模型的嵌入模型。</p>
<p>本示例使用<code translate="no">DefaultEmbeddingFunction</code> ，基于<code translate="no">all-MiniLM-L6-v2</code> Sentence Transformers 模型，以简化操作。该模型约 70MB，将在首次使用时下载：</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> model

<span class="hljs-comment"># This will download &quot;all-MiniLM-L6-v2&quot;, a lightweight model.</span>
ef = model.DefaultEmbeddingFunction()

<span class="hljs-comment"># Data from which embeddings are to be generated</span>
docs = [
   <span class="hljs-string">&quot;Artificial intelligence was founded as an academic discipline in 1956.&quot;</span>,
   <span class="hljs-string">&quot;Alan Turing was the first person to conduct substantial research in AI.&quot;</span>,
   <span class="hljs-string">&quot;Born in Maida Vale, London, Turing was raised in southern England.&quot;</span>,
]

embeddings = ef.encode_documents(docs)

<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Embeddings:&quot;</span>, embeddings)
<span class="hljs-comment"># Print dimension and shape of embeddings</span>
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Dim:&quot;</span>, ef.dim, embeddings[<span class="hljs-number">0</span>].shape)
<button class="copy-code-btn"></button></code></pre>
<p>预期输出结果如下：</p>
<pre><code translate="no">Embeddings: [array([<span class="hljs-number">-3.09392996e-02</span>, <span class="hljs-number">-1.80662833e-02</span>,  <span class="hljs-number">1.34775648e-02</span>,  <span class="hljs-number">2.77156215e-02</span>,
      <span class="hljs-number">-4.86349640e-03</span>, <span class="hljs-number">-3.12581174e-02</span>, <span class="hljs-number">-3.55921760e-02</span>,  <span class="hljs-number">5.76934684e-03</span>,
       <span class="hljs-number">2.80773244e-03</span>,  <span class="hljs-number">1.35783911e-01</span>,  <span class="hljs-number">3.59678417e-02</span>,  <span class="hljs-number">6.17732145e-02</span>,
...
      <span class="hljs-number">-4.61330153e-02</span>, <span class="hljs-number">-4.85207550e-02</span>,  <span class="hljs-number">3.13997865e-02</span>,  <span class="hljs-number">7.82178566e-02</span>,
      <span class="hljs-number">-4.75336798e-02</span>,  <span class="hljs-number">5.21207601e-02</span>,  <span class="hljs-number">9.04406682e-02</span>, <span class="hljs-number">-5.36676683e-02</span>],
     dtype=<span class="hljs-type">float32</span>)]
Dim: <span class="hljs-number">384</span> (<span class="hljs-number">384</span>,)
<button class="copy-code-btn"></button></code></pre>
<h3 id="Example-2-Generate-Sparse-Vectors-Using-The-BM25-Model" class="common-anchor-header">例 2：使用 BM25 模型生成稀疏向量</h3><p>BM25 是一种著名的方法，它使用单词出现频率来确定查询和文档之间的相关性。在本例中，我们将展示如何使用<code translate="no">BM25EmbeddingFunction</code> 为查询和文档生成稀疏嵌入。</p>
<p>在 BM25 中，计算文档中的统计数据以获得 IDF（反文档频率）非常重要，它可以代表文档中的模式。IDF 衡量一个词提供了多少信息，在所有文档中是常见还是罕见。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus.model.sparse <span class="hljs-keyword">import</span> BM25EmbeddingFunction

<span class="hljs-comment"># 1. Prepare a small corpus to search</span>
docs = [
   <span class="hljs-string">&quot;Artificial intelligence was founded as an academic discipline in 1956.&quot;</span>,
   <span class="hljs-string">&quot;Alan Turing was the first person to conduct substantial research in AI.&quot;</span>,
   <span class="hljs-string">&quot;Born in Maida Vale, London, Turing was raised in southern England.&quot;</span>,
]
query = <span class="hljs-string">&quot;Where was Turing born?&quot;</span>
bm25_ef = BM25EmbeddingFunction()

<span class="hljs-comment"># 2. Fit the corpus to get BM25 model parameters on your documents.</span>
bm25_ef.fit(docs)

<span class="hljs-comment"># 3. Store the fitted parameters to expedite future processing.</span>
bm25_ef.save(<span class="hljs-string">&quot;bm25_params.json&quot;</span>)

<span class="hljs-comment"># 4. Load the saved params</span>
new_bm25_ef = BM25EmbeddingFunction()
new_bm25_ef.load(<span class="hljs-string">&quot;bm25_params.json&quot;</span>)

docs_embeddings = new_bm25_ef.encode_documents(docs)
query_embeddings = new_bm25_ef.encode_queries([query])
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Dim:&quot;</span>, new_bm25_ef.dim, <span class="hljs-built_in">list</span>(docs_embeddings)[<span class="hljs-number">0</span>].shape)
<button class="copy-code-btn"></button></code></pre>
<h3 id="Example-3-Using-a-ReRanker" class="common-anchor-header">示例 3：使用 Reranker</h3><p>搜索系统旨在快速高效地找到最相关的结果。传统上，BM25 或 TF-IDF 等方法用于根据关键词匹配对搜索结果进行排序。最近的方法，如基于 Embeddings 的余弦相似度，虽然简单明了，但有时会忽略语言的微妙之处，最重要的是，忽略了文档与查询意图之间的相互作用。</p>
<p>这就是使用<a href="https://zilliz.com/learn/optimize-rag-with-rerankers-the-role-and-tradeoffs">重排序器</a>的好处。重新排序器是一种先进的人工智能模型，它可以从搜索中获取初始结果集（通常由基于 Embeddings/ 标记的搜索提供）并对其进行重新评估，以确保它们更符合用户的意图。它的着眼点不仅仅是表面上的术语匹配，而是考虑搜索查询与文档内容之间更深层次的交互。</p>
<p>在这个例子中，我们将使用<a href="https://milvus.io/docs/integrate_with_jina.md">Jina AI Reranker</a>。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus.model.reranker <span class="hljs-keyword">import</span> JinaRerankFunction

jina_api_key = <span class="hljs-string">&quot;&lt;YOUR_JINA_API_KEY&gt;&quot;</span>

rf = JinaRerankFunction(<span class="hljs-string">&quot;jina-reranker-v1-base-en&quot;</span>, jina_api_key)

query = <span class="hljs-string">&quot;What event in 1956 marked the official birth of artificial intelligence as a discipline?&quot;</span>

documents = [
   <span class="hljs-string">&quot;In 1950, Alan Turing published his seminal paper, &#x27;Computing Machinery and Intelligence,&#x27; proposing the Turing Test as a criterion of intelligence, a foundational concept in the philosophy and development of artificial intelligence.&quot;</span>,
   <span class="hljs-string">&quot;The Dartmouth Conference in 1956 is considered the birthplace of artificial intelligence as a field; here, John McCarthy and others coined the term &#x27;artificial intelligence&#x27; and laid out its basic goals.&quot;</span>,
   <span class="hljs-string">&quot;In 1951, British mathematician and computer scientist Alan Turing also developed the first program designed to play chess, demonstrating an early example of AI in game strategy.&quot;</span>,
   <span class="hljs-string">&quot;The invention of the Logic Theorist by Allen Newell, Herbert A. Simon, and Cliff Shaw in 1955 marked the creation of the first true AI program, which was capable of solving logic problems, akin to proving mathematical theorems.&quot;</span>
]

results = rf(query, documents)

<span class="hljs-keyword">for</span> result <span class="hljs-keyword">in</span> results:
   <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Index: <span class="hljs-subst">{result.index}</span>&quot;</span>)
   <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Score: <span class="hljs-subst">{result.score:<span class="hljs-number">.6</span>f}</span>&quot;</span>)
   <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Text: <span class="hljs-subst">{result.text}</span>\n&quot;</span>)
<button class="copy-code-btn"></button></code></pre>
<p>预期的输出结果类似于下图：</p>
<pre><code translate="no">Index: <span class="hljs-number">1</span>
Score: <span class="hljs-number">0.937096</span>
Text: The Dartmouth Conference <span class="hljs-keyword">in</span> <span class="hljs-number">1956</span> <span class="hljs-keyword">is</span> considered the birthplace of artificial intelligence <span class="hljs-keyword">as</span> a field; here, John McCarthy <span class="hljs-keyword">and</span> others coined the term <span class="hljs-string">&#x27;artificial intelligence&#x27;</span> <span class="hljs-keyword">and</span> laid <span class="hljs-keyword">out</span> its basic goals.

Index: <span class="hljs-number">3</span>
Score: <span class="hljs-number">0.354210</span>
Text: The invention of the Logic Theorist <span class="hljs-keyword">by</span> Allen Newell, Herbert A. Simon, <span class="hljs-keyword">and</span> Cliff Shaw <span class="hljs-keyword">in</span> <span class="hljs-number">1955</span> marked the creation of the first <span class="hljs-literal">true</span> AI program, which was capable of solving logic problems, akin to proving mathematical theorems.

Index: <span class="hljs-number">0</span>
Score: <span class="hljs-number">0.349866</span>
Text: In <span class="hljs-number">1950</span>, Alan Turing published his seminal paper, <span class="hljs-string">&#x27;Computing Machinery and Intelligence,&#x27;</span> proposing the Turing Test <span class="hljs-keyword">as</span> a criterion of intelligence, a foundational concept <span class="hljs-keyword">in</span> the philosophy <span class="hljs-keyword">and</span> development of artificial intelligence.

Index: <span class="hljs-number">2</span>
Score: <span class="hljs-number">0.272896</span>
Text: In <span class="hljs-number">1951</span>, British mathematician <span class="hljs-keyword">and</span> computer scientist Alan Turing also developed the first program designed to play chess, demonstrating an early example of AI <span class="hljs-keyword">in</span> game strategy.
<button class="copy-code-btn"></button></code></pre>
<h2 id="Star-Us-On-GitHub-and-Join-Our-Discord" class="common-anchor-header">在 GitHub 星级我们，加入我们的 Discord！<button data-href="#Star-Us-On-GitHub-and-Join-Our-Discord" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您喜欢这篇博文，请考虑在<a href="https://github.com/milvus-io/milvus">GitHub</a> 上给 Milvus 加星，并随时加入我们的<a href="https://discord.gg/FG6hMJStWu">Discord</a>！💙</p>


介绍 PyMilvus 与嵌入模型的集成

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/2_72e444c8dc.JPG" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p><a href="https://milvus.io/docs/milvus_lite.md">Milvus Lite</a> 是一种轻量级向量数据库，可在 Python 应用程序中本地运行。Milvus Lite 基于流行的开源<a href="https://milvus.io/intro">Milvus</a>向量数据库，重用了向量索引和查询解析的核心组件，同时删除了为分布式系统中高可扩展性而设计的元素。这种设计使得紧凑高效的解决方案非常适合计算资源有限的环境，如笔记本电脑、Jupyter 笔记本以及移动或边缘设备。</p>
<p>Milvus Lite 与 LangChain 和 LlamaIndex 等各种人工智能开发堆栈集成，使其能够在检索增强生成（RAG）管道中用作向量存储，而无需进行服务器设置。只需运行<code translate="no">pip install pymilvus</code> （2.4.3 或更高版本），即可将其作为 Python 库纳入人工智能应用程序。</p>
<p>Milvus Lite 共享 Milvus API，确保您的客户端代码既适用于小规模本地部署，也适用于部署在拥有数十亿向量的 Docker 或 Kubernetes 上的 Milvus 服务器。</p>
<h2 id="Why-We-Built-Milvus-Lite" class="common-anchor-header">我们为什么构建 Milvus Lite<button data-href="#Why-We-Built-Milvus-Lite" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>许多人工智能应用需要对非结构化数据（包括文本、图像、语音和视频）进行向量相似性搜索，用于聊天机器人和购物助手等应用。向量数据库是为存储和搜索向量 Embeddings 而精心设计的，是人工智能开发堆栈的重要组成部分，尤其适用于生成式人工智能用例，如<a href="https://zilliz.com/learn/Retrieval-Augmented-Generation">检索增强生成（RAG）</a>。</p>
<p>尽管有众多的向量搜索解决方案，但仍缺少一种易于上手、同时适用于大规模生产部署的选择。作为 Milvus 的创建者，我们设计了 Milvus Lite，以帮助人工智能开发人员更快地构建应用程序，同时确保在各种部署选项中获得一致的体验，包括 Kubernetes、Docker 和托管云服务上的 Milvus。</p>
<p>Milvus Lite 是我们在 Milvus 生态系统内提供的产品套件的重要补充。它为开发人员提供了一个多功能工具，支持他们开发过程中的每个阶段。从原型开发到生产环境，从边缘计算到大规模部署，Milvus 现在是唯一一款能覆盖任何规模的用例和所有开发阶段的向量数据库。</p>
<h2 id="How-Milvus-Lite-Works" class="common-anchor-header">Milvus Lite 如何工作<button data-href="#How-Milvus-Lite-Works" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus Lite 支持 Milvus 中的所有基本操作，如创建 Collections 以及插入、搜索和删除向量。它将很快支持混合搜索等高级功能。Milvus Lite 会将数据加载到内存中，以便进行高效搜索，并将其持久化为 SQLite 文件。</p>
<p>Milvus Lite 包含在<a href="https://github.com/milvus-io/pymilvus">Milvus 的 Python SDK</a>中，可通过简单的<code translate="no">pip install pymilvus</code> 进行部署。下面的代码片段演示了如何使用 Milvus Lite 设置向量数据库，方法是指定一个本地文件名，然后创建一个新的 Collections。对于熟悉 Milvus API 的人来说，唯一的区别是<code translate="no">uri</code> 指的是本地文件名而不是网络端点，例如，对于 Milvus 服务器来说，<code translate="no">&quot;milvus_demo.db&quot;</code> 而不是<code translate="no">&quot;http://localhost:19530&quot;</code> 。其他一切保持不变。Milvus Lite 还支持使用动态或明确定义的 Schema 将原始文本和其他标签作为元数据存储，如下图所示。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> MilvusClient

client = MilvusClient(<span class="hljs-string">&quot;milvus_demo.db&quot;</span>)
<span class="hljs-comment"># This collection can take input with mandatory fields named &quot;id&quot;, &quot;vector&quot; and</span>
<span class="hljs-comment"># any other fields as &quot;dynamic schema&quot;. You can also define the schema explicitly.</span>
client.create_collection(
    collection_name=<span class="hljs-string">&quot;demo_collection&quot;</span>,
    dimension=<span class="hljs-number">384</span>  <span class="hljs-comment"># Dimension for vectors.</span>
)
<button class="copy-code-btn"></button></code></pre>
<p>为了提高可扩展性，使用 Milvus Lite 开发的人工智能应用可以轻松过渡到使用部署在 Docker 或 Kubernetes 上的 Milvus，只需指定<code translate="no">uri</code> 与服务器端点即可。</p>
<h2 id="Integration-with-AI-Development-Stack" class="common-anchor-header">与人工智能开发堆栈集成<button data-href="#Integration-with-AI-Development-Stack" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>除了推出 Milvus Lite 以让向量搜索轻松上手之外，Milvus 还集成了人工智能开发堆栈的许多框架和提供商，包括<a href="https://python.langchain.com/v0.2/docs/integrations/vectorstores/milvus/">LangChain</a>、<a href="https://docs.llamaindex.ai/en/stable/examples/vector_stores/MilvusIndexDemo/">LlamaIndex</a>、<a href="https://haystack.deepset.ai/integrations/milvus-document-store">Haystack</a>、<a href="https://blog.voyageai.com/2024/05/30/semantic-search-with-milvus-lite-and-voyage-ai/">Voyage AI</a>、<a href="https://blog.relari.ai/case-study-using-synthetic-data-to-benchmark-rag-systems-be324904ace1">Ragas</a>、<a href="https://jina.ai/news/implementing-a-chat-history-rag-with-jina-ai-and-milvus-lite/">Jina</a> <a href="https://blog.relari.ai/case-study-using-synthetic-data-to-benchmark-rag-systems-be324904ace1">AI</a>、<a href="https://dspy-docs.vercel.app/docs/deep-dive/retrieval_models_clients/MilvusRM">DSPy</a>、<a href="https://www.bentoml.com/blog/building-a-rag-app-with-bentocloud-and-milvus-lite">BentoML</a>、<a href="https://chiajy.medium.com/70873c7576f1">WhyHow</a>、<a href="https://blog.relari.ai/case-study-using-synthetic-data-to-benchmark-rag-systems-be324904ace1">Relari AI</a>、<a href="https://docs.airbyte.com/integrations/destinations/milvus">Airbyte</a>、<a href="https://milvus.io/docs/integrate_with_hugging-face.md">HuggingFace</a>和<a href="https://memgpt.readme.io/docs/storage#milvus">MemGPT</a>。得益于其广泛的工具和服务，这些集成简化了具有向量搜索功能的人工智能应用的开发。</p>
<p>这仅仅是个开始，更多令人兴奋的集成即将推出！敬请期待！</p>
<h2 id="More-Resources-and-Examples" class="common-anchor-header">更多资源和示例<button data-href="#More-Resources-and-Examples" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>探索<a href="https://milvus.io/docs/quickstart.md">Milvus 快速入门文档</a>，了解使用 Milvus Lite 构建检索增强生成<a href="https://github.com/milvus-io/bootcamp/blob/master/bootcamp/tutorials/quickstart/build_RAG_with_milvus.ipynb">（RAG</a>）和<a href="https://github.com/milvus-io/bootcamp/blob/master/bootcamp/tutorials/quickstart/image_search_with_milvus.ipynb">图像搜索</a>等人工智能应用的详细指南和代码示例。</p>
<p>Milvus Lite 是一个开源项目，我们欢迎您的贡献。请查看我们的 "<a href="https://github.com/milvus-io/milvus-lite/blob/main/CONTRIBUTING.md">贡献指南"</a>。您还可以在<a href="https://github.com/milvus-io/milvus-lite">Milvus Lite GitHub</a>存储库中提交问题，报告错误或申请功能。</p>


Milvus Lite 简介：在几秒钟内开始构建 GenAI 应用程序

优化向量数据库，增强 RAG 驱动的生成式人工智能

开始使用 Milvus 集群和 K8s

<p>我们很高兴地宣布推出 Milvus 2.4，这是在增强大规模数据集搜索能力方面取得的重大进展。这个最新版本增加了一些新功能，如支持基于 GPU 的 CAGRA 索引、对<a href="https://zilliz.com/learn/sparse-and-dense-embeddings">稀疏嵌入的</a>测试版支持、分组搜索以及搜索功能方面的其他各种改进。这些发展加强了我们对社区的承诺，为像您这样的开发人员提供了处理和查询向量数据的强大而高效的工具。让我们一起来了解 Milvus 2.4 的主要优势。</p>
<h2 id="Enabled-Multi-vector-Search-for-Simplified-Multimodal-Searches" class="common-anchor-header">启用多向量搜索，简化多模式搜索<button data-href="#Enabled-Multi-vector-Search-for-Simplified-Multimodal-Searches" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.4 提供多矢量搜索功能，允许在同一 Milvus 系统中同时搜索不同类型的矢量并进行 Rerankers。这一功能简化了多模态搜索，显著提高了召回率，使开发人员能够轻松管理具有不同数据类型的复杂人工智能应用。此外，该功能还简化了自定义<a href="https://zilliz.com/vector-database-use-cases/recommender-system">Rerankers</a>模型的集成和微调，有助于创建高级搜索功能，如利用多维数据洞察力的精确<a href="https://zilliz.com/vector-database-use-cases/recommender-system">推荐系统</a>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/How_the_multi_vector_search_feature_works_6c85961349.png" alt="How the Milti-Vector Search Feature Works" class="doc-image" id="how-the-milti-vector-search-feature-works" />
    多 </span> <span class="img-wrapper"> <span>向量搜索功能的工作原理</span> </span></p>
<p>Milvus 的多矢量支持有两个组成部分：</p>
<ol>
<li><p>在一个 Collections 中为一个实体存储/查询多个向量的能力，这是一种更自然的数据组织方式</p></li>
<li><p>通过利用 Milvus 中预置的重排算法来构建/优化重排算法的能力</p></li>
</ol>
<p>除了是一项<a href="https://github.com/milvus-io/milvus/issues/25639">要求</a>很高的<a href="https://github.com/milvus-io/milvus/issues/25639">功能</a>外，我们之所以构建这项功能，还因为随着 GPT-4 和 Claude 3 的发布，业界正在向多模态模型发展。Rerankers 是进一步提高搜索查询性能的常用技术。我们的目标是让开发人员在 Milvus 生态系统内轻松构建和优化他们的 Rerankers。</p>
<h2 id="Grouping-Search-Support-for-Enhanced-Compute-Efficiency" class="common-anchor-header">支持分组搜索，提高计算效率<button data-href="#Grouping-Search-Support-for-Enhanced-Compute-Efficiency" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>分组搜索是我们在 Milvus 2.4 中添加的另一项经常被<a href="https://github.com/milvus-io/milvus/issues/25343">要求的功能</a>。它集成了专为 BOOL、INT 或 VARCHAR 类型字段设计的分组操作，填补了执行大规模分组查询的关键效率空白。</p>
<p>传统上，开发人员依赖于广泛的 Top-K 搜索，然后通过手动后处理来提炼特定分组的结果，这是一种计算密集、代码繁重的方法。分组搜索通过有效地将查询结果与文档或视频名称等集合分组标识符联系起来，改进了这一过程，从而简化了对大型数据集中分段实体的处理。</p>
<p>Milvus 的分组搜索采用基于迭代器的实现方式，与同类技术相比，计算效率明显提高。这种选择确保了卓越的性能可扩展性，特别是在计算资源优化至关重要的生产环境中。通过减少数据遍历和计算开销，Milvus 支持更高效的查询处理，与其他向量数据库相比，显著缩短了响应时间，降低了操作符成本。</p>
<p>分组搜索增强了 Milvus 管理大容量复杂查询的能力，并与高性能计算实践相一致，从而提供了强大的数据管理解决方案。</p>
<h2 id="Beta-Support-for-Sparse-Vector-Embeddings" class="common-anchor-header">稀疏向量嵌入测试版支持<button data-href="#Beta-Support-for-Sparse-Vector-Embeddings" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://zilliz.com/learn/sparse-and-dense-embeddings">稀疏矢量嵌入</a>是传统密集向量方法的范式转变，它迎合了语义相似性的细微差别，而不仅仅是关键词频率。这种区别使搜索能力更加细致入微，与查询和文档的语义内容密切相关。稀疏向量模型在信息检索和自然语言处理中尤为有用，与密集向量模型相比，稀疏向量模型具有强大的域外搜索能力和可解释性。</p>
<p>在 Milvus 2.4 中，我们扩展了混合搜索功能，使其包括由 SPLADEv2 等高级神经模型或 BM25 等统计模型生成的稀疏嵌入。在 Milvus 中，稀疏向量与稠密向量同等对待，可以创建具有稀疏向量场的 Collections、插入数据、建立索引和执行相似性搜索。值得注意的是，Milvus 中的稀疏 Embeddings 支持<a href="https://zilliz.com/blog/similarity-metrics-for-vector-search#Inner-Product">内积</a>（IP）距离度量，鉴于其高维特性，这一点非常有利，使得其他度量方法的效果大打折扣。该功能还支持维数为无符号 32 位整数、值为 32 位浮点数的数据类型，从而促进了从细微文本搜索到复杂<a href="https://zilliz.com/learn/information-retrieval-metrics">信息检索</a>系统的广泛应用。</p>
<p>有了这一新功能，Milvus 可以实现混合搜索方法，将关键字和基于 Embeddings 的技术融为一体，为从以关键字为中心的搜索框架转向寻求全面、低维护解决方案的用户提供无缝过渡。</p>
<p>我们将该功能标记为 "测试版"，以继续对该功能进行性能测试，并收集社区的反馈意见。稀疏向量支持功能预计将在 Milvus 3.0 发布时全面推出 (GA)。</p>
<h2 id="CAGRA-Index-Support-for-Advanced-GPU-Accelerated-Graph-Indexing" class="common-anchor-header">高级 GPU 加速图形索引的 CAGRA 索引支持<button data-href="#CAGRA-Index-Support-for-Advanced-GPU-Accelerated-Graph-Indexing" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://arxiv.org/abs/2308.15136">CAGRA</a>(Cuda Anns GRAph-based) 由英伟达™（NVIDIA®）开发，是一种基于 GPU 的图形索引技术，在效率和性能方面大大超过了传统的基于 CPU 的方法（如 HNSW 索引），尤其是在高吞吐量环境中。</p>
<p>随着 CAGRA 索引的引入，Milvus 2.4 提供了增强的 GPU 加速图索引能力。这一增强功能非常适合构建需要最小延迟的相似性搜索应用。此外，Milvus 2.4 还将暴力搜索与 CAGRA 索引整合在一起，以在应用中实现最大召回率。如需详细了解，请浏览<a href="https://zilliz.com/blog/Milvus-introduces-GPU-index-CAGRA">有关 CAGRA 的介绍博客</a>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Milvus_raft_cagra_vs_milvus_hnsw_ffe0415ff5.png" alt="Milvus Raft CAGRA vs. Milvus HNSW" class="doc-image" id="milvus-raft-cagra-vs.-milvus-hnsw" />
   </span> <span class="img-wrapper"> <span>Milvus Raft CAGRA 与 Milvus HNSW 的比较</span> </span></p>
<h2 id="Additional-Enhancements-and-Features" class="common-anchor-header">其他增强功能和特性<button data-href="#Additional-Enhancements-and-Features" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.4 还包括其他关键增强功能，例如支持正则表达式以增强<a href="https://zilliz.com/blog/metadata-filtering-with-zilliz-cloud-pipelines">元</a>数据过滤中的子字符串匹配、用于高效标量数据类型过滤的新标量反转索引，以及用于监控和复制 Milvus Collections 中更改的更改数据捕获工具。这些更新共同增强了 Milvus 的性能和多功能性，使其成为复杂数据操作的全面解决方案。</p>
<p>更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md">Milvus 2.4 文档</a>。</p>
<h2 id="Stay-Connected" class="common-anchor-header">保持联系！<button data-href="#Stay-Connected" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>想进一步了解 Milvus 2.4？<a href="https://zilliz.com/event/unlocking-advanced-search-capabilities-milvus">参加我们即将举行的网络研讨会</a>，与 Zilliz 工程副总裁 James Luan 深入探讨这一最新版本的功能。如果您有问题或反馈，请加入我们的<a href="https://discord.com/invite/8uyFbECzPX">Discord 频道</a>，与我们的工程师和社区成员交流。别忘了在<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a>上关注我们，了解有关 Milvus 的最新消息和更新。</p>


Milvus 2.4 Supports Multi-vector Search, Sparse Vector, CAGRA, and More!

揭开 Milvus 2.4 的神秘面纱：多向量搜索、稀疏向量、CAGRA 索引等！

<p><a href="https://zilliz.com/what-is-milvus">Milvus</a>是一个高度可扩展的向量数据库，以其处理庞大数据集的能力而闻名，它在<a href="https://zilliz.com/blog/what-is-new-in-milvus-2-3-4">2.3.4版本</a>中引入了对Parquet文件的支持，向前迈出了重要的一步。通过采用 Apache Parquet，用户可以简化数据导入流程，并大幅节省存储和计算成本。</p>
<p>在我们的最新文章中，我们探讨了 Parquet 的优势及其给 Milvus 用户带来的好处。我们讨论了集成这一功能背后的动机，并提供了将 Parquet 文件无缝导入 Milvus 的分步指南，为高效数据管理和分析开启了新的可能性。</p>
<h2 id="What-Is-Apache-Parquet" class="common-anchor-header">什么是 Apache Parquet？<button data-href="#What-Is-Apache-Parquet" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://parquet.apache.org/">Apache Parquet</a>是一种流行的面向列的开源数据文件格式，旨在提高大规模数据集的存储和处理效率。与 CSV 或 JSON 等传统的面向行的数据格式不同，Parquet 按列存储数据，提供更高效的数据压缩和编码方案。这种方法提高了性能，降低了存储要求，增强了处理能力，使其成为批量处理复杂数据的理想选择。</p>
<h2 id="How-Milvus-Users-Benefit-from-the-Support-for-Parquet-File-Imports" class="common-anchor-header">Milvus 用户如何受益于 Parquet 文件导入支持<button data-href="#How-Milvus-Users-Benefit-from-the-Support-for-Parquet-File-Imports" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 扩展了对 Parquet 文件导入的支持，为用户提供优化的体验和各种优势，包括降低存储和计算费用、精简数据管理和简化导入流程。</p>
<h3 id="Optimized-Storage-Efficiency-and-Streamlined-Data-Management" class="common-anchor-header">优化存储效率和简化数据管理</h3><p>Parquet 针对不同的数据类型提供灵活的压缩选项和高效的编码方案，确保最佳的存储效率。这种灵活性在云环境中尤为重要，因为在云环境中，每节省一盎司存储空间都直接关系到切实降低成本。有了 Milvus 的这一新功能，用户可以毫不费力地将所有不同的数据整合到一个文件中，从而简化数据管理，提升整体用户体验。这项功能对处理可变长度 Array 数据类型的用户尤其有益，他们现在可以享受简化的数据导入流程。</p>
<h3 id="Improved-Query-Performance" class="common-anchor-header">提高查询性能</h3><p>Parquet 的列式存储设计和先进的压缩方法大大提高了查询性能。在进行查询时，用户可以只关注相关数据，而无需扫描无关数据。这种有选择性的列读取最大限度地减少了 CPU 占用，从而加快了查询速度。</p>
<h3 id="Broad-Language-Compatibility" class="common-anchor-header">广泛的语言兼容性</h3><p>Parquet 支持多种语言，如 Java、C++ 和 Python，并与大量数据处理工具兼容。由于支持 Parquet 文件，使用不同 SDK 的 Milvus 用户可以无缝生成 Parquet 文件，以便在数据库内进行解析。</p>
<h2 id="How-to-Import-Parquet-Files-into-Milvus" class="common-anchor-header">如何将 Parquet 文件导入 Milvus<button data-href="#How-to-Import-Parquet-Files-into-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果你的数据已经是 Parquet 文件格式，导入很容易。将 Parquet 文件上传到 MinIO 等对象存储系统，就可以导入了。</p>
<p>下面的代码片段是将 Parquet 文件导入 Milvus 的示例。</p>
<pre><code translate="no">remote_files = []
<span class="hljs-keyword">try</span>:
    <span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Prepare upload files&quot;</span>)
    minio_client = Minio(endpoint=MINIO_ADDRESS, access_key=MINIO_ACCESS_KEY, secret_key=MINIO_SECRET_KEY,
                         secure=<span class="hljs-literal">False</span>)
    found = minio_client.bucket_exists(bucket_name)
    <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> found:
        minio_client.make_bucket(bucket_name)
        <span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;MinIO bucket &#x27;{}&#x27; doesn&#x27;t exist&quot;</span>.<span class="hljs-built_in">format</span>(bucket_name))
        <span class="hljs-keyword">return</span> <span class="hljs-literal">False</span>, []

    <span class="hljs-comment"># set your remote data path</span>
    remote_data_path = <span class="hljs-string">&quot;milvus_bulkinsert&quot;</span>

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">upload_file</span>(<span class="hljs-params">f: <span class="hljs-built_in">str</span></span>):
        file_name = os.path.basename(f)
        minio_file_path = os.path.join(remote_data_path, <span class="hljs-string">&quot;parquet&quot;</span>, file_name)
        minio_client.fput_object(bucket_name, minio_file_path, f)
        <span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Upload file &#x27;{}&#x27; to &#x27;{}&#x27;&quot;</span>.<span class="hljs-built_in">format</span>(f, minio_file_path))
        remote_files.append(minio_file_path)

    upload_file(data_file)

<span class="hljs-keyword">except</span> S3Error <span class="hljs-keyword">as</span> e:
    <span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Failed to connect MinIO server {}, error: {}&quot;</span>.<span class="hljs-built_in">format</span>(MINIO_ADDRESS, e))
    <span class="hljs-keyword">return</span> <span class="hljs-literal">False</span>, []

<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Successfully upload files: {}&quot;</span>.<span class="hljs-built_in">format</span>(remote_files))
<span class="hljs-keyword">return</span> <span class="hljs-literal">True</span>, remote_files
<button class="copy-code-btn"></button></code></pre>
<p>如果您的数据不是 Parquet 文件或具有 Dynamic Field，您可以利用我们的数据格式转换工具 BulkWriter 来帮助您生成 Parquet 文件。BulkWriter 现在已将 Parquet 作为其默认输出数据格式，确保为开发人员提供更直观的体验。</p>
<p>下面的代码片段是使用 BulkWriter 生成 Parquet 文件的示例。</p>
<pre><code translate="no"><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> json

<span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> (
    RemoteBulkWriter,
    BulkFileType,
)

remote_writer = RemoteBulkWriter(
        schema=your_collection_schema,
        remote_path=<span class="hljs-string">&quot;your_remote_data_path&quot;</span>,
        connect_param=RemoteBulkWriter.ConnectParam(
            endpoint=YOUR_MINIO_ADDRESS,
            access_key=YOUR_MINIO_ACCESS_KEY,
            secret_key=YOUR_MINIO_SECRET_KEY,
            bucket_name=<span class="hljs-string">&quot;a-bucket&quot;</span>,
        ),
        file_type=BulkFileType.PARQUET,
)

<span class="hljs-comment"># append your data</span>
batch_count = <span class="hljs-number">10000</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(batch_count):
    row = {
        <span class="hljs-string">&quot;id&quot;</span>: i,
        <span class="hljs-string">&quot;bool&quot;</span>: <span class="hljs-literal">True</span> <span class="hljs-keyword">if</span> i % <span class="hljs-number">5</span> == <span class="hljs-number">0</span> <span class="hljs-keyword">else</span> <span class="hljs-literal">False</span>,
        <span class="hljs-string">&quot;int8&quot;</span>: i % <span class="hljs-number">128</span>,
        <span class="hljs-string">&quot;int16&quot;</span>: i % <span class="hljs-number">1000</span>,
        <span class="hljs-string">&quot;int32&quot;</span>: i % <span class="hljs-number">100000</span>,
        <span class="hljs-string">&quot;int64&quot;</span>: i,
        <span class="hljs-string">&quot;float&quot;</span>: i / <span class="hljs-number">3</span>,
        <span class="hljs-string">&quot;double&quot;</span>: i / <span class="hljs-number">7</span>,
        <span class="hljs-string">&quot;varchar&quot;</span>: <span class="hljs-string">f&quot;varchar_<span class="hljs-subst">{i}</span>&quot;</span>,
        <span class="hljs-string">&quot;json&quot;</span>: {<span class="hljs-string">&quot;dummy&quot;</span>: i, <span class="hljs-string">&quot;ok&quot;</span>: <span class="hljs-string">f&quot;name_<span class="hljs-subst">{i}</span>&quot;</span>},
        <span class="hljs-string">&quot;vector&quot;</span>: gen_binary_vector() <span class="hljs-keyword">if</span> bin_vec <span class="hljs-keyword">else</span> gen_float_vector(),
        <span class="hljs-string">f&quot;dynamic_<span class="hljs-subst">{i}</span>&quot;</span>: i,
    }
    remote_writer.append_row(row)

<span class="hljs-comment"># append rows by numpy type</span>
<span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(batch_count):
    remote_writer.append_row({
        <span class="hljs-string">&quot;id&quot;</span>: np.int64(i + batch_count),
        <span class="hljs-string">&quot;bool&quot;</span>: <span class="hljs-literal">True</span> <span class="hljs-keyword">if</span> i % <span class="hljs-number">3</span> == <span class="hljs-number">0</span> <span class="hljs-keyword">else</span> <span class="hljs-literal">False</span>,
        <span class="hljs-string">&quot;int8&quot;</span>: np.int8(i % <span class="hljs-number">128</span>),
        <span class="hljs-string">&quot;int16&quot;</span>: np.int16(i % <span class="hljs-number">1000</span>),
        <span class="hljs-string">&quot;int32&quot;</span>: np.int32(i % <span class="hljs-number">100000</span>),
        <span class="hljs-string">&quot;int64&quot;</span>: np.int64(i),
        <span class="hljs-string">&quot;float&quot;</span>: np.float32(i / <span class="hljs-number">3</span>),
        <span class="hljs-string">&quot;double&quot;</span>: np.float64(i / <span class="hljs-number">7</span>),
        <span class="hljs-string">&quot;varchar&quot;</span>: <span class="hljs-string">f&quot;varchar_<span class="hljs-subst">{i}</span>&quot;</span>,
        <span class="hljs-string">&quot;json&quot;</span>: json.dumps({<span class="hljs-string">&quot;dummy&quot;</span>: i, <span class="hljs-string">&quot;ok&quot;</span>: <span class="hljs-string">f&quot;name_<span class="hljs-subst">{i}</span>&quot;</span>}),
        <span class="hljs-string">&quot;vector&quot;</span>: gen_binary_vector() <span class="hljs-keyword">if</span> bin_vec <span class="hljs-keyword">else</span> gen_float_vector(),
        <span class="hljs-string">f&quot;dynamic_<span class="hljs-subst">{i}</span>&quot;</span>: i,
    })

<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;<span class="hljs-subst">{remote_writer.total_row_count}</span> rows appends&quot;</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;<span class="hljs-subst">{remote_writer.buffer_row_count}</span> rows in buffer not flushed&quot;</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Generate data files...&quot;</span>)
remote_writer.commit()
<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Data files have been uploaded: <span class="hljs-subst">{remote_writer.batch_files}</span>&quot;</span>)
remote_files = remote_writer.batch_files
<button class="copy-code-btn"></button></code></pre>
<p>然后，您就可以开始将 Parquet 文件导入 Milvus。</p>
<pre><code translate="no">remote_files = [remote_file_path]
task_id = utility.do_bulk_insert(collection_name=collection_name,
                                 files=remote_files)

task_ids = [task_id]         
states = wait_tasks_to_state(task_ids, BulkInsertState.ImportCompleted)
complete_count = 0
for state in states:
    if state.state == BulkInsertState.ImportCompleted:
        complete_count = complete_count + 1
<button class="copy-code-btn"></button></code></pre>
<p>现在，您的数据已无缝集成到 Milvus 中。</p>
<h2 id="Whats-Next" class="common-anchor-header">下一步是什么？<button data-href="#Whats-Next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 继续支持不断增长的数据量，在管理大规模导入方面出现了挑战，特别是当 Parquet 文件超过 10GB 时。为了应对这一挑战，我们计划将导入数据分为标量列和向量列，每次导入创建两个 Parquet 文件，以减轻 I/O 压力。对于超过几百 GB 的数据集，我们建议多次导入数据。</p>


Milvus Supports Imports of Apache Parquet Files

Milvus 支持导入 Apache Parquet 文件，提高数据处理效率

<custom-h1>Milvus 版本介绍</custom-h1><p>选择合适的 Milvus 版本是任何利用向量搜索技术的项目取得成功的关键。不同的 Milvus 版本可满足不同的需求，了解选择正确版本的重要性对于实现预期结果至关重要。</p>
<p>正确的 Milvus 版本可以帮助开发人员快速学习和建立原型，或帮助优化资源利用、简化开发工作，并确保与现有基础设施和工具的兼容性。归根结底，这是为了保持开发人员的生产力，提高效率、可靠性和用户满意度。</p>
<h2 id="Available-Milvus-versions" class="common-anchor-header">Milvus 可用版本<button data-href="#Available-Milvus-versions" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 有三个版本可供开发人员使用，并且都是开源的。这三个版本分别是 Milvus Lite、Milvus Standalone 和 Milvus Cluster，它们在功能和用户计划短期和长期使用 Milvus 的方式上有所不同。因此，让我们逐一探讨。</p>
<h2 id="Milvus-Lite" class="common-anchor-header">Milvus Lite<button data-href="#Milvus-Lite" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>顾名思义，Milvus Lite 是与 Google Colab 和 Jupyter Notebook 无缝集成的轻量级版本。它被打包成一个二进制文件，没有额外的依赖关系，因此很容易在机器上安装和运行，或嵌入到 Python 应用程序中。此外，Milvus Lite 还包括一个基于 CLI 的 Milvus Standalone 服务器，为直接在机器上运行它提供了灵活性。是将其嵌入 Python 代码中，还是将其作为独立服务器使用，完全取决于您的偏好和具体应用要求。</p>
<h3 id="Features-and-Capabilities" class="common-anchor-header">特点和功能</h3><p>Milvus Lite 包含 Milvus 向量搜索的所有核心功能。</p>
<ul>
<li><p><strong>搜索功能</strong>：支持 top-k、范围和混合搜索，包括元数据过滤，以满足不同的搜索要求。</p></li>
<li><p><strong>索引类型和相似度指标</strong>：支持 11 种索引类型和 5 种相似度指标，为您的特定用例提供灵活性和定制选项。</p></li>
<li><p><strong>数据处理</strong>：支持批处理（Apache Parquet、数组、JSON）和流处理，并通过 Airbyte、Apache Kafka 和 Apache Spark 连接器实现无缝集成。</p></li>
<li><p><strong>CRUD 操作符</strong>：提供全面的 CRUD 支持（创建、读取、更新/上载、删除），赋予用户全面的数据管理能力。</p></li>
</ul>
<h3 id="Applications-and-limitations" class="common-anchor-header">应用和限制</h3><p>Milvus Lite 是快速原型开发和本地开发的理想选择，为在机器上快速设置和实验小规模数据集提供支持。然而，当过渡到具有更大数据集和更苛刻基础设施要求的生产环境时，它的局限性就显现出来了。因此，虽然 Milvus Lite 是初步探索和测试的绝佳工具，但它可能不适合在大容量或生产就绪的环境中部署应用程序。</p>
<h3 id="Available-Resources" class="common-anchor-header">可用资源</h3><ul>
<li><p><a href="https://milvus.io/docs/milvus_lite.md">文档</a></p></li>
<li><p><a href="https://github.com/milvus-io/milvus-lite/">Github 存储库</a></p></li>
<li><p><a href="https://github.com/milvus-io/milvus-lite/tree/main/examples">谷歌 Colab 示例</a></p></li>
<li><p><a href="https://www.youtube.com/watch?v=IgJdrGiB5ZY">入门视频</a></p></li>
</ul>
<h2 id="Milvus-Standalone" class="common-anchor-header">Milvus 单机版<button data-href="#Milvus-Standalone" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 提供两种操作模式：独立模式和集群模式。这两种模式的核心向量数据库功能相同，但在数据规模支持和可扩展性要求方面有所不同。这种区别使您可以选择最符合您的数据集大小、流量和其他生产基础设施要求的模式。</p>
<p>Milvus Standalone 是 Milvus 向量数据库系统的一种操作模式，它作为单一实例独立操作，没有任何集群或分布式设置。在这种模式下，Milvus 在单个服务器或机器上运行，提供索引和向量搜索等功能。它适用于数据和流量规模相对较小，不需要集群设置提供的分布式功能的情况。</p>
<h3 id="Features-and-Capabilities" class="common-anchor-header">特点和功能</h3><ul>
<li><p><strong>高性能</strong>：在海量数据集（数十亿或更多）上进行向量搜索，速度快，效率高。</p></li>
<li><p><strong>搜索功能</strong>：支持 top-k、范围和混合搜索，包括元数据过滤，以满足不同的搜索要求。</p></li>
<li><p><strong>索引类型和相似度指标</strong>：支持 11 种索引类型和 5 种相似度指标，为您的特定用例提供灵活性和定制选项。</p></li>
<li><p><strong>数据处理</strong>：支持批处理（Apache Parquet、数组、Json）和流处理，并通过 Airbyte、Apache Kafka 和 Apache Spark 连接器实现无缝集成。</p></li>
<li><p><strong>数据复制和故障切换</strong>：内置复制和故障转移/故障恢复功能可确保数据完整性和应用程序可用性，即使在中断或故障期间也是如此。</p></li>
<li><p><strong>可扩展性</strong>：通过组件级扩展实现动态可扩展性，可根据需求进行无缝的上下扩展。Milvus 可在组件级自动扩展，优化资源分配，提高效率。</p></li>
<li><p><strong>多租户</strong>：支持多租户，能够在一个集群中管理多达 10,000 个 Collections/分区，为不同用户或应用提供高效的资源利用和隔离。</p></li>
<li><p><strong>CRUD 操作符</strong>：提供全面的 CRUD 支持（创建、读取、更新/上载、删除），赋予用户全面的数据管理能力。</p></li>
</ul>
<h3 id="Essential-components" class="common-anchor-header">基本组件</h3><ul>
<li><p>Milvus：核心功能组件。</p></li>
<li><p>etcd：元数据引擎，负责访问和存储 Milvus 内部组件（包括代理、索引节点等）的元数据。</p></li>
<li><p>MinIO：负责 Milvus 内部数据持久性的存储引擎。</p></li>
</ul>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Screenshot_2024_02_19_at_4_16_41_PM_5e635586a7.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>图 1：Milvus 独立架构</p>
<h3 id="Available-Resources" class="common-anchor-header">可用资源</h3><ul>
<li><p>文档</p>
<ul>
<li><p><a href="https://milvus.io/docs/prerequisite-docker.md">使用 Docker Compose 安装 Milvus 的环境检查表</a></p></li>
<li><p><a href="https://milvus.io/docs/install_standalone-docker.md">使用 Docker 安装 Milvus 单机版</a></p></li>
</ul></li>
<li><p><a href="https://github.com/milvus-io/milvus">Github 存储库</a></p></li>
</ul>
<h2 id="Milvus-Cluster" class="common-anchor-header">Milvus 集群<button data-href="#Milvus-Cluster" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus Cluster 是 Milvus 向量数据库系统的一种操作模式，它在多个节点或服务器上操作和分布。在这种模式下，Milvus 实例集群在一起，形成一个统一的系统，与独立设置相比，可以处理更大的数据量和更高的流量负载。Milvus 集群具有可扩展性、容错性和负载平衡功能，适用于需要处理海量数据和高效服务多个并发查询的场景。</p>
<h3 id="Features-and-Capabilities" class="common-anchor-header">特点和功能</h3><ul>
<li><p>继承了 Milvus Standalone 的所有功能，包括高性能向量搜索、支持多种索引类型和相似度指标，以及与批处理和流处理框架的无缝集成。</p></li>
<li><p>通过跨多个节点的分布式计算和负载平衡，提供无与伦比的可用性、性能和成本优化。</p></li>
<li><p>通过有效利用整个集群的资源，并根据工作负载需求优化资源分配，以较低的总成本部署和扩展安全的企业级工作负载。</p></li>
</ul>
<h3 id="Essential-components" class="common-anchor-header">基本组件：</h3><p>Milvus 集群包括八个微服务组件和三个第三方依赖项。所有微服务都可以在 Kubernetes 上独立部署，互不影响。</p>
<h4 id="Microservice-components" class="common-anchor-header">微服务组件</h4><ul>
<li><p>根节点</p></li>
<li><p>代理</p></li>
<li><p>查询协调器</p></li>
<li><p>查询节点</p></li>
<li><p>索引坐标</p></li>
<li><p>索引节点</p></li>
<li><p>数据坐标</p></li>
<li><p>数据节点</p></li>
</ul>
<h4 id="Third-party-dependencies" class="common-anchor-header">第三方依赖</h4><ul>
<li><p>etcd：存储集群中各种组件的元数据。</p></li>
<li><p>MinIO：负责集群中大型文件的数据持久性，如索引和二进制日志文件。</p></li>
<li><p>Pulsar管理最近突变操作的日志，输出流式日志，并提供日志发布-订阅服务。</p></li>
</ul>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Screenshot_2024_02_19_at_4_18_01_PM_88971280ed.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>图 2：Milvus 集群架构</p>
<h4 id="Available-Resources" class="common-anchor-header">可用资源</h4><ul>
<li><p><a href="https://milvus.io/docs/install_cluster-milvusoperator.md">文档</a>| 如何开始</p>
<ul>
<li><p><a href="https://milvus.io/docs/install_cluster-milvusoperator.md">使用 Milvus Operator 安装 Milvus 群集</a></p></li>
<li><p><a href="https://milvus.io/docs/install_cluster-helm.md">使用 Helm 安装 Milvus 群集</a></p></li>
<li><p><a href="https://milvus.io/docs/scaleout.md">如何扩展 Milvus 集群</a></p></li>
</ul></li>
<li><p><a href="https://github.com/milvus-io/milvus">Github 存储库</a></p></li>
</ul>
<h2 id="Making-the-Decision-on-which-Milvus-version-to-use" class="common-anchor-header">决定使用哪个版本的 Milvus<button data-href="#Making-the-Decision-on-which-Milvus-version-to-use" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在决定项目使用哪个版本的 Milvus 时，必须考虑数据集大小、流量、可扩展性要求和生产环境限制等因素。Milvus Lite 非常适合在笔记本电脑上进行原型开发。Milvus Standalone 为在数据集上进行向量搜索提供了高性能和灵活性，适合较小规模的部署、CI/CD 以及在没有 Kubernetes 支持时进行离线部署......最后，Milvus Cluster 为企业级工作负载提供了无与伦比的可用性、可扩展性和成本优化，是大规模、高可用生产环境的首选。</p>
<p>还有一个版本是无忧版，那就是名为<a href="https://cloud.zilliz.com/signup">Zilliz Cloud</a>的Milvus托管版。</p>
<p>最终，Milvus 版本将取决于您的具体用例、基础设施要求和长期目标。通过仔细评估这些因素并了解每个版本的特点和功能，您可以做出符合项目需求和目标的明智决定。无论您选择 Milvus Standalone 还是 Milvus Cluster，您都可以利用向量数据库的强大功能来提高人工智能应用的性能和效率。</p>


从哪个版本的 Milvus 开始

<p>在 2023 年即将结束之际，让我们回顾一下 Milvus 社区的非凡历程：拥有<a href="https://github.com/milvus-io/milvus">25000 个 GitHub Stars</a>、推出<a href="https://milvus.io/blog/unveiling-milvus-2-3-milestone-release-offering-support-for-gpu-arm64-cdc-and-other-features.md">Milvus 2.3.0</a> 以及<a href="https://hub.docker.com/r/milvusdb/milvus">Docker 镜像</a>下载量突破 1000 万。这篇文章通过分析聊天记录和揭示讨论中的十大关键词来探索社区的核心。</p>
<iframe class="video-player" src="https://www.youtube.com/embed/o5uMdNLioQ0?list=PLPg7_faNDlT5Fb8WN8r1PzzQTNzdechnS" title="Mastering Milvus: Turbocharge Your Vector Database with Optimization Secrets!" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
<h2 id="1-Version--The-rise-of-AIGC-drives-rapid-Milvus-iteration" class="common-anchor-header">#1 版本--AIGC 的崛起推动了 Milvus 的快速迭代<button data-href="#1-Version--The-rise-of-AIGC-drives-rapid-Milvus-iteration" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>令人惊讶的是，"版本 "成为 2023 年讨论最多的关键词。这一启示源于这一年的人工智能浪潮，向量数据库是应对 AIGC 应用幻觉问题挑战的重要基础设施。</p>
<p>围绕向量数据库的热情推动Milvus进入快速迭代阶段。仅在2023年，社区就见证了20个版本的发布，满足了AIGC开发者的需求，他们涌入社区询问如何为各种应用选择最优版本的Milvus。对于浏览这些更新的用户，我们建议使用最新版本，以增强功能和性能。</p>
<p>如果您对 Milvus 的发布规划感兴趣，请参考官方网站上的<a href="https://wiki.lfaidata.foundation/display/MIL/Milvus+Long+Term+Roadmap+and+Time+schedule">Milvus 路线图</a>页面。</p>
<h2 id="2-Search--beyond-Vector-Search" class="common-anchor-header">#2 搜索--超越向量搜索<button data-href="#2-Search--beyond-Vector-Search" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>"搜索 "排在第二位，反映了它在数据库操作中的基础作用。Milvus 支持多种搜索功能，从 Top-K ANN 搜索到标量过滤搜索和范围搜索。即将发布的 Milvus 3.0（测试版）承诺提供关键字搜索（稀疏嵌入），许多 RAG 应用程序开发人员对此翘首以盼。</p>
<p>社区关于搜索的讨论主要集中在性能、功能和原则方面。用户经常提出有关属性过滤、设置索引阈值和解决延迟问题的问题。<a href="https://milvus.io/docs/v2.0.x/search.md">查询和搜索文档</a>、<a href="https://wiki.lfaidata.foundation/pages/viewpage.action?pageId=43287103">Milvus 增强提案（MEP）</a>和 Discord 讨论等资源已成为解开 Milvus 内部错综复杂的搜索问题的首选参考资料。</p>
<h2 id="3-Memory--trade-offs-between-performance-and-accuracy-for-minimized-memory-overhead" class="common-anchor-header">#3 内存--在性能和准确性之间权衡，尽量减少内存开销<button data-href="#3-Memory--trade-offs-between-performance-and-accuracy-for-minimized-memory-overhead" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在过去的一年里，"内存 "也是社区讨论的中心议题。作为一种独特的数据类型，向量本身具有很高的维度。为了获得最佳性能，将向量存储在内存中是一种常见的做法，但不断增长的数据量限制了可用内存。Milvus 通过采用<a href="https://zilliz.com/blog/milvus-introduced-mmap-for-redefined-data-management-increased-storage-capability">MMap</a>和 DiskANN 等技术来优化内存使用。</p>
<p>然而，在数据库系统中同时实现低内存使用率、卓越性能和高精确度仍然很复杂，需要在性能和精确度之间进行权衡，以尽量减少内存开销。</p>
<p>就人工智能生成内容（AIGC）而言，开发人员通常会优先考虑快速响应和结果准确性，而不是严格的性能要求。Milvus 增加的 MMap 和 DiskANN 在最大限度地提高数据处理速度和结果准确性的同时，最大限度地减少了内存使用量，达到了与 AIGC 应用程序的实际需求相一致的平衡。</p>
<h2 id="4-Insert--smooth-sailing-through-data-insertion" class="common-anchor-header">#4 插入--数据插入一帆风顺<button data-href="#4-Insert--smooth-sailing-through-data-insertion" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>高效的数据插入是开发人员关心的一个重要问题，这引发了 Milvus 社区对优化插入速度的频繁讨论。Milvus 在高效插入流式数据和建立索引方面表现出色，这要归功于它对流式数据和批量数据的巧妙分离。与其他向量数据库提供商（如 Pinecone）相比，这种能力使其脱颖而出，成为性能卓越的解决方案。</p>
<p>以下是关于数据插入的一些有价值的见解和建议：</p>
<ul>
<li><p><strong>批量插入：</strong>选择批量插入，而不是单行插入，以提高效率。值得注意的是，从文件插入的速度超过了批量插入。在处理超过 1000 万条记录的大型数据集时，可考虑使用<code translate="no">bulk_insert</code> 界面，以简化和加快导入流程。</p></li>
<li><p><strong>战略性使用<code translate="no">flush()</code> ：</strong>与其在每次批处理后调用<code translate="no">flush()</code> 接口，不如在完成所有数据插入后调用一次。在批次之间过度使用<code translate="no">flush()</code> 界面会导致生成碎片段文件，给系统带来相当大的压缩负担。</p></li>
<li><p><strong>主键重复数据删除：</strong>在使用<code translate="no">insert</code> 接口插入数据时，Milvus 不会执行主键重复数据删除。如果您需要重复数据删除主键，我们建议您部署<code translate="no">upsert</code> 接口。不过，由于多了一个内部查询操作，<code translate="no">upsert</code>的插入性能比<code translate="no">insert</code> 低。</p></li>
</ul>
<h2 id="5-Configuration--decoding-the-parameter-maze" class="common-anchor-header">#5 配置--解码参数迷宫<button data-href="#5-Configuration--decoding-the-parameter-maze" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 是一个分布式向量数据库，集成了许多第三方组件，如对象存储、消息队列和 Etcd。用户们努力调整参数，了解参数对 Milvus 性能的影响，因此 "配置 "成了经常讨论的话题。</p>
<p>在所有关于配置的问题中，"调整哪些参数 "可以说是最具挑战性的方面，因为在不同的情况下，参数会有所不同。例如，优化搜索性能参数不同于优化插入性能参数，在很大程度上依赖于实践经验。</p>
<p>一旦用户确定了 "需要调整哪些参数"，接下来的 "如何调整 "问题就变得更容易处理了。有关具体步骤，请参阅我们的<a href="https://milvus.io/docs/configure-helm.md">配置 Milvus</a> 文档。好消息是，Milvus 从 2.3.0 版开始支持动态参数调整，无需重新启动即可使更改生效。有关具体步骤，请参阅《<a href="https://milvus.io/docs/dynamic_config.md">动态配置 Milvus</a>》。</p>
<h2 id="6-Logs--navigating-the-troubleshooting-compass" class="common-anchor-header">#6 日志--故障排除指南针导航<button data-href="#6-Logs--navigating-the-troubleshooting-compass" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>"日志 "是故障排除指南针。用户在社区中寻求有关导出 Milvus 日志、调整日志级别以及与 Grafana 的 Loki 等系统集成的指导。以下是关于 Milvus 日志的一些建议。</p>
<ul>
<li><p><strong>如何查看和导出 Milvus 日志：</strong>您可以使用 GitHub 存储库中的<a href="https://github.com/milvus-io/milvus/tree/master/deployments/export-log">export-milvus-log.sh</a>一键脚本轻松导出<a href="https://github.com/milvus-io/milvus/tree/master/deployments/export-log">Milvus</a>日志。</p></li>
<li><p><strong>日志级别：</strong>Milvus 有多种日志级别，以适应不同的使用情况。info 级别足以应对大多数情况，而 debug 级别则用于调试。Milvus 日志过多可能意味着日志级别配置错误。</p></li>
<li><p><strong>我们建议将 Milvus 日志与</strong>Loki 等<strong>日志收集系统集成</strong>，以便在今后的故障排除中简化日志检索。</p></li>
</ul>
<h2 id="7-Cluster--scaling-for-production-environments" class="common-anchor-header">#7 集群--为生产环境扩展<button data-href="#7-Cluster--scaling-for-production-environments" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>鉴于 Milvus 作为分布式向量数据库的特性，"集群 "一词是社区中经常讨论的话题。讨论围绕集群中的数据扩展、数据迁移以及数据备份和同步展开。</p>
<p>在生产环境中，强大的可扩展性和高可用性是分布式数据库系统的标准要求。Milvus 的存储-计算分离架构可通过扩展计算和存储节点资源实现无缝数据扩展，从而适应无限的数据规模。Milvus 还通过多副本架构和强大的备份与同步功能提供高可用性。  更多信息，请参阅<a href="https://milvus.io/docs/coordinator_ha.md#Coordinator-HA">协调器 HA</a>。</p>
<h2 id="8-Documentation--the-gateway-to-understanding-Milvus" class="common-anchor-header">#8 文档--了解 Milvus 的入口<button data-href="#8-Documentation--the-gateway-to-understanding-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在社区讨论中，"文档 "是另一个经常被提及的关键词，通常是关于特定功能是否有文档页面以及在哪里可以找到文档的问题。</p>
<p>作为了解 Milvus 的入口，大约 80% 的社区咨询都能在<a href="https://milvus.io/docs">官方文档</a>中找到答案。我们建议您在使用 Milvus 或遇到任何问题之前阅读我们的文档。此外，您还可以从各种 SDK 软件仓库中的代码示例中了解如何使用 Milvus。</p>
<h2 id="9-Deployment--simplifying-the-Milvus-journey" class="common-anchor-header">#9 部署--简化 Milvus 之旅<button data-href="#9-Deployment--simplifying-the-Milvus-journey" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>简单部署一直是 Milvus 团队的目标。为了实现这一承诺，我们推出了<a href="https://milvus.io/docs/milvus_lite.md#Get-Started-with-Milvus-Lite">Milvus Lite</a>，它是 Milvus 的轻量级替代品，功能齐全，但不依赖 K8s 或 Docker。</p>
<p>通过引入更轻量级的<a href="https://zilliz.com/blog/optimizing-data-communication-milvus-embraces-nats-messaging">NATS</a>消息传递解决方案和整合节点组件，我们进一步简化了部署。根据用户的反馈，我们正在准备发布一个不依赖于 K8s 的独立版本，并不断努力增强功能和简化部署操作符。Milvus 的快速迭代展示了社区对不断完善部署流程的持续承诺。</p>
<h2 id="10-Deletion--unraveling-the-impact" class="common-anchor-header">#10 删除--消除影响<button data-href="#10-Deletion--unraveling-the-impact" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>关于 "删除 "的普遍讨论围绕着删除后数据数量不变、删除数据的持续可检索性以及删除后磁盘空间恢复失败等问题。</p>
<p>Milvus 2.3 引入了<code translate="no">count(*)</code> 表达式，以解决实体计数更新延迟的问题。查询中已删除数据的持续性可能是由于<a href="https://zilliz.com/blog/understand-consistency-models-for-vector-databases">数据一致性模型</a>使用不当造成的。磁盘空间恢复失败的担忧促使我们重新设计 Milvus 的垃圾 Collection 机制，该机制在完全删除数据前设置了一个等待期。这种方法为可能的恢复提供了时间窗口。</p>
<h2 id="Conclusion" class="common-anchor-header">结论<button data-href="#Conclusion" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>从排名前 10 的关键词中，我们可以窥见 Milvus 社区内的热烈讨论。随着 Milvus 的不断发展，社区仍然是开发人员寻求解决方案、分享经验以及在人工智能时代推动向量数据库发展的宝贵资源。</p>
<p>请在 2024 年加入我们的<a href="https://discord.com/invite/8uyFbECzPX">Discord 频道</a>，加入这一激动人心的旅程。在那里，您可以与我们出色的工程师互动，与志同道合的 Milvus 爱好者交流。此外，还可以参加每周二下午 12:00 至 12:30 的<a href="https://discord.com/invite/RjNbk8RR4f">Milvus 社区午餐学习</a>会。分享您的想法、问题和反馈，因为每个人的贡献都会为推动 Milvus 前进的协作精神添砖加瓦。我们不仅欢迎您的积极参与，更感谢您的参与。让我们一起创新！</p>


Top 10 Keywords Dominating the Milvus Community in 2023

揭晓 2023 年主导 Milvus 社区的十大关键词

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/What_is_new_in_Milvus_2_3_4_1847b0fa8a.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>我们很高兴发布最新的 Milvus 2.3.4 版本。此次更新引入了一系列精心设计的功能和增强功能，以优化性能、提高效率并提供无缝的用户体验。在这篇博文中，我们将深入探讨 Milvus 2.3.4 的亮点。</p>
<h2 id="Access-logs-for-improved-monitoring" class="common-anchor-header">改进监控的访问日志<button data-href="#Access-logs-for-improved-monitoring" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 现在支持访问日志，为了解与外部接口的交互提供了宝贵的信息。这些日志记录了方法名称、用户请求、响应时间、错误代码和其他交互信息，使开发人员和系统管理员能够进行性能分析、安全审计和高效的故障排除。</p>
<p><strong><em>注：</em></strong> <em>目前，访问日志仅支持 gRPC 交互。不过，我们将继续致力于改进，未来版本将扩展此功能，以包括 RESTful 请求日志。</em></p>
<p>有关详细信息，请参阅<a href="https://milvus.io/docs/configure_access_logs.md">配置访问日志</a>。</p>
<h2 id="Parquet-file-imports-for-enhanced-data-processing-efficiency" class="common-anchor-header">通过 Parquet 文件导入提高数据处理效率<button data-href="#Parquet-file-imports-for-enhanced-data-processing-efficiency" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.3.4 现在支持导入 Parquet 文件，这是一种广受欢迎的列式存储格式，旨在提高大规模数据集的存储和处理效率。这一新增功能提高了用户处理数据的灵活性和效率。通过省去费力的数据格式转换，管理 Parquet 格式大型数据集的用户将体验到简化的数据导入流程，大大缩短从初始数据准备到后续向量检索的时间。</p>
<p>此外，我们的数据格式转换工具 BulkWriter 现在已将 Parquet 作为其默认输出数据格式，确保为开发人员提供更直观的体验。</p>
<h2 id="Binlog-index-on-growing-segments-for-faster-searches" class="common-anchor-header">在不断增长的数据段上建立 Binlog 索引，加快搜索速度<button data-href="#Binlog-index-on-growing-segments-for-faster-searches" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 现在可在不断增长的数据段上利用 binlog 索引，从而将不断增长的数据段中的搜索速度提高 10 倍。这一改进大大提高了搜索效率，并支持 IVF 或快速扫描等高级索引，从而改善了整体用户体验。</p>
<h2 id="Support-for-up-to-10000-collectionspartitions" class="common-anchor-header">支持多达 10,000 个 Collections/分区<button data-href="#Support-for-up-to-10000-collectionspartitions" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>与关系数据库中的表和分区一样，Collections 和分区是 Milvus 中存储和管理向量数据的核心单元。为了满足用户对细微数据组织不断变化的需求，Milvus 2.3.4 现在支持一个集群中多达 10,000 个 Collections/分区，与之前的 4,096 个限制相比有了大幅提升。这一改进有利于知识库管理和多租户环境等各种使用案例。对 Collections/分区支持的扩大源于对时间刻度机制、"程序 "管理和内存使用的改进。</p>
<p><strong><em>注意：</em></strong> <em>建议将 Collections/partition 的数量限制为 10,000 个，因为超过这一限制可能会影响故障恢复和资源使用。</em></p>
<h2 id="Other-enhancements" class="common-anchor-header">其他增强功能<button data-href="#Other-enhancements" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>除上述功能外，Milvus 2.3.4 还包括各种改进和错误修复。这些改进包括降低数据检索和变长数据处理过程中的内存使用率、改进错误消息传递、加快加载速度以及改进查询分片平衡。这些 Collections 增强功能有助于实现更流畅、更高效的整体用户体验。</p>
<p>如需全面了解 Milvus 2.3.4 中引入的所有更改，请参阅我们的<a href="https://milvus.io/docs/release_notes.md#v234">发行说明</a>。</p>
<h2 id="Stay-connected" class="common-anchor-header">保持联系！<button data-href="#Stay-connected" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您有关于 Milvus 的问题或反馈，请加入我们的<a href="https://discord.com/invite/8uyFbECzPX">Discord 频道</a>，直接与我们的工程师和社区交流，或参加每周二下午 12:12:30 的<a href="https://discord.com/invite/RjNbk8RR4f">Milvus 社区午餐学习会</a>。也欢迎您在<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a>上关注我们，了解有关 Milvus 的最新消息和更新。</p>


Milvus 2.3.4：更快的搜索、更大的数据支持、更好的监控等

<p>
 <span class="img-wrapper">
   <img translate="no" src="https://assets.zilliz.com/image_7_1c3b05e71c.jpg" alt="This image is generated by AI. " class="doc-image" id="this-image-is-generated-by-ai.-" />
   <span>该图像由人工智能生成。 </span> </span>
  
</p>
<custom-h1>2023 年的 Milvus：科技热潮中前所未有的向量数据库</custom-h1><p><em>本文章由 James Luan 在 ChatGPT 的帮助下撰写。詹姆斯主要负责撰写提示，并对人工智能生成的内容进行审核和润色。</em></p>
<h2 id="2023-the-year-of-AI" class="common-anchor-header">2023：人工智能年<button data-href="#2023-the-year-of-AI" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>2023 年是人工智能（AI）的一个关键转折点。<a href="https://zilliz.com/glossary/large-language-models-(llms)">大型语言模型（LLMs）</a>已经成为舞台的中心，其卓越的自然语言处理能力获得了广泛认可。这一流行趋势极大地扩展了机器学习应用的可能性，使开发人员能够构建更加智能和交互式的应用。</p>
<p>在这场革命中，<a href="https://zilliz.com/learn/what-is-vector-database">向量数据库</a>作为LLMs的长期存储器，已成为一个至关重要的组成部分。<a href="https://zilliz.com/use-cases/llm-retrieval-augmented-generation">Retrieval-Augmented Generation（RAG）</a>模型、智能代理和多模态检索应用程序的兴起，证明了向量数据库在提高多模态数据检索效率、减少 LLMs 中的幻觉和补充领域知识方面的巨大潜力。</p>
<p>LLM 的发展也催化了嵌入技术的长足进步。根据 HuggingFace 上的<a href="https://huggingface.co/spaces/mteb/leaderboard">大规模文本嵌入基准（MTEB）排行榜</a>，UAE、VoyageAI、CohereV3 和 Bge 等领先的嵌入模型都是在 2023 年发布的。这些进步增强了 Milvus 等各种向量搜索技术的向量检索效果，为人工智能应用提供了更精准、更高效的数据处理能力。</p>
<p>然而，随着向量数据库的日益普及，关于专业化解决方案必要性的争论也随之而来。数十家初创公司纷纷进入向量数据库领域。许多传统的关系型数据库和 NoSQL 数据库开始将向量作为一种重要的数据类型，许多人声称能够在各种情况下替代专门的向量数据库。</p>
<p>在我们进入 2024 年之际，这是一个反思整个向量数据库行业的明智时刻，我们要特别关注 Milvus--这个在这一格局中脱颖而出的产品。</p>
<h2 id="Milvus-in-2023-numbers-dont-lie" class="common-anchor-header">2023 年的 Milvus：数字不会说谎<button data-href="#Milvus-in-2023-numbers-dont-lie" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://zilliz.com/what-is-milvus">Milvus</a>于 2019 年首次推出，开创了向量数据库的概念，并始终保持着高可靠性、可扩展性、搜索质量和性能的声誉。2023年，Milvus取得了令人瞩目的成绩，并发生了重大转变，这主要是由LLMs的快速进步和AIGC应用的蓬勃发展所推动的。以下是最能代表 Milvus 在 2023 年进步的一些关键数据。</p>
<h3 id="ZERO-downtime-during-rolling-upgrades" class="common-anchor-header">滚动升级期间零停机</h3><p>对于那些刚接触向量数据库的人来说，他们主要关注的中心是功能而不是操作维护。与事务型数据库相比，许多应用程序开发人员对向量数据库稳定性的关注也较少，因为他们的应用程序通常处于早期探索阶段。但是，如果要在生产环境中部署 AIGC 应用程序并获得最佳用户体验，稳定性就变得不可或缺。</p>
<p>Milvus 的与众不同之处在于，它不仅将功能性放在首位，还将操作的稳定性放在首位。从 2.2.3 版开始，我们为 Milvus 增加了滚动升级功能。经过不断改进，该功能可确保升级期间零停机，而不会中断业务流程。</p>
<h3 id="3x-performance-improvement-in-production-environments" class="common-anchor-header">在生产环境中提高 3 倍性能</h3><p>提升向量搜索性能需要成为向量数据库的首要目标。许多向量搜索解决方案都选择以调整<a href="https://zilliz.com/learn/hierarchical-navigable-small-worlds-HNSW">HNSW</a>算法为基础，以便快速进入市场；不幸的是，这导致它们在实际生产环境中面临巨大挑战，尤其是在高度过滤搜索（超过 90%）和频繁删除数据的情况下。Milvus 从一开始就考虑了性能问题，在开发的任何阶段都能出色地优化性能，特别是在生产环境中，实现了搜索性能的三倍提升，尤其是在过滤搜索和流式插入/搜索情况下。</p>
<p>为了进一步帮助向量数据库社区，我们去年推出了开源基准测试工具<a href="https://github.com/zilliztech/VectorDBBench">VectorDBBench</a>。该工具对于在不同条件下对向量数据库进行早期评估至关重要。与传统的评估方法不同，VectorDBBench 使用真实世界的数据（包括超大数据集或与实际 Embeddings 模型数据近似的数据集）对数据库进行评估，为用户做出明智决策提供更具洞察力的信息。</p>
<h3 id="5-recall-improvement-on-the-Beir-dataset" class="common-anchor-header">在 Beir 数据集上的召回率提高了 5</h3><p>虽然<a href="https://zilliz.com/learn/sparse-and-dense-embeddings">密集嵌入</a>在向量搜索中被证明是有效的，但在搜索名称、对象、缩写和简短查询上下文时，它们必须迎头赶上。针对它们的局限性，Milvus 推出了一种混合查询方法，将密集嵌入式与<a href="https://zilliz.com/learn/sparse-and-dense-embeddings">稀疏嵌入式</a>整合在一起，以提高搜索结果的质量。这种混合解决方案与 Rerankers 模型的协同作用使 Beir 数据集上的召回率大幅提高了 5%，我们的测试也验证了这一点。</p>
<p>除了搜索质量的提高，Milvus 还推出了为稀疏嵌入量身定制的基于图的检索解决方案，其性能超过了 WAND 等传统搜索算法。</p>
<p>在 2023 年的 NeurIPS BigANN 比赛上，Zilliz 公司的天才工程师王梓豪展示了<a href="https://big-ann-benchmarks.com/neurips23.html#winners">Pyanns</a>，这是一种搜索算法，在稀疏嵌入搜索赛道上表现出明显优于其他参赛作品的性能。这一突破性解决方案是我们用于生产环境的稀疏嵌入搜索算法的先驱。</p>
<h3 id="10x-memory-saving-on-large-datasets" class="common-anchor-header">在大型数据集上节省 10 倍内存</h3><p><a href="https://zilliz.com/use-cases/llm-retrieval-augmented-generation">检索增强生成</a>（RAG）是 2023 年向量数据库最流行的用例。然而，RAG 应用带来的向量数据量的增加给这些应用带来了存储挑战。当转换后的向量量超过原始文档块的量时，这种挑战尤其明显，有可能使内存使用成本上升。例如，将文档划分成块后，由 500 个标记块（约 1kb）转化而来的 1536 维 float32 向量（约 3kb）的大小要大于 500 个标记块。</p>
<p>Milvus 是首个支持基于磁盘的索引的开源向量数据库，带来了 5 倍的显著内存节省。到 2023 年年底，我们推出了<a href="https://milvus.io/docs/release_notes.md#v234">Milvus 2.3.4</a>，使标量和向量数据/索引能够使用内存映射文件<a href="https://zilliz.com/blog/milvus-introduced-mmap-for-redefined-data-management-increased-storage-capability">（MMap</a>）加载到磁盘上。与传统的内存索引相比，这一进步可将内存使用量减少 10 倍以上。</p>
<h3 id="20-Milvus-releases" class="common-anchor-header">20 个 Milvus 版本</h3><p>2023 年，Milvus 经历了具有重大里程碑意义的转型之旅。在这一年中，我们发布了 20 个版本，这证明了 300 多名社区开发人员的奉献精神，以及我们在开发过程中实现用户驱动方法的承诺。</p>
<p>例如，Milvus 2.2.9 引入了<a href="https://zilliz.com/blog/what-is-dynamic-schema">动态 Schema</a>，标志着从优先考虑性能到提高可用性的重要转变。在此基础上，<a href="https://milvus.io/blog/unveiling-milvus-2-3-milestone-release-offering-support-for-gpu-arm64-cdc-and-other-features.md">Milvus 2.3</a>引入了 Upsert、<a href="https://zilliz.com/blog/unlock-advanced-recommendation-engines-with-milvus-new-range-search">范围搜索</a>、余弦度量等关键功能，所有这些功能都是由用户社区的特定需求和反馈驱动的。这种迭代开发过程凸显了我们不断使 Milvus 符合用户不断变化的需求的承诺。</p>
<h3 id="1000000-tenants-in-a-Single-Custer" class="common-anchor-header">单个卡斯特中的 1,000,000 个租户</h3><p>实施多租户对于开发 RAG 系统、人工智能 Agents 和其他 LLM 应用程序至关重要，可满足用户对数据隔离的更高要求。对于 B2C 企业来说，租户数量可能会激增到数百万，这使得用户数据的物理隔离变得不切实际（举例来说，不可能有人会在关系数据库中创建数百万个表）。Milvus 引入了 Partition Key 功能，可以根据分区键实现高效的逻辑隔离和数据过滤，这在大规模使用时非常方便。</p>
<p>相反，习惯于处理数以万计租户的 B2B 企业则受益于涉及物理资源隔离的更细致策略。最新的 Milvus 2.3.4 带来了增强的内存管理、例行程序处理和 CPU 优化，使在单个集群内创建数万张表变得更加容易。这一增强功能还能满足 B2B 企业的需求，提高效率和控制力。</p>
<h3 id="10000000-Docker-image-pulls" class="common-anchor-header">拉取 10,000,000 个 Docker 映像</h3><p>2023 年即将过去，Milvus 达到了一个令人印象深刻的里程碑，<a href="https://hub.docker.com/r/milvusdb/milvus">Docker 拉取</a>下载量达到<a href="https://hub.docker.com/r/milvusdb/milvus">1000 万次</a>。这一成就标志着开发者社区对 Milvus 的迷恋与日俱增，也凸显了其在向量数据库领域不断提升的重要性。</p>
<p>作为世界上第一个云原生向量数据库，Milvus 可以与 Kubernetes 和更广泛的容器生态系统无缝集成。展望未来，人们不禁会思考不断发展的向量数据库领域的下一个焦点。这会是无服务器服务的兴起吗？</p>
<h3 id="10-billion-entities-in-a-single-collection" class="common-anchor-header">单个 Collections 中的 100 亿个实体</h3><p>虽然可扩展性目前可能不会成为人工智能现象中的焦点，但它肯定扮演着举足轻重的角色，而不仅仅是一个配角。Milvus 向量数据库可以无缝扩展，容纳数十亿的向量数据，而不会让人捏一把汗。以我们的一位 LLM 客户为例。Milvus 毫不费力地帮助这位客户存储、处理和检索了惊人的 100 亿个数据点。但是，在处理如此海量的数据时，如何平衡成本和性能呢？请放心，Mivus 有各种能力帮助您应对这一挑战并提升您的体验。</p>
<h2 id="Beyond-the-numbers-the-new-insights-into-vector-databases" class="common-anchor-header">数字之外：向量数据库的新见解<button data-href="#Beyond-the-numbers-the-new-insights-into-vector-databases" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>除了数字上的里程碑，2023 年还丰富了我们的宝贵见解。我们深入研究了向量数据库的错综复杂，超越了单纯的统计数据，掌握了向量搜索技术的细微差别和不断发展的动态。</p>
<h3 id="LLM-apps-are-still-in-the-early-stages" class="common-anchor-header">LLM 应用程序仍处于早期阶段。</h3><p>回想移动互联网蓬勃发展的早期，许多开发者创建了手电筒或天气预报等简单的应用程序，这些应用程序最终被集成到智能手机操作系统中。去年，大多数人工智能原生应用，如在GitHub上迅速获得10万颗星的AutoGPT，并没有带来实际价值，而只是代表着有意义的实验。对于向量数据库应用来说，目前的用例可能只是 AI Native 转型的第一波，我热切期待更多的杀手级用例出现。</p>
<h3 id="Vector-databases-go-toward-diversification" class="common-anchor-header">向量数据库走向多样化。</h3><p>与数据库演变为 OLTP、OLAP 和 NoSQL 等类别类似，向量数据库也呈现出明显的多元化趋势。与传统的在线服务不同，离线分析获得了显著的发展。2023 年发布的开源语义缓存<a href="https://zilliz.com/blog/building-llm-apps-100x-faster-responses-drastic-cost-reduction-using-gptcache">GPTCache</a> 就是这种转变的另一个显著例子。它通过存储和检索语言模型生成的响应，提高了基于 GPT 的应用程序的效率和速度。</p>
<p>我们希望并期待在未来一年见证向量数据库更加多样化的应用和系统设计。</p>
<h3 id="Vector-operations-are-becoming-more-complicated" class="common-anchor-header">向量操作符正变得越来越复杂。</h3><p>虽然支持<a href="https://zilliz.com/glossary/anns">近似近邻（ANN）</a>搜索是向量数据库的一个决定性特征，但它并不是孤立存在的。人们普遍认为，仅仅保持近似邻域搜索就足以将数据库归类为向量或人工智能原生数据库，这种想法过于简化了向量操作的复杂性。除了混合标量过滤和向量搜索的基本功能外，为人工智能原生应用定制的数据库还应支持更复杂的语义功能，如 NN 过滤、KNN 连接和集群查询。</p>
<h3 id="Elastic-scalability-is-essential-for-AI-native-applications" class="common-anchor-header">弹性可扩展性对人工智能原生应用至关重要。</h3><p>人工智能应用的指数级增长（如 ChatGPT 在两个月内就积累了超过 1 亿的月活跃用户）超越了以往任何商业轨迹。一旦企业的发展步入正轨，迅速从 100 万个数据点扩展到 10 亿个数据点就变得至关重要。人工智能应用开发人员受益于 LLM 提供商设定的 "即用即付 "服务模型，从而大幅降低了操作成本。同样，存储符合这种定价模型的数据也证明对开发人员有利，使他们能够将更多注意力转移到核心业务上。</p>
<p>与语言模型（LLMs）和其他各种技术系统不同，向量数据库是以有状态的方式操作的，其功能需要持久的数据存储。因此，在选择向量数据库时，优先考虑弹性和可扩展性至关重要。这种优先级可确保与不断发展的人工智能应用的动态需求保持一致，从而突出了无缝适应不断变化的工作负载的必要性。</p>
<h3 id="Leveraging-machine-learning-in-vector-databases-can-yield-extraordinary-results" class="common-anchor-header">在向量数据库中利用机器学习可以产生非凡的效果。</h3><p>2023 年，我们在 AI4DB（人工智能数据库）项目上的大量投资取得了显著成效。作为努力的一部分，我们为全面管理的 Milvus 解决方案<a href="https://zilliz.com/cloud">Zilliz Cloud</a> 引入了两项举足轻重的功能：1）AutoIndex，一种植根于机器学习的自动参数调整索引；2）基于数据聚类的数据分区策略。这两项创新在显著提升 Zilliz Cloud 的搜索性能方面发挥了至关重要的作用。</p>
<h3 id="Open-source-vs-closed-source" class="common-anchor-header">开源与闭源</h3><p>目前，OpenAI 的 GPT 系列和 Claude 等闭源 LLMs 占据领先地位，由于缺乏可比的计算和数据资源，开源社区处于劣势。</p>
<p>不过，在向量数据库中，开源最终将成为用户的首选。选择开源会带来许多优势，包括更多样化的使用案例、加速迭代和培养更强大的生态系统。此外，数据库系统错综复杂，无法承受通常与 LLMs 相关的不透明性。用户在选择最合理的使用方法之前，必须彻底了解数据库。此外，开放源码所具有的透明度使用户能够根据自己的需要自由定制数据库。</p>
<h2 id="Epilogue---And-a-new-beginning" class="common-anchor-header">后记--新的开始！<button data-href="#Epilogue---And-a-new-beginning" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>2023 年在变革中悄然过去，向量数据库的故事才刚刚开始。我们与 Milvus 向量数据库一起走过的历程，除了迷失在 AIGC 的炒作中，还有其他意义。相反，我们专注于精心开发我们的产品，识别和培养符合我们优势的应用案例，并坚定不移地为我们的用户提供服务。我们致力于开源，目的是在我们与用户之间架起一座桥梁，让他们即使远隔千山万水，也能感受到我们的专注和匠心。</p>
<p>2023 年还见证了许多人工智能初创企业的成立和首轮融资。看到这些开发者的创新，我感到非常兴奋，这也让我想起了当初为什么要从事 VectorDB 开发。2024年将是所有这些创新应用获得真正牵引力的一年，吸引的不仅仅是资金，还有真正的付费客户。客户收入将给这些开发人员带来不同的要求，因为构建一个完全可扩展、几乎没有停机时间的解决方案是最重要的。</p>
<p>让我们在 2024 年创造非凡！</p>


2023：人工智能年

使用 Milvus 和英伟达™（NVIDIA®）Merlin 在推荐工作流中进行高效向量相似性搜索

如何获得正确的向量嵌入

如何将数据无缝迁移到 Milvus：综合指南

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Exploring_NATS_878f48c848.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>在错综复杂的数据处理过程中，无缝通信是连接操作符的纽带。具有开拓性的<a href="https://zilliz.com/cloud">开源向量数据库</a> <a href="https://zilliz.com/what-is-milvus">Milvus</a> 凭借其最新功能踏上了转型之旅：NATS 消息集成。在这篇综合性博文中，我们将揭开这一集成的神秘面纱，探讨其核心功能、设置过程、迁移优势以及与其前身 RocksMQ 相比的优势。</p>
<h2 id="Understanding-the-role-of-message-queues-in-Milvus" class="common-anchor-header">了解消息队列在 Milvus 中的作用<button data-href="#Understanding-the-role-of-message-queues-in-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 Milvus 的云原生架构中，消息队列或日志代理（Log Broker）具有举足轻重的地位。它是确保持久数据流、同步、事件通知和系统恢复期间数据完整性的支柱。传统上，在 Milvus Standalone 模式中，RocksMQ 是最直接的选择，尤其是与 Pulsar 和 Kafka 相比，但在大量数据和复杂场景下，它的局限性就显而易见了。</p>
<p>Milvus 2.3 引入了单节点 MQ 实现 NATS，重新定义了如何管理数据流。与前代产品不同，NATS 将 Milvus 用户从性能限制中解放出来，为处理大量数据提供无缝体验。</p>
<h2 id="What-is-NATS" class="common-anchor-header">什么是 NATS？<button data-href="#What-is-NATS" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>NATS 是用 Go 实现的分布式系统连接技术。它支持跨系统的各种通信模式，如请求-回复（Request-Reply）和发布-订阅（Publish-Subscribe），通过 JetStream 提供数据持久性，并通过内置的 RAFT 提供分布式功能。有关 NATS 的更多详情，请参阅 NATS<a href="https://nats.io/">官方网站</a>。</p>
<p>在 Milvus 2.3 Standalone 模式下，NATS、JetStream 和 PubSub 为 Milvus 提供了强大的 MQ 功能。</p>
<h2 id="Enabling-NATS" class="common-anchor-header">启用 NATS<button data-href="#Enabling-NATS" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.3 提供了一个新的控制选项<code translate="no">mq.type</code> ，允许用户指定要使用的 MQ 类型。要启用 NATS，请设置<code translate="no">mq.type=natsmq</code> 。如果在启动 Milvus 实例后看到类似下面的日志，就说明已成功启用 NATS 作为消息队列。</p>
<pre><code translate="no">[INFO] [dependency/factory.go:83] [<span class="hljs-string">&quot;try to init mq&quot;</span>] [standalone=<span class="hljs-literal">true</span>] [mqType=natsmq]
<button class="copy-code-btn"></button></code></pre>
<h2 id="Configuring-NATS-for-Milvus" class="common-anchor-header">为 Milvus 配置 NATS<button data-href="#Configuring-NATS-for-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>NATS 自定义选项包括指定监听端口、JetStream 存储目录、最大有效载荷大小和初始化超时。微调这些设置可确保最佳性能和可靠性。</p>
<pre><code translate="no">natsmq:
server: <span class="hljs-comment"># server side configuration for natsmq.</span>
port: <span class="hljs-number">4222</span> <span class="hljs-comment"># 4222 by default, Port for nats server listening.</span>
storeDir: /var/lib/milvus/nats <span class="hljs-comment"># /var/lib/milvus/nats by default, directory to use for JetStream storage of nats.</span>
maxFileStore: <span class="hljs-number">17179869184</span> <span class="hljs-comment"># (B) 16GB by default, Maximum size of the &#x27;file&#x27; storage.</span>
maxPayload: <span class="hljs-number">8388608</span> <span class="hljs-comment"># (B) 8MB by default, Maximum number of bytes in a message payload.</span>
maxPending: <span class="hljs-number">67108864</span> <span class="hljs-comment"># (B) 64MB by default, Maximum number of bytes buffered for a connection Applies to client connections.</span>
initializeTimeout: <span class="hljs-number">4000</span> <span class="hljs-comment"># (ms) 4s by default, waiting for initialization of natsmq finished.</span>
monitor:
trace: false <span class="hljs-comment"># false by default, If true enable protocol trace log messages.</span>
debug: false <span class="hljs-comment"># false by default, If true enable debug log messages.</span>
logTime: true <span class="hljs-comment"># true by default, If set to false, log without timestamps.</span>
logFile: /tmp/milvus/logs/nats.log <span class="hljs-comment"># /tmp/milvus/logs/nats.log by default, Log file path relative to .. of milvus binary if use relative path.</span>
logSizeLimit: <span class="hljs-number">536870912</span> <span class="hljs-comment"># (B) 512MB by default, Size in bytes after the log file rolls over to a new one.</span>
retention:
maxAge: <span class="hljs-number">4320</span> <span class="hljs-comment"># (min) 3 days by default, Maximum age of any message in the P-channel.</span>
maxBytes: <span class="hljs-comment"># (B) None by default, How many bytes the single P-channel may contain. Removing oldest messages if the P-channel exceeds this size.</span>
maxMsgs: <span class="hljs-comment"># None by default, How many message the single P-channel may contain. Removing oldest messages if the P-channel exceeds this limit.</span>
<button class="copy-code-btn"></button></code></pre>
<p><strong>注意</strong></p>
<ul>
<li><p>必须为 NATS 服务器监听指定<code translate="no">server.port</code> 。如果存在端口冲突，Milvus 将无法启动。将<code translate="no">server.port=-1</code> 设置为随机选择端口。</p></li>
<li><p><code translate="no">storeDir</code> 指定 JetStream 存储目录。建议将目录存储在高性能固态硬盘 (SSD) 中，以提高 Milvus 的读/写吞吐量。</p></li>
<li><p><code translate="no">maxFileStore</code> 设置 JetStream 存储容量的上限。超过此上限将阻止继续写入数据。</p></li>
<li><p><code translate="no">maxPayload</code> 限制单条信息的大小。应保持在 5MB 以上，以避免任何写入拒绝。</p></li>
<li><p><code translate="no">initializeTimeout</code>控制 NATS 服务器启动超时。</p></li>
<li><p><code translate="no">monitor</code> 配置 NATS 的独立日志。</p></li>
<li><p><code translate="no">retention</code> 控制 NATS 报文的保留机制。</p></li>
</ul>
<p>更多信息，请参阅<a href="https://docs.nats.io/running-a-nats-service/configuration">NATS 官方文档</a>。</p>
<h2 id="Migrating-from-RocksMQ-to-NATS" class="common-anchor-header">从RocksMQ迁移到NATS<button data-href="#Migrating-from-RocksMQ-to-NATS" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>从 RocksMQ 迁移到 NATS 是一个无缝的过程，涉及到停止写操作、刷新数据、修改配置和通过 Milvus Operator 日志验证迁移等步骤。</p>
<ol>
<li><p>在开始迁移之前，先停止 Milvus 中的所有写操作。</p></li>
<li><p>在 Milvus 中执行<code translate="no">FlushALL</code> 操作符并等待其完成。此步骤可确保所有待处理数据都已刷新，系统已为关闭做好准备。</p></li>
<li><p>修改 Milvus 配置文件，在<code translate="no">natsmq</code> 部分下设置<code translate="no">mq.type=natsmq</code> 并调整相关选项。</p></li>
<li><p>启动 Milvus 2.3。</p></li>
<li><p>备份并清理存储在<code translate="no">rocksmq.path</code> 目录中的原始数据。可选</p></li>
</ol>
<h2 id="NATS-vs-RocksMQ-A-Performance-Showdown" class="common-anchor-header">NATS 与 RocksMQ：性能对决<button data-href="#NATS-vs-RocksMQ-A-Performance-Showdown" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="PubSub-Performance-Testing" class="common-anchor-header">发布/子性能测试</h3><ul>
<li><p><strong>测试平台</strong>M1 Pro 芯片/内存：16GB</p></li>
<li><p><strong>测试场景</strong>向一个主题重复订阅和发布随机数据包，直到收到最后一个发布结果。</p></li>
<li><p><strong>测试结果</strong></p>
<ul>
<li><p>对于较小的数据包（&lt; 64kb），RocksMQ 在内存、CPU 和响应速度方面都优于 NATS。</p></li>
<li><p>对于较大的数据包（&gt; 64kb），NATS 的响应速度要比 RocksMQ 快得多。</p></li>
</ul></li>
</ul>
<table>
<thead>
<tr><th>测试类型</th><th>MQ</th><th>操作次数</th><th>每次操作成本</th><th>内存成本</th><th>CPU 总时间</th><th>存储成本</th></tr>
</thead>
<tbody>
<tr><td>5MB*100 发布/分</td><td>NATS</td><td>50</td><td>1.650328186 秒/操作</td><td>4.29 GB</td><td>85.58</td><td>25G</td></tr>
<tr><td>5MB*100 发布/分</td><td>RocksMQ</td><td>50</td><td>2.475595131 s/op</td><td>1.18 GB</td><td>81.42</td><td>19G</td></tr>
<tr><td>1MB*500 发布/分</td><td>NATS</td><td>50</td><td>2.248722593 S/OP</td><td>2.60 GB</td><td>96.50</td><td>25G</td></tr>
<tr><td>1MB*500 发布/分</td><td>RocksMQ</td><td>50</td><td>2.554614279 s/op</td><td>614.9 MB</td><td>80.19</td><td>19G</td></tr>
<tr><td>64KB*10000 发布/分</td><td>国家统计局</td><td>50</td><td>2.133345262 S/OP</td><td>3.29 GB</td><td>97.59</td><td>31G</td></tr>
<tr><td>64KB*10000 发布/分</td><td>RocksMQ</td><td>50</td><td>3.253778195 s/op</td><td>331.2 MB</td><td>134.6</td><td>24G</td></tr>
<tr><td>1KB*50000 发布/分</td><td>NATS</td><td>50</td><td>2.629391004 S/OP</td><td>635.1 MB</td><td>179.67</td><td>2.6G</td></tr>
<tr><td>1KB*50000 发布/子</td><td>RocksMQ</td><td>50</td><td>0.897638581 s/op</td><td>232.3 MB</td><td>60.42</td><td>521M</td></tr>
</tbody>
</table>
<p>表 1：Pub/Sub 性能测试结果</p>
<h3 id="Milvus-Integration-Testing" class="common-anchor-header">Milvus 集成测试</h3><p><strong>数据大小：</strong>100M</p>
<p><strong>结果</strong>在使用 1 亿向量数据集进行的大量测试中，NATS 展示了较低的向量搜索和查询延迟。</p>
<table>
<thead>
<tr><th>指标</th><th>RocksMQ (毫秒)</th><th>NATS （毫秒）</th></tr>
</thead>
<tbody>
<tr><td>向量搜索平均延迟</td><td>23.55</td><td>20.17</td></tr>
<tr><td>每秒向量搜索请求数 (RPS)</td><td>2.95</td><td>3.07</td></tr>
<tr><td>平均查询延迟</td><td>7.2</td><td>6.74</td></tr>
<tr><td>每秒查询请求 (RPS)</td><td>1.47</td><td>1.54</td></tr>
</tbody>
</table>
<p>表 2：Milvus 与 100M 数据集的集成测试结果</p>
<p><strong>数据集：&lt;100M</strong></p>
<p><strong>结果</strong>对于小于 100M 的数据集，NATS 和 RocksMQ 显示出相似的性能。</p>
<h2 id="Conclusion-Empowering-Milvus-with-NATS-messaging" class="common-anchor-header">结论用 NATS 消息传递增强 Milvus 的能力<button data-href="#Conclusion-Empowering-Milvus-with-NATS-messaging" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 Milvus 中集成 NATS 标志着在数据处理方面取得了重大进展。无论是深入研究实时分析、机器学习应用，还是任何数据密集型风险投资，NATS 都能为您的项目带来效率、可靠性和速度。随着数据领域的不断发展，在 Milvus 中拥有像 NATS 这样强大的消息传递系统，可以确保无缝、可靠和高性能的数据通信。</p>


优化数据通信：Milvus 采用 NATS 信息传输技术

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/What_s_New_in_Milvus_2_3_2_and_2_3_3_d3d0db03c3.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>在不断发展的向量搜索技术领域，Milvus 始终站在最前沿，不断突破界限，设立新的标准。今天，我们非常高兴地宣布 Milvus 2.3.2 和 2.3.3 正式发布！这些更新带来了许多令人兴奋的功能、优化和改进，提高了系统性能、灵活性和整体用户体验。</p>
<h2 id="Support-for-Array-data-types---making-search-results-more-accurate-and-relevant" class="common-anchor-header">支持数组数据类型--使搜索结果更准确、更相关<button data-href="#Support-for-Array-data-types---making-search-results-more-accurate-and-relevant" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>添加对数组数据类型的支持是 Milvus 的一项关键改进，尤其是在查询过滤场景（如交集和联合）中。这一新增功能可确保搜索结果不仅更加准确，而且更加相关。在实际应用中，例如在电子商务领域，存储为字符串数组的产品标签允许消费者执行高级搜索，过滤掉不相关的结果。</p>
<p>进入我们的综合<a href="https://milvus.io/docs/array_data_type.md">文档</a>，深入了解如何在 Milvus 中使用数组类型。</p>
<h2 id="Support-for-complex-delete-expressions---improving-your-data-management" class="common-anchor-header">支持复杂的删除表达式--改善您的数据管理<button data-href="#Support-for-complex-delete-expressions---improving-your-data-management" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在以前的版本中，Milvus 支持主键删除表达式，提供了稳定和精简的架构。使用 Milvus 2.3.2 或 2.3.3，用户可以采用复杂的删除表达式，促进复杂的数据管理任务，如基于用户 ID 的旧数据滚动清理或 GDPR 合规驱动的数据删除。</p>
<p>注意：在使用复杂表达式之前，请确保已加载了 Collections。此外，需要注意的是，删除过程不保证原子性。</p>
<h2 id="TiKV-integration---scalable-metadata-storage-with-stability" class="common-anchor-header">TiKV 集成--具有稳定性的可扩展元数据存储<button data-href="#TiKV-integration---scalable-metadata-storage-with-stability" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 以前依赖 Etcd 进行元数据存储，在元数据存储方面面临容量有限和可扩展性的挑战。为解决这些问题，Milvus 增加了开源键值存储 TiKV，作为元数据存储的又一选择。TiKV 具有更强的可扩展性、稳定性和效率，是满足 Milvus 不断发展的需求的理想解决方案。从 Milvus 2.3.2 开始，用户可以通过修改配置无缝过渡到 TiKV 作为元数据存储。</p>
<h2 id="Support-for-FP16-vector-type---embracing-machine-learning-efficiency" class="common-anchor-header">支持 FP16 向量类型--拥抱机器学习效率<button data-href="#Support-for-FP16-vector-type---embracing-machine-learning-efficiency" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.3.2 及更高版本现在在接口级支持 FP16 向量类型。FP16 或 16 位浮点是一种广泛应用于深度学习和机器学习的数据格式，可高效地表示和计算数值。虽然对 FP16 的全面支持正在进行中，但索引层中的各种索引需要在构建过程中将 FP16 转换为 FP32。</p>
<p>我们将在 Milvus 的后续版本中全面支持 FP16、BF16 和 int8 数据类型。敬请期待。</p>
<h2 id="Significant-improvement-in-the-rolling-upgrade-experience---seamless-transition-for-users" class="common-anchor-header">显著改善滚动升级体验--为用户提供无缝过渡<button data-href="#Significant-improvement-in-the-rolling-upgrade-experience---seamless-transition-for-users" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>滚动升级是分布式系统的一项重要功能，可在不中断业务服务或停机的情况下实现系统升级。在最新发布的 Milvus 版本中，我们加强了 Milvus 的滚动升级功能，确保用户从 2.2.15 版升级到 2.3.3 版及所有后续版本时，过渡更加简洁高效。社区还投入大量精力进行测试和优化，将升级过程中的查询影响降至 5 分钟以内，为用户提供无忧体验。</p>
<h2 id="Performance-optimization" class="common-anchor-header">性能优化<button data-href="#Performance-optimization" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>除了引入新功能，我们还在最新的两个版本中大幅优化了 Milvus 的性能。</p>
<ul>
<li><p>最小化数据复制操作，优化数据加载</p></li>
<li><p>使用批量 varchar 读取简化了大容量插入操作</p></li>
<li><p>删除了数据填充过程中不必要的偏移检查，以提高调用阶段的性能。</p></li>
<li><p>解决了在插入大量数据的情况下 CPU 消耗过高的问题</p></li>
</ul>
<p>这些优化 Collections 共同为更快、更高效的 Milvus 体验做出了贡献。查看我们的监控仪表板，快速了解 Milvus 是如何提高性能的。</p>
<h2 id="Incompatible-changes" class="common-anchor-header">不兼容的更改<button data-href="#Incompatible-changes" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p>永久删除 TimeTravel 相关代码。</p></li>
<li><p>不再支持 MySQL 作为元数据存储。</p></li>
</ul>
<p>有关所有新功能和增强功能的详细信息，请参阅<a href="https://milvus.io/docs/release_notes.md">Milvus 发行说明</a>。</p>
<h2 id="Conclusion" class="common-anchor-header">总结<button data-href="#Conclusion" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>通过最新的 Milvus 2.3.2 和 2.3.3 版本，我们致力于提供一个强大、功能丰富、高性能的数据库解决方案。探索这些新功能，利用优化功能，加入我们的旅程，让 Milvus 不断发展，以满足现代数据管理的需求。立即下载最新版本，体验 Milvus 数据存储的未来！</p>
<h2 id="Let’s-keep-in-touch" class="common-anchor-header">让我们保持联系！<button data-href="#Let’s-keep-in-touch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您有关于 Milvus 的问题或反馈，请加入我们的<a href="https://discord.com/invite/8uyFbECzPX">Discord 频道</a>，直接与我们的工程师和社区交流，或参加每周二下午 12:12:30 的<a href="https://discord.com/invite/RjNbk8RR4f">Milvus 社区午餐学习会</a>。也欢迎您在<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a>上关注我们，了解有关 Milvus 的最新消息和更新。</p>


揭秘 Milvus 2.3.2 和 2.3.3：支持数组数据类型、复杂删除、TiKV 集成等功能

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Exploring_M_Map_5086d652bd.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p><a href="https://zilliz.com/what-is-milvus">Milvus</a>是开源<a href="https://zilliz.com/blog/what-is-a-real-vector-database">向量数据库</a>中速度最快的解决方案，可满足用户对密集型性能的需求。然而，用户需求的多样性反映了他们所处理的数据的多样性。有些用户优先考虑预算友好型解决方案和大容量存储，而不是纯粹的速度。Milvus 了解这些需求，推出了 MMap 功能，重新定义了我们处理大数据量的方式，同时承诺在不牺牲功能的情况下实现成本效益。</p>
<h2 id="What-is-MMap" class="common-anchor-header">什么是 MMap？<button data-href="#What-is-MMap" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>MMap 是内存映射文件的简称，它在操作系统中的文件和内存之间架起了一座桥梁。这项技术允许 Milvus 将大型文件直接映射到系统内存空间，将文件转化为连续的内存块。这种整合消除了显式读取或写入操作的需要，从根本上改变了 Milvus Operator 管理数据的方式。它确保了大文件或用户需要随机访问文件的情况下的无缝访问和高效存储。</p>
<h2 id="Who-benefits-from-MMap" class="common-anchor-header">谁能从 MMap 中受益？<button data-href="#Who-benefits-from-MMap" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>由于向量数据的存储要求，向量数据库需要大量内存容量。有了 MMap 功能，在有限的内存中处理更多数据就成为现实。但是，这种能力的提高需要付出性能代价。系统会智能地管理内存，根据负载和使用情况驱逐部分数据。这种驱逐允许 Milvus 在相同内存容量下处理更多数据。</p>
<p>在测试过程中，我们发现在内存充足的情况下，所有数据在预热期后都会驻留在内存中，从而保持了系统性能。但是，随着数据量的增加，性能会逐渐下降。<strong>因此，我们建议对性能波动不太敏感的用户使用 MMap 功能。</strong></p>
<h2 id="Enabling-MMap-in-Milvus-a-simple-configuration" class="common-anchor-header">在 Milvus 中启用 MMap：简单配置<button data-href="#Enabling-MMap-in-Milvus-a-simple-configuration" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 Milvus 中启用 MMap 非常简单。您只需修改<code translate="no">milvus.yaml</code> 文件：在<code translate="no">queryNode</code> 配置下添加<code translate="no">mmapDirPath</code> 项，并将有效路径设为其值。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/enabling_mmap_a2df88276b.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<h2 id="Striking-the-balance-performance-storage-and-system-limits" class="common-anchor-header">取得平衡：性能、存储和系统限制<button data-href="#Striking-the-balance-performance-storage-and-system-limits" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>数据访问模式对性能有很大影响。Milvus 的 MMap 功能可根据位置优化数据访问。MMap 使 Milvus 能够将顺序访问数据段的标量数据直接写入磁盘。字符串等长度可变的数据会被扁平化，并使用内存中的偏移数组进行索引。这种方法确保了数据访问的本地性，并消除了单独存储每个变长数据的开销。对向量索引的优化非常细致。MMap 有选择地用于向量数据，同时在内存中保留邻接表，在不影响性能的情况下节省了大量内存。</p>
<p>此外，MMap 还能最大限度地减少内存使用量，从而提高数据处理效率。与以前的 Milvus 版本不同的是，QueryNode 会复制整个数据集，而 MMap 在开发过程中采用了简化的无复制流式处理。这种优化大大减少了内存开销。</p>
<p><strong>我们的内部测试结果表明，启用 MMap 后，Milvus 可以高效处理双倍的数据量。</strong></p>
<h2 id="The-road-ahead-continuous-innovation-and-user-centric-enhancements" class="common-anchor-header">未来之路：持续创新和以用户为中心的增强功能<button data-href="#The-road-ahead-continuous-innovation-and-user-centric-enhancements" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>虽然 MMap 功能还处于测试阶段，但 Milvus 团队致力于不断改进。未来的更新将完善系统的内存使用情况，使 Milvus 能够在单个节点上支持更大的数据量。用户可以预期对 MMap 功能进行更细粒度的控制，实现对 Collections 的动态更改和高级字段加载模式。这些增强功能提供了前所未有的灵活性，使用户能够根据具体要求定制数据处理策略。</p>
<h2 id="Conclusion-redefining-data-processing-excellence-with-Milvus-MMap" class="common-anchor-header">结论：用 Milvus MMap 重新定义卓越的数据处理能力<button data-href="#Conclusion-redefining-data-processing-excellence-with-Milvus-MMap" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.3 的 MMap 功能标志着数据处理技术的重大飞跃。通过在性能、成本和系统限制之间取得微妙的平衡，Milvus 使用户能够高效、经济地处理海量数据。随着 Milvus 的不断发展，它将继续走在创新解决方案的前沿，重新定义数据管理的极限。</p>
<p>Milvus 将继续向无与伦比的卓越数据处理迈进，敬请期待更多突破性发展。</p>


Milvus 推出 MMap，重新定义数据管理并提高存储能力

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Vector_Databases_vs_Vector_Search_Plugins_vs_Vector_Search_Libraries_74def521ad.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>大家好--欢迎回到向量数据库 101！</p>
<p><a href="https://zilliz.com/learn/ChatGPT-Vector-Database-Prompt-as-code">ChatGPT</a>和其他大型语言模型（LLMs）的迅猛发展推动了向量搜索技术的发展，其中包括<a href="https://zilliz.com/what-is-milvus">Milvus</a>和<a href="https://zilliz.com/cloud">Zilliz Cloud</a>等专业向量数据库，以及<a href="https://zilliz.com/blog/set-up-with-facebook-ai-similarity-search-faiss">FAISS</a>等库和传统数据库中的集成向量搜索插件。</p>
<p>在<a href="https://zilliz.com/learn/what-is-vector-database">上一篇系列文章</a>中，我们深入探讨了向量数据库的基本原理。在这篇文章中，我们将继续探索矢量搜索的复杂领域，比较矢量数据库、矢量搜索插件和矢量搜索库。</p>
<h2 id="What-is-vector-search" class="common-anchor-header">什么是向量搜索？<button data-href="#What-is-vector-search" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>向量<a href="https://zilliz.com/learn/vector-similarity-search">搜索</a>又称向量相似性搜索，是一种在大量密集向量数据 Collections 中检索与给定查询向量最相似或语义最相关的 top-k 结果的技术。在进行相似性搜索之前，我们利用神经网络将文本、图像、视频和音频等<a href="https://zilliz.com/learn/introduction-to-unstructured-data">非结构化数据</a>转化为高维数字向量，称为嵌入向量。生成嵌入向量后，向量搜索引擎会比较输入查询向量与向量存储中的向量之间的空间距离。它们在空间上的距离越近，相似度就越高。</p>
<p>市场上有多种向量搜索技术，包括 Python 的 NumPy 等机器学习库、FAISS 等向量搜索库、建立在传统数据库上的向量搜索插件，以及 Milvus 和 Zilliz Cloud 等专业向量数据库。</p>
<h2 id="Vector-databases-vs-vector-search-libraries" class="common-anchor-header">向量数据库与向量搜索库的比较<button data-href="#Vector-databases-vs-vector-search-libraries" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://zilliz.com/blog/what-is-a-real-vector-database">专业矢量数据库</a>并不是相似性搜索的唯一堆栈。在向量数据库出现之前，FAISS、ScaNN 和 HNSW 等许多向量搜索库都用于向量检索。</p>
<p>向量搜索库可以帮助你快速构建高性能的向量搜索原型系统。以 FAISS 为例，它是开源的，由 Meta 公司开发，用于高效的相似性搜索和密集向量聚类。FAISS 可以处理任何大小的向量 Collections，甚至可以处理那些无法完全加载到内存中的向量 Collections。此外，FAISS 还提供了评估和参数调整工具。尽管 FAISS 是用 C++ 编写的，但它提供了 Python/NumPy 接口。</p>
<p>不过，向量搜索库只是轻量级 ANN 库，而不是托管解决方案，而且功能有限。如果您的数据集较小且有限，这些库足以满足非结构化数据处理的需要，甚至对于在生产中运行的系统也是如此。但是，随着数据集规模的扩大和更多用户的加入，规模问题变得越来越难以解决。此外，它们不允许对索引数据进行任何修改，也不能在数据导入时进行查询。</p>
<p>相比之下，向量数据库是非结构化数据存储和检索的更优解决方案。它们可以存储和查询数百万甚至数十亿个向量，同时提供实时响应；它们具有很强的可扩展性，可以满足用户不断增长的业务需求。</p>
<p>此外，Milvus 等向量数据库对于结构化/半结构化数据具有更多用户友好的功能：云计算性、多租户、可扩展性等。当我们深入学习本教程时，这些功能将变得更加清晰。</p>
<p>它们的操作抽象层也与向量搜索库完全不同--向量数据库是完全成熟的服务，而 ANN 库则是要集成到您正在开发的应用程序中。从这个意义上说，ANN 库是向量数据库构建在其之上的众多组件之一，这与 Elasticsearch 构建在 Apache Lucene 之上的情况类似。</p>
<p>为了举例说明为什么这种抽象如此重要，让我们来看看在向量数据库中插入一个新的非结构化数据元素。这在 Milvus 中超级简单：</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> <span class="hljs-title class_">Collectioncollection</span> = <span class="hljs-title class_">Collection</span>(<span class="hljs-string">&#x27;book&#x27;</span>)mr = collection.<span class="hljs-title function_">insert</span>(data)
<button class="copy-code-btn"></button></code></pre>
<p>只需 3 行代码。遗憾的是，对于 FAISS 或 ScaNN 这样的库，如果不在某些检查点手动重新创建整个索引，就无法轻松实现这一功能。即使可以，向量搜索库仍然缺乏可扩展性和多租户性，而这是向量数据库最重要的两个功能。</p>
<h2 id="Vector-databases-vs-vector-search-plugins-for-traditional-databases" class="common-anchor-header">向量数据库与传统数据库的向量搜索插件对比<button data-href="#Vector-databases-vs-vector-search-plugins-for-traditional-databases" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>很好，既然我们已经确定了向量搜索库和向量数据库之间的区别，那么让我们来看看向量数据库与<strong>向量搜索插件</strong>有何不同。</p>
<p>越来越多的传统关系型数据库，以及 Clickhouse 和<a href="https://zilliz.com/blog/elasticsearch-cloud-vs-zilliz">Elasticsearch</a>等搜索系统都包含了内置的向量搜索插件。例如，Elasticsearch 8.0 包括向量插入和 ANN 搜索功能，可以通过 restful API 端点调用。矢量搜索插件的问题应该是一目了然的--<strong>这些解决方案并没有采用全栈方法来进行嵌入管理和矢量搜索</strong>。相反，这些插件的目的是在现有架构的基础上进行增强，从而使其具有局限性和未优化性。在传统数据库上开发非结构化数据应用程序，就好比试图在汽油动力汽车的框架内安装锂电池和电动马达，这不是一个好主意！</p>
<p>为了说明原因，让我们回到向量数据库应实现的功能列表（从第一部分开始）。向量搜索插件缺少其中的两个功能--可调性和用户友好的 API/SDK。我将继续以 Elasticsearch 的 ANN 引擎为例；其他向量搜索插件的操作非常类似，因此我就不再过多赘述了。Elasticsearch 通过<code translate="no">dense_vector</code> 数据字段类型支持向量存储，并允许通过<code translate="no">knnsearch endpoint</code> 进行查询：</p>
<pre><code translate="no" class="language-json">PUT index
{
<span class="hljs-string">&quot;mappings&quot;</span>: {
  <span class="hljs-string">&quot;properties&quot;</span>: {
    <span class="hljs-string">&quot;image-vector&quot;</span>: {
      <span class="hljs-string">&quot;type&quot;</span>: <span class="hljs-string">&quot;dense_vector&quot;</span>,
      <span class="hljs-string">&quot;dims&quot;</span>: 128,
      <span class="hljs-string">&quot;index&quot;</span>: <span class="hljs-literal">true</span>,
      <span class="hljs-string">&quot;similarity&quot;</span>: <span class="hljs-string">&quot;l2_norm&quot;</span>
    }
  }
}
}


PUT index/_doc
{
<span class="hljs-string">&quot;image-vector&quot;</span>: [0.12, 1.34, ...]
}
<button class="copy-code-btn"></button></code></pre>
<pre><code translate="no" class="language-json">GET index/_knn_search
{
<span class="hljs-string">&quot;knn&quot;</span>: {
  <span class="hljs-string">&quot;field&quot;</span>: <span class="hljs-string">&quot;image-vector&quot;</span>,
  <span class="hljs-string">&quot;query_vector&quot;</span>: [-0.5, 9.4, ...],
  <span class="hljs-string">&quot;k&quot;</span>: 10,
  <span class="hljs-string">&quot;num_candidates&quot;</span>: 100
}
}
<button class="copy-code-btn"></button></code></pre>
<p>Elasticsearch 的 ANN 插件只支持一种索引算法：分层导航小世界（Hierarchical Navigable Small Worlds），又称 HNSW（我想，在普及多元宇宙方面，创造者走在了漫威的前面）。除此之外，它只支持 L2/Euclidean 距离作为距离度量。这是一个不错的开端，但让我们把它与完整的向量数据库 Milvus 进行比较。使用<code translate="no">pymilvus</code> ：</p>
<pre><code translate="no" class="language-python"><span class="hljs-meta">&gt;&gt;&gt; </span>field1 = FieldSchema(name=<span class="hljs-string">&#x27;id&#x27;</span>, dtype=DataType.INT64, description=<span class="hljs-string">&#x27;int64&#x27;</span>, is_primary=<span class="hljs-literal">True</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>field2 = FieldSchema(name=<span class="hljs-string">&#x27;embedding&#x27;</span>, dtype=DataType.FLOAT_VECTOR, description=<span class="hljs-string">&#x27;embedding&#x27;</span>, dim=<span class="hljs-number">128</span>, is_primary=<span class="hljs-literal">False</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>schema = CollectionSchema(fields=[field1, field2], description=<span class="hljs-string">&#x27;hello world collection&#x27;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>collection = Collection(name=<span class="hljs-string">&#x27;my_collection&#x27;</span>, data=<span class="hljs-literal">None</span>, schema=schema)
<span class="hljs-meta">&gt;&gt;&gt; </span>index_params = {
       <span class="hljs-string">&#x27;index_type&#x27;</span>: <span class="hljs-string">&#x27;IVF_FLAT&#x27;</span>,
       <span class="hljs-string">&#x27;params&#x27;</span>: {<span class="hljs-string">&#x27;nlist&#x27;</span>: <span class="hljs-number">1024</span>},
       <span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&#x27;L2&#x27;</span>}
<span class="hljs-meta">&gt;&gt;&gt; </span>collection.create_index(<span class="hljs-string">&#x27;embedding&#x27;</span>, index_params)
<button class="copy-code-btn"></button></code></pre>
<pre><code translate="no" class="language-python"><span class="hljs-meta">&gt;&gt;&gt; </span>search_param = {
       <span class="hljs-string">&#x27;data&#x27;</span>: vector,
       <span class="hljs-string">&#x27;anns_field&#x27;</span>: <span class="hljs-string">&#x27;embedding&#x27;</span>,
       <span class="hljs-string">&#x27;param&#x27;</span>: {<span class="hljs-string">&#x27;metric_type&#x27;</span>: <span class="hljs-string">&#x27;L2&#x27;</span>, <span class="hljs-string">&#x27;params&#x27;</span>: {<span class="hljs-string">&#x27;nprobe&#x27;</span>: <span class="hljs-number">16</span>}},
       <span class="hljs-string">&#x27;limit&#x27;</span>: <span class="hljs-number">10</span>,
       <span class="hljs-string">&#x27;expr&#x27;</span>: <span class="hljs-string">&#x27;id_field &gt; 0&#x27;</span>
   }
<span class="hljs-meta">&gt;&gt;&gt; </span>results = collection.search(**search_param)
<button class="copy-code-btn"></button></code></pre>
<p>虽然<a href="https://zilliz.com/comparison/elastic-vs-milvus">Elasticsearch 和 Milvus</a>都有创建索引、插入嵌入向量和执行近邻搜索的方法，但从这些示例中可以明显看出，Milvus 拥有更直观的向量搜索 API（更好的面向用户的 API）和更广泛的向量索引 + 距离度量支持（更好的可调性）。Milvus 还计划在未来支持更多向量索引，并允许通过类似 SQL 的语句进行查询，从而进一步提高可调性和可用性。</p>
<p>我们刚刚介绍了很多内容。这部分内容确实比较长，所以对于那些略读过这部分内容的人来说，我在这里简要地说一下：Milvus 比向量搜索插件更好，因为 Milvus 从一开始就是作为向量数据库构建的，因此具有更丰富的功能和更适合非结构化数据的架构。</p>
<h2 id="How-to-choose-from-different-vector-search-technologies" class="common-anchor-header">如何从不同的向量搜索技术中进行选择？<button data-href="#How-to-choose-from-different-vector-search-technologies" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>并不是所有的向量数据库都是一样的；每种数据库都具有迎合特定应用的独特特征。矢量搜索库和插件对用户友好，非常适合处理拥有数百万矢量的小规模生产环境。如果您的数据规模较小，只需要基本的向量搜索功能，这些技术就足以满足您的业务需求。</p>
<p>但是，对于处理数亿矢量数据并要求实时响应的数据密集型企业来说，专业的矢量数据库应该是您的首选。例如，Milvus 可以毫不费力地管理数十亿个向量，提供快如闪电的查询速度和丰富的功能。此外，像 Zilliz 这样的全面管理解决方案证明更具优势，它能将您从操作挑战中解放出来，专注于您的核心业务活动。</p>
<h2 id="Take-another-look-at-the-Vector-Database-101-courses" class="common-anchor-header">再看看向量数据库 101 课程<button data-href="#Take-another-look-at-the-Vector-Database-101-courses" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ol>
<li><a href="https://zilliz.com/blog/introduction-to-unstructured-data">非结构化数据简介</a></li>
<li><a href="https://zilliz.com/learn/what-is-vector-database">什么是向量数据库？</a></li>
<li><a href="https://zilliz.com/learn/comparing-vector-database-vector-search-library-and-vector-search-plugin">比较向量数据库、向量搜索库和向量搜索插件</a></li>
<li><a href="https://zilliz.com/blog/introduction-to-milvus-vector-database">Milvus 简介</a></li>
<li><a href="https://zilliz.com/blog/milvus-vector-database-quickstart">Milvus 快速入门</a></li>
<li><a href="https://zilliz.com/blog/vector-similarity-search">向量相似性搜索简介</a></li>
<li><a href="https://zilliz.com/blog/vector-index">向量索引基础和反转文件索引</a></li>
<li><a href="https://zilliz.com/blog/scalar-quantization-and-product-quantization">标量量化和乘积量化</a></li>
<li><a href="https://zilliz.com/blog/hierarchical-navigable-small-worlds-HNSW">分层可导航小世界（HNSW）</a></li>
<li><a href="https://zilliz.com/learn/approximate-nearest-neighbor-oh-yeah-ANNOY">近似最近邻（ANNOY）</a></li>
<li><a href="https://zilliz.com/learn/choosing-right-vector-index-for-your-project">为项目选择合适的向量索引</a></li>
<li><a href="https://zilliz.com/learn/DiskANN-and-the-Vamana-Algorithm">DiskANN 和 Vamana 算法</a></li>
</ol>


比较向量数据库、向量搜索库和向量搜索插件

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Ingesting_Chaos_20231017_110103_54fe2009cb.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>以各种可以想象到的形式生成数据的速度比以往任何时候都快。这些数据是推动新一轮人工智能应用的汽油，但这些提高生产力的引擎需要帮助来摄取这些燃料。围绕非结构化数据的各种应用场景和边缘案例使其在生产型人工智能系统中的应用充满挑战。</p>
<p>首先，有大量的数据源。这些数据源以各种文件格式输出数据，每种格式都有其独特之处。例如，处理 PDF 文件的方式因其来源而大不相同。为证券诉讼案件输入 PDF 文件时，可能会侧重于文本数据。相比之下，火箭工程师的系统设计说明书则充满了需要可视化处理的图表。非结构化数据缺乏确定的 Schema，进一步增加了复杂性。即使克服了处理数据的难题，大规模采集数据的问题依然存在。文件的大小可能相差很大，这就改变了文件的处理方式。您可以通过 HTTP API 快速处理 1MB 的上传数据，但从单个文件中读取数十 GB 的数据则需要流式处理和专用工作者。</p>
<p>对于通过<a href="https://github.com/milvus-io/milvus">Milvus</a> 等<a href="https://zilliz.com/learn/what-is-vector-database">向量数据库</a>将原始数据连接到<a href="https://zilliz.com/glossary/large-language-models-(llms)">LLMs</a>来说，克服这些传统的数据工程挑战是小菜一碟。但是，借助向量数据库执行语义相似性搜索等新兴用例需要新的处理步骤，如对源数据进行分块、为混合搜索协调元数据、选择合适的向量嵌入模型以及调整搜索参数以确定向 LLM 输入哪些数据。这些工作流程非常新颖，没有既定的最佳实践可供开发人员遵循。相反，他们必须通过实验来找到适合其数据的正确配置和用例。为了加快这一过程，使用向量嵌入管道将数据摄入向量数据库是非常有价值的。</p>
<p>像<a href="https://github.com/dgarnitz/vectorflow">VectorFlow</a>这样的向量嵌入管道将把原始数据连接到向量数据库，包括分块、元数据协调、嵌入和上传。VectorFlow 使工程团队能够专注于核心应用逻辑，试验从嵌入模型、分块策略、元数据字段和搜索的各个方面生成的不同检索参数，看看哪种性能最好。</p>
<p>在帮助工程团队将<a href="https://zilliz.com/use-cases/llm-retrieval-augmented-generation">检索增强生成（RAG）</a>系统从原型推向生产的过程中，我们发现以下方法可以成功测试 RAG 搜索管道的不同参数：</p>
<ol>
<li>使用一小部分你熟悉的数据来加快迭代速度，比如一些 PDF 文件，其中有与搜索查询相关的数据块。</li>
<li>针对该数据子集制定一套标准的问题和答案。例如，在阅读 PDF 文件后，编写一份问题清单，然后让团队商定答案。</li>
<li>创建一个自动评估系统，对每个问题的检索结果进行评分。其中一种方法是从 RAG 系统中获取答案，并通过 LLM 进行回放，同时提示 RAG 结果是否回答了给出的正确答案。答案应为 "是 "或 "否"。例如，如果您的文档上有 25 个问题，而系统得到了 20 个正确答案，那么您就可以以此为基准与其他方法进行比较。</li>
<li>确保在评估时使用的 LLM 与对数据库中存储的向量 Embeddings 进行编码时使用的 LLM 不同。评估 LLM 通常是解码器类型的模型，如 GPT-4。需要记住的一点是，重复运行这些评估的成本很高。像 Llama2 70B 或 Deci AI LLM 6B 这样的开源模型，可以在单个较小的 GPU 上运行，其性能大致相同，而成本只是其一小部分。</li>
<li>将每个测试运行多次，取平均值来平滑 LLM 的随机性。</li>
</ol>
<p>在所有选项都保持不变的情况下，您可以快速确定哪些参数最适合您的使用情况。像 VectorFlow 这样的向量嵌入管道可以让摄取方面的工作变得尤为简单，你可以快速尝试不同的分块策略、分块长度、分块重叠和开源嵌入模型，看看哪种方法能带来最好的结果。当你的数据集有各种文件类型和数据源，需要自定义逻辑时，这一点尤其有用。</p>
<p>一旦团队知道什么适合其用例，向量嵌入流水线就能让他们快速投入生产，而无需重新设计系统来考虑可靠性和监控等问题。借助 VectorFlow 和<a href="https://zilliz.com/what-is-milvus">Milvus</a> 等开源和平台无关的技术，团队可以在不同环境中高效地进行测试，同时遵守隐私和安全要求。</p>


摄取混乱：为 RAG 大规模可靠处理非结构化数据背后的 MLOps

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Why_you_need_a_real_vector_database2_20230830_075505_1_4b32582c87.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p><em>本文最初发表于<a href="https://www.aiacceleratorinstitute.com/why-and-when-do-you-need-a-purpose-built-vector-database/">AIAI</a>，经授权在此转发。</em></p>
<p><a href="https://zilliz.com/learn/ChatGPT-Vector-Database-Prompt-as-code">ChatGPT</a>和其他大型语言模型 (LLM) 的日益普及推动了向量搜索技术的兴起，其中包括<a href="https://milvus.io/docs/overview.md">Milvus</a>和<a href="https://zilliz.com/cloud">Zilliz Cloud</a> 等专用向量数据库、<a href="https://zilliz.com/blog/set-up-with-facebook-ai-similarity-search-faiss">FAISS</a> 等向量搜索库以及与传统数据库集成的向量搜索插件。然而，选择满足您需求的最佳解决方案可能具有挑战性。就像在高端餐厅和快餐连锁店之间做出选择一样，选择合适的矢量搜索技术取决于您的需求和期望。</p>
<p>在本篇文章中，我将概述矢量搜索及其功能，比较不同的矢量搜索技术，并解释为什么选择专用的矢量数据库至关重要。</p>
<h2 id="What-is-vector-search-and-how-does-it-work" class="common-anchor-header">什么是向量搜索，它是如何工作的？<button data-href="#What-is-vector-search-and-how-does-it-work" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>向量<a href="https://zilliz.com/blog/vector-similarity-search">搜索</a>又称向量相似性搜索，是一种在大量密集向量数据 Collections 中检索与给定查询向量最相似或语义最相关的 top-k 结果的技术。</p>
<p>在进行相似性搜索之前，我们先利用神经网络将文本、图像、视频和音频等<a href="https://zilliz.com/blog/introduction-to-unstructured-data">非结构化数据</a>转化为称为 Embeddings 向量的高维数值向量。例如，我们可以使用预先训练好的 ResNet-50 卷积神经网络，将鸟类图像转化为 2048 维的嵌入向量 Collections。在此，我们列出前三个和后三个向量元素：<code translate="no">[0.1392, 0.3572, 0.1988, ..., 0.2888, 0.6611, 0.2909]</code> 。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/bird_image_4a1be18f99.png" alt="A bird image by Patrice Bouchard" class="doc-image" id="a-bird-image-by-patrice-bouchard" />
   </span> <span class="img-wrapper"> <span>Patrice Bouchard 拍摄的鸟类图像</span> </span></p>
<p>生成嵌入向量后，向量搜索引擎会比较输入查询向量和向量存储中的向量之间的空间距离。它们在空间上的距离越近，相似度就越高。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Frame_3732_20230510_073643_25f985523e.png" alt="Embedding arithmetic" class="doc-image" id="embedding-arithmetic" />
   </span> <span class="img-wrapper"> <span>嵌入运算</span> </span></p>
<h2 id="Popular-vector-search-technologies" class="common-anchor-header">流行的向量搜索技术<button data-href="#Popular-vector-search-technologies" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>市场上有多种向量搜索技术，包括 Python 的 NumPy 等机器学习库、FAISS 等向量搜索库、基于传统数据库构建的向量搜索插件，以及 Milvus 和 Zilliz Cloud 等专业向量数据库。</p>
<h3 id="Machine-learning-libraries" class="common-anchor-header">机器学习库</h3><p>使用机器学习库是实现向量搜索的最简单方法。例如，我们可以使用 Python 的 NumPy 在 20 行代码以内实现近邻算法。</p>
<pre><code translate="no"><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np

<span class="hljs-comment"># Function to calculate euclidean distance</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">euclidean_distance</span>(<span class="hljs-params">a, b</span>):
<span class="hljs-keyword">return</span> np.linalg.norm(a - b)

<span class="hljs-comment"># Function to perform knn</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">knn</span>(<span class="hljs-params">data, target, k</span>):
<span class="hljs-comment"># Calculate distances between target and all points in the data</span>
distances = [euclidean_distance(d, target) <span class="hljs-keyword">for</span> d <span class="hljs-keyword">in</span> data]
<span class="hljs-comment"># Combine distances with data indices</span>
distances = np.array(<span class="hljs-built_in">list</span>(<span class="hljs-built_in">zip</span>(distances, np.arange(<span class="hljs-built_in">len</span>(data)))))

<span class="hljs-comment"># Sort by distance</span>
sorted_distances = distances[distances[:, <span class="hljs-number">0</span>].argsort()]

<span class="hljs-comment"># Get the top k closest indices</span>
closest_k_indices = sorted_distances[:k, <span class="hljs-number">1</span>].astype(<span class="hljs-built_in">int</span>)

<span class="hljs-comment"># Return the top k closest vectors</span>
<span class="hljs-keyword">return</span> data[closest_k_indices]
<button class="copy-code-btn"></button></code></pre>
<p>我们可以生成 100 个二维向量，并找到向量 [0.5, 0.5] 的最近邻。</p>
<pre><code translate="no"><span class="hljs-comment"># Define some 2D vectors</span>
data = np.random.rand(<span class="hljs-number">100</span>, <span class="hljs-number">2</span>)

<span class="hljs-comment"># Define a target vector</span>
target = np.array([<span class="hljs-number">0.5</span>, <span class="hljs-number">0.5</span>])

<span class="hljs-comment"># Define k</span>
k = <span class="hljs-number">3</span>

<span class="hljs-comment"># Perform knn</span>
closest_vectors = knn(data, target, k)

<span class="hljs-comment"># Print the result</span>
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;The closest vectors are:&quot;</span>)
<span class="hljs-built_in">print</span>(closest_vectors)
<button class="copy-code-btn"></button></code></pre>
<p>机器学习库（如 Python 的 NumPy）以低成本提供了极大的灵活性。不过，它们也有一些局限性。例如，它们只能处理少量数据，而且不能确保数据的持久性。</p>
<p>我只建议在以下情况下使用 NumPy 或其他机器学习库进行向量搜索：</p>
<ul>
<li>需要快速建立原型。</li>
<li>不关心数据持久性。</li>
<li>数据量小于一百万，不需要标量过滤。</li>
<li>不需要高性能。</li>
</ul>
<h3 id="Vector-search-libraries" class="common-anchor-header">向量搜索库</h3><p>向量搜索库可以帮助您快速构建高性能的向量搜索原型系统。FAISS 就是一个典型的例子。它是开源的，由 Meta 公司开发，用于高效的相似性搜索和密集向量聚类。FAISS 可以处理任何大小的向量 Collections，甚至可以处理那些无法完全加载到内存中的向量 Collections。此外，FAISS 还提供了评估和参数调整工具。尽管 FAISS 是用 C++ 编写的，但它提供了 Python/NumPy 接口。</p>
<p>下面是基于 FAISS 的向量搜索示例代码：</p>
<pre><code translate="no"><span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np
<span class="hljs-keyword">import</span> faiss

<span class="hljs-comment"># Generate some example data</span>
dimension = <span class="hljs-number">64</span> <span class="hljs-comment"># dimension of the vector space</span>
database_size = <span class="hljs-number">10000</span> <span class="hljs-comment"># size of the database</span>
query_size = <span class="hljs-number">100</span> <span class="hljs-comment"># number of queries to perform</span>
np.random.seed(<span class="hljs-number">123</span>) <span class="hljs-comment"># make the random numbers predictable</span>

<span class="hljs-comment"># Generating vectors to index in the database (db_vectors)</span>
db_vectors = np.random.random((database_size, dimension)).astype(<span class="hljs-string">&#x27;float32&#x27;</span>)

<span class="hljs-comment"># Generating vectors for query (query_vectors)</span>
query_vectors = np.random.random((query_size, dimension)).astype(<span class="hljs-string">&#x27;float32&#x27;</span>)

<span class="hljs-comment"># Building the index</span>
index = faiss.IndexFlatL2(dimension) <span class="hljs-comment"># using the L2 distance metric</span>
<span class="hljs-built_in">print</span>(index.is_trained) <span class="hljs-comment"># should return True</span>

<span class="hljs-comment"># Adding vectors to the index</span>
index.add(db_vectors)
<span class="hljs-built_in">print</span>(index.ntotal) <span class="hljs-comment"># should return database_size (10000)</span>

<span class="hljs-comment"># Perform a search</span>
k = <span class="hljs-number">4</span> <span class="hljs-comment"># we want to see 4 nearest neighbors</span>
distances, indices = index.search(query_vectors, k)

<span class="hljs-comment"># Print the results</span>
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Indices of nearest neighbors: \n&quot;</span>, indices)
<span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;\nL2 distances to the nearest neighbors: \n&quot;</span>, distances)
<button class="copy-code-btn"></button></code></pre>
<p>FAISS 等矢量搜索库易于使用，速度快，足以处理拥有数百万矢量的小规模生产环境。您可以利用量化和 GPU 以及减少数据维度来提高它们的查询性能。</p>
<p>不过，这些库在生产环境中使用时有一些限制。例如，FAISS 不支持实时数据添加和删除、远程调用、多语言、标量过滤、可扩展性或灾难恢复。</p>
<h3 id="Different-types-of-vector-databases" class="common-anchor-header">不同类型的向量数据库</h3><p>向量数据库的出现解决了上述库的局限性，为生产应用提供了更全面、更实用的解决方案。</p>
<p>目前战场上有四种类型的向量数据库：</p>
<ul>
<li>集成了向量搜索插件的现有关系型或列型数据库。PG Vector 就是一个例子。</li>
<li>支持密集向量索引的传统倒排索引搜索引擎。<a href="https://zilliz.com/comparison/elastic-vs-milvus">ElasticSearch</a>就是一个例子。</li>
<li>基于向量搜索库构建的轻量级向量数据库。Chroma 就是一个例子。</li>
<li><strong>专用向量数据库</strong>。这类数据库专门为向量搜索而设计，并自下而上地进行了优化。专用向量数据库通常提供更先进的功能，包括分布式计算、灾难恢复和数据持久性。<a href="https://zilliz.com/what-is-milvus">Milvus</a>就是一个主要的例子。</li>
</ul>
<p>并非所有的向量数据库都是一样的。每个堆栈都有独特的优势和局限性，因此或多或少适合不同的应用。</p>
<p>与其他解决方案相比，我更喜欢专用向量数据库，因为它们是最高效、最方便的选择，具有众多独特优势。在下面的章节中，我将以 Milvus 为例，解释我偏爱的原因。</p>
<h2 id="Key-benefits-of-purpose-built-vector-databases" class="common-anchor-header">专用向量数据库的主要优势<button data-href="#Key-benefits-of-purpose-built-vector-databases" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://milvus.io/">Milvus</a>是一个开源、分布式的专用向量数据库，可以存储、索引、管理和检索数十亿个嵌入向量。它也是用于<a href="https://zilliz.com/use-cases/llm-retrieval-augmented-generation">LLM 检索增强生成的</a>最受欢迎的向量数据库之一。作为专门构建的向量数据库的典范实例，Milvus 与其同行共享许多独特的优势。</p>
<h3 id="Data-Persistence-and-Cost-Effective-Storage" class="common-anchor-header">数据持久性和低成本存储</h3><p>虽然防止数据丢失是对数据库的最低要求，但许多单机和轻量级向量数据库并不把数据可靠性放在首位。相比之下，<a href="https://zilliz.com/what-is-milvus">Milvus</a>等专门构建的分布式向量数据库通过分离存储和计算，优先考虑了系统弹性、可扩展性和数据持久性。</p>
<p>此外，大多数利用近似近邻（ANN）索引的向量数据库都需要大量内存来执行向量搜索，因为它们将 ANN 索引纯粹加载到内存中。然而，Milvus 支持磁盘索引，使存储的成本效益比内存索引高十倍以上。</p>
<h3 id="Optimal-Query-Performance" class="common-anchor-header">最佳查询性能</h3><p>与其他向量搜索方案相比，专门的向量数据库可提供最佳的查询性能。例如，Milvus 处理查询的速度比向量搜索插件快十倍。Milvus 使用<a href="https://zilliz.com/glossary/anns">ANN 算法</a>而不是 KNN 野蛮搜索算法，以实现更快的向量搜索。此外，Milvus 还对索引进行碎片化处理，从而在数据量增加时减少构建索引所需的时间。这种方法使 Milvus 能够轻松处理数十亿向量的实时数据增删。相比之下，其他向量搜索插件只适用于数据量少于数千万、添加和删除不频繁的场景。</p>
<p>Milvus 还支持 GPU 加速。内部测试显示，在搜索数千万数据时，GPU 加速的向量索引可达到 10,000+ QPS，在单机查询性能上比传统的 CPU 索引至少快十倍。</p>
<h3 id="System-Reliability" class="common-anchor-header">系统可靠性</h3><p>许多应用使用向量数据库进行在线查询，要求低查询延迟和高吞吐量。这些应用要求在分钟级进行单机故障切换，有些甚至要求在关键场景下进行跨区域灾难恢复。基于 Raft/Paxos 的传统复制策略存在严重的资源浪费问题，并且需要帮助预先分片数据，导致可靠性较差。相比之下，Milvus 采用分布式架构，利用 K8s 消息队列实现高可用性，缩短了恢复时间，节省了资源。</p>
<h3 id="Operability-and-Observability" class="common-anchor-header">操作符和可观察性</h3><p>为了更好地服务企业用户，向量数据库必须提供一系列企业级功能，以获得更好的操作符和可观察性。Milvus 支持多种部署方法，包括 K8s Operator 和 Helm 图表、docker-compose 和 pip install，使不同需求的用户都能使用。Milvus 还提供了基于 Grafana、Prometheus 和 Loki 的监控和报警系统，提高了其可观察性。Milvus 采用分布式云原生架构，是业界首个支持多租户隔离、RBAC、配额限制和滚动升级的向量数据库。所有这些方法都使 Milvus 的管理和监控变得更加简单。</p>
<h2 id="Getting-started-with-Milvus-in-3-simple-steps-within-10-minutes" class="common-anchor-header">在 10 分钟内通过 3 个简单步骤开始使用 Milvus<button data-href="#Getting-started-with-Milvus-in-3-simple-steps-within-10-minutes" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>建立向量数据库是一项复杂的任务，但使用向量数据库就像使用 Numpy 和 FAISS 一样简单。即使是不熟悉人工智能的学生，也能在短短十分钟内基于 Milvus 实现向量搜索。要体验高度可扩展和高性能的向量搜索服务，请遵循以下三个步骤：</p>
<ul>
<li>借助 Milvus<a href="https://milvus.io/docs/install_standalone-docker.md">部署文档</a>在服务器上部署 Milvus。</li>
<li>参考<a href="https://milvus.io/docs/example_code.md">Hello Milvus 文档</a>，仅用 50 行代码实现向量搜索。</li>
<li>探索<a href="https://github.com/towhee-io/examples/">Towhee 的示例文档</a>，深入了解<a href="https://zilliz.com/use-cases">向量数据库的</a>流行<a href="https://zilliz.com/use-cases">用例</a>。</li>
</ul>


为什么以及何时需要专用向量数据库？

揭开 Milvus 2.3 的神秘面纱：支持 GPU、Arm64、CDC 和其他许多备受期待的功能的里程碑式版本

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/What_s_New_in_2_2_12_20230720_143424_7d19280738.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>我们非常高兴地宣布 Milvus 2.2.12 的最新发布。此次更新包括多个新功能，如支持 RESTful API、<code translate="no">json_contains</code> 功能以及 ANN 搜索过程中的向量检索，以回应用户反馈。我们还简化了用户体验，提高了向量搜索速度，并解决了许多问题。让我们深入了解一下 Milvus 2.2.12 的功能。</p>
<h2 id="Support-for-RESTful-API" class="common-anchor-header">支持 RESTful API<button data-href="#Support-for-RESTful-API" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.2.12 现在支持 RESTful API，用户无需安装客户端即可访问 Milvus，使客户端-服务器操作毫不费力。此外，由于 Milvus SDK 和 RESTful API 共享相同的端口号，部署 Milvus 变得更加方便。</p>
<p><strong>注</strong>：我们仍然建议使用 SDK 部署 Milvus 进行高级操作，或者如果您的业务对延迟敏感的话。</p>
<h2 id="Vector-retrieval-during-ANN-searches" class="common-anchor-header">ANN 搜索期间的向量检索<button data-href="#Vector-retrieval-during-ANN-searches" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在早期版本中，为了优先考虑性能和内存使用情况，Milvus 不允许在近似近邻（ANN）搜索期间检索向量。因此，检索原始向量必须分为两个步骤：执行 ANN 搜索，然后根据原始向量的 ID 对其进行查询。这种方法增加了开发成本，使用户更难部署和采用 Milvus。</p>
<p>有了 Milvus 2.2.12，用户可以在进行 ANN 搜索时检索原始向量，方法是将向量字段设置为输出字段，并在 HNSW、DiskANN 或 IVF-FLAT 索引的 Collections 中进行查询。此外，用户还可以期待更快的向量检索速度。</p>
<h2 id="Support-for-operations-on-JSON-arrays" class="common-anchor-header">支持对 JSON 数组的操作符<button data-href="#Support-for-operations-on-JSON-arrays" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>我们最近在 Milvus 2.2.8 中添加了对 JSON 的支持。从那时起，用户发出了大量请求，希望我们能支持更多 JSON 数组操作，如包含、排除、交集、联合、差分等。在 Milvus 2.2.12 中，我们优先支持了<code translate="no">json_contains</code> 函数，以启用包含操作。我们将在未来版本中继续添加对其他操作符的支持。</p>
<h2 id="Enhancements-and-bug-fixes" class="common-anchor-header">增强功能和错误修复<button data-href="#Enhancements-and-bug-fixes" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>除了引入新功能外，Milvus 2.2.12 还提高了向量搜索性能，减少了开销，使其更容易处理大量 topk 搜索。此外，它还增强了在启用 Partition Key 和多分区情况下的写入性能，并优化了大型机器的 CPU 占用率。 本次更新解决了各种问题：磁盘使用率过高、压缩卡住、数据删除不频繁以及批量插入失败。更多信息，请参阅<a href="https://milvus.io/docs/release_notes.md#2212">Milvus 2.2.12 发布说明</a>。</p>
<h2 id="Lets-keep-in-touch" class="common-anchor-header">让我们保持联系！<button data-href="#Lets-keep-in-touch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您有关于 Milvus 的问题或反馈，请随时通过<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a> 与我们联系。也欢迎您加入我们的<a href="https://milvus.io/slack/">Slack 频道</a>，直接与我们的工程师和社区交流，或查看我们的<a href="https://us02web.zoom.us/meeting/register/tZ0pcO6vrzsuEtVAuGTpNdb6lGnsPBzGfQ1T#/registration">周二办公时间</a>！</p>


Milvus 2.2.12：更方便的访问、更快的向量搜索速度和更好的用户体验

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/What_s_New_in_Milvus_2_2_10_and_2_2_11_5018946465.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>Milvus 的粉丝们，你们好！我们很高兴地宣布，我们刚刚发布了 Milvus 2.2.10 和 2.2.11，这两个小更新主要集中在错误修复和整体性能提升上。您可以期待这两个更新带来更稳定的系统和更好的用户体验。让我们快速了解一下这两个版本的新功能。</p>
<h2 id="Milvus-2210" class="common-anchor-header">Milvus 2.2.10<button data-href="#Milvus-2210" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.2.10 修正了偶尔出现的系统崩溃问题，加速了加载和索引，降低了数据节点的内存使用率，并做了许多其他改进。以下是一些显著的变化：</p>
<ul>
<li>用纯 Go 语言编写的新程序替换了旧的 CGO 有效载荷写入器，降低了数据节点的内存使用率。</li>
<li>在<code translate="no">milvus-proto</code> 文件中添加了<code translate="no">go-api/v2</code> ，以防止与不同的<code translate="no">milvus-proto</code> 版本混淆。</li>
<li>将 Gin 从 1.9.0 版升级到 1.9.1 版，以修复<code translate="no">Context.FileAttachment</code> 函数中的一个错误。</li>
<li>为 FlushAll 和数据库 API 添加了基于角色的访问控制 (RBAC)。</li>
<li>修复了 AWS S3 SDK 导致的随机崩溃。</li>
<li>提高了加载和索引速度。</li>
</ul>
<p>更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md#2210">Milvus 2.2.10 发布说明</a>。</p>
<h2 id="Milvus-2211" class="common-anchor-header">Milvus 2.2.11<button data-href="#Milvus-2211" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.2.11 解决了各种问题，提高了系统的稳定性。它还提高了监控、日志记录、速率限制和拦截跨集群请求的性能。请看下面的更新要点。</p>
<ul>
<li>为 Milvus GRPC 服务器添加了拦截器，以防止跨集群路由出现任何问题。</li>
<li>为 minio 块管理器添加了错误代码，使诊断和修复错误更容易。</li>
<li>使用了单例例程池，以避免浪费例程并最大限度地利用资源。</li>
<li>通过启用 zstd 压缩，把 RocksMq 的磁盘使用量减少到原来的十分之一。</li>
<li>修正了加载过程中偶尔出现的 QueryNode 恐慌。</li>
<li>修正了因两次计算队列长度而导致的读取请求节流问题。</li>
<li>修正了 MacOS 上 GetObject 返回空值的问题。</li>
<li>修正了因错误使用 noexcept 修饰符而导致的崩溃。</li>
</ul>
<p>更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md#2211">Milvus 2.2.11 发行说明</a>。</p>
<h2 id="Let’s-keep-in-touch" class="common-anchor-header">让我们保持联系！<button data-href="#Let’s-keep-in-touch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您有关于 Milvus 的问题或反馈，请随时通过<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a> 与我们联系。也欢迎您加入我们的<a href="https://milvus.io/slack/">Slack 频道</a>，直接与我们的工程师和社区交流，或查看我们的<a href="https://us02web.zoom.us/meeting/register/tZ0pcO6vrzsuEtVAuGTpNdb6lGnsPBzGfQ1T#/registration">周二办公时间</a>！</p>


Milvus 2.2.10 & 2.2.11 Enhanced System Stability and User Experience

Milvus 2.2.10 和 2.2.11：增强系统稳定性和用户体验的小更新

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Milvus_hit_20_000_stars_284ed694d2.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>让我们尽情庆祝吧！</p>
<p><a href="https://github.com/milvus-io/milvus">Milvus</a>已经达到了一个辉煌的里程碑--在 GitHub 上突破了 20,000 颗星！如果没有忠实粉丝和社区成员的支持和反馈，我们不可能取得这样的成绩。非常感谢你们。</p>
<p>为了分享喜悦，我们整理了来自广大 Milvus 社区的重要话题，其中包括：</p>
<ul>
<li>六个利用 Milvus 的著名项目</li>
<li>五个与其他开源项目的集成</li>
<li>Milvus 的五个知名用例</li>
<li>五个即将推出的优秀功能</li>
</ul>
<h2 id="Six-LLM-projects-that-utilize-Milvus" class="common-anchor-header">六个利用 Milvus 的 LLM 项目<button data-href="#Six-LLM-projects-that-utilize-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="PaperGPT" class="common-anchor-header">PaperGPT</h3><p><a href="http://papergpt.bio">PaperGPT</a>是由 LLM 和向量数据库驱动的生物医学论文搜索工具。它利用 PubMed 数据库以及 SentenceTransformers 和 Zilliz Cloud 等技术实现高效搜索。</p>
<h3 id="NoticeAI" class="common-anchor-header">NoticeAI</h3><p>NoticeAI 可帮助公司实现客户支持流程自动化。它利用 Milvus 和 LangChain 跟踪客户支持问题，更新知识库，并决定是否让人工参与。</p>
<h3 id="Searchanythingio" class="common-anchor-header">搜索</h3><p><a href="http://search.anything.io">Search Anything</a>利用 LLMs 和 Milvus 提供更好的搜索体验。它接收用户的文字描述，并在网络上找到相应的图片。</p>
<h3 id="IkuStudies" class="common-anchor-header">IkuStudies</h3><p><a href="https://ikustudies.xyz/">IkuStudies</a>是一个允许用户搜索 28 种语言同音字的项目。它使用 Milvus 作为向量存储来查找单词之间的相似性。</p>
<h3 id="AssistLink-AI" class="common-anchor-header">AssistLink AI</h3><p><a href="https://www.linkedin.com/company/assistlink/about/">AssistLink AI</a>是一家位于西雅图的初创公司，它使用 Milvus 和 LLaMa 65bn 为政府援助系统存储变量。</p>
<h3 id="OSS-Chat" class="common-anchor-header">OSS 聊天</h3><p><a href="http://osschat.io">OSS Chat</a>允许您与开源软件聊天。它使用 Milvus 注入有关开源项目的领域知识，并使用<a href="https://zilliz.com/blog/Caching-LLM-Queries-for-performance-improvements">GPTCache</a>缓存常见问题，以降低 LLM 成本。</p>
<h2 id="Five-AI-projects-Milvus-integrates-with" class="common-anchor-header">Milvus 集成的五个人工智能项目<button data-href="#Five-AI-projects-Milvus-integrates-with" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="LlamaIndex" class="common-anchor-header">LlamaIndex</h3><p><a href="https://github.com/jerryjliu/llama_index">LlamaIndex</a>是用于 LLM 应用程序的数据框架，它提供数据连接器，可将外部数据源与 LLM 连接起来。通过 LlamaIndex，您可以将私人数据或特定领域的知识直接注入 LLM 应用程序。</p>
<h3 id="LangChainLangChainJS" class="common-anchor-header">LangChain/LangChainJS</h3><p><a href="https://github.com/hwchase17/langchain">LangChain</a>是一个用于加速 LLM 应用程序开发的库，提供提示管理、链、数据增量生成、内存等功能。</p>
<h3 id="ChatGPT-Retrieval-Plugin" class="common-anchor-header">ChatGPT 检索插件</h3><p>OpenAI 的<a href="https://github.com/openai/chatgpt-retrieval-plugin">ChatGPT 检索插件</a>可使用自然语言查询对个人或组织文档进行语义搜索和检索，允许开发人员部署自己的插件并将其注册到 ChatGPT 中。</p>
<h3 id="Haystack" class="common-anchor-header">HayStack</h3><p><a href="https://github.com/deepset-ai/haystack">HayStack</a>是一个端到端 NLP 框架，用于构建由 LLMs、转换器模型、向量搜索和其他技术驱动的 NLP 应用程序，以完成问题解答、语义文档搜索和构建复杂决策等任务。</p>
<h3 id="GPTCache" class="common-anchor-header">GPTCache</h3><p>LLM API 调用既昂贵又缓慢。<a href="https://github.com/zilliztech/gptcache">GPTCache</a>可为 LLM 查询提供语义缓存，从而解决这两个问题。</p>
<h2 id="Five-well-known-use-cases-of-Milvus" class="common-anchor-header">Milvus 的五个知名用例<button data-href="#Five-well-known-use-cases-of-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="LLM-augmentation" class="common-anchor-header">LLM 增强</h3><p>LLMs 或 LLM 应用程序有三大问题：缺乏特定领域数据、数据过时和成本高昂。Milvus 可以解决这三个问题，允许您注入外部数据，并作为频繁查询的缓存。</p>
<h3 id="Anomaly-detection" class="common-anchor-header">异常检测</h3><p>异常数据与给定集合中的其他数据明显不同。Milvus 等向量数据库有利于进行相似性搜索，从而更容易识别此类异常数据。</p>
<h3 id="Recommender-systems" class="common-anchor-header">推荐系统</h3><p>推荐系统向人们推荐与他们已经喜欢的东西相似的物品。这是 Milvus 通过进行相似性搜索来加速这一过程的典型例子。</p>
<h3 id="Semantic-search" class="common-anchor-header">语义搜索</h3><p>当您想搜索文本以查找具有相似含义的事物时，关键词搜索就无能为力了。这就是语义搜索的用武之地，也是 Milvus 可以提供帮助的地方。Milvus 可让您比较文本背后的意图，而不仅仅是单词本身。</p>
<h3 id="Automatic-data-labeling" class="common-anchor-header">自动数据标注</h3><p>有了标注数据，还需要标注更多吗？通过在 Milvus 中存储向量表示法，您可以自动检测新数据中最相似的数据点，并应用相应的标签。</p>
<h2 id="Five-awesome-upcoming-features" class="common-anchor-header">即将推出的五项超棒功能<button data-href="#Five-awesome-upcoming-features" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="NVIDIA-GPU-support" class="common-anchor-header">英伟达™（NVIDIA®）图形处理器支持</h3><p>GPU 支持将在 Milvus 2.3 中推出，并已在最新的<a href="https://github.com/milvus-io/milvus/releases/tag/v2.3.0-beta">测试版</a>中提供！</p>
<h3 id="Delete-by-Expression" class="common-anchor-header">通过表达式删除</h3><p>您已经可以在 Milvus 中通过布尔表达式执行标量/元数据过滤。通过表达式删除功能也即将推出。</p>
<h3 id="Change-Data-Capture-CDC" class="common-anchor-header">变更数据捕获 (CDC)</h3><p>CDC 是一种实时捕获和跟踪对 Milvus 实例所做更改的技术。</p>
<h3 id="Range-Search" class="common-anchor-header">范围搜索</h3><p>范围搜索在某些领域也被称为ε搜索，它可以让你找到与你的查询向量相距一定距离内的所有向量。</p>
<h3 id="Fast-Scan" class="common-anchor-header">快速扫描</h3><p>FAISS 最近添加了 4 位量化和快速扫描功能，Milvus 也将加入这两项功能。</p>
<h2 id="Looking-forward-to-Milvus-reaching-even-greater-heights" class="common-anchor-header">期待 Milvus 达到更高的高度！<button data-href="#Looking-forward-to-Milvus-reaching-even-greater-heights" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>我们要向我们的用户、社区成员、生态系统合作伙伴和观星者表示最衷心的感谢，感谢他们一直以来的支持、反馈和贡献。期待 Milvus 达到更高的高度！</p>


恒星里程碑：Milvus 在 GitHub 上的星级突破 20,000 个

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Conversational_Memory_in_Lang_Chain_7c1b4b7ba9.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>LangChain 是构建 LLM 应用程序的强大框架。然而，强大的功能也带来了一定的复杂性。LangChain 提供了许多提示 LLM 的方法以及会话记忆等基本功能。会话记忆为 LLM 提供了上下文以记住您的聊天内容。</p>
<p>在本篇文章中，我们将介绍如何在 LangChain 和 Milvus 中使用会话记忆。要继续学习，您需要<code translate="no">pip</code> 安装四个库和一个 OpenAI API 密钥。您可以通过运行<code translate="no">pip install langchain milvus pymilvus python-dotenv</code> 来安装所需的四个库。或执行本文<a href="https://colab.research.google.com/drive/11p-u8nKqrQYePlXR0HiSrUapmKLD0QN9?usp=sharing">CoLab Notebook</a>中的第一个区块。</p>
<p>在本篇文章中，我们将学习以下内容：</p>
<ul>
<li>使用 LangChain 进行对话记忆</li>
<li>设置对话上下文</li>
<li>使用 LangChain 提示对话记忆</li>
<li>LangChain 对话记忆总结</li>
</ul>
<h2 id="Conversational-Memory-with-LangChain" class="common-anchor-header">使用 LangChain 的对话记忆<button data-href="#Conversational-Memory-with-LangChain" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在默认状态下，您通过单个提示与 LLM 进行交互。增加上下文记忆或 "对话记忆 "意味着您不必再通过一个提示发送所有内容。LangChain 提供了存储与 LLM 对话的功能，以便日后检索这些信息。</p>
<p>要通过向量存储建立持久对话记忆，我们需要从 LangChain 获取六个模块。首先，我们必须获得<code translate="no">OpenAIEmbeddings</code> 和<code translate="no">OpenAI</code> LLM。我们还需要<code translate="no">VectorStoreRetrieverMemory</code> 和 LangChain 版本的<code translate="no">Milvus</code> 来使用向量存储后台。然后，我们需要<code translate="no">ConversationChain</code> 和<code translate="no">PromptTemplate</code> 来保存对话并进行查询。</p>
<p><code translate="no">os</code> 、<code translate="no">dotenv</code> 和<code translate="no">openai</code> 库主要用于操作符。我们使用它们来加载和使用 OpenAI API 密钥。最后一个设置步骤是启动本地<a href="https://milvus.io/docs/milvus_lite.md">Milvus Lite</a>实例。我们通过使用 Milvus Python 软件包中的<code translate="no">default_server</code> 来完成。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> langchain.<span class="hljs-property">embeddings</span>.<span class="hljs-property">openai</span> <span class="hljs-keyword">import</span> <span class="hljs-title class_">OpenAIEmbeddings</span>
<span class="hljs-keyword">from</span> langchain.<span class="hljs-property">llms</span> <span class="hljs-keyword">import</span> <span class="hljs-title class_">OpenAI</span>
<span class="hljs-keyword">from</span> langchain.<span class="hljs-property">memory</span> <span class="hljs-keyword">import</span> <span class="hljs-title class_">VectorStoreRetrieverMemory</span>
<span class="hljs-keyword">from</span> langchain.<span class="hljs-property">chains</span> <span class="hljs-keyword">import</span> <span class="hljs-title class_">ConversationChain</span>
<span class="hljs-keyword">from</span> langchain.<span class="hljs-property">prompts</span> <span class="hljs-keyword">import</span> <span class="hljs-title class_">PromptTemplate</span>
<span class="hljs-keyword">from</span> langchain.<span class="hljs-property">vectorstores</span> <span class="hljs-keyword">import</span> <span class="hljs-title class_">Milvus</span>
embeddings = <span class="hljs-title class_">OpenAIEmbeddings</span>()


<span class="hljs-keyword">import</span> os
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
<span class="hljs-keyword">import</span> openai
<span class="hljs-title function_">load_dotenv</span>()
openai.<span class="hljs-property">api_key</span> = os.<span class="hljs-title function_">getenv</span>(<span class="hljs-string">&quot;OPENAI_API_KEY&quot;</span>)


<span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> default_server
default_server.<span class="hljs-title function_">start</span>()
<button class="copy-code-btn"></button></code></pre>
<h2 id="Setting-Up-Conversation-Context" class="common-anchor-header">设置对话上下文<button data-href="#Setting-Up-Conversation-Context" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>现在，我们已经设置好了所有的先决条件，可以开始创建对话内存了。第一步是使用 LangChain 创建与 Milvus 服务器的连接。接下来，我们使用空字典创建 LangChain Milvus Collections。此外，我们还会传入上文创建的嵌入式数据以及 Milvus Lite 服务器的连接详情。</p>
<p>要将向量数据库用于会话记忆，我们需要将其实例化为检索器。在这种情况下，我们只检索前 1 个结果，设置为<code translate="no">k=1</code> 。最后一个会话内存设置步骤是通过刚才设置的检索器和向量数据库连接，将<code translate="no">VectorStoreRetrieverMemory</code> 对象用作我们的会话内存。</p>
<p>要使用我们的会话内存，它必须有一些上下文。因此，让我们给记忆体一些上下文。在这个例子中，我们提供了五条信息。让我们存储我最喜欢的零食（巧克力）、运动（游泳）、啤酒（吉尼斯）、甜点（芝士蛋糕）和音乐家（泰勒-斯威夫特）。每个条目都将通过<code translate="no">save_context</code> 功能保存到存储器中。</p>
<pre><code translate="no">vectordb = Milvus.from_documents(
   {},
   embeddings,
   connection_args={<span class="hljs-string">&quot;host&quot;</span>: <span class="hljs-string">&quot;127.0.0.1&quot;</span>, <span class="hljs-string">&quot;port&quot;</span>: default_server.listen_port})
retriever = Milvus.as_retriever(vectordb, search_kwargs=<span class="hljs-built_in">dict</span>(k=<span class="hljs-number">1</span>))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
   {<span class="hljs-string">&quot;input&quot;</span>: <span class="hljs-string">&quot;My favorite snack is chocolate&quot;</span>,
    <span class="hljs-string">&quot;output&quot;</span>: <span class="hljs-string">&quot;Nice&quot;</span>},
   {<span class="hljs-string">&quot;input&quot;</span>: <span class="hljs-string">&quot;My favorite sport is swimming&quot;</span>,
    <span class="hljs-string">&quot;output&quot;</span>: <span class="hljs-string">&quot;Cool&quot;</span>},
   {<span class="hljs-string">&quot;input&quot;</span>: <span class="hljs-string">&quot;My favorite beer is Guinness&quot;</span>,
    <span class="hljs-string">&quot;output&quot;</span>: <span class="hljs-string">&quot;Great&quot;</span>},
   {<span class="hljs-string">&quot;input&quot;</span>: <span class="hljs-string">&quot;My favorite dessert is cheesecake&quot;</span>,
    <span class="hljs-string">&quot;output&quot;</span>: <span class="hljs-string">&quot;Good to know&quot;</span>},
   {<span class="hljs-string">&quot;input&quot;</span>: <span class="hljs-string">&quot;My favorite musician is Taylor Swift&quot;</span>,
    <span class="hljs-string">&quot;output&quot;</span>: <span class="hljs-string">&quot;Same&quot;</span>}
]
<span class="hljs-keyword">for</span> example <span class="hljs-keyword">in</span> about_me:
   memory.save_context({<span class="hljs-string">&quot;input&quot;</span>: example[<span class="hljs-string">&quot;input&quot;</span>]}, {<span class="hljs-string">&quot;output&quot;</span>: example[<span class="hljs-string">&quot;output&quot;</span>]})
<button class="copy-code-btn"></button></code></pre>
<h2 id="Prompting-the-Conversational-Memory-with-LangChain" class="common-anchor-header">使用 LangChain 提示会话内存<button data-href="#Prompting-the-Conversational-Memory-with-LangChain" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>现在我们来看看如何使用会话记忆库。首先，让我们通过 LangChain 连接 OpenAI LLM。我们使用温度 0 来表示我们不希望 LLM 具有创造性。</p>
<p>接下来，我们创建一个模板。我们告诉 LLM，它正在与人类进行友好对话，并插入两个变量。<code translate="no">history</code> 变量提供对话记忆中的上下文。<code translate="no">input</code> 变量提供当前输入。我们使用<code translate="no">PromptTemplate</code> 对象插入这些变量。</p>
<p>我们使用<code translate="no">ConversationChain</code> 对象将提示、LLM 和内存结合起来。现在，我们可以通过给对话一些提示来检查对话记忆。我们首先告诉 LLM，我们的名字叫加里，是口袋妖怪系列中的主要对手（对话记忆中的其他内容都是关于我的事实）。</p>
<pre><code translate="no">llm = OpenAI(temperature=<span class="hljs-number">0</span>) <span class="hljs-comment"># Can be any valid LLM</span>
_DEFAULT_TEMPLATE = <span class="hljs-string">&quot;&quot;&quot;The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.


Relevant pieces of previous conversation:
{history}


(You do not need to use these pieces of information if not relevant)


Current conversation:
Human: {input}
AI:&quot;&quot;&quot;</span>
PROMPT = PromptTemplate(
   input_variables=[<span class="hljs-string">&quot;history&quot;</span>, <span class="hljs-string">&quot;input&quot;</span>], template=_DEFAULT_TEMPLATE
)
conversation_with_summary = ConversationChain(
   llm=llm,
   prompt=PROMPT,
   memory=memory,
   verbose=<span class="hljs-literal">True</span>
)
conversation_with_summary.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">&quot;Hi, my name is Gary, what&#x27;s up?&quot;</span>)
<button class="copy-code-btn"></button></code></pre>
<p>下图显示了 LLM 的预期回复。在这个例子中，它的回答是它的名字叫 "AI"。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Conversational_Memory_in_Lang_Chain_graphics_1_2bf386d22a.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>现在，让我们来测试一下到目前为止的内存。我们使用之前创建的<code translate="no">ConversationChain</code> 对象，查询我最喜欢的音乐家。</p>
<pre><code translate="no">conversation_with_summary.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">&quot;who is my favorite musician?&quot;</span>)
<button class="copy-code-btn"></button></code></pre>
<p>下图显示了对话链的预期响应。由于我们使用了 "verbose"（详细说明）选项，因此它还显示了相关对话。我们可以看到，正如预期的那样，它返回了我最喜欢的艺术家是泰勒-斯威夫特（Taylor Swift）。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Conversational_Memory_in_Lang_Chain_graphics_2_8355206f3e.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>接下来，让我们查询我最喜欢的甜点--芝士蛋糕。</p>
<pre><code translate="no">conversation_with_summary.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">&quot;Whats my favorite dessert?&quot;</span>)
<button class="copy-code-btn"></button></code></pre>
<p>当我们查询我最喜欢的甜点时，我们可以看到对话链再次从 Milvus 挑选了正确的信息。它发现我最喜欢的甜点是芝士蛋糕，正如我之前告诉它的那样。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Conversational_Memory_in_Lang_Chain_graphics_3_66a5c9690f.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>既然我们已经确认可以查询我们之前提供的信息，那么我们再来检查一件事--我们在对话开始时提供的信息。对话开始时，我们告诉人工智能我们的名字叫加里。</p>
<pre><code translate="no">conversation_with_summary.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">&quot;What&#x27;s my name?&quot;</span>)
<button class="copy-code-btn"></button></code></pre>
<p>我们最后的检查结果是，对话链在向量存储对话记忆中存储了关于我们名字的信息。它返回的结果是，我们说了我们的名字叫加里。</p>
<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/Conversational_Memory_in_Lang_Chain_graphics_4_f446f49672.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<h2 id="LangChain-Conversational-Memory-Summary" class="common-anchor-header">LangChain 对话内存总结<button data-href="#LangChain-Conversational-Memory-Summary" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在本教程中，我们学习了如何在 LangChain 中使用会话内存。LangChain 提供了像 Milvus 这样的向量存储后端访问，以实现持久的会话内存。我们可以在提示中注入历史记录，并将历史上下文保存在<code translate="no">ConversationChain</code> 对象中，从而使用会话记忆。</p>
<p>在本教程示例中，我们向对话链提供了关于我的五个事实，并假装自己是《口袋妖怪》中的主要对手加里。然后，我们用我们存储的先验知识--我最喜欢的音乐家和甜点--提问对话链。它正确回答了这两个问题，并显示了相关条目。最后，我们向它询问了对话开始时我们的名字，它正确地回答了我们说我们的名字是 "加里"。</p>


LangChain 中的对话记忆

<p>
  <span class="img-wrapper">
    <img translate="no" src="https://assets.zilliz.com/What_s_New_in_2_2_9_858e54a2d3.png" alt="" class="doc-image" id="" />
    <span></span>
  </span>
</p>
<p>我们非常高兴地宣布 Milvus 2.2.9 版本的到来，这是一个备受期待的版本，标志着团队和社区的一个重要里程碑。该版本提供了许多令人兴奋的功能，包括期待已久的 JSON 数据类型、动态 Schema 和 Partition Key 支持，确保优化用户体验和简化开发工作流程。此外，该版本还包含大量增强功能和错误修复。请与我们一起探索 Milvus 2.2.9，了解该版本为何如此令人兴奋。</p>
<h2 id="Optimized-user-experience-with-JSON-support" class="common-anchor-header">通过 JSON 支持优化用户体验<button data-href="#Optimized-user-experience-with-JSON-support" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 推出了备受期待的 JSON 数据类型支持，允许在用户的 Collections 中无缝存储 JSON 数据以及向量的元数据。通过这一增强功能，用户可以高效地批量插入 JSON 数据，并根据 JSON 字段的内容执行高级查询和过滤。此外，用户还可以利用表达式，针对数据集的 JSON 字段执行操作，根据 JSON 字段的内容和结构构建查询和应用过滤器，从而更好地提取相关信息和操作数据。</p>
<p>未来，Milvus 团队将为 JSON 类型中的字段添加索引，进一步优化混合标量和向量查询的性能。敬请期待未来激动人心的发展！</p>
<h2 id="Added-flexibility-with-support-for-dynamic-schema" class="common-anchor-header">通过支持动态 Schema 增加灵活性<button data-href="#Added-flexibility-with-support-for-dynamic-schema" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>由于支持 JSON 数据，Milvus 2.2.9 现在可通过简化的软件开发工具包（SDK）提供动态模式功能。</p>
<p>从 Milvus 2.2.9 开始，Milvus SDK 包括一个高级 API，可自动将动态字段填入 Collections 的隐藏 JSON 字段，使用户只需专注于业务字段。</p>
<h2 id="Better-data-separation-and-enhanced-search-efficiency-with-Partition-Key" class="common-anchor-header">利用 Partition Key 更好地分离数据并提高搜索效率<button data-href="#Better-data-separation-and-enhanced-search-efficiency-with-Partition-Key" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.2.9 通过引入分区键功能增强了分区能力。它允许将用户特定列作为主键进行分区，无需使用<code translate="no">loadPartition</code> 和<code translate="no">releasePartition</code> 等额外的 API。这项新功能还取消了对分区数量的限制，从而提高了资源利用效率。</p>
<h2 id="Support-for-Alibaba-Cloud-OSS" class="common-anchor-header">支持阿里云 OSS<button data-href="#Support-for-Alibaba-Cloud-OSS" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.2.9 现在支持阿里巴巴云对象存储服务（OSS）。阿里云用户可轻松将<code translate="no">cloudProvider</code> 配置到阿里云，并利用无缝集成的优势，在云中高效存储和检索向量数据。</p>
<p>除了前面提到的功能外，Milvus 2.2.9 还在基于角色的访问控制（RBAC）中提供了数据库支持，引入了连接管理，并包含多个增强功能和错误修复。更多信息，请参阅<a href="https://milvus.io/docs/release_notes.md">Milvus 2.2.9 发行说明</a>。</p>
<h2 id="Let’s-keep-in-touch" class="common-anchor-header">让我们保持联系！<button data-href="#Let’s-keep-in-touch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您有关于 Milvus 的问题或反馈，请随时通过<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a> 与我们联系。也欢迎您加入我们的<a href="https://milvus.io/slack/">Slack 频道</a>，直接与我们的工程师和社区交流，或查看我们的<a href="https://us02web.zoom.us/meeting/register/tZ0pcO6vrzsuEtVAuGTpNdb6lGnsPBzGfQ1T#/registration">周二办公时间</a>！</p>


Milvus 2.2.9：备受期待的最佳用户体验版本

<p><strong><em>重要说明</em></strong></p>
<p><em>我们于 2024 年 6 月升级了 Milvus Lite，使人工智能开发人员能够更快地构建应用程序，同时确保在各种部署选项（包括 Kurbernetes 上的 Milvus、Docker 和托管云服务）中获得一致的体验。Milvus Lite 还集成了各种人工智能框架和技术，通过向量搜索功能简化了人工智能应用的开发。欲了解更多信息，请参阅以下参考资料：</em></p>
<ul>
<li><p><em>Milvus Lite 发布博客：h<a href="https://milvus.io/blog/introducing-milvus-lite.md">ttps://</a>milvus.io/blog/introducing-milvus-lite.md</em></p></li>
<li><p><em>Milvus Lite 文档：<a href="https://milvus.io/docs/quickstart.md">https://milvus.io/docs/quickstart.md</a></em></p></li>
<li><p><em>Milvus Lite GitHub 存储库：<a href="https://github.com/milvus-io/milvus-lite">https://github.com/milvus-io/milvus-lite</a></em></p></li>
</ul>
<p><br></p>
<p><a href="https://github.com/milvus-io/milvus">Milvus</a>是一个开源向量数据库，专门用于索引、存储和查询由深度神经网络和其他机器学习（ML）模型生成的数十亿规模的 embedding 向量。它已成为许多必须在大规模数据集上执行相似性搜索的公司、研究人员和开发人员的首选。</p>
<p>不过，有些用户可能会觉得完整版 Milvus 太重或太复杂。为了解决这个问题，Milvus 社区最活跃的贡献者之一<a href="https://github.com/matrixji">Bin Ji</a> 创建了 Milvus<a href="https://github.com/milvus-io/milvus-lite">Lite</a>，一个轻量级的 Milvus 版本。</p>
<h2 id="What-is-Milvus-Lite" class="common-anchor-header">Milvus Lite 是什么？<button data-href="#What-is-Milvus-Lite" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如前所述，<a href="https://github.com/milvus-io/milvus-lite">Milvus Lite</a>是 Milvus 的简化替代品，它具有如此多的优点和好处。</p>
<ul>
<li>你可以将它集成到你的 Python 应用程序中，而不会增加额外的重量。</li>
<li>由于 Milvus Standalone 能够与嵌入式 Etcdings 和本地存储协同工作，因此它自成一体，不需要任何其他依赖项。</li>
<li>你可以将它作为 Python 库导入，也可以将它作为基于命令行界面（CLI）的独立服务器使用。</li>
<li>它能与 Google Colab 和 Jupyter Notebook 顺利配合。</li>
<li>你可以安全地将工作和编写的代码迁移到其他 Milvus 实例（单机版、集群版和完全托管版），而不会有任何丢失数据的风险。</li>
</ul>
<h2 id="When-should-you-use-Milvus-Lite" class="common-anchor-header">什么时候应该使用 Milvus Lite？<button data-href="#When-should-you-use-Milvus-Lite" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>具体来说，Milvus Lite 在以下情况下最有帮助：</p>
<ul>
<li>当你喜欢在没有<a href="https://milvus.io/docs/install_standalone-operator.md">Milvus Operator</a>、<a href="https://milvus.io/docs/install_standalone-helm.md">Helm</a> 或<a href="https://milvus.io/docs/install_standalone-docker.md">Docker Compose</a> 等容器技术和工具的情况下使用 Milvus 时。</li>
<li>使用 Milvus 时不需要虚拟机或容器。</li>
<li>希望在 Python 应用程序中加入 Milvus 功能时。</li>
<li>想在 Colab 或 Notebook 中启动 Milvus 实例进行快速实验时。</li>
</ul>
<p><strong>注意</strong>：如果你需要高性能、高可用性或高可扩展性，我们不建议在任何生产环境中使用 Milvus Lite。相反，请考虑在生产环境中使用<a href="https://github.com/milvus-io/milvus">Milvus 集群</a>或<a href="https://zilliz.com/cloud">Zilliz Cloud 上完全托管的 Milvus</a>。</p>
<h2 id="How-to-get-started-with-Milvus-Lite" class="common-anchor-header">如何开始使用 Milvus Lite？<button data-href="#How-to-get-started-with-Milvus-Lite" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>现在，让我们来看看如何安装、配置和使用 Milvus Lite。</p>
<h3 id="Prerequisites" class="common-anchor-header">先决条件</h3><p>要使用 Milvus Lite，请确保已完成以下要求：</p>
<ul>
<li>安装 Python 3.7 或更高版本。</li>
<li>使用下列经过验证的操作系统之一：<ul>
<li>Ubuntu &gt;= 18.04 (x86_64)</li>
<li>CentOS &gt;= 7.0 (x86_64)</li>
<li>MacOS &gt;= 11.0 (Apple Silicon)</li>
</ul></li>
</ul>
<p><strong>备注</strong>：</p>
<ol>
<li>Milvus Lite 使用<code translate="no">manylinux2014</code> 作为基础镜像，使其与大多数 Linux 发行版兼容，适合 Linux 用户使用。</li>
<li>在 Windows 上运行 Milvus Lite 也是可能的，不过这还有待全面验证。</li>
</ol>
<h3 id="Install-Milvus-Lite" class="common-anchor-header">安装 Milvus Lite</h3><p>Milvus Lite 在 PyPI 上提供，因此你可以通过<code translate="no">pip</code> 安装。</p>
<pre><code translate="no">$ python3 -m pip install milvus
<button class="copy-code-btn"></button></code></pre>
<p>你也可以按如下方法用 PyMilvus 安装它：</p>
<pre><code translate="no">$ python3 -m pip install milvus[client]
<button class="copy-code-btn"></button></code></pre>
<h3 id="Use-and-start-Milvus-Lite" class="common-anchor-header">使用并启动 Milvus Lite</h3><p>从我们项目库的示例文件夹下载示例<a href="https://github.com/milvus-io/milvus-lite/tree/main/examples">笔记本</a>。你有两个使用 Milvus Lite 的选择：要么将它作为 Python 库导入，要么使用 CLI 将它作为独立服务器在你的机器上运行。</p>
<ul>
<li>要将 Milvus Lite 作为 Python 模块启动，请执行以下命令：</li>
</ul>
<pre><code translate="no"><span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> default_server
<span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> connections, utility

<span class="hljs-comment"># Start your milvus server</span>
default_server.start()

<span class="hljs-comment"># Now you can connect with localhost and the given port</span>
<span class="hljs-comment"># Port is defined by default_server.listen_port</span>
connections.connect(host=<span class="hljs-string">&#x27;127.0.0.1&#x27;</span>, port=default_server.listen_port)

<span class="hljs-comment"># Check if the server is ready.</span>
<span class="hljs-built_in">print</span>(utility.get_server_version())

<span class="hljs-comment"># Stop your milvus server</span>
default_server.stop()
<button class="copy-code-btn"></button></code></pre>
<ul>
<li>要暂停或停止 Milvus Lite，使用<code translate="no">with</code> 语句。</li>
</ul>
<pre><code translate="no"><span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> default_server

<span class="hljs-keyword">with</span> default_server:
  <span class="hljs-comment"># Milvus Lite has already started, use default_server here.</span>
  connections.connect(host=<span class="hljs-string">&#x27;127.0.0.1&#x27;</span>, port=default_server.listen_port)
<button class="copy-code-btn"></button></code></pre>
<ul>
<li>要将 Milvus Lite 作为基于 CLI 的独立服务器启动，请运行以下命令：</li>
</ul>
<pre><code translate="no">milvus-server
<button class="copy-code-btn"></button></code></pre>
<p>启动 Milvus Lite 后，你可以使用 PyMilvus 或其他你喜欢的工具连接到独立服务器。</p>
<h3 id="Start-Milvus-Lite-in-a-debug-mode" class="common-anchor-header">以调试模式启动 Milvus Lite</h3><ul>
<li>要以 Python 模块的调试模式运行 Milvus Lite，请执行以下命令：</li>
</ul>
<pre><code translate="no"><span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> debug_server, MilvusServer

debug_server.run()

<span class="hljs-comment"># Or you can create a MilvusServer by yourself</span>
<span class="hljs-comment"># server = MilvusServer(debug=True)</span>
<button class="copy-code-btn"></button></code></pre>
<ul>
<li>要在调试模式下运行独立服务器，请执行以下命令：</li>
</ul>
<pre><code translate="no">milvus-server --debug
<button class="copy-code-btn"></button></code></pre>
<h3 id="Persist-data-and-logs" class="common-anchor-header">保存数据和日志</h3><ul>
<li>要为 Milvus Lite 创建一个包含所有相关数据和日志的本地目录，请执行以下命令：</li>
</ul>
<pre><code translate="no"><span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> default_server

<span class="hljs-keyword">with</span> <span class="hljs-attr">default_server</span>:
  default_server.<span class="hljs-title function_">set_base_dir</span>(<span class="hljs-string">&#x27;milvus_data&#x27;</span>)
<button class="copy-code-btn"></button></code></pre>
<ul>
<li>要在本地硬盘上保存独立服务器生成的所有数据和日志，请执行以下命令：</li>
</ul>
<pre><code translate="no">$ milvus-server --data milvus_data
<button class="copy-code-btn"></button></code></pre>
<h3 id="Configure-Milvus-Lite" class="common-anchor-header">配置 Milvus Lite</h3><p>配置 Milvus Lite 与使用 Python API 或 CLI 设置 Milvus 实例类似。</p>
<ul>
<li>要使用 Python API 配置 Milvus Lite，请使用<code translate="no">MilvusServer</code> 实例的<code translate="no">config.set</code> API 进行基本和额外设置：</li>
</ul>
<pre><code translate="no"><span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> default_server

<span class="hljs-keyword">with</span> default_server:
  default_server.config.<span class="hljs-built_in">set</span>(<span class="hljs-string">&#x27;system_Log_level&#x27;</span>, <span class="hljs-string">&#x27;info&#x27;</span>)
  default_server.config.<span class="hljs-built_in">set</span>(<span class="hljs-string">&#x27;proxy_port&#x27;</span>, <span class="hljs-number">19531</span>)
  default_server.config.<span class="hljs-built_in">set</span>(<span class="hljs-string">&#x27;dataCoord.segment.maxSize&#x27;</span>, <span class="hljs-number">1024</span>)
<button class="copy-code-btn"></button></code></pre>
<ul>
<li>要使用 CLI 配置 Milvus Lite，运行以下命令进行基本设置：</li>
</ul>
<pre><code translate="no">$ milvus-server --system-log-level info
$ milvus-server --proxy-port 19531
<button class="copy-code-btn"></button></code></pre>
<ul>
<li>或运行以下命令进行额外配置。</li>
</ul>
<pre><code translate="no">$ milvus-server --extra-config dataCoord.segment.maxSize=1024
<button class="copy-code-btn"></button></code></pre>
<p>所有可配置项目都在 Milvus 软件包随附的<code translate="no">config.yaml</code> 模板中。</p>
<p>有关如何安装和配置 Milvus Lite 的更多技术细节，请参阅我们的<a href="https://milvus.io/docs/milvus_lite.md#Prerequisites">文档</a>。</p>
<h2 id="Summary" class="common-anchor-header">概述<button data-href="#Summary" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus Lite 是那些希望以简洁格式获得 Milvus 功能的用户的最佳选择。无论您是研究人员、开发人员还是数据科学家，都值得一试。</p>
<p>Milvus Lite 也是开源社区的一道亮丽风景线，展示了贡献者们的非凡工作。在季斌的努力下，Milvus 现在可以供更多用户使用了。我们迫不及待地想看到季斌和 Milvus 社区其他成员在未来带来的创新想法。</p>
<h2 id="Let’s-keep-in-touch" class="common-anchor-header">让我们保持联系！<button data-href="#Let’s-keep-in-touch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您在安装或使用 Milvus Lite 时遇到问题，可以<a href="https://github.com/milvus-io/milvus-lite/issues/new">在这里提交问题</a>，或通过<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a> 联系我们。我们也欢迎你加入我们的<a href="https://milvus.io/slack/">Slack 频道</a>，与我们的工程师和整个社区聊天，或者查看<a href="https://us02web.zoom.us/meeting/register/tZ0pcO6vrzsuEtVAuGTpNdb6lGnsPBzGfQ1T#/registration">我们的周二办公时间</a>！</p>


Milvus Lite 简介：Milvus 的轻量级版本

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/What_s_New_in_2_2_8_f4dd6de0f2.png" alt="Milvus 2.2.8" class="doc-image" id="milvus-2.2.8" />
   </span> <span class="img-wrapper"> <span>Milvus 2.2.8</span> </span></p>
<p>我们很高兴地宣布最新发布的 Milvus 2.2.8。该版本包含大量改进和对之前版本的错误修复，从而提高了查询性能、节省了资源并提高了吞吐量。让我们一起看看该版本的新功能。</p>
<h2 id="Reduced-peak-memory-consumption-during-collection-loading" class="common-anchor-header">降低 Collections 加载过程中的内存消耗峰值<button data-href="#Reduced-peak-memory-consumption-during-collection-loading" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>要执行查询，Milvus 需要将数据和索引加载到内存中。然而，在加载过程中，多个内存副本会导致内存使用峰值比实际运行时增加三到四倍。最新版本的 Milvus 2.2.8 有效解决了这一问题，优化了内存使用。</p>
<h2 id="Expanded-querying-scenarios-with-QueryNode-supporting-plugins" class="common-anchor-header">通过支持插件的 QueryNode 扩展查询场景<button data-href="#Expanded-querying-scenarios-with-QueryNode-supporting-plugins" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在最新的 Milvus 2.2.8 中，QueryNode 现已支持插件。您可以通过<code translate="no">queryNode.soPath</code> 配置轻松指定插件文件的路径。然后，Milvus 可以在运行时加载该插件，并扩展可用的查询场景。如果需要有关开发插件的指导，请参阅<a href="https://pkg.go.dev/plugin">Go 插件文档</a>。</p>
<h2 id="Optimized-querying-performance-with-enhanced-compaction-algorithm" class="common-anchor-header">利用增强型压缩算法优化查询性能<button data-href="#Optimized-querying-performance-with-enhanced-compaction-algorithm" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>压缩算法决定了线段收敛的速度，直接影响查询性能。随着最近对压缩算法的改进，收敛效率大幅提高，从而加快了查询速度。</p>
<h2 id="Better-resource-saving-and-querying-performance-with-reduced-collection-shards" class="common-anchor-header">通过减少 Collections 分片，更好地节省资源并提高查询性能<button data-href="#Better-resource-saving-and-querying-performance-with-reduced-collection-shards" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 是一个大规模并行处理（MPP）系统，这意味着集合分片的数量会影响 Milvus 的写入和查询效率。在旧版本中，一个 Collections 默认有两个分片，这导致了出色的写入性能，但却影响了查询性能和资源成本。在 Milvus 2.2.8 新版本更新后，默认的 Collections 分片减少为一个，用户可以节省更多资源，执行更好的查询。社区中大多数用户的数据量少于 1 千万，一个分片足以实现良好的写入性能。</p>
<p><strong>注意</strong>：此升级不会影响在此版本之前创建的 Collections。</p>
<h2 id="20-throughput-increase-with-an-improved-query-grouping-algorithm" class="common-anchor-header">使用改进的查询分组算法，吞吐量提高 20<button data-href="#20-throughput-increase-with-an-improved-query-grouping-algorithm" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 拥有高效的查询分组算法，可将队列中的多个查询请求合并为一个，以加快执行速度，从而显著提高吞吐量。在最新版本中，我们对这一算法做了更多改进，将 Milvus 的吞吐量提高了至少 20%。</p>
<p>除了上述改进之外，Milvus 2.2.8 还修复了各种错误。更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md">Milvus 发行说明</a>。</p>
<h2 id="Let’s-keep-in-touch" class="common-anchor-header">让我们保持联系！<button data-href="#Let’s-keep-in-touch" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果您有关于 Milvus 的问题或反馈，请随时通过<a href="https://twitter.com/milvusio">Twitter</a>或<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a> 与我们联系。我们也欢迎您加入我们的<a href="https://milvus.io/slack/">Slack 频道</a>，与我们的工程师和整个社区直接交流，或查看我们的<a href="https://us02web.zoom.us/meeting/register/tZ0pcO6vrzsuEtVAuGTpNdb6lGnsPBzGfQ1T#/registration">周二办公时间</a>！</p>


Milvus 2.2.8：查询性能更佳，吞吐量提高 20

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/exploring_milvus_latest_versions_4fa890533e.png" alt="Milvus at Its Best" class="doc-image" id="milvus-at-its-best" />
   </span> <span class="img-wrapper"> <span>最好的 Milvus</span> </span></p>
<p>欢迎回来，Milvus 的粉丝们！我们知道，自从上次分享关于这个前沿开源向量数据库的更新以来，已经有一段时间了。但不用担心，因为我们在这里将为您介绍自去年 8 月以来发生的所有令人兴奋的进展。</p>
<p>在这篇博文中，我们将带您了解 Milvus 从 2.2 版到 2.2.6 版的最新版本。我们要介绍的内容很多，包括新功能、改进、错误修复和优化。因此，请系好安全带，让我们一起深入了解！</p>
<h2 id="Milvus-v22-a-major-release-with-enhanced-stability-faster-search-speed-and-flexible-scalability" class="common-anchor-header">Milvus v2.2：稳定性更强、搜索速度更快、扩展性更灵活的重要版本<button data-href="#Milvus-v22-a-major-release-with-enhanced-stability-faster-search-speed-and-flexible-scalability" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus v2.2 是一个重要的版本，它引入了七项全新功能，并对以前的版本进行了大量突破性改进。让我们仔细看看其中的一些亮点：</p>
<ul>
<li><strong>从文件批量插入实体</strong>：有了这项功能，你只需几行代码就能将一个或多个文件中的实体批量直接上传到 Milvus，省时省力。</li>
<li><strong>查询结果分页</strong>：为了避免在一次远程过程调用（RPC）中返回大量搜索和查询结果，Milvus v2.2 允许你在搜索和查询中配置偏移量并用关键字过滤结果。</li>
<li><strong>基于角色的访问控制（RBAC）</strong>：Milvus v2.2 现在支持 RBAC，允许你通过管理用户、角色和权限来控制对 Milvus 实例的访问。</li>
<li><strong>配额和限制</strong>：配额和限制是 Milvus v2.2 中的一种新机制，可保护数据库系统在突然流量激增时不会发生内存不足（OOM）错误和崩溃。有了这项功能，你可以控制摄取、搜索和内存使用。</li>
<li><strong>Collection 级别的生存时间 (TTL)：</strong>在以前的版本中，Milvus 只允许你为集群配置 TTL。不过，Milvus v2.2 现在支持在 Collections 级别配置 TTL。为特定 Collections 配置 TTL，该 Collections 中的实体将在 TTL 结束后自动过期。这种配置可对数据保留进行更精细的控制。</li>
<li><strong>基于磁盘的近似近邻搜索（ANNS）索引（测试版）</strong>：Milvus v2.2 引入了对 DiskANN 的支持，这是一种固态硬盘驻留和基于 Vamana 图的 ANNS 算法。该支持允许在大规模数据集上直接搜索，可显著减少内存使用量，最多可减少 10 倍。</li>
<li><strong>数据备份（测试版）</strong>：Milvus v2.2 提供了<a href="https://github.com/zilliztech/milvus-backup">一个全新的工具</a>，可通过命令行或 API 服务器正确备份和恢复 Milvus 数据。</li>
</ul>
<p>除上述新功能外，Milvus v2.2 还包括对 5 个错误的修复和多项改进，以增强 Milvus 的稳定性、可观测性和性能。更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md#v220">Milvus v2.2 发布说明</a>。</p>
<h2 id="Milvus-v221--v222-minor-releases-with-issues-fixed" class="common-anchor-header">Milvus v2.2.1 和 v2.2.2：已修复问题的小版本<button data-href="#Milvus-v221--v222-minor-releases-with-issues-fixed" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus v2.2.1 和 v2.2.2 是小版本，主要修复旧版本中的关键问题并引入新功能。以下是一些亮点：</p>
<h3 id="Milvus-v221" class="common-anchor-header">Milvus v2.2.1</h3><ul>
<li>支持 Pulsa 租户和身份验证</li>
<li>在 etcd 配置源中支持传输层安全（TLS）</li>
<li>搜索性能提高 30% 以上</li>
<li>优化调度程序，提高合并任务的概率</li>
<li>修复了多个错误，包括索引标量字段上的术语过滤失败和索引节点在创建索引失败时的恐慌问题</li>
</ul>
<h3 id="Milvus-v222" class="common-anchor-header">Milvus v2.2.2</h3><ul>
<li>修复了代理不更新分片领导缓存的问题</li>
<li>修复了已发布的 Collection/分区的加载信息未清理的问题</li>
<li>修复了加载计数未及时清除的问题</li>
</ul>
<p>更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md#v221">Milvus v2.2.1 发布说明</a>和<a href="https://milvus.io/docs/release_notes.md#v222">Milvus v2.2.2 发布说明</a>。</p>
<h2 id="Milvus-v223-more-secure-stable-and-available" class="common-anchor-header">Milvus v2.2.3：更安全、更稳定、更可用<button data-href="#Milvus-v223-more-secure-stable-and-available" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus v2.2.3 是一个注重增强系统安全性、稳定性和可用性的版本。此外，它还引入了两个重要功能：</p>
<ul>
<li><p><strong>滚动升级</strong>：该功能允许 Milvus 在升级过程中响应传入的请求，这在以前的版本中是不可能实现的。滚动升级可确保系统在升级过程中仍然可用，并对用户请求做出响应。</p></li>
<li><p><strong>协调器高可用性（HA）</strong>：该功能使 Milvus 协调员以主动-备用模式工作，降低了单点故障的风险。即使发生意外灾难，恢复时间也最多可缩短至 30 秒。</p></li>
</ul>
<p>除这些新功能外，Milvus v2.2.3 还包括大量改进和错误修复，包括增强批量插入性能、降低内存使用率、优化监控指标和改进元存储性能。更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md#v223">Milvus v2.2.3 发行说明</a>。</p>
<h2 id="Milvus-v224-faster-more-reliable-and-resource-saving" class="common-anchor-header">Milvus v2.2.4：更快、更可靠、更节省资源<button data-href="#Milvus-v224-faster-more-reliable-and-resource-saving" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus v2.2.4 是 Milvus v2.2 的小更新。它引入了四项新功能和几项增强功能，使性能更快、可靠性更高、资源消耗更少。该版本的亮点包括</p>
<ul>
<li><strong>资源分组</strong>：Milvus 现在支持将 QueryNodes 分组到其他资源组中，允许完全隔离对不同组中物理资源的访问。</li>
<li><strong>Collections 重命名</strong>：Collections 重命名 API 允许用户更改 Collections 的名称，为管理 Collections 提供了更大的灵活性，并提高了可用性。</li>
<li><strong>支持谷歌云存储</strong></li>
<li><strong>搜索和查询 API 中的新选项</strong>：这项新功能允许用户跳过对所有增长段的搜索，在搜索与数据插入同时进行的情况下提供更好的搜索性能。</li>
</ul>
<p>更多信息，请参阅<a href="https://milvus.io/docs/release_notes.md#v224">Milvus v2.2.4 发布说明</a>。</p>
<h2 id="Milvus-v225-NOT-RECOMMENDED" class="common-anchor-header">Milvus v2.2.5：不建议使用<button data-href="#Milvus-v225-NOT-RECOMMENDED" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus v2.2.5 有几个关键问题，因此我们不建议使用此版本。  对于由此造成的不便，我们深表歉意。不过，这些问题已在 Milvus v2.2.6 中得到解决。</p>
<h2 id="Milvus-v226-resolves-critical-issues-from-v225" class="common-anchor-header">Milvus v2.2.6：解决了 v2.2.5 中的关键问题<button data-href="#Milvus-v226-resolves-critical-issues-from-v225" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus v2.2.6 已成功解决了在 v2.2.5 中发现的关键问题，包括回收脏 binlog 数据和 DataCoord GC 失效的问题。如果您目前使用的是 v2.2.5，请升级以确保最佳性能和稳定性。</p>
<p>已修复的关键问题包括</p>
<ul>
<li>DataCoord GC 故障</li>
<li>覆盖已传递的索引参数</li>
<li>RootCoord 消息积压导致的系统延迟</li>
<li>指标 RootCoordInsertChannelTimeTick 不准确</li>
<li>可能的时间戳停止</li>
<li>重启过程中协调器角色偶尔自毁</li>
<li>垃圾收集异常退出导致检查点落后</li>
</ul>
<p>更多详情，请参阅<a href="https://milvus.io/docs/release_notes.md#v226">Milvus v2.2.6 发布说明</a>。</p>
<h2 id="Summary" class="common-anchor-header">总结<button data-href="#Summary" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>总之，Milvus 从 v2.2 到 v2.2.6 的最新版本提供了许多令人兴奋的更新和改进。从新功能到错误修复和优化，Milvus 将继续履行承诺，提供最前沿的解决方案，并增强各领域应用的能力。请继续关注 Milvus 社区带来的更多激动人心的更新和创新。</p>


最好的 Milvus：从 v2.2 到 v2.2.6 的探索

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Dynamically_Change_Log_Levels_in_the_Milvus_Vector_Database_58e31c66cc.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由<a href="https://github.com/jiaoew1991">焦恩伟</a>撰写，<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>翻译。</p>
</blockquote>
<p>为了防止日志输出过多影响磁盘和系统性能，Milvus 在运行时默认输出<code translate="no">info</code> 级别的日志。然而，有时<code translate="no">info</code> 级别的日志并不足以帮助我们有效地识别错误和问题。更糟糕的是，在某些情况下，更改日志级别并重新启动服务可能会导致问题无法重现，使故障排除变得更加困难。因此，迫切需要在 Milvus 向量数据库中支持动态更改日志级别。</p>
<p>本文旨在介绍实现动态更改日志级别的机制，并提供如何在 Milvus 向量数据库中进行更改的说明。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#Mechanism">机制</a></li>
<li><a href="#How-to-dynamically-change-log-levels">如何动态更改日志级别</a></li>
</ul>
<h2 id="Mechanism" class="common-anchor-header">机制<button data-href="#Mechanism" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 向量数据库采用了由 Uber 开源的<a href="https://github.com/uber-go/zap">zap</a>日志记录器。作为 Go 语言生态系统中功能最强大的日志组件之一，zap 集成了<a href="https://github.com/uber-go/zap/blob/master/http_handler.go">http_handler.go</a>模块，因此您可以通过 HTTP 接口查看当前日志级别并动态更改日志级别。</p>
<p>Milvus 监听<code translate="no">9091</code> 端口提供的 HTTP 服务。因此，你可以访问<code translate="no">9091</code> 端口，利用性能调试、度量、健康检查等功能。同样，<code translate="no">9091</code> 端口也可重复使用，以实现动态日志级别修改，并在端口中添加<code translate="no">/log/level</code> 路径。更多信息，请参阅<a href="https://github.com/milvus-io/milvus/pull/18430"> 日志接口 PR</a>。</p>
<h2 id="How-to-dynamically-change-log-levels" class="common-anchor-header">如何动态更改日志级别<button data-href="#How-to-dynamically-change-log-levels" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>本节介绍如何动态更改日志级别，而无需重启正在运行的 Milvus 服务。</p>
<h3 id="Prerequisite" class="common-anchor-header">前提条件</h3><p>确保可以访问 Milvus 组件的<code translate="no">9091</code> 端口。</p>
<h3 id="Change-the-log-level" class="common-anchor-header">更改日志级别</h3><p>假设 Milvus 代理的 IP 地址是<code translate="no">192.168.48.12</code> 。</p>
<p>可以先运行<code translate="no">$ curl -X GET 192.168.48.12:9091/log/level</code> 检查代理当前的日志级别。</p>
<p>然后通过指定日志级别进行调整。日志级别选项包括</p>
<ul>
<li><p><code translate="no">debug</code></p></li>
<li><p><code translate="no">info</code></p></li>
<li><p><code translate="no">warn</code></p></li>
<li><p><code translate="no">error</code></p></li>
<li><p><code translate="no">dpanic</code></p></li>
<li><p><code translate="no">panic</code></p></li>
<li><p><code translate="no">fatal</code></p></li>
</ul>
<p>以下示例代码将日志级别从默认日志级别<code translate="no">info</code> 更改为<code translate="no">error</code> 。</p>
<pre><code translate="no" class="language-Python">$ curl -X PUT 192.168.48.12:9091/log/level -d level=error
<button class="copy-code-btn"></button></code></pre>


动态更改 Milvus 向量数据库中的日志级别

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1280_X1280_0e0d4bc107.png" alt="Cover_image" class="doc-image" id="cover_image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文作者<a href="https://github.com/longjiquan">龙继权</a>，<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>译。</p>
</blockquote>
<p>在<a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">上</a>一篇关于一致性的<a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">博客</a>中，我们解释了什么是分布式向量数据库中一致性的内涵，介绍了 Milvus 向量数据库中支持的强一致性、有界滞后性、会话一致性和最终一致性四种一致性级别，并解释了每种一致性级别最适合的应用场景。</p>
<p>在本篇文章中，我们将继续研究 Milvus 向量数据库的用户能够灵活选择各种应用场景的理想一致性级别的机制。我们还将提供如何在 Milvus 向量数据库中调整一致性级别的基本教程。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#The-underlying-time-tick-mechanism">底层时间刻度机制</a></li>
<li><a href="#Guarantee-timestamp">保证时间戳</a></li>
<li><a href="#Consistency-levels">一致性级别</a></li>
<li><a href="#How-to-tune-consistency-level-in-Milvus">如何调整 Milvus 中的一致性级别？</a></li>
</ul>
<h2 id="The-underlying-time-tick-mechanism" class="common-anchor-header">底层时间刻度机制<button data-href="#The-underlying-time-tick-mechanism" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在进行向量搜索或查询时，Milvus 使用时间刻度机制来确保不同级别的一致性。时间刻度是 Milvus 的水印，它就像 Milvus 中的时钟，标志着 Milvus 系统处于哪个时间点。每当有数据操作语言（DML）请求发送到 Milvus 向量数据库时，它就会给请求分配一个时间戳。如下图所示，例如，当有新数据插入信息队列时，Milvus 不仅会在这些插入的数据上标记时间戳，还会每隔一段时间插入时间刻度。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/timetick_b395df9804.png" alt="timetick" class="doc-image" id="timetick" />
   </span> <span class="img-wrapper"> <span>时间刻度</span> </span></p>
<p>以上图中的<code translate="no">syncTs1</code> 为例。当查询节点等下游消费者看到<code translate="no">syncTs1</code> 时，消费者组件就会明白，所有早于<code translate="no">syncTs1</code> 插入的数据都已被消费。换句话说，时间戳值小于<code translate="no">syncTs1</code> 的数据插入请求将不再出现在消息队列中。</p>
<h2 id="Guarantee-Timestamp" class="common-anchor-header">保证时间戳<button data-href="#Guarantee-Timestamp" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如上一节所述，下游消费组件（如查询节点）会不断从消息队列中获取数据插入请求和时间刻度的消息。每消耗一个时间刻度，查询节点就会将这个消耗的时间刻度标记为可服务时间 -<code translate="no">ServiceTime</code> ，查询节点可看到<code translate="no">ServiceTime</code> 之前插入的所有数据。</p>
<p>除了<code translate="no">ServiceTime</code> 之外，Milvus 还采用了一种时间戳--保证时间戳（<code translate="no">GuaranteeTS</code> ），以满足不同用户对不同程度的一致性和可用性的需求。这意味着，Milvus 向量数据库的用户可以指定<code translate="no">GuaranteeTs</code> ，以便通知查询节点，在进行搜索或查询时，<code translate="no">GuaranteeTs</code> 之前的所有数据都应是可见的和涉及的。</p>
<p>当查询节点在 Milvus 向量数据库中执行搜索请求时，通常有两种情况。</p>
<h3 id="Scenario-1-Execute-search-request-immediately" class="common-anchor-header">情况 1：立即执行搜索请求</h3><p>如下图所示，如果<code translate="no">GuaranteeTs</code> 小于<code translate="no">ServiceTime</code> ，查询节点可以立即执行搜索请求。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/execute_immediately_dd1913775d.png" alt="execute_immediately" class="doc-image" id="execute_immediately" />
   </span> <span class="img-wrapper"> <span>立即执行</span> </span></p>
<h3 id="Scenario-2-Wait-till-ServiceTime--GuaranteeTs" class="common-anchor-header">方案 2：等待至 "ServiceTime &gt; GuaranteeTs"（服务时间 &gt; 保证时间</h3><p>如果<code translate="no">GuaranteeTs</code> 大于<code translate="no">ServiceTime</code> ，查询节点必须继续消耗消息队列中的时间刻度。在<code translate="no">ServiceTime</code> 大于<code translate="no">GuaranteeTs</code> 之前，查询请求无法执行。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/wait_search_f09a2f6cf9.png" alt="wait_search" class="doc-image" id="wait_search" />
   </span> <span class="img-wrapper"> <span>等待搜索</span> </span></p>
<h2 id="Consistency-Levels" class="common-anchor-header">一致性级别<button data-href="#Consistency-Levels" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>因此，可以在搜索请求中配置<code translate="no">GuaranteeTs</code> ，以实现您指定的一致性级别。<code translate="no">GuaranteeTs</code> 的值越大，<a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md#Strong">一致性越强</a>，但搜索延迟也越高。而<code translate="no">GuaranteeTs</code> 的值越小，搜索延迟越短，但数据的可见性会受到影响。</p>
<p><code translate="no">GuaranteeTs</code> 在 Milvus 是一种混合时间戳格式。而用户对 Milvus 内部的<a href="https://github.com/milvus-io/milvus/blob/master/docs/design_docs/20211214-milvus_hybrid_ts.md">TSO</a>一无所知。因此，对用户来说，指定 的值是一项过于复杂的任务。为了省去用户的麻烦，提供最佳的用户体验，Milvus 只需要用户选择特定的一致性级别，Milvus 向量数据库就会自动为用户处理 值。也就是说，Milvus 用户只需从四种一致性级别中进行选择：, , , 和 。每个一致性级别都对应一定的 值。<code translate="no">GuaranteeTs</code> <code translate="no">GuaranteeTs</code> <code translate="no">Strong</code> <code translate="no">Bounded</code> <code translate="no">Session</code> <code translate="no">Eventually</code> <code translate="no">GuaranteeTs</code> </p>
<p>下图展示了 Milvus 向量数据库中四个一致性级别的<code translate="no">GuaranteeTs</code> 。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/guarantee_ts_f4b3e119d3.png" alt="guarantee_ts" class="doc-image" id="guarantee_ts" />
   </span> <span class="img-wrapper"> <span>保证</span> </span></p>
<p>Milvus 向量数据库支持四级一致性：</p>
<ul>
<li><p><code translate="no">CONSISTENCY_STRONG</code>：<code translate="no">GuaranteeTs</code> 设置为与最新系统时间戳相同的值，查询节点等待服务时间到达最新系统时间戳后再处理搜索或查询请求。</p></li>
<li><p><code translate="no">CONSISTENCY_EVENTUALLY</code>：<code translate="no">GuaranteeTs</code> 设置为比最新系统时间戳小得多的值，以跳过一致性检查。查询节点会立即在现有数据视图上进行搜索。</p></li>
<li><p><code translate="no">CONSISTENCY_BOUNDED</code>：<code translate="no">GuaranteeTs</code> 设置为相对小于最新系统时间戳的值，查询节点会在更新较少的数据视图上进行搜索。</p></li>
<li><p><code translate="no">CONSISTENCY_SESSION</code>:客户端使用最后一次写操作的时间戳作为<code translate="no">GuaranteeTs</code> ，这样每个客户端至少可以检索到自己插入的数据。</p></li>
</ul>
<h2 id="How-to-tune-consistency-level-in-Milvus" class="common-anchor-header">如何调整 Milvus 的一致性级别？<button data-href="#How-to-tune-consistency-level-in-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 支持在<a href="https://milvus.io/docs/v2.1.x/create_collection.md">创建 Collections</a>或进行<a href="https://milvus.io/docs/v2.1.x/search.md">搜索</a>或<a href="https://milvus.io/docs/v2.1.x/query.md">查询</a>时调整一致性级别。</p>
<h3 id="Conduct-a-vector-similarity-search" class="common-anchor-header">进行向量相似性搜索</h3><p>要按照所需的一致性级别进行向量相似性搜索，只需将参数<code translate="no">consistency_level</code> 的值设置为<code translate="no">Strong</code>,<code translate="no">Bounded</code>,<code translate="no">Session</code>, 或<code translate="no">Eventually</code> 即可。如果不设置参数<code translate="no">consistency_level</code> 的值，一致性级别默认为<code translate="no">Bounded</code> 。该示例使用<code translate="no">Strong</code> 一致性进行向量相似性搜索。</p>
<pre><code translate="no">results = collection.search(
        data=[[0.1, 0.2]], 
        anns_field=<span class="hljs-string">&quot;book_intro&quot;</span>, 
        param=search_params, 
        <span class="hljs-built_in">limit</span>=10, 
        <span class="hljs-built_in">expr</span>=None,
        consistency_level=<span class="hljs-string">&quot;Strong&quot;</span>
)
<button class="copy-code-btn"></button></code></pre>
<h3 id="Conduct-a-vector-query" class="common-anchor-header">进行向量查询</h3><p>与进行向量相似性搜索类似，在进行向量查询时也可以指定参数<code translate="no">consistency_level</code> 的值。示例使用<code translate="no">Strong</code> 一致性进行了向量查询。</p>
<pre><code translate="no">res = collection.query(
  <span class="hljs-built_in">expr</span> = <span class="hljs-string">&quot;book_id in [2,4,6,8]&quot;</span>, 
  output_fields = [<span class="hljs-string">&quot;book_id&quot;</span>, <span class="hljs-string">&quot;book_intro&quot;</span>],
  consistency_level=<span class="hljs-string">&quot;Strong&quot;</span>
)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Whats-next" class="common-anchor-header">下一步<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客中的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库的一致性水平</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database-2.md">了解 Milvus 向量数据库的一致性水平（第二部分）</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


了解 Milvus 向量数据库中的一致性水平 - 第二部分

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Security_192e35a790.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<p>为充分考虑您的数据安全，用户认证和传输层安全（TLS）连接现已在 Milvus 2.1 中正式提供。如果没有用户身份验证，任何人都可以通过 SDK 访问向量数据库中的所有数据。不过，从 Milvus 2.1 开始，只有拥有有效用户名和密码的人才能访问 Milvus 向量数据库。此外，Milvus 2.1 还通过 TLS 进一步保护数据安全，确保计算机网络中的通信安全。</p>
<p>本文旨在分析 Milvus 向量数据库如何通过用户身份验证和 TLS 连接来确保数据安全，并说明作为用户在使用向量数据库时如何利用这两项功能来确保数据安全。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#What-is-database-security-and-why-is-it-important">什么是数据库安全，为什么它很重要？</a></li>
<li><a href="#How-does-the-Milvus-vector-database-ensure-data-security">Milvus 向量数据库如何确保数据安全？</a><ul>
<li><a href="#User-authentication">用户身份验证</a></li>
<li><a href="#TLS-connection">TLS 连接</a></li>
</ul></li>
</ul>
<h2 id="What-is-database-security-and-why-is-it-important" class="common-anchor-header">什么是数据库安全？<button data-href="#What-is-database-security-and-why-is-it-important" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>数据库安全是指为确保数据库中所有数据的安全和保密而采取的措施。最近<a href="https://firewalltimes.com/recent-data-breaches/">Twitter、万豪酒店和德克萨斯州保险部等</a>发生的数据泄露事件让我们对数据安全问题更加警惕。所有这些案例不断提醒我们，如果数据没有得到很好的保护，如果使用的数据库不安全，公司和企业就会遭受严重损失。</p>
<h2 id="How-does-the-Milvus-vector-database-ensure-data-security" class="common-anchor-header">Milvus 向量数据库如何确保数据安全？<button data-href="#How-does-the-Milvus-vector-database-ensure-data-security" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在当前发布的 2.1 版中，Milvus 向量数据库试图通过身份验证和加密来确保数据库安全。更具体地说，在访问层面，Milvus 支持基本的用户身份验证，以控制谁可以访问数据库。同时，在数据库层面，Milvus 采用传输层安全（TLS）加密协议来保护数据通信。</p>
<h3 id="User-authentication" class="common-anchor-header">用户身份验证</h3><p>出于数据安全的考虑，Milvus 的基本用户认证功能支持使用用户名和密码访问向量数据库。这意味着客户只有在提供经过验证的用户名和密码后才能访问 Milvus 实例。</p>
<h4 id="The-authentication-workflow-in-the-Milvus-vector-database" class="common-anchor-header">Milvus 向量数据库的验证工作流程</h4><p>所有 gRPC 请求都由 Milvus 代理处理，因此身份验证由代理完成。使用凭据登录以连接 Milvus 实例的工作流程如下。</p>
<ol>
<li>为每个 Milvus 实例创建凭据，加密后的密码存储在 etcd 中。Milvus 使用<a href="https://golang.org/x/crypto/bcrypt">bcrypt</a>进行加密，因为它实现了 Provos 和 Mazières 的<a href="http://www.usenix.org/event/usenix99/provos/provos.pdf">自适应散列算法</a>。</li>
<li>在客户端，SDK 会在连接 Milvus 服务时发送密码文本。base64 密文（<username>:<password> ）以密钥<code translate="no">authorization</code> 附加到元数据中。</li>
<li>Milvus 代理拦截请求并验证凭据。</li>
<li>凭证缓存在代理服务器本地。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1280_X1280_021e90e3c8.jpeg" alt="authetication_workflow" class="doc-image" id="authetication_workflow" />
   </span> <span class="img-wrapper"> <span>自动验证工作流程</span> </span></p>
<p>更新证书时，Milvus 的系统工作流程如下</p>
<ol>
<li>当调用插入、查询、删除 API 时，根协调员负责凭证。</li>
<li>当你因为忘记密码等原因更新证书时，新密码会被持久化到 etcd 中。然后，代理本地缓存中的所有旧凭证都会失效。</li>
<li>身份验证拦截器会首先从本地缓存中查找记录。如果缓存中的凭据不正确，就会触发 RPC 调用，从根协调器中获取最新记录。本地缓存中的凭据也会相应更新。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/update_5af81a4173.jpeg" alt="credential_update_workflow" class="doc-image" id="credential_update_workflow" />
   </span> <span class="img-wrapper"> <span>凭证更新工作流程</span> </span></p>
<h4 id="How-to-manage-user-authentication-in-the-Milvus-vector-database" class="common-anchor-header">如何在 Milvus 向量数据库中管理用户身份验证</h4><p>要启用身份验证，首先需要在<code translate="no">milvus.yaml</code> 文件中配置 Milvus 时将<code translate="no">common.security.authorizationEnabled</code> 设置为<code translate="no">true</code> 。</p>
<p>启用后，将为 Milvus 实例创建一个根用户。这个根用户可以使用<code translate="no">Milvus</code> 的初始密码连接到 Milvus 向量数据库。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> connections
connections.<span class="hljs-title function_">connect</span>(
    alias=<span class="hljs-string">&#x27;default&#x27;</span>,
    host=<span class="hljs-string">&#x27;localhost&#x27;</span>,
    port=<span class="hljs-string">&#x27;19530&#x27;</span>,
    user=<span class="hljs-string">&#x27;root_user&#x27;</span>,
    password=<span class="hljs-string">&#x27;Milvus&#x27;</span>,
)
<button class="copy-code-btn"></button></code></pre>
<p>我们强烈建议在首次启动 Milvus 时更改根用户的密码。</p>
<p>然后，root 用户可以进一步创建更多新用户，通过运行以下命令创建新用户来进行身份验证访问。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> utility
utility.<span class="hljs-title function_">create_credential</span>(<span class="hljs-string">&#x27;user&#x27;</span>, <span class="hljs-string">&#x27;password&#x27;</span>, <span class="hljs-keyword">using</span>=<span class="hljs-string">&#x27;default&#x27;</span>) 
<button class="copy-code-btn"></button></code></pre>
<p>创建新用户时要注意两点：</p>
<ol>
<li><p>新用户名长度不能超过 32 个字符，必须以字母开头。用户名中只能包含下划线、字母或数字。例如，不接受 "2abc!"这样的用户名。</p></li>
<li><p>至于密码，长度应为 6-256 个字符。</p></li>
</ol>
<p>设置好新凭证后，新用户就可以用用户名和密码连接到 Milvus 实例。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> connections
connections.<span class="hljs-title function_">connect</span>(
    alias=<span class="hljs-string">&#x27;default&#x27;</span>,
    host=<span class="hljs-string">&#x27;localhost&#x27;</span>,
    port=<span class="hljs-string">&#x27;19530&#x27;</span>,
    user=<span class="hljs-string">&#x27;user&#x27;</span>,
    password=<span class="hljs-string">&#x27;password&#x27;</span>,
)
<button class="copy-code-btn"></button></code></pre>
<p>与所有身份验证过程一样，您不必担心忘记密码。可以使用以下命令重置现有用户的密码。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> utility
utility.<span class="hljs-title function_">reset_password</span>(<span class="hljs-string">&#x27;user&#x27;</span>, <span class="hljs-string">&#x27;new_password&#x27;</span>, <span class="hljs-keyword">using</span>=<span class="hljs-string">&#x27;default&#x27;</span>)
<button class="copy-code-btn"></button></code></pre>
<p>阅读<a href="https://milvus.io/docs/v2.1.x/authenticate.md">Milvus 文档</a>，了解有关用户身份验证的更多信息。</p>
<h3 id="TLS-connection" class="common-anchor-header">TLS 连接</h3><p>传输层安全（TLS）是一种身份验证协议，为计算机网络提供通信安全。TLS 使用证书在两个或多个通信方之间提供身份验证服务。</p>
<h4 id="How-to-enable-TLS-in-the-Milvus-vector-database" class="common-anchor-header">如何在 Milvus 向量数据库中启用 TLS</h4><p>要在 Milvus 中启用 TLS，首先需要运行以下命令来准备两个用于生成证书的文件：一个名为<code translate="no">openssl.cnf</code> 的默认 OpenSSL 配置文件和一个用于生成相关证书的名为<code translate="no">gen.sh</code> 的文件。</p>
<pre><code translate="no"><span class="hljs-built_in">mkdir</span> cert &amp;&amp; <span class="hljs-built_in">cd</span> cert
<span class="hljs-built_in">touch</span> openssl.cnf gen.sh
<button class="copy-code-btn"></button></code></pre>
<p>然后，只需将我们提供的配置复制并粘贴到<a href="https://milvus.io/docs/v2.1.x/tls.md#Create-files">这</a>两个文件中即可。或者，你也可以根据我们的配置进行修改，以更好地适应你的应用。</p>
<p>两个文件准备就绪后，就可以运行<code translate="no">gen.sh</code> 文件来创建九个证书文件了。同样，你也可以根据自己的需要修改九个证书文件中的配置。</p>
<pre><code translate="no"><span class="hljs-built_in">chmod</span> +x gen.sh
./gen.sh
<button class="copy-code-btn"></button></code></pre>
<p>在使用 TLS 连接 Milvus 服务之前，还有最后一步。您必须将<code translate="no">tlsEnabled</code> 设置为<code translate="no">true</code> ，并在<code translate="no">config/milvus.yaml</code> 中为服务器配置<code translate="no">server.pem</code> 、<code translate="no">server.key</code> 和<code translate="no">ca.pem</code> 的文件路径。下面的代码是一个示例。</p>
<pre><code translate="no">tls:
  serverPemPath: configs/cert/server.pem
  serverKeyPath: configs/cert/server.key
  caPemPath: configs/cert/ca.pem

common:
  security:
    tlsEnabled: <span class="hljs-literal">true</span>
<button class="copy-code-btn"></button></code></pre>
<p>然后，只要在使用 Milvus 连接 SDK 时为客户端指定<code translate="no">client.pem</code>,<code translate="no">client.key</code>, 和<code translate="no">ca.pem</code> 的文件路径，就可以使用 TLS 连接 Milvus 服务了。下面的代码也是一个示例。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> connections

_HOST = <span class="hljs-string">&#x27;127.0.0.1&#x27;</span>
_PORT = <span class="hljs-string">&#x27;19530&#x27;</span>

<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;\nCreate connection...&quot;</span>)
connections.connect(host=_HOST, port=_PORT, secure=<span class="hljs-literal">True</span>, client_pem_path=<span class="hljs-string">&quot;cert/client.pem&quot;</span>,
                        client_key_path=<span class="hljs-string">&quot;cert/client.key&quot;</span>,
                        ca_pem_path=<span class="hljs-string">&quot;cert/ca.pem&quot;</span>, server_name=<span class="hljs-string">&quot;localhost&quot;</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;\nList connections:&quot;</span>)
<span class="hljs-built_in">print</span>(connections.list_connections())
<button class="copy-code-btn"></button></code></pre>
<h2 id="Whats-next" class="common-anchor-header">下一步计划<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客中的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库中的一致性水平</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database-2.md">了解 Milvus 向量数据库的一致性水平（第二部分）</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


Milvus 向量数据库如何确保数据安全？

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1280_X1280_0e0d4bc107.png" alt="Cover_image" class="doc-image" id="cover_image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由<a href="https://github.com/JackLCL">李成龙</a>撰写，<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>翻译。</p>
</blockquote>
<p>您是否想过，为什么有时从 Mlivus 向量数据库中删除的数据仍然会出现在搜索结果中？</p>
<p>一个很可能的原因是，您没有为自己的应用程序设置适当的一致性级别。分布式向量数据库中的一致性级别至关重要，因为它决定了系统在哪一点上可以读取特定的数据写入。</p>
<p>因此，本文旨在揭开一致性概念的神秘面纱，并深入探讨 Milvus 向量数据库支持的一致性级别。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#What-is-consistency">什么是一致性</a></li>
<li><a href="#Four-levels-of-consistency-in-the-Milvus-vector-database">Milvus 向量数据库的四种一致性级别</a><ul>
<li><a href="#Strong">强</a></li>
<li><a href="#Bounded-staleness">有界滞后性</a></li>
<li><a href="#Session">会话</a></li>
<li><a href="#Eventual">最终</a></li>
</ul></li>
</ul>
<h2 id="What-is-consistency" class="common-anchor-header">什么是一致性<button data-href="#What-is-consistency" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在开始讨论之前，我们首先需要澄清本文中一致性的内涵，因为 "一致性 "一词在计算机行业中是一个过载的术语。分布式数据库中的一致性特指确保每个节点或副本在给定时间写入或读取数据时对数据有相同看法的属性。因此，我们在这里讨论的是<a href="https://en.wikipedia.org/wiki/CAP_theorem">CAP 定理</a>中的一致性。</p>
<p>在现代世界中，为了服务于大规模的在线业务，通常会采用多个副本。例如，在线电子商务巨头亚马逊在多个数据中心、地区甚至国家复制其订单或 SKU 数据，以确保在系统崩溃或故障时系统的高可用性。这就给系统带来了一个挑战--多个副本之间的数据一致性。如果没有一致性，亚马逊购物车中被删除的商品很可能会重新出现，造成非常糟糕的用户体验。</p>
<p>因此，我们需要为不同的应用提供不同的数据一致性级别。幸运的是，Milvus 作为一款人工智能数据库，提供了灵活的一致性级别，您可以设置最适合自己应用的一致性级别。</p>
<h3 id="Consistency-in-the-Milvus-vector-database" class="common-anchor-header">Milvus 向量数据库中的一致性</h3><p>一致性级别的概念是在 Milvus 2.0 发布时首次提出的。Milvus 1.0 版本不是分布式向量数据库，因此我们当时没有涉及可调整的一致性级别。Milvus 1.0 每秒刷新一次数据，这意味着新数据插入后几乎立即可见，而且当向量相似性搜索或查询请求到来时，Milvus 会在准确的时间点读取最新的数据视图。</p>
<p>不过，Milvus 在 2.0 版本中进行了重构，<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">Milvus 2.0 是</a>基于 pub-sub 机制<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">的分布式向量数据库</a>。<a href="https://en.wikipedia.org/wiki/PACELC_theorem">PACELC</a>定理指出，分布式系统必须在一致性、可用性和延迟之间进行权衡。此外，不同级别的一致性适用于不同的应用场景。因此，<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">Milvus 2.0</a>引入了一致性的概念，并支持一致性级别的调整。</p>
<h2 id="Four-levels-of-consistency-in-the-Milvus-vector-database" class="common-anchor-header">Milvus 向量数据库的四级一致性<button data-href="#Four-levels-of-consistency-in-the-Milvus-vector-database" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 支持四种级别的一致性：强一致性、有界滞后性、会话一致性和最终一致性。而 Milvus 用户可以在<a href="https://milvus.io/docs/v2.1.x/create_collection.md">创建 Collections</a>或进行<a href="https://milvus.io/docs/v2.1.x/search.md">向量相似性搜索</a>或<a href="https://milvus.io/docs/v2.1.x/query.md">查询</a>时指定一致性级别。本节将继续解释这四种一致性级别有何不同，以及它们最适合哪种情况。</p>
<h3 id="Strong" class="common-anchor-header">强</h3><p>强是最高、最严格的一致性级别。它确保用户可以读取最新版本的数据。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Consistency_Strong_5d791eb8b2.png" alt="Strong" class="doc-image" id="strong" />
   </span> <span class="img-wrapper"> <span>强</span> </span></p>
<p>根据 PACELC 定理，如果将一致性级别设置为强，延迟会增加。因此，我们建议在功能测试时选择强一致性，以确保测试结果的准确性。强一致性也最适合那些以牺牲搜索速度为代价、对数据一致性有严格要求的应用。处理订单付款和账单的在线财务系统就是一个例子。</p>
<h3 id="Bounded-staleness" class="common-anchor-header">有界滞后</h3><p>有界僵化，顾名思义，允许数据在一定时间内不一致。不过，一般来说，在这段时间之外，数据始终是全局一致的。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Consistency_Bounded_c034bc6e51.png" alt="Bounded_staleness" class="doc-image" id="bounded_staleness" />
   </span> <span class="img-wrapper"> <span>有界滞后</span> </span></p>
<p>有界滞后性适用于需要控制搜索延迟并能接受零星数据不可见的场景。例如，在视频推荐引擎等推荐系统中，偶尔的数据不可见对总体召回率的影响确实很小，但却能显著提升推荐系统的性能。一个例子是用于跟踪在线订单状态的应用程序。</p>
<h3 id="Session" class="common-anchor-header">会话</h3><p>会话确保所有数据写入都能在同一会话中立即被读取。换句话说，当你通过一个客户端写入数据时，新插入的数据会立即成为可搜索的数据。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Consistency_Session_6dc4782212.png" alt="Session" class="doc-image" id="session" />
   </span> <span class="img-wrapper"> <span>会话</span> </span></p>
<p>我们建议在对同一会话中数据一致性要求较高的情况下选择会话作为一致性级别。例如，从图书馆系统中删除图书条目的数据，在确认删除并刷新页面（不同的会话）后，该图书在搜索结果中应该不再可见。</p>
<h3 id="Eventual" class="common-anchor-header">最终</h3><p>读取和写入的顺序没有保证，在不再进行写操作的情况下，副本最终会收敛到相同的状态。在最终一致性下，副本会使用最新更新的值开始处理读取请求。最终一致性是四种一致性中最弱的一种。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Consistency_Eventual_7c66dd5b6f.png" alt="Eventual" class="doc-image" id="eventual" />
   </span> <span class="img-wrapper"> <span>最终</span> </span>一致性</p>
<p>然而，根据 PACELC 定理，牺牲一致性可以大大缩短搜索延迟。因此，最终一致性最适用于对数据一致性要求不高但需要极快搜索性能的场景。使用最终一致性检索亚马逊产品的评论和评级就是一个例子。</p>
<h2 id="Endnote" class="common-anchor-header">尾注<button data-href="#Endnote" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>回到本文开头提出的问题，由于用户没有选择适当的一致性级别，删除的数据仍会作为搜索结果返回。在 milvus 向量数据库中，一致性级别的默认值是有界滞后（<code translate="no">Bounded</code> ）。因此，数据读取可能会滞后，Milvus 可能会碰巧在您进行相似性搜索或查询时进行删除操作之前读取数据视图。不过，这个问题很容易解决。您只需在创建 Collections 或进行向量相似性搜索或查询时<a href="https://milvus.io/docs/v2.1.x/tune_consistency.md">调整一致性级别</a>即可。很简单！</p>
<p>在下一篇文章中，我们将揭开其背后的机制，并解释 Milvus 向量数据库如何实现不同级别的一致性。敬请期待！</p>
<h2 id="Whats-next" class="common-anchor-header">下一步<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客中的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库中的一致性水平</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database-2.md">了解 Milvus 向量数据库的一致性水平（第二部分）</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


了解 Milvus 向量数据库中的一致性水平

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/in_memory_replica_af1fa21d61.png" alt="Cover_image" class="doc-image" id="cover_image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文<a href="https://github.com/congqixia">由夏琮琦</a>和<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>共同撰写。</p>
</blockquote>
<p>Milvus 2.1 正式发布后，新增了许多功能，为用户提供了便利和更好的用户体验。虽然对于分布式数据库世界来说，内存中副本的概念并不新鲜，但它却是一个能帮助你轻松提高系统性能和增强系统可用性的关键功能。因此，本篇文章将着手解释什么是内存中复制以及它的重要性，然后介绍如何在用于人工智能的向量数据库 Milvus 中启用这项新功能。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><p><a href="#Concepts-related-to-in-memory-replica">与内存中复制相关的概念</a></p></li>
<li><p><a href="#What-is-in-memory-replica">什么是内存中复制？</a></p></li>
<li><p><a href="#Why-are-in-memory-replicas-important">为什么内存中副本很重要？</a></p></li>
<li><p><a href="#Enable-in-memory-replicas-in-the-Milvus-vector-database">在 Milvus 向量数据库中启用内存中副本</a></p></li>
</ul>
<h2 id="Concepts-related-to-in-memory-replica" class="common-anchor-header">与内存中副本相关的概念<button data-href="#Concepts-related-to-in-memory-replica" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在了解什么是内存中副本以及为什么它很重要之前，我们首先需要了解一些相关概念，包括副本组、分片副本、流式副本、历史副本和分片领导者。下图是这些概念的示意图。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/diagram_1_525afc706a.jpg" alt="Replica_concepts" class="doc-image" id="replica_concepts" />
   </span> <span class="img-wrapper"> <span>复制概念</span> </span></p>
<h3 id="Replica-group" class="common-anchor-header">副本组</h3><p>副本组由多个负责处理历史数据和副本的<a href="https://milvus.io/docs/v2.1.x/four_layers.md#Query-node">查询节点</a>组成。</p>
<h3 id="Shard-replica" class="common-anchor-header">碎片副本</h3><p>分片副本由流式副本和历史副本组成，两者属于同一个<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md#Shard">分片</a>（即 DML 通道）。多个分片副本组成一个副本组。而副本组中碎片副本的确切数量是由指定 Collections 中碎片的数量决定的。</p>
<h3 id="Streaming-replica" class="common-anchor-header">流副本</h3><p>流式副本包含来自同一 DML 通道的所有<a href="https://milvus.io/docs/v2.1.x/glossary.md#Segment">增长片段</a>。从技术上讲，流副本只能由一个副本中的一个查询节点提供服务。</p>
<h3 id="Historical-replica" class="common-anchor-header">历史副本</h3><p>历史副本包含来自同一 DML 通道的所有密封数据段。一个历史副本的密封分段可分布在同一副本组内的多个查询节点上。</p>
<h3 id="Shard-leader" class="common-anchor-header">分片组长</h3><p>分片领导是在分片副本中为流式副本提供服务的查询节点。</p>
<h2 id="What-is-in-memory-replica" class="common-anchor-header">什么是内存复制？<button data-href="#What-is-in-memory-replica" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>启用内存中副本后，就可以在多个查询节点上加载 Collections 中的数据，这样就可以充分利用额外的 CPU 和内存资源。如果你的数据集相对较小，但又想提高读取吞吐量和硬件资源的利用率，这项功能就非常有用。</p>
<p>Milvus 向量数据库暂时在内存中为每个数据段保存一个副本。不过，有了内存中的副本，就可以在不同的查询节点上对一个数据段进行多次复制。这意味着，如果一个查询节点正在对一个数据段进行搜索，那么新收到的搜索请求可以分配给另一个空闲的查询节点，因为这个查询节点拥有完全相同的数据段副本。</p>
<p>此外，如果我们有多个内存复制，就能更好地应对查询节点崩溃的情况。以前，我们必须等待段重新加载，才能在另一个查询节点上继续搜索。但是，有了内存复制，搜索请求可以立即重新发送到新的查询节点，而无需再次重新加载数据。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/replication_3_1_2c25513cb9.jpg" alt="Replication" class="doc-image" id="replication" />
   </span> <span class="img-wrapper"> <span>复制</span> </span></p>
<h2 id="Why-are-in-memory-replicas-important" class="common-anchor-header">内存中复制为何重要？<button data-href="#Why-are-in-memory-replicas-important" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>启用内存复制的最大好处之一是提高整体 QPS（每秒查询次数）和吞吐量。此外，还可以维护多个网段副本，系统在发生故障切换时也更有弹性。</p>
<h2 id="Enable-in-memory-replicas-in-the-Milvus-vector-database" class="common-anchor-header">在 Milvus 向量数据库中启用内存内副本<button data-href="#Enable-in-memory-replicas-in-the-Milvus-vector-database" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 Milvus 向量数据库中启用内存中复制这一新功能毫不费力。只需在加载 Collections 时指定所需的副本数量即可（即调用<code translate="no">collection.load()</code> ）。</p>
<p>在下面的示例教程中，我们假设你已经<a href="https://milvus.io/docs/v2.1.x/create_collection.md">创建了一个</a>名为 "book "<a href="https://milvus.io/docs/v2.1.x/create_collection.md">的 Collections</a>并向其中<a href="https://milvus.io/docs/v2.1.x/insert_data.md">插入了数据</a>。然后，您可以运行以下命令，在<a href="https://milvus.io/docs/v2.1.x/load_collection.md">加载</a>图书 Collection 时创建两个副本。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> Collection
collection = Collection(<span class="hljs-string">&quot;book&quot;</span>)      <span class="hljs-comment"># Get an existing collection.</span>
collection.load(replica_number=<span class="hljs-number">2</span>) <span class="hljs-comment"># load collection as 2 replicas</span>
<button class="copy-code-btn"></button></code></pre>
<p>您可以灵活修改上述示例代码中的副本数量，以最适合您的应用场景。然后，您就可以直接在多个副本上进行向量相似性<a href="https://milvus.io/docs/v2.1.x/search.md">搜索</a>或<a href="https://milvus.io/docs/v2.1.x/query.md">查询</a>，而无需运行任何额外的命令。不过，需要注意的是，允许的最大副本数量受限于运行查询节点的可用内存总量。如果您指定的副本数量超过了可用内存的限制，那么在数据加载过程中将返回错误信息。</p>
<p>您还可以通过运行<code translate="no">collection.get_replicas()</code> 来检查您创建的内存中副本的信息。将返回副本组以及相应查询节点和分片的信息。下面是一个输出示例。</p>
<pre><code translate="no">Replica <span class="hljs-built_in">groups</span>:
- Group: &lt;group_id:435309823872729305&gt;, &lt;group_nodes:(21, 20)&gt;, &lt;shards:[Shard: &lt;channel_name:milvus-zong-rootcoord-dml_27_435367661874184193v0&gt;, &lt;shard_leader:21&gt;, &lt;shard_nodes:[21]&gt;, Shard: &lt;channel_name:milvus-zong-rootcoord-dml_28_435367661874184193v1&gt;, &lt;shard_leader:20&gt;, &lt;shard_nodes:[20, 21]&gt;]&gt;
- Group: &lt;group_id:435309823872729304&gt;, &lt;group_nodes:(25,)&gt;, &lt;shards:[Shard: &lt;channel_name:milvus-zong-rootcoord-dml_28_435367661874184193v1&gt;, &lt;shard_leader:25&gt;, &lt;shard_nodes:[25]&gt;, Shard: &lt;channel_name:milvus-zong-rootcoord-dml_27_435367661874184193v0&gt;, &lt;shard_leader:25&gt;, &lt;shard_nodes:[25]&gt;]&gt;
<button class="copy-code-btn"></button></code></pre>
<h2 id="Whats-next" class="common-anchor-header">下一步<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客中的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库的一致性水平</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database-2.md">了解 Milvus 向量数据库的一致性水平（第二部分）</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


利用内存副本提高向量数据库的读取吞吐量

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Benchmark_Quick_Setup_58cc8eed5b.png" alt="Cover" class="doc-image" id="cover" />
   </span> <span class="img-wrapper"> <span>封面</span> </span></p>
<p>最近，我们更新了<a href="https://milvus.io/docs/v2.1.x/benchmark.md">Milvus 2.1 的基准报告</a>。使用 100 万向量数据集进行的测试证明，通过合并<a href="https://milvus.io/docs/v2.1.x/benchmark.md#Terminology">小</a>查询，QPS 可以显著提高。</p>
<p>下面是一些简单的脚本，您可以轻松重现测试结果。</p>
<h2 id="Procedures" class="common-anchor-header">操作步骤<button data-href="#Procedures" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ol>
<li><p>部署 Milvus 单机或集群。在本例中，Milvus 服务器的 IP 地址是 10.100.31.105。</p></li>
<li><p>部署客户端。在本例中，我们使用 Ubuntu 18.04 和 Python 3.8.13 进行部署。运行以下代码安装 PyMilvus 2.1.1。</p></li>
</ol>
<pre><code translate="no">pip install pymilvus==2.1.1
<button class="copy-code-btn"></button></code></pre>
<ol start="3">
<li><p>下载并复制以下文件到与客户端相同的工作目录。在本例中，工作目录是<code translate="no">/go_ben</code>.</p>
<ul>
<li><p><a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/collection_prepare.py"><code translate="no">collection_prepare.py</code></a></p></li>
<li><p><a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/go_benchmark.py"><code translate="no">go_benchmark.py</code></a></p></li>
<li><p><a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/benchmark"><code translate="no">benchmark</code></a>(适用于 Ubuntu）或 <a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/benchmark-mac"><code translate="no">benchmark-mac</code></a>(适用于 macOS）</p></li>
</ul>
<p><strong>注意</strong></p>
<ul>
<li><p><code translate="no">benchmark</code> 和 是使用 Go SDK 2.1.1 开发和编译的可执行文件。它们仅用于进行并发搜索。<code translate="no">benchmark-mac</code> </p></li>
<li><p>Ubuntu 用户请下载<code translate="no">benchmark</code> ；macOS 用户请下载<code translate="no">benchmark-mac</code> 。</p></li>
<li><p>访问<code translate="no">benchmark</code> 或<code translate="no">benchmark-mac</code> 需要可执行权限。</p></li>
<li><p>Mac 用户需要通过在 "系统偏好设置 "中配置 "安全与隐私 "来信任<code translate="no">benchmark-mac</code> 文件。</p></li>
<li><p>有关并发搜索的设置可在<code translate="no">go_benchmark.py</code> 源代码中找到并修改。</p></li>
</ul></li>
</ol>
<ol start="4">
<li>创建 Collections 并插入向量数据。</li>
</ol>
<pre><code translate="no">root@milvus-pytest:/go_ben<span class="hljs-comment"># python collection_prepare.py 10.100.31.105 </span>
<button class="copy-code-btn"></button></code></pre>
<ol start="5">
<li>打开<code translate="no">/tmp/collection_prepare.log</code> 查看运行结果。</li>
</ol>
<pre><code translate="no">...
08/11/2022 17:33:34 PM - INFO - Build index costs 263.626
08/11/2022 17:33:54 PM - INFO - Collection prepared completed
<button class="copy-code-btn"></button></code></pre>
<ol start="6">
<li>调用<code translate="no">benchmark</code> （或 macOS 上的<code translate="no">benchmark-mac</code> ）进行并发搜索。</li>
</ol>
<pre><code translate="no">root@milvus-pytest:/go_ben<span class="hljs-meta"># python go_benchmark.py 10.100.31.105 ./benchmark</span>
[<span class="hljs-meta">write_json_file</span>] <span class="hljs-function">Remove <span class="hljs-title">file</span>(<span class="hljs-params">search_vector_file.json</span>).
[write_json_file] Write json <span class="hljs-keyword">file</span>:search_vector_file.json done.
Params of go_benchmark: [&#x27;./benchmark&#x27;, &#x27;locust&#x27;, &#x27;-u&#x27;, &#x27;10.100.31.105:19530&#x27;, &#x27;-q&#x27;, &#x27;search_vector_file.json&#x27;, &#x27;-s&#x27;, &#x27;</span>{\n  <span class="hljs-string">&quot;collection_name&quot;</span>: <span class="hljs-string">&quot;random_1m&quot;</span>,\n  <span class="hljs-string">&quot;partition_names&quot;</span>: [],\n  <span class="hljs-string">&quot;fieldName&quot;</span>: <span class="hljs-string">&quot;embedding&quot;</span>,\n  <span class="hljs-string">&quot;index_type&quot;</span>: <span class="hljs-string">&quot;HNSW&quot;</span>,\n  <span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;L2&quot;</span>,\n  <span class="hljs-string">&quot;params&quot;</span>: {\n    <span class="hljs-string">&quot;sp_value&quot;</span>: <span class="hljs-number">64</span>,\n    <span class="hljs-string">&quot;dim&quot;</span>: <span class="hljs-number">128</span>\n  },\n  <span class="hljs-string">&quot;limit&quot;</span>: <span class="hljs-number">1</span>,\n  <span class="hljs-string">&quot;expr&quot;</span>: <span class="hljs-literal">null</span>,\n  <span class="hljs-string">&quot;output_fields&quot;</span>: [],\n  <span class="hljs-string">&quot;timeout&quot;</span>: <span class="hljs-number">600</span>\n}<span class="hljs-string">&#x27;, &#x27;</span>-p<span class="hljs-string">&#x27;, &#x27;</span><span class="hljs-number">10&#x27;</span>, <span class="hljs-string">&#x27;-f&#x27;</span>, <span class="hljs-string">&#x27;json&#x27;</span>, <span class="hljs-string">&#x27;-t&#x27;</span>, <span class="hljs-string">&#x27;60&#x27;</span>, <span class="hljs-string">&#x27;-i&#x27;</span>, <span class="hljs-string">&#x27;20&#x27;</span>, <span class="hljs-string">&#x27;-l&#x27;</span>, <span class="hljs-string">&#x27;go_log_file.log&#x27;</span>]
[<span class="hljs-meta">2022-08-11 11:37:39.811</span>][    INFO] - Name      <span class="hljs-meta">#   reqs      # fails  |       Avg       Min       Max    Median  |     req/s  failures/s (benchmark_run.go:212:sample)</span>
[<span class="hljs-meta">2022-08-11 11:37:39.811</span>][    INFO] - go search     <span class="hljs-number">9665</span>     <span class="hljs-number">0</span>(<span class="hljs-number">0.00</span>%)  |    <span class="hljs-number">20.679</span>     <span class="hljs-number">6.499</span>    <span class="hljs-number">81.761</span>    <span class="hljs-number">12.810</span>  |    <span class="hljs-number">483.25</span>        <span class="hljs-number">0.00</span> (benchmark_run.go:<span class="hljs-number">213</span>:sample)
[<span class="hljs-meta">2022-08-11 11:37:59.811</span>][    INFO] - Name      <span class="hljs-meta">#   reqs      # fails  |       Avg       Min       Max    Median  |     req/s  failures/s (benchmark_run.go:212:sample)</span>
[<span class="hljs-meta">2022-08-11 11:37:59.811</span>][    INFO] - go search    <span class="hljs-number">19448</span>     <span class="hljs-number">0</span>(<span class="hljs-number">0.00</span>%)  |    <span class="hljs-number">20.443</span>     <span class="hljs-number">6.549</span>    <span class="hljs-number">78.121</span>    <span class="hljs-number">13.401</span>  |    <span class="hljs-number">489.22</span>        <span class="hljs-number">0.00</span> (benchmark_run.go:<span class="hljs-number">213</span>:sample)
[<span class="hljs-meta">2022-08-11 11:38:19.811</span>][    INFO] - Name      <span class="hljs-meta">#   reqs      # fails  |       Avg       Min       Max    Median  |     req/s  failures/s (benchmark_run.go:212:sample)</span>
[<span class="hljs-meta">2022-08-11 11:38:19.811</span>][    INFO] - go search    <span class="hljs-number">29170</span>     <span class="hljs-number">0</span>(<span class="hljs-number">0.00</span>%)  |    <span class="hljs-number">20.568</span>     <span class="hljs-number">6.398</span>    <span class="hljs-number">76.887</span>    <span class="hljs-number">12.828</span>  |    <span class="hljs-number">486.15</span>        <span class="hljs-number">0.00</span> (benchmark_run.go:<span class="hljs-number">213</span>:sample)
[<span class="hljs-meta">2022-08-11 11:38:19.811</span>][   DEBUG] - go search run finished, parallel: <span class="hljs-number">10</span>(benchmark_run.go:<span class="hljs-number">95</span>:benchmark)
[<span class="hljs-meta">2022-08-11 11:38:19.811</span>][    INFO] - Name      <span class="hljs-meta">#   reqs      # fails  |       Avg       Min       Max    Median  |     req/s  failures/s (benchmark_run.go:159:samplingLoop)</span>
[<span class="hljs-meta">2022-08-11 11:38:19.811</span>][    INFO] - go search    <span class="hljs-number">29180</span>     <span class="hljs-number">0</span>(<span class="hljs-number">0.00</span>%)  |    <span class="hljs-number">20.560</span>     <span class="hljs-number">6.398</span>    <span class="hljs-number">81.761</span>    <span class="hljs-number">13.014</span>  |    <span class="hljs-number">486.25</span>        <span class="hljs-number">0.00</span> (benchmark_run.go:<span class="hljs-number">160</span>:samplingLoop)
Result of go_benchmark: {<span class="hljs-string">&#x27;response&#x27;</span>: True, <span class="hljs-string">&#x27;err_code&#x27;</span>: <span class="hljs-number">0</span>, <span class="hljs-string">&#x27;err_message&#x27;</span>: <span class="hljs-string">&#x27;&#x27;</span>} 
<button class="copy-code-btn"></button></code></pre>
<ol start="7">
<li>打开当前目录下的<code translate="no">go_log_file.log</code> 文件，查看详细搜索日志。以下是搜索日志中的搜索信息。<ul>
<li><p>reqs：从并发开始到当前时刻（当前时间跨度）的搜索请求数</p></li>
<li><p>fails（失败）：失败请求数占当前时间跨度内请求数的百分比</p></li>
<li><p>Avg：当前时间跨度内的平均请求响应时间（单位：毫秒）</p></li>
<li><p>Min：当前时间跨度内的最小请求响应时间（单位：毫秒）</p></li>
<li><p>Max：当前时间跨度内的最大请求响应时间（单位：毫秒）</p></li>
<li><p>中位数：当前时间跨度内请求响应时间的中位数（单位：毫秒）</p></li>
<li><p>req/s：每秒请求数，即 QPS</p></li>
<li><p>failures/s：当前时间跨度内每秒请求失败的平均次数。</p></li>
</ul></li>
</ol>
<h2 id="Downloading-Scripts-and-Executable-Files" class="common-anchor-header">下载脚本和可执行文件<button data-href="#Downloading-Scripts-and-Executable-Files" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p><a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/collection_prepare.py">collection_prepare.py</a></p></li>
<li><p><a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/go_benchmark.py">go_benchmark.py</a></p></li>
<li><p>用于 Ubuntu 的<a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/benchmark">benchmark</a></p></li>
<li><p>用于 macOS 的<a href="https://github.com/milvus-io/milvus-tools/blob/main/benchmark/benchmark-mac">benchmark-mac</a></p></li>
</ul>
<h2 id="Whats-next" class="common-anchor-header">下一步<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客中的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库的一致性水平</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


Milvus 2.1 基准测试快速指南

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/embeddded_milvus_1_8132468cac.png" alt="Cover" class="doc-image" id="cover" />
   </span> <span class="img-wrapper"> <span>封面</span> </span></p>
<blockquote>
<p>本文由<a href="https://github.com/soothing-rain/">Alex Gao</a>和<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">Angela Ni</a> 合著。</p>
</blockquote>
<p>Milvus 是一个面向人工智能应用的开源向量数据库。它提供多种安装方法，包括从源代码构建，以及使用 Docker Compose/ Helm/APT/YUM/Ansible 安装 Milvus。用户可以根据自己的操作系统和偏好选择其中一种安装方法。不过，Milvus 社区中有许多使用 Python 工作的数据科学家和人工智能工程师，他们渴望获得比现有安装方法更简单的安装方法。</p>
<p>因此，我们在发布 Milvus 2.1 的同时，还发布了对 Python 用户友好的嵌入式 Milvus 版本，以增强社区中更多 Python 开发人员的能力。本文将介绍什么是 Embeddings Milvus，并提供如何安装和使用它的说明。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#An-overview-of-embedded-Milvus">嵌入式 Milvus 概述</a><ul>
<li><a href="#When-to-use-embedded-Milvus">何时使用嵌入式 Milvus？</a></li>
<li><a href="#A-comparison-of-different-modes-of-Milvus">Milvus 不同模式的比较</a></li>
</ul></li>
<li><a href="#How-to-install-embedded-Milvus">如何安装嵌入式 Milvus</a></li>
<li><a href="#Start-and-stop-embedded-Milvus">启动和停止嵌入式 Milvus</a></li>
</ul>
<h2 id="An-overview-of-embedded-Milvus" class="common-anchor-header">嵌入式 Milvus 概述<button data-href="#An-overview-of-embedded-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://github.com/milvus-io/embd-milvus">嵌入式 Mil</a>vus 能让你用 Python 快速安装和使用 Milvus。它能快速调用 Milvus 实例，并允许你随时启动和停止 Milvus 服务。即使停止嵌入式 Milvus，所有数据和日志也会持续存在。</p>
<p>嵌入式 Milvus 本身没有任何内部依赖关系，也不需要预先安装和运行任何第三方依赖关系，如 etcd、MinIO、Pulsar 等。</p>
<p>你在嵌入式 Milvus 上所做的一切，以及为它编写的每一段代码，都可以安全地迁移到 Milvus 的其他模式--单机版、集群版、云版本等。这体现了 Embedded Milvus 最显著的特点之一--<strong>"一次编写，随处运行"。</strong></p>
<h3 id="When-to-use-embedded-Milvus" class="common-anchor-header">何时使用嵌入式 Milvus？</h3><p>Embedded Milvus 和<a href="https://milvus.io/docs/v2.1.x/install-pymilvus.md">PyMilvus</a>的构造目的不同。在以下情况下，您可以考虑选择嵌入式 Milvus：</p>
<ul>
<li><p>你想<a href="https://milvus.io/docs/v2.1.x/install_standalone-docker.md">在</a>不安装 Milvus 的情况下使用 Milvus。</p></li>
<li><p>想使用 Milvus 而不需要在机器中保留一个长期运行的 Milvus 进程。</p></li>
<li><p>想快速使用 Milvus，而无需启动单独的 Milvus 进程和其他必要组件，如 etcd、MinIO、Pulsar 等。</p></li>
</ul>
<p>建议<strong>不要</strong>使用 Embeddings Milvus：</p>
<ul>
<li><p>在生产环境中。<em>(要将 Milvus 用于生产，请考虑使用 Milvus 集群或<a href="https://zilliz.com/cloud">Zilliz Cloud</a>（一种完全托管的 Milvus 服务</em>））<em>。</em></p></li>
<li><p>对性能要求较高。<em>(相对而言，嵌入式 Milvus 可能无法提供最佳性能</em>）<em>。</em></p></li>
</ul>
<h3 id="A-comparison-of-different-modes-of-Milvus" class="common-anchor-header">Milvus 不同模式的比较</h3><p>下表比较了 Milvus 的几种模式：Standalone、集群、嵌入式 Milvus 和完全托管的 Milvus 服务 Zilliz Cloud。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/comparison_ebcd7c5b07.jpeg" alt="comparison" class="doc-image" id="comparison" />
   </span> <span class="img-wrapper"> <span>比较</span> </span></p>
<h2 id="How-to-install-embedded-Milvus" class="common-anchor-header">如何安装嵌入式 Milvus？<button data-href="#How-to-install-embedded-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在安装嵌入式 Milvus 之前，首先需要确保安装了 Python 3.6 或更高版本。Embedded Milvus 支持以下操作系统：</p>
<ul>
<li><p>Ubuntu 18.04</p></li>
<li><p>Mac x86_64 &gt;= 10.4</p></li>
<li><p>Mac M1 &gt;= 11.0</p></li>
</ul>
<p>如果满足要求，可以运行<code translate="no">$ python3 -m pip install milvus</code> 安装 Embeddings Milvus。你也可以在命令中添加版本，安装特定版本的嵌入式 Milvus。例如，如果要安装 2.1.0 版本，请运行<code translate="no">$ python3 -m pip install milvus==2.1.0</code> 。以后有新版本的嵌入式 Milvus 发布时，也可以运行<code translate="no">$ python3 -m pip install --upgrade milvus</code> 将嵌入式 Milvus 升级到最新版本。</p>
<p>如果你是 Milvus 的老用户，以前已经安装过 PyMilvus，现在想安装嵌入式 Milvus，可以运行<code translate="no">$ python3 -m pip install --no-deps milvus</code> 。</p>
<p>运行安装命令后，需要在<code translate="no">/var/bin/e-milvus</code> 下为嵌入式 Milvus 创建一个数据文件夹，方法是运行以下命令：</p>
<pre><code translate="no"><span class="hljs-built_in">sudo</span> <span class="hljs-built_in">mkdir</span> -p /var/bin/e-milvus
<span class="hljs-built_in">sudo</span> <span class="hljs-built_in">chmod</span> -R 777 /var/bin/e-milvus
<button class="copy-code-btn"></button></code></pre>
<h2 id="Start-and-stop-embedded-Milvus" class="common-anchor-header">启动和停止嵌入式 Milvus<button data-href="#Start-and-stop-embedded-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>安装成功后，即可启动服务。</p>
<p>如果第一次运行嵌入式 Milvus，需要先导入 Milvus 并设置嵌入式 Milvus。</p>
<pre><code translate="no">$ python3
Python 3.9.10 (main, Jan 15 2022, 11:40:53)
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type <span class="hljs-string">&quot;help&quot;</span>, <span class="hljs-string">&quot;copyright&quot;</span>, <span class="hljs-string">&quot;credits&quot;</span> or <span class="hljs-string">&quot;license&quot;</span> <span class="hljs-keyword">for</span> more information.
&gt;&gt;&gt; import milvus
&gt;&gt;&gt; milvus.before()
please <span class="hljs-keyword">do</span> the following <span class="hljs-keyword">if</span> you have not already <span class="hljs-keyword">done</span> so:
1. install required dependencies: bash /var/bin/e-milvus/lib/install_deps.sh
2. <span class="hljs-built_in">export</span> LD_PRELOAD=/SOME_PATH/embd-milvus.so
3. <span class="hljs-built_in">export</span> LD_LIBRARY_PATH=<span class="hljs-variable">$LD_LIBRARY_PATH</span>:/usr/lib:/usr/local/lib:/var/bin/e-milvus/lib/
&gt;&gt;&gt;
<button class="copy-code-btn"></button></code></pre>
<p>如果之前已经成功启动过嵌入式 Milvus，回来重新启动，则可以在导入 Milvus 后直接运行<code translate="no">milvus.start()</code> 。</p>
<pre><code translate="no">$ python3
Python <span class="hljs-number">3.9</span><span class="hljs-number">.10</span> (main, Jan <span class="hljs-number">15</span> <span class="hljs-number">2022</span>, <span class="hljs-number">11</span>:<span class="hljs-number">40</span>:<span class="hljs-number">53</span>)
[Clang <span class="hljs-number">13.0</span><span class="hljs-number">.0</span> (clang-<span class="hljs-number">1300.0</span><span class="hljs-number">.29</span><span class="hljs-number">.3</span>)] on darwinType <span class="hljs-string">&quot;help&quot;</span>, <span class="hljs-string">&quot;copyright&quot;</span>, <span class="hljs-string">&quot;credits&quot;</span> <span class="hljs-keyword">or</span> <span class="hljs-string">&quot;license&quot;</span> <span class="hljs-keyword">for</span> more information.
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> milvus
<span class="hljs-meta">&gt;&gt;&gt; </span>milvus.start()
&gt;&gt;&gt;
<button class="copy-code-btn"></button></code></pre>
<p>如果成功启动了嵌入式 Milvus 服务，你将看到如下输出。</p>
<pre><code translate="no">---<span class="hljs-title class_">Milvus</span> <span class="hljs-title class_">Proxy</span> successfully initialized and ready to serve!---
<button class="copy-code-btn"></button></code></pre>
<p>服务启动后，你可以启动另一个终端窗口，运行<a href="https://github.com/milvus-io/embd-milvus/blob/main/milvus/examples/hello_milvus.py">&quot;Hello Milvus</a>&quot;的示例代码来玩转嵌入式 Milvus！</p>
<pre><code translate="no"><span class="hljs-comment"># Download hello_milvus script</span>
$ wget https://raw.githubusercontent.com/milvus-io/pymilvus/v2.1.0/examples/hello_milvus.py
<span class="hljs-comment"># Run Hello Milvus </span>
$ python3 hello_milvus.py
<button class="copy-code-btn"></button></code></pre>
<p>完成嵌入式 Milvus 的使用后，建议优雅地停止它，并运行以下命令或按 Ctrl-D 键清理环境变量。</p>
<pre><code translate="no">&gt;&gt;&gt; milvus.stop()
<span class="hljs-keyword">if</span> you need to clean up the environment variables, run:
<span class="hljs-built_in">export</span> LD_PRELOAD=
<span class="hljs-built_in">export</span> LD_LIBRARY_PATH=
&gt;&gt;&gt;
&gt;&gt;&gt; <span class="hljs-built_in">exit</span>()
<button class="copy-code-btn"></button></code></pre>
<h2 id="Whats-next" class="common-anchor-header">下一步<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库的一致性水平</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database-2.md">了解 Milvus 向量数据库的一致性水平（第二部分）</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


使用 Embedded Milvus 即时安装和运行带有 Python 的 Milvus

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/string_6129ce83e6.png" alt="Cover" class="doc-image" id="cover" />
   </span> <span class="img-wrapper"> <span>封面</span> </span></p>
<p>Milvus 2.1 有了<a href="https://milvus.io/blog/2022-08-05-whats-new-in-milvus-2-1.md">一些重大更新</a>，使使用 Milvus 变得更加容易。其中之一就是支持字符串数据类型。目前，Milvus<a href="https://milvus.io/docs/v2.1.x/schema.md#Supported-data-type">支持的数据类型</a>包括字符串、向量、布尔、整数、浮点数等。</p>
<p>本文将介绍对字符串数据类型的支持。请阅读并学习它的功能和使用方法。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#What-can-you-do-with-string-data">你能用字符串数据做什么？</a></li>
<li><a href="#How-to-manage-string-data-in-Milvus-21">如何在 Milvus 2.1 中管理字符串数据？</a><ul>
<li><a href="#Create-a-collection">创建 Collections</a></li>
<li><a href="#Insert-data">插入和删除数据</a></li>
<li><a href="#Build-an-index">建立索引</a></li>
<li><a href="#Hybrid-search">混合搜索</a></li>
<li><a href="#String-expressions">字符串表达式</a></li>
</ul></li>
</ul>
<custom-h1>你能用字符串数据做什么？</custom-h1><p>支持字符串数据类型是用户最期待的功能之一。它既简化了使用 Milvus 向量数据库构建应用程序的过程，又加快了相似性搜索和向量查询的速度，无论您正在开发什么应用程序，都能在很大程度上提高效率，降低维护成本。</p>
<p>具体来说，Milvus 2.1 支持 VARCHAR 数据类型，它可以存储不同长度的字符串。支持 VARCHAR 数据类型后，您可以</p>
<ol>
<li>直接管理字符串数据，而无需借助外部关系数据库。</li>
</ol>
<p>支持 VARCHAR 数据类型后，在向 Milvus 插入数据时，就可以跳过将字符串转换为其他数据类型的步骤。假设您正在为自己的网上书店开发一个图书搜索系统。您正在创建一个图书数据集，并希望用名称来识别图书。在以前的版本中，Milvus 不支持字符串数据类型，因此在将数据插入 Milvus 之前，您可能需要先借助 MySQL 等关系数据库将字符串（书籍名称）转换为书籍 ID。现在，由于支持字符串数据类型，您只需创建一个字符串字段，然后直接输入图书名称而不是其 ID 编号即可。</p>
<p>搜索和查询过程也同样方便。想象一下，有一个客户最喜欢的书是《<em>Hello Milvus</em>》。您想在系统中搜索类似书籍并推荐给客户。在 Milvus 以前的版本中，系统只会返回图书 ID，您需要多走一步，在关系数据库中查询相应的图书信息。但在 Milvus 2.1 中，您可以直接获取图书名称，因为您已经创建了一个包含图书名称的字符串字段。</p>
<p>总之，对字符串数据类型的支持省去了您求助于其他工具管理字符串数据的精力，大大简化了开发过程。</p>
<ol start="2">
<li>通过属性过滤加快<a href="https://milvus.io/docs/v2.1.x/hybridsearch.md">混合搜索</a>和<a href="https://milvus.io/docs/v2.1.x/query.md">向量查询</a>的速度。</li>
</ol>
<p>与其他标量数据类型一样，VARCHAR 也可以在混合搜索和向量查询中通过布尔表达式进行属性过滤。特别值得一提的是，Milvus 2.1 增加了操作符<code translate="no">like</code> ，可以执行前缀匹配。此外，还可以使用操作符<code translate="no">==</code> 进行精确匹配。</p>
<p>此外，Milvus 2.1 还支持基于 MARISA-trie 的倒排索引，以加速混合搜索和查询。请继续阅读，了解使用字符串数据执行属性筛选时可能需要了解的所有字符串表达式。</p>
<custom-h1>如何在 Milvus 2.1 中管理字符串数据？</custom-h1><p>现在我们知道字符串数据类型非常有用，但在构建自己的应用程序时，我们究竟什么时候需要使用这种数据类型呢？在下文中，您将看到一些可能涉及字符串数据的场景代码示例，这将让您更好地理解如何在 Milvus 2.1 中管理 VARCHAR 数据。</p>
<h2 id="Create-a-collection" class="common-anchor-header">创建 Collections<button data-href="#Create-a-collection" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>让我们继续前面的示例。您仍在开发图书推荐系统，并希望创建一个图书 Collections，其中有一个名为<code translate="no">book_name</code> 的主键字段，您将在该字段中插入字符串数据。在这种情况下，您可以在设置字段 Schema 时将数据类型设置为<code translate="no">DataType.VARCHAR</code>，如下例所示。</p>
<p>请注意，在创建 VARCHAR 字段时，必须通过参数<code translate="no">max_length</code> 指定最大字符长度，其值范围为 1 至 65,535 之间。  在本例中，我们将最大长度设置为 200。</p>
<pre><code translate="no" class="language-Python"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> CollectionSchema, FieldSchema, DataType
book_id = FieldSchema(
  name=<span class="hljs-string">&quot;book_id&quot;</span>, 
  dtype=DataType.INT64, 
)
book_name = FieldSchema( 
  name=<span class="hljs-string">&quot;book_name&quot;</span>, 
  dtype=DataType.VARCHAR, 
  max_length=<span class="hljs-number">200</span>, 
  is_primary=<span class="hljs-literal">True</span>, 
)
word_count = FieldSchema(
  name=<span class="hljs-string">&quot;word_count&quot;</span>, 
  dtype=DataType.INT64,  
)
book_intro = FieldSchema(
  name=<span class="hljs-string">&quot;book_intro&quot;</span>, 
  dtype=DataType.FLOAT_VECTOR, 
  dim=<span class="hljs-number">2</span>
)
schema = CollectionSchema(
  fields=[book_id, word_count, book_intro], 
  description=<span class="hljs-string">&quot;Test book search&quot;</span>
)
collection_name = <span class="hljs-string">&quot;book&quot;</span>
<button class="copy-code-btn"></button></code></pre>
<h2 id="Insert-data" class="common-anchor-header">插入数据<button data-href="#Insert-data" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>现在，Collection 已创建，我们可以向其中插入数据。在下面的示例中，我们插入了 2,000 行随机生成的字符串数据。</p>
<pre><code translate="no" class="language-Python"><span class="hljs-keyword">import</span> random
data = [
  [i <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">2000</span>)],
  [<span class="hljs-string">&quot;book_&quot;</span> + <span class="hljs-built_in">str</span>(i) <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">2000</span>)],
  [i <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">10000</span>, <span class="hljs-number">12000</span>)],
  [[random.random() <span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">2</span>)] <span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">2000</span>)],
]
<button class="copy-code-btn"></button></code></pre>
<h2 id="Delete-data" class="common-anchor-header">删除数据<button data-href="#Delete-data" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>假设有两本名为<code translate="no">book_0</code> 和<code translate="no">book_1</code> 的书在商店中已停售，因此您想从数据库中删除相关信息。在这种情况下，您可以使用术语表达式<code translate="no">in</code> 过滤要删除的实体，如下例所示。</p>
<p>请记住，Milvus 只支持删除具有明确指定主键的实体，因此在运行以下代码之前，请确保已将<code translate="no">book_name</code> 字段设置为主键字段。</p>
<pre><code translate="no" class="language-Python">expr = <span class="hljs-string">&quot;book_name in [\&quot;book_0\&quot;, \&quot;book_1\&quot;]&quot;</span> 
<span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> <span class="hljs-title class_">Collection</span>
collection = <span class="hljs-title class_">Collection</span>(<span class="hljs-string">&quot;book&quot;</span>)     
collection.<span class="hljs-title function_">delete</span>(expr)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Build-an-Index" class="common-anchor-header">建立索引<button data-href="#Build-an-Index" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.1 支持建立标量索引，这将大大加快过滤字符串字段的速度。与建立向量索引不同，在建立标量索引之前，你不必准备参数。Milvus 暂时只支持字典树（MARISA-trie）索引，因此 VARCHAR 类型字段的索引类型默认为 MARISA-trie。</p>
<p>在建立索引时，可以指定索引名称。如果未指定，<code translate="no">index_name</code> 的默认值为<code translate="no">&quot;_default_idx_&quot;</code> 。在下面的示例中，我们将索引命名为<code translate="no">scalar_index</code> 。</p>
<pre><code translate="no" class="language-Python"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> <span class="hljs-title class_">Collection</span>
collection = <span class="hljs-title class_">Collection</span>(<span class="hljs-string">&quot;book&quot;</span>)   
collection.<span class="hljs-title function_">create_index</span>(
  field_name=<span class="hljs-string">&quot;book_name&quot;</span>, 
  index_name=<span class="hljs-string">&quot;scalar_index&quot;</span>,
)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Hybrid-search" class="common-anchor-header">混合搜索<button data-href="#Hybrid-search" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>通过指定布尔表达式，可以在向量相似性搜索过程中过滤字符串字段。</p>
<p>例如，如果要搜索简介与《Hello Milvus》最相似的图书，但只想得到名称以 "book_2 "开头的图书，可以使用操作符<code translate="no">like</code>进行前缀匹配，得到目标图书，如下例所示。</p>
<pre><code translate="no" class="language-Python">search_param = {
  <span class="hljs-string">&quot;data&quot;</span>: [[<span class="hljs-number">0.1</span>, <span class="hljs-number">0.2</span>]],
  <span class="hljs-string">&quot;anns_field&quot;</span>: <span class="hljs-string">&quot;book_intro&quot;</span>,
  <span class="hljs-string">&quot;param&quot;</span>: {<span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;L2&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nprobe&quot;</span>: <span class="hljs-number">10</span>}},
  <span class="hljs-string">&quot;limit&quot;</span>: <span class="hljs-number">2</span>,
  <span class="hljs-string">&quot;expr&quot;</span>: <span class="hljs-string">&quot;book_name like \&quot;Hello%\&quot;&quot;</span>,
}
res = collection.<span class="hljs-title function_">search</span>(**search_param)
<button class="copy-code-btn"></button></code></pre>
<h2 id="String-expressions" class="common-anchor-header">字符串表达式<button data-href="#String-expressions" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>除了新添加的操作符<code translate="no">like</code> 之外，Milvus 先前版本已经支持的其他操作符也可用于字符串字段过滤。下面是一些常用<a href="https://milvus.io/docs/v2.1.x/boolean.md">字符串表达式</a>的示例，其中<code translate="no">A</code> 表示 VARCHAR 类型的字段。请记住，下面的所有字符串表达式都可以使用 AND、OR 和 NOT 等逻辑操作符进行逻辑组合。</p>
<h3 id="Set-operations" class="common-anchor-header">集合操作符</h3><p>可以使用<code translate="no">in</code> 和<code translate="no">not in</code> 实现集合操作，如<code translate="no">A in [&quot;str1&quot;, &quot;str2&quot;]</code> 。</p>
<h3 id="Compare-two-string-fields" class="common-anchor-header">比较两个字符串字段</h3><p>您可以使用关系操作符来比较两个字符串字段的值。此类关系操作符包括<code translate="no">==</code>,<code translate="no">!=</code>,<code translate="no">&gt;</code>,<code translate="no">&gt;=</code>,<code translate="no">&lt;</code>,<code translate="no">&lt;=</code> 。更多信息，请参阅<a href="https://milvus.io/docs/v2.1.x/boolean.md#Relational-operators">关系操作符</a>。</p>
<p>请注意，字符串字段只能与其他字符串字段比较，而不能与其他数据类型的字段比较。例如，VARCHAR 类型的字段不能与布尔或整数类型的字段比较。</p>
<h3 id="Compare-a-field-with-a-constant-value" class="common-anchor-header">将字段与常量值进行比较</h3><p>您可以使用<code translate="no">==</code> 或<code translate="no">!=</code> 验证字段的值是否等于常量值。</p>
<h3 id="Filter-fields-with-a-single-range" class="common-anchor-header">用单一范围过滤字段</h3><p>可以使用<code translate="no">&gt;</code>,<code translate="no">&gt;=</code>,<code translate="no">&lt;</code>,<code translate="no">&lt;=</code> 过滤具有单一范围的字符串字段，如<code translate="no">A &gt; &quot;str1&quot;</code> 。</p>
<h3 id="Prefix-matching" class="common-anchor-header">前缀匹配</h3><p>如前所述，Milvus 2.1 增加了用于前缀匹配的操作符<code translate="no">like</code> ，如<code translate="no">A like &quot;prefix%&quot;</code> 。</p>
<h2 id="Whats-next" class="common-anchor-header">下一步<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的正式发布，我们准备了一系列介绍新功能的博客。请阅读本系列博客中的更多内容：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-08-08-How-to-use-string-data-to-empower-your-similarity-search-applications.md">如何使用字符串数据增强相似性搜索应用程序的功能</a></li>
<li><a href="https://milvus.io/blog/embedded-milvus.md">使用 Embedded Milvus 即时安装并用 Python 运行 Milvus</a></li>
<li><a href="https://milvus.io/blog/in-memory-replicas.md">利用内存复制提高向量数据库的读取吞吐量</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database.md">了解 Milvus 向量数据库的一致性水平</a></li>
<li><a href="https://milvus.io/blog/understanding-consistency-levels-in-the-milvus-vector-database-2.md">了解 Milvus 向量数据库的一致性水平（第二部分）</a></li>
<li><a href="https://milvus.io/blog/data-security.md">Milvus 向量数据库如何确保数据安全？</a></li>
</ul>


如何使用字符串数据增强相似性搜索应用程序的功能

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/What_s_New_in_2_1_2_a0660df2a5.png" alt="What's new in Milvus 2.1 - Towards simplicity and speed" class="doc-image" id="what's-new-in-milvus-2.1---towards-simplicity-and-speed" />
   </span> <span class="img-wrapper"> <span>Milvus 2.1 中的新功能--趋向简洁和快速</span> </span></p>
<p>经过 Milvus 社区所有贡献者六个月的辛勤工作，我们非常高兴地宣布 Milvus 2.1 正式<a href="https://milvus.io/docs/v2.1.x/release_notes.md">发布</a>。这个广受欢迎的向量数据库的重大迭代强调了<strong>性能</strong>和<strong>可用性</strong>，这是我们关注的两个最重要的关键词。我们增加了对字符串、Kafka 消息队列和嵌入式 Milvus 的支持，并在性能、可扩展性、安全性和可观测性方面做了大量改进。Milvus 2.1 是一次激动人心的更新，它将打通从算法工程师的笔记本电脑到生产级向量相似性搜索服务的 "最后一公里"。</p>
<custom-h1>性能 - 提升 3.2 倍以上</custom-h1><h2 id="5ms-level-latency" class="common-anchor-header">5 毫秒级延迟<button data-href="#5ms-level-latency" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 已经支持近似近邻（ANN）搜索，这与传统的 KNN 方法相比是一个实质性的飞跃。然而，吞吐量和延迟问题仍然是需要处理十亿级向量数据检索场景的用户所面临的挑战。</p>
<p>在 Milvus 2.1 中，有一个新的路由协议，不再依赖检索链路中的消息队列，大大降低了小数据集的检索延迟。我们的测试结果表明，Milvus 现在把延迟水平降到了 5ms，满足了相似性搜索和推荐等关键在线链接的要求。</p>
<h2 id="Concurrency-control" class="common-anchor-header">并发控制<button data-href="#Concurrency-control" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.1 通过引入新的成本评估模型和并发调度程序，对其并发模型进行了微调。它现在提供并发控制，确保不会出现大量并发请求争夺 CPU 和缓存资源的情况，也不会因为请求数量不足而导致 CPU 利用率不高。Milvus 2.1 中全新的智能调度层还能合并请求参数一致的小 nq 查询，在小 nq 和高查询并发的场景下，性能提升了惊人的 3.2 倍。</p>
<h2 id="In-memory-replicas" class="common-anchor-header">内存复制<button data-href="#In-memory-replicas" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.1 带来了内存副本，提高了小型数据集的可扩展性和可用性。与传统数据库中的只读副本类似，当读取 QPS 较高时，内存中的副本可以通过增加机器进行水平扩展。在针对小型数据集的向量检索中，推荐系统往往需要提供超过单台机器性能极限的 QPS。现在，在这些情况下，通过在内存中加载多个副本，可以显著提高系统的吞吐量。未来，我们还将引入基于内存中副本的对冲读取机制，在系统需要从故障中恢复时，快速请求其他功能副本，充分利用内存冗余提高系统的整体可用性。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/What_s_New_in_Milvus_2_1_Figure_1_excalidraw_1f7fe3c998.png" alt="In-memory replicas allow query services to be based on separate
copies of the same data." class="doc-image" id="in-memory-replicas-allow-query-services-to-be-based-on-separate-copies-of-the-same-data." />
   </span> <span class="img-wrapper"> <span>内存副本允许查询服务基于相同数据的不同副本</span>。 </span></p>
<h2 id="Faster-data-loading" class="common-anchor-header">更快的数据加载<button data-href="#Faster-data-loading" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>最后一项性能提升来自数据加载。Milvus 2.1 现在使用 Zstandard (zstd) 压缩<a href="https://milvus.io/docs/v2.1.x/glossary.md#Log-snapshot">二进制日志</a>，这大大减少了对象存储区和消息存储区的数据大小以及数据加载过程中的网络开销。此外，现在还引入了 goroutine 池，这样 Milvus 就能在控制内存占用的情况下并发加载程序段，并最大限度地减少故障恢复和加载数据所需的时间。</p>
<p>Milvus 2.1 的完整基准测试结果将很快在我们的网站上发布。敬请期待。</p>
<h2 id="String-and-scalar-index-support" class="common-anchor-header">字符串和标量索引支持<button data-href="#String-and-scalar-index-support" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.1 现在支持变长字符串 (VARCHAR) 作为标量数据类型。VARCHAR 可用作输出返回的主键，也可用作属性筛选器。<a href="https://milvus.io/docs/v2.1.x/hybridsearch.md">属性筛选</a>是 Milvus 用户最需要的功能之一。如果您经常发现自己想要 &quot;找到与用户最相似的<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>200-200</mo></mrow><annotation encoding="application/x-tex">-</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">200-300</span></span></span></span>价格区间的产品&quot;，或者 &quot;找到关键词为'向量数据库'且与云原生主题相关的文章&quot;，那么您一定会爱上 Milvus 2.1。</p>
<p>Milvus 2.1 还支持标量倒排索引，以提高基于<a href="https://www.cs.le.ac.uk/people/ond1/XMLcomp/confersWEA06_LOUDS.pdf">简洁</a><a href="https://github.com/s-yata/marisa-trie">MARISA-Tries</a>作为数据结构的过滤速度。现在，所有数据都能以极低的占用空间加载到内存中，从而能更快地对字符串进行比较、过滤和前缀匹配。我们的测试结果表明，MARISA-trie 将所有数据载入内存并提供查询功能所需的内存仅为 Python 字典的 10%。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/What_s_new_in_Milvus_Figure_2_excalidraw_a1149aca96.png" alt="Milvus 2.1 combines MARISA-Trie with inverted index to significantly improve filtering speed." class="doc-image" id="milvus-2.1-combines-marisa-trie-with-inverted-index-to-significantly-improve-filtering-speed." />
   </span> <span class="img-wrapper"> <span>Milvus 2.1 将 MARISA-Trie 与倒排索引相结合，大大提高了过滤速度。</span> </span></p>
<p>未来，Milvus 将继续关注标量查询相关的开发，支持更多的标量索引类型和查询操作符，并提供基于磁盘的标量查询功能，这些都是为降低标量数据的存储和使用成本而不断努力的一部分。</p>
<custom-h1>可用性改进</custom-h1><h2 id="Kafka-support" class="common-anchor-header">卡夫卡支持<button data-href="#Kafka-support" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>我们的社区长期以来一直要求在 Milvus 中支持<a href="https://kafka.apache.org">Apache Kafka</a>作为<a href="https://milvus.io/docs/v2.1.x/deploy_pulsar.md">消息存储</a>。 由于 Milvus 的抽象和封装设计以及 Confluent 提供的 Go Kafka SDK，Milvus 2.1 现在可以根据用户配置选择使用<a href="https://pulsar.apache.org">Pulsar</a>或 Kafka 作为消息存储。</p>
<h2 id="Production-ready-Java-SDK" class="common-anchor-header">生产就绪的 Java SDK<button data-href="#Production-ready-Java-SDK" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.1 的发布，我们的<a href="https://github.com/milvus-io/milvus-sdk-java">Java SDK</a>也正式发布。Java SDK 具有与 Python SDK 完全相同的功能，并具有更好的并发性能。下一步，我们的社区贡献者将逐步完善 Java SDK 的文档和用例，并帮助 Go 和 RESTful SDK 进入生产就绪阶段。</p>
<h2 id="Observability-and-maintainability" class="common-anchor-header">可观察性和可维护性<button data-href="#Observability-and-maintainability" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 2.1 增加了向量插入计数、搜索延迟/吞吐量、节点内存开销和 CPU 开销等重要的监控<a href="https://milvus.io/docs/v2.1.x/metrics_dashboard.md">指标</a>。此外，新版本还通过调整日志级别和减少无用的日志打印，大大优化了日志保存。</p>
<h2 id="Embedded-Milvus" class="common-anchor-header">嵌入式 Milvus<button data-href="#Embedded-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 大大简化了大规模海量向量数据检索服务的部署，但对于希望在较小规模上验证算法的科学家来说，Docker 或 K8s 还是太过于不必要的复杂。随着<a href="https://github.com/milvus-io/embd-milvus">嵌入式 Milvus</a> 的推出，你现在可以使用 pip 安装 Milvus，就像使用 Pyrocksb 和 Pysqlite 一样。Embedded Milvus 支持集群版和 Standalone 版的所有功能，让您可以轻松地从笔记本电脑切换到分布式生产环境，而无需更改一行代码。算法工程师在使用 Milvus 构建原型时将获得更好的体验。</p>
<custom-h1>立即试用开箱即用的向量搜索</custom-h1><p>此外，Milvus 2.1 在稳定性和可扩展性方面也有很大改进，我们期待您的使用和反馈。</p>
<h2 id="Whats-next" class="common-anchor-header">下一步计划<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li>有关 Milvus 2.1 的所有变化，请参阅详细的<a href="https://milvus.io/docs/v2.1.x/release_notes.md">发行说明</a></li>
<li><a href="https://milvus.io/docs/v2.1.x/install_standalone-docker.md">安装</a>Milvus 2.1 并试用新功能</li>
<li>加入我们的<a href="https://slack.milvus.io/">Slack 社区</a>，与全球数以千计的 Milvus 用户讨论新功能。</li>
<li>在<a href="https://twitter.com/milvusio">Twitter</a>和<a href="https://www.linkedin.com/company/the-milvus-project">LinkedIn</a>上关注我们，以便在我们的博客发布特定新功能时获得更新。</li>
</ul>
<blockquote>
<p>编辑：<a href="https://github.com/songxianj">蒋松贤</a></p>
</blockquote>


Milvus 2.1 的新功能--趋向简洁和快速

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Frame_1282_edc1fb7d99.png" alt="cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<p>如果您正在寻找一款能完美装入卧室或试衣间的衣柜，我敢打赌，大多数人都会想到量身定制的衣柜。然而，并不是每个人的预算都能达到那么多。那么，现成的衣柜又如何呢？这类衣柜的问题在于，它们很可能达不到你的期望，因为它们不够灵活，无法满足你独特的存储需求。此外，在网上搜索时，用关键字来概括您要寻找的特定类型的衣柜相当困难。很有可能，你在搜索框中输入的关键字（例如：带珠宝托盘的衣柜）与搜索引擎中的定义（例如：带<a href="https://www.ikea.com/us/en/p/komplement-pull-out-tray-with-insert-black-brown-s79249366/">嵌入式抽拉托盘</a>的衣柜）大相径庭。</p>
<p>不过，有了新兴技术，问题就迎刃而解了！家具零售集团宜家（IKEA）提供了一种流行的设计工具<a href="https://www.ikea.com/us/en/rooms/bedroom/how-to/how-to-design-your-perfect-pax-wardrobe-pub8b76dda0">PAX 衣柜</a>，用户可以从许多现成的衣柜中进行选择，并定制衣柜的颜色、尺寸和内部设计。无论您需要的是悬挂空间、多个搁板还是内部抽屉，这个智能衣柜定制系统总能满足您的需求。</p>
<p>要使用这款智能衣柜设计系统找到或打造理想的衣柜，您需要</p>
<ol>
<li>指定基本要求--衣柜的形状（普通型、L 型或 U 型）、长度和深度。</li>
<li>指定您的存储需求和衣柜内部结构（例如，需要悬挂空间、拉出式裤架等）。</li>
<li>添加或删除衣柜的抽屉或搁板等部件。</li>
</ol>
<p>然后，您的设计就完成了。简单方便！</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Pax_system_ff4c3fa182.png" alt="pax system" class="doc-image" id="pax-system" />
   </span> <span class="img-wrapper"> <span>大同系统</span> </span></p>
<p>使这样的衣柜设计系统成为可能的一个非常关键的组件是<a href="https://zilliz.com/learn/what-is-vector-database">向量数据库</a>。因此，本文旨在介绍用于构建由向量相似性搜索驱动的智能衣柜定制系统的工作流程和相似性搜索解决方案。</p>
<p>跳转到</p>
<ul>
<li><a href="#System-overview">系统概述</a></li>
<li><a href="#Data-flow">数据流</a></li>
<li><a href="#System-demo">系统演示</a></li>
</ul>
<h2 id="System-Overview" class="common-anchor-header">系统概述<button data-href="#System-Overview" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>为了提供这样一个智能衣柜定制工具，我们首先需要定义业务逻辑，了解物品属性和用户旅程。衣柜及其组件（如抽屉、托盘、衣架）都是非结构化数据。因此，第二步就是利用人工智能算法和规则、先验知识、物品描述等，将这些非结构化数据转换成计算机可以理解的数据类型--向量！</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Customization_tool_overview_86d62e1730.png" alt="Customization tool overview" class="doc-image" id="customization-tool-overview" />
   </span> <span class="img-wrapper"> <span>定制工具概述</span> </span></p>
<p>有了生成的向量，我们需要强大的向量数据库和搜索引擎来处理它们。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/tool_architecutre_33fb646954.png" alt="tool architecture" class="doc-image" id="tool-architecture" />
   </span> <span class="img-wrapper"> <span>工具架构</span> </span></p>
<p>定制工具利用了一些最流行的搜索引擎和数据库：Elasticsearch、<a href="https://milvus.io/">Milvus</a> 和 PostgreSQL。</p>
<h3 id="Why-Milvus" class="common-anchor-header">为什么选择 Milvus？</h3><p>衣柜组件包含非常复杂的信息，如颜色、形状和内部结构等。然而，将衣柜数据保存在关系数据库中的传统方法远远不够。一种流行的方式是使用 Embeddings 技术将衣柜转换成向量。因此，我们需要寻找一种专门用于向量存储和相似性搜索的新型数据库。在探究了几种流行的解决方案后，<a href="https://github.com/milvus-io/milvus">Milvus</a>向量数据库以其卓越的性能、稳定性、兼容性和易用性被选中。下图是几种流行的向量搜索解决方案的比较。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Solution_comparison_d96b8f1dd5.png" alt="solution comparison" class="doc-image" id="solution-comparison" />
   </span> <span class="img-wrapper"> <span>解决方案比较</span> </span></p>
<h3 id="System-workflow" class="common-anchor-header">系统工作流程</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/System_workflow_250c275ec1.png" alt="System workflow" class="doc-image" id="system-workflow" />
   </span> <span class="img-wrapper"> <span>系统工作流程</span> </span></p>
<p>使用 Elasticsearch 按衣柜尺寸、颜色等进行粗略过滤。然后，过滤后的结果通过 Milvus 向量数据库进行相似性搜索，并根据结果与查询向量的距离/相似性进行排序。最后，根据业务洞察力对结果进行合并和进一步完善。</p>
<h2 id="Data-flow" class="common-anchor-header">数据流<button data-href="#Data-flow" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>衣柜定制系统与传统的搜索引擎和推荐系统非常相似。它包括三个部分</p>
<ul>
<li>离线数据准备，包括数据定义和生成。</li>
<li>在线服务，包括召回和排序。</li>
<li>基于业务逻辑的数据后处理。</li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/data_flow_d0d9fa0fca.png" alt="Data flow" class="doc-image" id="data-flow" />
   </span> <span class="img-wrapper"> <span>数据流</span> </span></p>
<h3 id="Offline-data-flow" class="common-anchor-header">离线数据流</h3><ol>
<li>利用业务洞察力定义数据。</li>
<li>利用先验知识定义如何将不同组件组合成衣柜。</li>
<li>识别衣柜的特征标签，并将特征编码为<code translate="no">.json</code> 文件中的 Elasticsearch 数据。</li>
<li>通过将非结构化数据编码成向量来准备召回数据。</li>
<li>使用向量数据库 Milvus 对上一步获得的召回结果进行排序。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/offline_data_flow_f91ac9cf4c.png" alt="offline data flow" class="doc-image" id="offline-data-flow" />
   </span> <span class="img-wrapper"> <span>离线数据流</span> </span></p>
<h3 id="Online-data-flow" class="common-anchor-header">在线数据流</h3><ol>
<li>接收用户的查询请求并收集用户资料。</li>
<li>通过确定用户对衣柜的要求来理解用户的查询。</li>
<li>使用 Elasticsearch 进行粗搜索。</li>
<li>根据 Milvus 中向量相似度的计算方法，对粗搜索得到的结果进行评分和排序。</li>
<li>在后端平台上对结果进行后处理和整理，生成最终结果。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/online_data_flow_1f2af25cc3.png" alt="online data flow" class="doc-image" id="online-data-flow" />
   </span> <span class="img-wrapper"> <span>在线数据流</span> </span></p>
<h3 id="Data-post-processing" class="common-anchor-header">数据后处理</h3><p>每个公司的业务逻辑各不相同。您可以应用贵公司的业务逻辑对结果进行最后润色。</p>
<h2 id="System-demo" class="common-anchor-header">系统演示<button data-href="#System-demo" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>现在让我们来看看我们建立的系统是如何实际运行的。</p>
<p>用户界面（UI）显示衣柜组件不同组合的可能性。</p>
<p>每个组件都按其特征（尺寸、颜色等）贴上标签，并存储在 Elasticsearch（ES）中。在 ES 中存储标签时，需要填写四个主要数据字段：ID、标签、存储路径和其他支持字段。ES 和标签数据用于细粒度召回和属性过滤。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/es_d5b0639610.png" alt="es" class="doc-image" id="es" />
   </span> <span class="img-wrapper"> <span>ES</span> </span></p>
<p>然后使用不同的人工智能算法将衣柜编码成向量集。向量集存储在 Milvus 中，用于相似性搜索和排序。这一步骤可返回更精细、更准确的结果。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Milvus_38dd93a439.jpeg" alt="Milvus" class="doc-image" id="milvus" />
   </span> <span class="img-wrapper"> <span>Milvus</span> </span></p>
<p>Elasticsearch、Milvus 和其他系统组件共同构成了定制设计平台的整体。在回忆过程中，Elasticsearch 和 Milvus 中的特定领域语言（DSL）如下。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/dsl_df60097d23.png" alt="dsl" class="doc-image" id="dsl" />
   </span> <span class="img-wrapper"> <span>DSL</span> </span></p>
<h2 id="Looking-for-more-resources" class="common-anchor-header">寻找更多资源？<button data-href="#Looking-for-more-resources" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>了解 Milvus 向量数据库如何为更多人工智能应用提供动力：</p>
<ul>
<li><a href="https://milvus.io/blog/2022-06-23-How-Short-video-Platform-Likee-Removes-Duplicate-Videos-with-Milvus.md">短视频平台 Likee 如何利用 Milvus 删除重复视频</a></li>
<li><a href="https://milvus.io/blog/2022-06-20-Zhentu-the-Photo-Fraud-Detector-Based-on-Milvus.md">Zhentu - 基于 Milvus 的照片欺诈检测器</a></li>
</ul>


建立由 Milvus 向量数据库支持的智能衣柜定制系统

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/How_Short_video_Platform_Likee_Removes_Duplicate_Videos_with_Milvus_07bd75ec82.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由 BIGO 工程师郭昕阳和韩宝玉撰写，<a href="https://www.linkedin.cn/incareer/in/rosie-zhang-694528149">Rosie Zhang</a> 翻译。</p>
</blockquote>
<p><a href="https://www.bigo.sg/">BIGO Technology</a>（BIGO）是新加坡发展最快的科技公司之一。在人工智能技术的支持下，BIGO 基于视频的产品和服务在全球大受欢迎，在 150 多个国家拥有超过 4 亿用户。这些产品和服务包括<a href="https://www.bigo.tv/bigo_intro/en.html?hk=true">Bigo Live</a>（直播）和<a href="https://likee.video/">Likee</a>（短视频）。</p>
<p>Likee 是一个全球性的短视频创作平台，用户可以在这里分享他们的精彩瞬间，表达自我，并与世界建立联系。为了提高用户体验并向用户推荐更高质量的内容，Likee 需要从用户每天产生的海量视频中剔除重复视频，而这并不是一项简单的任务。</p>
<p>本博客介绍了 BIGO 如何使用开源向量数据库<a href="https://milvus.io">Milvus</a> 来有效去除重复视频。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#Overview">概述</a></li>
<li><a href="#Video-deduplication-workflow">重复数据删除工作流程</a></li>
<li><a href="#System-architecture">系统架构</a></li>
<li><a href="#Using-Milvus-vector-database-to-power-similarity-search">使用 Milvus 进行相似性搜索</a></li>
</ul>
<custom-h1>概述</custom-h1><p>Milvus 是一个开源向量数据库，具有超快速向量搜索功能。在 Milvus 的支持下，Likee 能够在 200 毫秒内完成搜索，同时确保高召回率。同时，通过<a href="https://milvus.io/docs/v2.0.x/scaleout.md#Scale-a-Milvus-Cluster">横向扩展 Milvus</a>，Likee 成功提高了向量查询的吞吐量，进一步提高了效率。</p>
<custom-h1>重复数据删除工作流程</custom-h1><p>Likee 如何识别重复视频？每次将查询视频输入 Likee 系统时，都会将其剪切成 15-20 帧，并将每一帧转换成特征向量。然后，Likee 会在包含 7 亿个向量的数据库中进行搜索，找出最相似的前 K 个向量。前 K 个向量中的每一个都对应数据库中的一段视频。Likee 会进一步进行细化搜索，以获得最终结果并确定要删除的视频。</p>
<custom-h1>系统架构</custom-h1><p>让我们仔细看看 Likee 的视频去重系统是如何使用 Milvus 工作的。如下图所示，上传到 Likee 的新视频将实时写入数据存储系统 Kafka，并被 Kafka 消费者消费。这些视频的特征向量通过深度学习模型提取，非结构化数据（视频）被转换成特征向量。这些特征向量将由系统打包，发送给相似性审核员。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Likee_1_6f7ebcd8fc.png" alt="Architechure of Likee's video de-duplication system" class="doc-image" id="architechure-of-likee's-video-de-duplication-system" />
   </span> <span class="img-wrapper"> <span>Likee 视频重复数据删除系统架构图</span> </span></p>
<p>提取的特征向量将被 Milvus 索引并存储在 Ceph 中，然后<a href="https://milvus.io/blog/deep-dive-5-real-time-query.md">由 Milvus 查询节点加载</a>，以便进一步搜索。这些特征向量对应的视频 ID 也将根据实际需要同时存储在 TiDB 或 Pika 中。</p>
<h3 id="Using-Milvus-vector-database-to-power-similarity-search" class="common-anchor-header">利用 Milvus 向量数据库助力相似性搜索</h3><p>在搜索相似向量时，现有的数十亿数据，加上每天产生的大量新数据，给向量搜索引擎的功能带来了极大的挑战。经过全面分析，Likee 最终选择了高性能、高召回率的分布式向量搜索引擎 Milvus 来进行向量相似性搜索。</p>
<p>如下图所示，相似性搜索的流程如下：</p>
<ol>
<li><p>首先，Milvus 对从新视频中提取的多个特征向量进行批量搜索，为每个特征向量召回前 100 个相似向量。每个相似向量都与其对应的视频 ID 绑定。</p></li>
<li><p>其次，通过比较视频 ID，Milvus 会删除重复视频，并从 TiDB 或 Pika 中检索剩余视频的特征向量。</p></li>
<li><p>最后，Milvus 计算检索到的每组特征向量与查询视频的特征向量之间的相似度并打分。得分最高的视频 ID 将作为结果返回。至此，视频相似性搜索结束。</p></li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/02_a24d251c8f.png" alt="Procedure of a similarity search" class="doc-image" id="procedure-of-a-similarity-search" />
   </span> <span class="img-wrapper"> <span>相似性搜索的程序</span> </span></p>
<p>作为高性能的向量搜索引擎，Milvus 在 Likee 的视频去重系统中发挥了非凡的作用，极大地推动了 BIGO 短视频业务的发展。在视频业务方面，Milvus 还可以应用于许多其他场景，如非法内容拦截或个性化视频推荐等。BIGO 和 Milvus 都期待未来在更多领域开展合作。</p>


短视频平台 Likee 如何利用 Milvus 删除重复视频

利用 Milvus 向量数据库进行可扩展的快速相似性搜索

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/zhentu_0ae11c98ee.png" alt="cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由 BestPay 高级算法工程师石岩和唐敏伟撰写，<a href="https://www.linkedin.cn/incareer/in/rosie-zhang-694528149">Rosie Zhang</a> 翻译。</p>
</blockquote>
<p>近年来，随着电子商务和在线交易在全球的普及，电子商务欺诈也随之兴起。欺诈者通过使用电脑生成的照片代替真实照片通过网络商务平台的身份验证，创建大量虚假账户，套取商家的优惠信息（如会员礼品、优惠券、代金券等），给消费者和商家都带来了无法挽回的损失。</p>
<p>面对大量数据，传统的风险控制方法已不再有效。为了解决这一问题，<a href="https://www.bestpay.com.cn">BestPay</a>基于深度学习（DL）和数字图像处理（DIP）技术，开发了一款照片欺诈检测器，即Zhentu（中文意思是检测图像）。Zhentu 适用于涉及图像识别的各种场景，其中一个重要的分支是识别假营业执照。如果用户提交的营业执照照片与平台照片库中已有的另一张照片非常相似，那么该用户很可能在某处盗用了该照片或伪造了营业执照以达到欺诈目的。</p>
<p>传统的图像相似度测量算法，如<a href="https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio">PSNR</a>和 ORB，速度慢且不准确，只适用于离线任务。而深度学习能够实时处理大规模图像数据，是匹配相似图像的终极方法。在BestPay研发团队和<a href="https://milvus.io/">Milvus社区</a>的共同努力下，作为Zhentu的一部分，图片欺诈检测系统被开发出来。它的功能是通过深度学习模型将海量图像数据转化为特征向量，并将其插入向量搜索引擎<a href="https://milvus.io/">Milvus</a>。借助 Milvus，该检测系统能够索引数万亿向量，并在数千万张图片中高效检索出相似的照片。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#an-overview-of-zhentu">振图概述</a></li>
<li><a href="#system-structure">系统结构</a></li>
<li><a href="#deployment"><strong>系统部署</strong></a></li>
<li><a href="#real-world-performance"><strong>实际性能</strong></a></li>
<li><a href="#reference"><strong>参考资料</strong></a></li>
<li><a href="#about-bestpay"><strong>关于 BestPay</strong></a></li>
</ul>
<h2 id="An-overview-of-Zhentu" class="common-anchor-header">Zhentu 概述<button data-href="#An-overview-of-Zhentu" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Zhentu 是 BestPay 自主设计的多媒体视觉风险控制产品，深度集成了机器学习（ML）和神经网络图像识别技术。其内置算法可在用户身份验证过程中准确识别欺诈者，并在毫秒级响应。凭借行业领先的技术和创新的解决方案，征途已获得五项专利和两项软件著作权。目前，它已被多家银行和金融机构采用，帮助提前识别潜在风险。</p>
<h2 id="System-structure" class="common-anchor-header">系统结构<button data-href="#System-structure" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>目前，BestPay 拥有超过 1000 万张营业执照照片，随着业务的发展，实际数量仍在成倍增长。为了从如此庞大的数据库中快速检索出相似照片，征途选择了 Milvus 作为特征向量相似度计算引擎。照片欺诈检测系统的总体结构如下图所示。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Structure_of_the_photo_fraud_detection_system_cf5d20d431.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>img</span> </span></p>
<p>该程序可分为四个步骤：</p>
<ol>
<li><p>图像预处理。预处理包括降噪、去噪和对比度增强，既能确保原始信息的完整性，又能去除图像信号中的无用信息。</p></li>
<li><p>特征向量提取。通过专门训练的深度学习模型来提取图像的特征向量。将图像转换成向量，以便进一步进行相似性搜索，这是一项常规操作。</p></li>
<li><p>归一化。对提取的特征向量进行归一化处理，有助于提高后续处理的效率。</p></li>
<li><p>使用 Milvus 进行向量搜索。将归一化特征向量插入 Milvus 数据库，进行向量相似性搜索。</p></li>
</ol>
<h2 id="Deployment" class="common-anchor-header"><strong>部署</strong><button data-href="#Deployment" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>下面简要介绍一下 Zhentu 照片欺诈检测系统的部署情况。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/milvus_architecture_ea45a5ab53.png" alt="Milvus system architecture" class="doc-image" id="milvus-system-architecture" />
   </span> <span class="img-wrapper"> <span>Milvus 系统架构</span> </span></p>
<p>我们将<a href="https://milvus.io/docs/v2.0.x/install_cluster-helm.md">Milvus 集群</a>部署<a href="https://milvus.io/docs/v2.0.x/install_cluster-helm.md">在 Kubernetes 上</a>，以确保云服务的高可用性和实时同步。一般步骤如下：</p>
<ol>
<li><p>查看可用资源。运行<code translate="no">kubectl describe nodes</code> 命令，查看 Kubernetes 集群可分配给已创建案例的资源。</p></li>
<li><p>分配资源。运行命令<code translate="no">kubect`` -- apply xxx.yaml</code> ，使用 Helm 为 Milvus 群集组件分配内存和 CPU 资源。</p></li>
<li><p>应用新配置。运行命令<code translate="no">helm upgrade my-release milvus/milvus --reuse-values -fresources.yaml</code> 。</p></li>
<li><p>将新配置应用到 Milvus 群集。这样部署的集群不仅可以根据不同的业务需求调整系统容量，还能更好地满足海量向量数据检索的高性能要求。</p></li>
</ol>
<p>您可以对<a href="https://milvus.io/docs/v2.0.x/configure-docker.md">Milvus 进行配置</a>，针对不同业务场景的不同数据类型优化搜索性能，如以下两个示例所示。</p>
<p>在<a href="https://milvus.io/docs/v2.0.x/build_index.md">构建向量索引</a>时，我们根据系统的实际场景对索引进行如下参数设置：</p>
<pre><code translate="no" class="language-Python">index = {<span class="hljs-string">&quot;index_type&quot;</span>: <span class="hljs-string">&quot;IVF_PQ&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nlist&quot;</span>: <span class="hljs-number">2048</span>}, <span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;IP&quot;</span>}
<button class="copy-code-btn"></button></code></pre>
<p><a href="https://milvus.io/docs/v2.0.x/index.md#IVF_PQ">IVF_PQ</a>先进行 IVF 索引聚类，再对向量的乘积进行量化。它具有高速磁盘查询和极低内存消耗的特点，可以满足 Zhentu 的实际应用需求。</p>
<p>此外，我们还设置了如下最优搜索参数：</p>
<pre><code translate="no" class="language-Python">search_params = {<span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;IP&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nprobe&quot;</span>: <span class="hljs-number">32</span>}}
<button class="copy-code-btn"></button></code></pre>
<p>由于向量在输入 Milvus 之前已经进行了归一化处理，因此选择内积（IP）来计算两个向量之间的距离。实验证明，使用 IP 比使用欧氏距离（L2）的召回率提高了约 15%。</p>
<p>上述例子表明，我们可以根据不同的业务场景和性能要求来测试和设置 Milvus 的参数。</p>
<p>此外，Milvus 不仅集成了不同的索引库，还支持不同的索引类型和相似度计算方法。Milvus 还提供多种语言的官方 SDK 和丰富的 API，用于插入、查询等，使我们的前端业务组可以使用 SDK 调用风险控制中心。</p>
<h2 id="Real-world-performance" class="common-anchor-header"><strong>实际性能</strong><button data-href="#Real-world-performance" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>到目前为止，照片欺诈检测系统一直在稳定运行，帮助企业识别潜在的欺诈者。2021 年，该系统全年共检测出 2 万多张假证。在查询速度方面，数千万向量中单个向量查询时间小于1秒，批量查询平均时间小于0.08秒。Milvus 的高性能搜索满足了企业对准确性和并发性的双重需求。</p>
<h2 id="Reference" class="common-anchor-header"><strong>参考文献</strong><button data-href="#Reference" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Aglave P, Kolkure V S. 使用定向快速旋转简约算法实现高性能特征提取方法[J].Int.J. Res. Eng.Technol, 2015, 4: 394-397.</p>
<h2 id="About-BestPay" class="common-anchor-header"><strong>关于百付宝</strong><button data-href="#About-BestPay" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>中国电信翼支付有限公司是中国电信的全资子公司。它操作支付和金融业务。BestPay致力于利用大数据、人工智能、云计算等前沿技术赋能业务创新，提供智能产品、风控解决方案等服务。截至 2016 年 1 月，这款名为 "BestPay "的应用已吸引超过 2 亿用户，成为紧随支付宝和微信支付之后的中国第三大支付平台操作符。</p>


Zhentu - 基于 Milvus 的照片欺诈检测器

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Tech_Modify_5_e18025ffbc.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由<a href="https://github.com/xiaofan-luan">栾晓帆</a>撰写，<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>转译。</p>
</blockquote>
<p>基于共识的复制是许多云原生分布式数据库广泛采用的策略。然而，它也有一定的缺陷，绝对不是万能的。</p>
<p>本文章旨在首先解释云原生分布式数据库中复制、一致性和共识的概念，然后阐明为什么 Paxos 和 Raft 等基于共识的算法不是灵丹妙药，最后提出<a href="#a-log-replication-strategy-for-cloud-native-and-distributed-database">基于共识的复制的解决方案</a>。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#Understanding-replication-consistency-and-consensus">了解复制、一致性和共识</a></li>
<li><a href="#Consensus-based-replication">基于共识的复制</a></li>
<li><a href="#A-log-replication-strategy-for-cloud-native-and-distributed-database">云原生和分布式数据库的日志复制策略</a></li>
<li><a href="#Summary">摘要</a></li>
</ul>
<h2 id="Understanding-replication-consistency-and-consensus" class="common-anchor-header">了解复制、一致性和共识<button data-href="#Understanding-replication-consistency-and-consensus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在深入探讨 Paxos 和 Raft 的优缺点并提出最合适的日志复制策略之前，我们需要先解开复制、一致性和共识等概念的神秘面纱。</p>
<p>请注意，本文主要关注增量数据/日志的同步。因此，在讨论数据/日志复制时，仅提及增量数据的复制，而不是历史数据的复制。</p>
<h3 id="Replication" class="common-anchor-header">复制</h3><p>复制是将数据复制多份并存储在不同磁盘、进程、机器、集群等中的过程，目的是提高数据可靠性并加速数据查询。由于在复制过程中，数据被复制并存储在多个位置，因此面对磁盘故障、物理机器故障或集群错误时，数据的可靠性更高。此外，多个数据副本还能大大加快查询速度，从而提高分布式数据库的性能。</p>
<p>复制有多种模式，如同步/异步复制、强一致性/最终一致性复制、领导者-追随者/分散复制。复制模式的选择会影响系统的可用性和一致性。因此，正如著名的<a href="https://medium.com/analytics-vidhya/cap-theorem-in-distributed-system-and-its-tradeoffs-d8d981ecf37e">CAP 定理</a>所提出的，当网络分区不可避免时，系统架构师需要在一致性和可用性之间做出权衡。</p>
<h3 id="Consistency" class="common-anchor-header">一致性</h3><p>简而言之，分布式数据库中的一致性是指在给定时间写入或读取数据时，确保每个节点或副本对数据具有相同视图的属性。有关一致性级别的完整列表，请阅读<a href="https://docs.microsoft.com/en-us/azure/cosmos-db/consistency-levels">此处的</a>文档。</p>
<p>需要说明的是，这里我们讨论的是 CAP 定理中的一致性，而不是 ACID（原子性、一致性、隔离性、持久性）。CAP 定理中的一致性指的是系统中的每个节点都拥有相同的数据，而 ACID 中的一致性指的是单个节点对每个潜在提交执行相同的规则。</p>
<p>一般来说，OLTP（在线事务处理）数据库需要很强的一致性或线性化，以确保</p>
<ul>
<li>每次读取都能访问最新插入的数据。</li>
<li>如果在一次读取后返回了新值，那么接下来的所有读取（无论在相同或不同的客户端上）都必须返回新值。</li>
</ul>
<p>可线性化的本质是保证多个数据副本的再现性--一旦写入或读取了新值，所有后续读取都可以查看新值，直到该值后来被覆盖。提供线性化功能的分布式系统可以为用户省去关注多个副本的麻烦，并能保证每个操作的原子性和顺序。</p>
<h3 id="Consensus" class="common-anchor-header">共识</h3><p>共识的概念被引入分布式系统，因为用户渴望看到分布式系统以与独立系统相同的方式运行。</p>
<p>简单地说，共识就是对价值的普遍认同。例如，史蒂夫和弗兰克想去吃点东西。史蒂夫建议吃三明治。弗兰克同意了史蒂夫的建议，两人都吃了三明治。他们达成了共识。更具体地说，其中一人提出的价值（三明治）得到了两人的同意，两人都根据该价值采取了行动。同样，分布式系统中的共识指的是，当一个进程提出一个值时，系统中的所有其他进程都同意并根据这个值采取行动。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2bb46e57_9eb5_456e_be7e_e7762aa9eb7e_68dd2e8e65.png" alt="Consensus" class="doc-image" id="consensus" />
   </span> <span class="img-wrapper"> <span>共识</span> </span></p>
<h2 id="Consensus-based-replication" class="common-anchor-header">基于共识的复制<button data-href="#Consensus-based-replication" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>最早的基于共识的算法是在 1988 年与<a href="https://pmg.csail.mit.edu/papers/vr.pdf">视图标记复制</a>一起提出的。1989 年，Leslie Lamport 提出了基于共识的算法<a href="https://lamport.azurewebsites.net/pubs/paxos-simple.pdf">Paxos</a>。</p>
<p>近年来，我们看到了业界另一种流行的基于共识的算法--<a href="https://raft.github.io/">Raft</a>。它已被 CockroachDB、TiDB、OceanBase 等许多主流 NewSQL 数据库所采用。</p>
<p>值得注意的是，分布式系统即使采用基于共识的复制，也不一定支持线性化。但是，线性化是构建 ACID 分布式数据库的前提条件。</p>
<p>在设计数据库系统时，应考虑日志和状态机的提交顺序。此外，还需要格外小心地维护 Paxos 或 Raft 的领导者租约，防止网络分区下的分脑。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://user-images.githubusercontent.com/1500781/165926429-69b5144c-f3ba-4819-87c3-ab7e04a7e22e.png" alt="Raft replication state machine" class="doc-image" id="raft-replication-state-machine" />
   </span> <span class="img-wrapper"> <span>Raft 复制状态机</span> </span></p>
<h3 id="Pros-and-cons" class="common-anchor-header">优点和缺点</h3><p>事实上，Raft、ZAB 和 Aurora 中<a href="https://aws.amazon.com/blogs/database/amazon-aurora-under-the-hood-quorum-and-correlated-failure/">基于法定人数的日志协议</a>都是 Paxos 的变体。基于共识的复制有以下优点：</p>
<ol>
<li>虽然基于共识的复制更注重 CAP 定理中的一致性和网络分区，但与传统的领导者-追随者复制相比，它能提供相对更好的可用性。</li>
<li>Raft 是一项突破，大大简化了基于共识的算法。GitHub 上有许多开源的 Raft 库（如<a href="https://github.com/sofastack/sofa-jraft">sofa-jraft</a>）。</li>
<li>基于共识的复制的性能可以满足大多数应用和业务的需要。随着高性能 SSD 和千兆网卡（网络接口卡）的普及，同步多个副本的负担得以减轻，Paxos 和 Raft 算法成为业界主流。</li>
</ol>
<p>一个误解是，基于共识的复制是在分布式数据库中实现数据一致性的灵丹妙药。然而，事实并非如此。基于共识的算法在可用性、复杂性和性能方面面临的挑战使其无法成为完美的解决方案。</p>
<ol>
<li><p>可用性大打折扣 优化的 Paxos 或 Raft 算法对领导副本有很强的依赖性，因此对抗灰色故障的能力较弱。在基于共识的复制中，只有当领导节点长时间没有响应时，才会重新选举领导副本。因此，基于共识的复制无法处理领导节点速度慢或发生故障的情况。</p></li>
<li><p>复杂性高 虽然已经有很多基于 Paxos 和 Raft 的扩展算法，但<a href="http://www.vldb.org/pvldb/vol13/p3072-huang.pdf">多 Raft</a>和<a href="https://www.vldb.org/pvldb/vol11/p1849-cao.pdf">并行 Raft</a>的出现需要对日志和状态机之间的同步进行更多的考虑和测试。</p></li>
<li><p>性能受损 在云原生时代，本地存储被 EBS 和 S3 等共享存储解决方案所取代，以确保数据的可靠性和一致性。因此，基于共识的复制不再是分布式系统的必备条件。更重要的是，基于共识的复制会带来数据冗余的问题，因为解决方案和 EBS 都有多个副本。</p></li>
</ol>
<p>对于多数据中心和多云复制来说，追求一致性不仅会影响可用性，还会影响<a href="https://en.wikipedia.org/wiki/PACELC_theorem">延迟</a>，导致性能下降。因此，在大多数应用中，线性化并不是多数据中心容灾的必要条件。</p>
<h2 id="A-log-replication-strategy-for-cloud-native-and-distributed-database" class="common-anchor-header">云原生和分布式数据库的日志复制策略<button data-href="#A-log-replication-strategy-for-cloud-native-and-distributed-database" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>不可否认，Raft 和 Paxos 等基于共识的算法仍是许多 OLTP 数据库采用的主流算法。不过，通过观察<a href="https://www.microsoft.com/en-us/research/publication/pacifica-replication-in-log-based-distributed-storage-systems/">PacificA</a>协议、<a href="https://www.microsoft.com/en-us/research/uploads/prod/2019/05/socrates.pdf">Socrates</a>和<a href="https://rockset.com/">Rockset</a> 等实例，我们可以发现趋势正在发生转变。</p>
<p>为云原生分布式数据库提供最佳服务的解决方案有两大原则。</p>
<h3 id="1-Replication-as-a-service" class="common-anchor-header">1.复制即服务</h3><p>需要一个单独的微服务，专门用于数据同步。同步模块和存储模块不应再紧密耦合在同一个流程中。</p>
<p>例如，Socrates 将存储、日志和计算解耦。只有一个专门的日志服务（下图中间的 XLog 服务）。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_0d7822a781.png" alt="Socrates architecture" class="doc-image" id="socrates-architecture" />
   </span> <span class="img-wrapper"> <span>苏格拉底架构</span> </span></p>
<p>XLog 服务是一个单独的服务。借助低延迟存储实现数据持久化。Socrates 中的登陆区负责以更快的速度保存三个副本。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_6d1182b6f1.png" alt="Socrates XLog service" class="doc-image" id="socrates-xlog-service" />
   </span> <span class="img-wrapper"> <span>苏格拉底 XLog 服务</span> </span></p>
<p>领导节点将日志异步分发到日志代理，并将数据刷新到 Xstore。本地固态硬盘缓存可加速数据读取。一旦数据刷新成功，就可以清理登陆区的缓冲区。显然，所有日志数据都分为三层--着陆区、本地固态硬盘和 Xstore。</p>
<h3 id="2-Russian-doll-principle" class="common-anchor-header">2.俄罗斯娃娃原理</h3><p>设计系统的一种方法是遵循俄罗斯娃娃原则：每一层都是完整的，完全适合该层所做的事情，这样就可以在其之上或周围构建其他层。</p>
<p>在设计云原生数据库时，我们需要巧妙地利用其他第三方服务来降低系统架构的复杂性。</p>
<p>要避免单点故障，我们似乎无法绕过 Paxos。不过，我们仍然可以通过将领导者选举交给 Raft 或基于<a href="https://research.google.com/archive/chubby-osdi06.pdf">Chubby</a>、<a href="https://github.com/bloomreach/zk-replicator">Zk</a> 和<a href="https://etcd.io/">etcd</a> 的 Paxos 服务来大大简化日志复制。</p>
<p>例如，<a href="https://rockset.com/">Rockset</a>架构遵循俄罗斯娃娃原则，使用 Kafka/Kineses 处理分布式日志，使用 S3 进行存储，并使用本地 SSD 缓存来提高查询性能。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://user-images.githubusercontent.com/1500781/165926697-c8b380dc-d71a-41a9-a76d-a261b77f0b5d.png" alt="Rockset architecture" class="doc-image" id="rockset-architecture" />
   </span> <span class="img-wrapper"> <span>Rockset 架构</span> </span></p>
<h3 id="The-Milvus-approach" class="common-anchor-header">Milvus 方法</h3><p>Milvus 中的可调一致性实际上与基于共识的复制中的跟随者读类似。从属读取功能是指在强一致性的前提下，使用从属副本承担数据读取任务。其目的是提高集群吞吐量，减少领导者的负载。从属读取功能背后的机制是查询最新日志的提交索引，并在提交索引中的所有数据应用到状态机之前提供查询服务。</p>
<p>不过，Milvus 的设计并未采用跟随者策略。换句话说，Milvus 不会在每次收到查询请求时都查询提交索引。相反，Milvus 采用了一种类似<a href="https://flink.apache.org/">Flink</a> 中水印的机制，即定期通知查询节点提交索引的位置。采用这种机制的原因是，Milvus 用户通常对数据一致性的要求不高，他们可以接受为了提高系统性能而在数据可见性方面做出的妥协。</p>
<p>此外，Milvus 还采用了多种微服务，并将存储与计算分离。在<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md#A-bare-bones-skeleton-of-the-Milvus-architecture">Milvus 架构</a>中，S3、MinIo 和 Azure Blob 被用于存储。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Milvus_architecture_b7743a4a7f.png" alt="Milvus architecture" class="doc-image" id="milvus-architecture" />
   </span> <span class="img-wrapper"> <span>Milvus 架构</span> </span></p>
<h2 id="Summary" class="common-anchor-header">概述<button data-href="#Summary" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如今，越来越多的云原生数据库将日志复制作为一项单独的服务。这样做可以降低添加只读复制和异构复制的成本。使用多个微服务可以快速利用成熟的云基础架构，这是传统数据库无法做到的。单个日志服务可以依赖基于共识的复制，但也可以采用俄罗斯娃娃策略，与 Paxos 或 Raft 一起采用各种一致性协议，以实现线性化。</p>
<h2 id="References" class="common-anchor-header">参考文献<button data-href="#References" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li>Lamport L. Paxos made simple[J].ACM SIGACT News (Distributed Computing Column) 32, 4 (Whole Number 121, December 2001), 2001: 51-58.</li>
<li>Ongaro D, Ousterhout J. In search of an understandable consensus algorithm[C]//2014 USENIX Annual Technical Conference (Usenix ATC 14).2014:305-319.</li>
<li>Oki B M, Liskov B H. Viewstamped replication：A new primary copy method to support highly-available distributed systems[C]//Proceedings of the seventh annual ACM Symposium on Principles of distributed computing.1988: 8-17.</li>
<li>Lin W, Yang M, Zhang L, et al. PacificA: Replication in log-based distributed storage systems[J].2008.</li>
<li>Verbitski A, Gupta A, Saha D, et al. Amazon aurora：关于避免 i/os、提交和成员变更的分布式共识[C]//2018 国际数据管理大会论文集.2018: 789-796.</li>
<li>Antonopoulos P, Budovski A, Diaconu C, et al. Socrates：云中的新 sql 服务器[C]//2019 国际数据管理大会论文集.2019: 1743-1756.</li>
</ul>


筏还是不筏？云原生数据库数据一致性的最佳解决方案

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Deep_Dive_8_6919720d59.png" alt="cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由<a href="https://github.com/cydrain">蔡玉东</a>撰写，<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>翻译。</p>
</blockquote>
<p>作为核心向量执行引擎，Knowhere之于Milvus，就如同发动机之于跑车。本文将介绍什么是 Knowhere，它与 Faiss 有何不同，以及 Knowhere 的代码结构。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#The-concept-of-Knowhere">Knowhere 的概念</a></li>
<li><a href="#Knowhere-in-the-Milvus-architecture">Milvus架构中的Knowhere</a></li>
<li><a href="#Knowhere-Vs-Faiss">Knowhere 与 Faiss</a></li>
<li><a href="#Understanding-the-Knowhere-code">了解Knowhere代码</a></li>
<li><a href="#Adding-indexes-to-Knowhere">为Knowhere添加索引</a></li>
</ul>
<h2 id="The-concept-of-Knowhere" class="common-anchor-header">Knowhere的概念<button data-href="#The-concept-of-Knowhere" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>狭义地说，Knowhere是一个操作界面，用于访问系统上层的服务和系统下层的向量相似性搜索库（如<a href="https://github.com/facebookresearch/faiss">Faiss</a>、<a href="https://github.com/nmslib/hnswlib">Hnswlib</a>、<a href="https://github.com/spotify/annoy">Annoy</a>）。此外，Knowhere 还负责异构计算。更具体地说，Knowhere控制在哪种硬件（如CPU或GPU）上执行索引构建和搜索请求。这就是 Knowhere 名字的由来--知道在哪里执行操作符。未来的版本将支持更多类型的硬件，包括DPU和TPU。</p>
<p>从广义上讲，Knowhere还集成了其他第三方索引库，如Faiss。因此，从整体上看，Knowhere 是公认的 Milvus 向量数据库的核心向量计算引擎。</p>
<p>从Knowhere的概念可以看出，它只处理数据计算任务，而分片、负载均衡、灾难恢复等任务则超出了Knowhere的工作范围。</p>
<p>从Milvus 2.0.1开始，<a href="https://github.com/milvus-io/knowhere">Knowhere</a>（广义上的）从Milvus项目中独立出来。</p>
<h2 id="Knowhere-in-the-Milvus-architecture" class="common-anchor-header">Milvus 架构中的 Knowhere<button data-href="#Knowhere-in-the-Milvus-architecture" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/ec63d1e9_86e1_48e3_9d75_8fed305bbcb5_26b842e9f6.png" alt="knowhere architecture" class="doc-image" id="knowhere-architecture" />
   </span> <span class="img-wrapper"> <span>Knowhere 架构</span> </span></p>
<p>Milvus 中的计算主要涉及向量和标量操作。Knowhere 只处理 Milvus 中对向量的操作符。上图展示了 Milvus 中的 Knowhere 架构。</p>
<p>最底层是系统硬件。第三方索引库位于硬件之上。然后，Knowhere通过CGO与顶层的索引节点和查询节点交互。</p>
<p>本文所讨论的Knowhere是广义上的Knowhere，即架构图中蓝色框内所标注的Knowhere。</p>
<h2 id="Knowhere-Vs-Faiss" class="common-anchor-header">Knowhere 与 Faiss<button data-href="#Knowhere-Vs-Faiss" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Knowhere不仅进一步扩展了Faiss的功能，还优化了性能。更具体地说，Knowhere 具有以下优势。</p>
<h3 id="1-Support-for-BitsetView" class="common-anchor-header">1.支持比特视图</h3><p>最初，在 Milvus 中引入 bitset 是为了实现 &quot;软删除&quot;。软删除的向量仍然存在于数据库中，但在向量相似性搜索或查询时不会被计算。比特集中的每个比特都对应一个索引向量。如果某个向量在比特集中被标记为 "1"，则表示该向量已被软删除，在向量搜索过程中将不会涉及。</p>
<p>比特集参数被添加到 Knowhere 中所有公开的 Faiss 索引查询 API 中，包括 CPU 和 GPU 索引。</p>
<p>进一步了解<a href="https://milvus.io/blog/2022-2-14-bitset.md">bitset 如何实现向量搜索的多功能性</a>。</p>
<h3 id="2-Support-for-more-similarity-metrics-for-indexing-binary-vectors" class="common-anchor-header">2.支持更多二进制向量索引的相似度指标</h3><p>除<a href="https://milvus.io/docs/v2.0.x/metric.md#Hamming-distance">Hamming</a> 外，Knowhere 还支持<a href="https://milvus.io/docs/v2.0.x/metric.md#Jaccard-distance">Jaccard</a>、<a href="https://milvus.io/docs/v2.0.x/metric.md#Tanimoto-distance">Tanimoto</a>、<a href="https://milvus.io/docs/v2.0.x/metric.md#Superstructure">Superstructure</a> 和<a href="https://milvus.io/docs/v2.0.x/metric.md#Substructure">Substructure</a>。Jaccard 和 Tanimoto 可用于测量两个样本集之间的相似性，而 Superstructure 和 Substructure 可用于测量化学结构的相似性。</p>
<h3 id="3-Support-for-AVX512-instruction-set" class="common-anchor-header">3.支持 AVX512 指令集</h3><p>Faiss 本身支持多种指令集，包括<a href="https://en.wikipedia.org/wiki/AArch64">AArch64</a>、<a href="https://en.wikipedia.org/wiki/SSE4#SSE4.2">SSE4.2</a> 和<a href="https://en.wikipedia.org/wiki/Advanced_Vector_Extensions">AVX2</a>。Knowhere 通过添加<a href="https://en.wikipedia.org/wiki/AVX-512">AVX512</a> 进一步扩展了支持的指令集，与 AVX2 相比，<a href="https://en.wikipedia.org/wiki/AVX-512">AVX512</a> 可<a href="https://milvus.io/blog/milvus-performance-AVX-512-vs-AVX2.md">将索引构建和查询性能提高 20% 至 30%</a>。</p>
<h3 id="4-Automatic-SIMD-instruction-selection" class="common-anchor-header">4.自动选择 SIMD 指令</h3><p>Knowhere 的设计目标是在具有不同 SIMD 指令（如 SIMD SSE、AVX、AVX2 和 AVX512）的各种 CPU 处理器（本地部署和云平台）上良好运行。因此，面临的挑战是，给定一个软件二进制文件（即 Milvus），如何让它在任何 CPU 处理器上自动调用合适的 SIMD 指令？Faiss 不支持自动选择 SIMD 指令，用户需要在编译时手动指定 SIMD 标志（如"-msse4"）。不过，Knowhere 是通过重构 Faiss 的代码库而构建的。依赖 SIMD 加速的常用函数（如相似性计算）被分解出来。然后为每个函数实现四个版本（即 SSE、AVX、AVX2、AVX512），并将每个版本放入单独的源文件中。然后，使用相应的 SIMD 标志对源文件进行单独编译。因此，在运行时，Knowhere 可以根据当前的 CPU 标志自动选择最合适的 SIMD 指令，然后使用挂钩功能链接正确的函数指针。</p>
<h3 id="5-Other-performance-optimization" class="common-anchor-header">5.其他性能优化</h3><p>阅读《<a href="https://www.cs.purdue.edu/homes/csjgwang/pubs/SIGMOD21_Milvus.pdf">Milvus: A Purpose-Built Vector Data Management System</a>》，了解有关 Knowhere 性能优化的更多信息。</p>
<h2 id="Understanding-the-Knowhere-code" class="common-anchor-header">了解 Knowhere 代码<button data-href="#Understanding-the-Knowhere-code" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如第一节所述，Knowhere 只处理向量搜索操作。因此，Knowhere只处理实体的向量场（目前只支持一个 Collections 中实体的一个向量场）。索引建立和向量相似性搜索也是针对段中的向量场。要想更好地了解数据模型，请阅读<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md#Data-Model">此处的</a>博客。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Entity_fields_6aa517cc4c.png" alt="entity fields" class="doc-image" id="entity-fields" />
   </span> <span class="img-wrapper"> <span>实体字段</span> </span></p>
<h3 id="Index" class="common-anchor-header">索引</h3><p>索引是一种独立于原始向量数据的数据结构。索引需要四个步骤：创建索引、训练数据、插入数据和建立索引。</p>
<p>对于某些人工智能应用来说，数据集训练是一个独立于向量搜索的过程。在这类应用中，首先要对数据集的数据进行训练，然后将数据插入到 Milvus 这样的向量数据库中进行相似性搜索。开放数据集（如 sift1M 和 sift1B）为训练和测试提供了数据。然而，在 Knowhere 中，训练数据和搜索数据是混合在一起的。也就是说，Knowhere 会训练一个数据段中的所有数据，然后插入所有训练过的数据并为它们建立索引。</p>
<h3 id="Knowhere-code-structure" class="common-anchor-header">Knowhere 代码结构</h3><p>DataObj 是 Knowhere 中所有数据结构的基类。<code translate="no">Size()</code> 是 DataObj 中唯一的虚拟方法。Index 类继承自 DataObj，并带有一个名为 &quot;size_&quot;的字段。Index 类还有两个虚拟方法--<code translate="no">Serialize()</code> 和<code translate="no">Load()</code> 。从 Index 派生的 VecIndex 类是所有向量索引的虚拟基类。VecIndex 提供的方法包括<code translate="no">Train()</code>,<code translate="no">Query()</code>,<code translate="no">GetStatistics()</code> 和<code translate="no">ClearStatistics()</code> 。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Knowhere_base_classes_9d610618d9.png" alt="base clase" class="doc-image" id="base-clase" />
   </span> <span class="img-wrapper"> <span>基类</span> </span></p>
<p>上图右侧列出了其他索引类型。</p>
<ul>
<li>Faiss 索引有两个子类：FaissBaseIndex 用于浮点向量上的所有索引，FaissBaseBinaryIndex 用于二进制向量上的所有索引。</li>
<li>GPUIndex 是所有 Faiss GPU 索引的基类。</li>
<li>OffsetBaseIndex 是所有自主开发索引的基类。索引文件中只存储向量 ID。因此，128 维向量的索引文件大小可以减少 2 个数量级。我们建议在使用这类索引进行向量相似性搜索时，也将原始向量考虑在内。</li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/IDMAP_8773a4511c.png" alt="IDMAP" class="doc-image" id="idmap" />
   </span> <span class="img-wrapper"> <span>IDMAP</span> </span></p>
<p>从技术上讲，<a href="https://github.com/facebookresearch/faiss/wiki/Guidelines-to-choose-an-index#then-flat">IDMAP</a>不是索引，而是用于暴力搜索。当向量被插入到向量数据库时，不需要进行数据训练和建立索引。搜索将直接在插入的向量数据上进行。</p>
<p>不过，为了代码的一致性，IDMAP 也继承自 VecIndex 类及其所有虚拟接口。IDMAP 的用法与其他索引相同。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/IVF_42b0f123d1.png" alt="IVF" class="doc-image" id="ivf" />
   </span> <span class="img-wrapper"> <span>反转</span> </span>文件</p>
<p>IVF（倒置文件）索引是最常用的索引。IVF 类派生自 VecIndex 和 FaissBaseIndex，并进一步扩展到 IVFSQ 和 IVFPQ。GPUIVF 衍生自 GPUIndex 和 IVF。然后 GPUIVF 进一步扩展到 GPUIVFSQ 和 GPUIVFPQ。</p>
<p>IVFSQHybrid 是一个自主开发的混合索引类，它在 GPU 上通过粗量化执行。而桶中的搜索则在 CPU 上执行。这种索引可以利用 GPU 的计算能力，减少 CPU 和 GPU 之间的内存拷贝。IVFSQHybrid 的召回率与 GPUIVFSQ 相同，但性能更好。</p>
<p>二进制索引的基类结构相对更简单。BinaryIDMAP 和 BinaryIVF 源自 FaissBaseBinaryIndex 和 VecIndex。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/third_party_index_34ad029848.png" alt="third-party index" class="doc-image" id="third-party-index" />
   </span> <span class="img-wrapper"> <span>第三方索引</span> </span></p>
<p>目前，除了 Faiss 之外，只支持两种第三方索引：基于树的索引 Annoy 和基于图的索引 HNSW。这两种常用的第三方索引都源自 VecIndex。</p>
<h2 id="Adding-indexes-to-Knowhere" class="common-anchor-header">向Knowhere添加索引<button data-href="#Adding-indexes-to-Knowhere" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如果想在Knowhere中添加新的索引，可以先参考现有的索引：</p>
<ul>
<li>要添加基于量化的索引，请参考 IVF_FLAT。</li>
<li>要添加基于图形的索引，请参考 HNSW。</li>
<li>要添加基于树的索引，请参考 Annoy。</li>
</ul>
<p>参考现有索引后，可以按照以下步骤向 Knowhere 添加新索引。</p>
<ol>
<li>在<code translate="no">IndexEnum</code> 中添加新索引的名称。数据类型为字符串。</li>
<li>在文件<code translate="no">ConfAdapter.cpp</code> 中为新索引添加数据验证检查。验证检查主要用于验证数据训练和查询的参数。</li>
<li>为新索引创建一个新文件。新索引的基类应包括<code translate="no">VecIndex</code> 和<code translate="no">VecIndex</code> 的必要虚拟接口。</li>
<li>在<code translate="no">VecIndexFactory::CreateVecIndex()</code> 中添加新索引的索引构建逻辑。</li>
<li>在<code translate="no">unittest</code> 目录下添加单元测试。</li>
</ol>
<h2 id="About-the-Deep-Dive-Series" class="common-anchor-header">关于深入研究系列<button data-href="#About-the-Deep-Dive-Series" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.0<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">正式宣布全面上市</a>，我们精心策划了这个 Milvus 深度挖掘系列博客，对 Milvus 架构和源代码进行深入解读。本系列博客涉及的主题包括</p>
<ul>
<li><a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">Milvus 架构概述</a></li>
<li><a href="https://milvus.io/blog/deep-dive-2-milvus-sdk-and-api.md">应用程序接口和 Python SDK</a></li>
<li><a href="https://milvus.io/blog/deep-dive-3-data-processing.md">数据处理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md">数据管理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-5-real-time-query.md">实时查询</a></li>
<li><a href="https://milvus.io/blog/deep-dive-7-query-expression.md">标量执行引擎</a></li>
<li><a href="https://milvus.io/blog/deep-dive-6-oss-qa.md">质量保证系统</a></li>
<li><a href="https://milvus.io/blog/deep-dive-8-knowhere.md">向量执行引擎</a></li>
</ul>


是什么增强了 Milvus 向量数据库的相似性搜索功能？

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Deep_Dive_7_baae830823.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">Angela Ni</a> 译。</p>
</blockquote>
<p>在 Milvus 中，<a href="https://milvus.io/docs/v2.0.x/query.md">向量查询</a>是通过基于布尔表达式的标量过滤检索向量的过程。通过标量过滤，用户可以根据数据属性的某些条件限制查询结果。例如，如果用户查询 1990-2010 年间上映且评分高于 8.5 分的电影，那么只有属性（上映年份和评分）符合条件的电影才能被查询到。</p>
<p>本文章旨在探讨 Milvus 如何完成从输入查询表达式到生成查询计划和执行查询的整个查询过程。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#Query-expression">查询表达式</a></li>
<li><a href="#Plan-AST-generation">生成计划 AST</a></li>
<li><a href="#Query-execution">查询执行</a></li>
</ul>
<h2 id="Query-expression" class="common-anchor-header">查询表达式<button data-href="#Query-expression" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 中带有属性过滤的查询表达式采用 EBNF（Extended Backus-Naur form）语法。下图是 Milvus 中的表达规则。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Expression_Syntax_966493a5be.png" alt="Expression Syntax" class="doc-image" id="expression-syntax" />
   </span> <span class="img-wrapper"> <span>表达式语法</span> </span></p>
<p>逻辑表达式可以使用二元逻辑操作符、一元逻辑操作符、逻辑表达式和单表达式的组合来创建。由于 EBNF 语法本身具有递归性，因此逻辑表达式可以是更大逻辑表达式的组合结果或一部分。一个逻辑表达式可以包含许多子逻辑表达式。同样的规则也适用于 Milvus。如果用户需要用许多条件来筛选结果的属性，用户可以通过组合不同的逻辑操作符和表达式来创建自己的筛选条件集。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Boolean_expression_1_dce12f8483.png" alt="Boolean expression" class="doc-image" id="boolean-expression" />
   </span> <span class="img-wrapper"> <span>布尔表达式</span> </span></p>
<p>上图显示了 Milvus 中<a href="https://milvus.io/docs/v2.0.x/boolean.md">布尔表达式规则</a>的一部分。一元逻辑操作符可以添加到表达式中。目前 Milvus 只支持一元逻辑操作符 &quot;not&quot;，表示系统需要取标量域值不满足计算结果的向量。二元逻辑操作符包括 &quot;和 &quot;和 &quot;或&quot;。单表达式包括项表达式和比较表达式。</p>
<p>在 Milvus 查询过程中，还支持加、减、乘、除等基本算术计算。下图展示了操作符的优先级。操作符从上到下按优先级降序排列。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Precedence_b8cfbdf17b.png" alt="Precedence" class="doc-image" id="precedence" />
   </span> <span class="img-wrapper"> <span>优先级</span> </span></p>
<h3 id="How-a-query-expression-on-certain-films-is-processed-in-Milvus" class="common-anchor-header">Milvus 如何处理对某些胶片的查询表达式？</h3><p>假设 Milvus 中存储了大量影片数据，用户想查询某些影片。举例来说，Milvus 中存储的每部影片数据都有以下五个字段：影片 ID、上映年份、影片类型、配乐和海报。在本例中，电影 ID 和上映年份的数据类型为 int64，而电影分数则为浮点数据。另外，电影海报以浮点向量格式存储，电影类型以字符串数据格式存储。值得注意的是，支持字符串数据类型是 Milvus 2.1 的一项新功能。</p>
<p>例如，如果用户想查询得分高于 8.5 分的电影。这些电影还必须是在 2000 年之前的十年到 2000 年之后的十年间上映的，或者它们的类型必须是喜剧片或动作片，那么用户需要输入以下谓词表达式：<code translate="no">score &gt; 8.5 &amp;&amp; (2000 - 10 &lt; release_year &lt; 2000 + 10 || type in [comedy,action])</code> 。</p>
<p>收到查询表达式后，系统将按以下优先顺序执行：</p>
<ol>
<li>查询得分高于 8.5 分的电影。查询结果称为 &quot;result1&quot;。</li>
<li>计算 2000 - 10，得到 "result2"（1990）。</li>
<li>计算 2000 + 10，得到 "result3"（2010 年）。</li>
<li>查询<code translate="no">release_year</code> 的值大于 &quot;result2 &quot;且小于 &quot;result3 &quot;的电影。也就是说，系统需要查询 1990 年至 2010 年上映的电影。查询结果称为 &quot;result4&quot;。</li>
<li>查询喜剧片或动作片。查询结果称为 &quot;result5&quot;。</li>
<li>将 "result4 "和 "result5 "合并，得到在 1990 年至 2010 年间上映或属于喜剧片或动作片类别的影片。结果称为 &quot;result6&quot;。</li>
<li>取 "result1 "和 "result6 "中的公共部分，得到满足所有条件的最终结果。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Frame_1_16_00972a6e5d.png" alt="Film example" class="doc-image" id="film-example" />
   </span> <span class="img-wrapper"> <span>电影示例</span> </span></p>
<h2 id="Plan-AST-generation" class="common-anchor-header">生成计划 AST<button data-href="#Plan-AST-generation" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 利用开源工具<a href="https://www.antlr.org/">ANTLR</a>（ANother Tool for Language Recognition）来生成计划 AST（抽象语法树）。ANTLR 是一种功能强大的解析器生成器，用于读取、处理、执行或翻译结构文本或二进制文件。更具体地说，ANTLR 可以生成一个解析器，用于根据预定义的语法或规则构建和行走解析树。下图是一个输入表达式为 &quot;SP=100; &quot;的示例。ANTLR 内置的语言识别功能 LEXER 会为输入表达式生成四个标记--&quot;SP&quot;、&quot;=&quot;、&quot;100 &quot;和&quot;;&quot;。然后，该工具将进一步解析这四个词素，生成相应的解析树。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/parse_tree_b2c3fb0b36.png" alt="parse tree" class="doc-image" id="parse-tree" />
   </span> <span class="img-wrapper"> <span>解析树</span> </span></p>
<p>走读机制是 ANTLR 工具的关键部分。它的作用是遍历所有解析树，检查每个节点是否符合语法规则，或检测某些敏感词。下图列出了一些相关的 API。由于 ANTLR 从根节点开始，通过每个子节点一直走到底部，因此无需区分解析树的行走顺序。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/parse_tree_walker_9a27942502.png" alt="parse tree walker" class="doc-image" id="parse-tree-walker" />
   </span> <span class="img-wrapper"> <span>解析树行走器</span> </span></p>
<p>Milvus 生成查询用 PlanAST 的方式与 ANTLR 类似。不过，使用 ANTLR 需要重新定义相当复杂的语法规则。因此，Milvus 采用了一种最普遍的规则--布尔表达式规则，并依赖于 GitHub 上开源的<a href="https://github.com/antonmedv/expr">Expr</a>包来查询和解析查询表达式的语法。</p>
<p>在带属性过滤的查询过程中，Milvus 会在接收到查询表达式后使用 Expr 提供的解析方法 ant-parser 生成一棵原始的未解计划树。我们将得到的原始计划树是一棵简单的二叉树。然后，Expr 和 Milvus 内置的优化器会对计划树进行微调。Milvus 中的优化器与前述的步行者机制颇为相似。由于 Expr 提供的计划树优化功能相当复杂，因此在很大程度上减轻了 Milvus 内置优化器的负担。最终，分析器会以递归方式分析优化后的计划树，以<a href="https://developers.google.com/protocol-buffers">协议缓冲区</a>（protobuf）的结构生成计划 AST。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/plan_AST_workflow_3e50b7a0d4.png" alt="plan AST workflow" class="doc-image" id="plan-ast-workflow" />
   </span> <span class="img-wrapper"> <span>计划 AST 工作流程</span> </span></p>
<h2 id="Query-execution" class="common-anchor-header">查询执行<button data-href="#Query-execution" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>查询执行的根本是执行前面步骤中生成的计划 AST。</p>
<p>在 Milvus 中，计划 AST 是在 proto 结构中定义的。下图是带有 protobuf 结构的信息。有六种表达式，其中二进制表达式和一元表达式可以进一步分为二进制逻辑表达式和一元逻辑表达式。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Protobuf1_232132dcf2.png" alt="protobuf1" class="doc-image" id="protobuf1" />
   </span> <span class="img-wrapper"> <span>原语 1</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/protobuf2_193f92f033.png" alt="protobuf2" class="doc-image" id="protobuf2" />
   </span> <span class="img-wrapper"> <span>protobuf2</span> </span></p>
<p>下图是查询表达式的 UML 图像。它展示了每个表达式的基本类和派生类。每个类都有一个接受访问者参数的方法。这是一种典型的访问者设计模式。Milvus 使用这种模式来执行计划 AST，因为它的最大优点是用户不必对原始表达式做任何操作，而是可以直接访问模式中的某个方法来修改某些查询表达式类和相关元素。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/UML_1238bc30e1.png" alt="UML" class="doc-image" id="uml" />
   </span> <span class="img-wrapper"> <span>UML</span> </span></p>
<p>在执行计划 AST 时，Milvus 首先接收一个原型计划节点。然后，通过内部 C++ 原型解析器获得 segcore 类型的计划节点。获得这两种类型的计划节点后，Milvus 会接受一系列类访问，然后在计划节点的内部结构中进行修改和执行。最后，Milvus 对所有执行计划节点进行搜索，获得过滤后的结果。最终结果以位掩码的格式输出。位掩码是一个位数数组（"0 "和 "1"）。满足筛选条件的数据在位掩码中标记为 "1"，不满足筛选条件的数据在位掩码中标记为 "0"。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/execute_workflow_d89f1ee925.png" alt="execute workflow" class="doc-image" id="execute-workflow" />
   </span> <span class="img-wrapper"> <span>执行工作流程</span> </span></p>
<h2 id="About-the-Deep-Dive-Series" class="common-anchor-header">关于深度学习系列<button data-href="#About-the-Deep-Dive-Series" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.0<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">正式宣布全面上市</a>，我们精心策划了这个 Milvus 深度剖析系列博客，对 Milvus 架构和源代码进行深入解读。本系列博客涉及的主题包括</p>
<ul>
<li><a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">Milvus 架构概述</a></li>
<li><a href="https://milvus.io/blog/deep-dive-2-milvus-sdk-and-api.md">应用程序接口和 Python SDK</a></li>
<li><a href="https://milvus.io/blog/deep-dive-3-data-processing.md">数据处理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md">数据管理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-5-real-time-query.md">实时查询</a></li>
<li><a href="https://milvus.io/blog/deep-dive-7-query-expression.md">标量执行引擎</a></li>
<li><a href="https://milvus.io/blog/deep-dive-6-oss-qa.md">质量保证系统</a></li>
<li><a href="https://milvus.io/blog/deep-dive-8-knowhere.md">向量执行引擎</a></li>
</ul>


数据库如何理解和执行您的查询？

开放源码软件（OSS）质量保证 - Milvus 案例研究

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220516_163732_d40acac221.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<p>最近，我们在向量数据库的发展历程中迎来了一个令人难以置信的里程碑--<a href="https://github.com/milvus-io/milvus">Milvus 的 GitHub repo</a> 上的星星数超过了 10K。感谢每一位支持我们的用户，他们给了我们一颗星 ⭐️。</p>
<p>Milvus 成为开源项目至今已有两年半的美好时光。在我们刚起步的时候，很少有人确切地了解什么是向量数据库，更不用说谈论它将如何在我们的日常生活中实现并加速人工智能的应用了。Milvus 向量数据库承载着我们定义和构建人工智能下一代数据库的愿景。在 Milvus 项目中，我们将 SOTA 算法与云技术相结合，因此开发人员可以利用 Milvus 向量数据库轻松构建人工智能应用程序。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Milvus_0_10000_d50a914332.gif" alt="Gif2" class="doc-image" id="gif2" />
   </span> <span class="img-wrapper"> <span>Gif2</span> </span></p>
<div align="center">点击<a href="https://www.youtube.com/watch?v=zIAX_oPI2Jk&ab_channel=Milvus-VectorDatabase">这里</a>观看 Milvus 资源库开发可视化完整视频。</div>
<p><br/></p>
<p>有许多<a href="https://github.com/milvus-io/milvus">辉煌的项目</a>为 Milvus 奠定了基础，我们很感谢能站在巨人的肩膀上。没有他们，就没有 Milvus。</p>
<p>同时，我们也非常感谢我们令人敬畏的社区，他们为这种新型数据库开启了激动人心的篇章。在展望未来之前，我们想花一点时间回顾一下这一路走来的历程，凝视我们的里程碑，并向我们的开发人员致谢：</p>
<ul>
<li>我们在<a href="https://lfaidata.foundation/blog/2020/04/02/milvus-joins-lf-ai-as-new-incubation-project/">孵化</a>阶段加入了 LF AI &amp; Data 基金会，与其他许多优秀的开源 AI 和数据项目一起找到了自己的家园。现在，Milvus 已经是一个<a href="https://lfaidata.foundation/blog/2021/06/23/lf-ai-data-foundation-announces-graduation-of-milvus-project/">毕业项目</a>。</li>
<li>我们发布了两个重要版本：<a href="https://milvus.io/docs/v1.0.0/announcement.md">Milvus 1.0</a>和<a href="https://milvus.io/docs/v2.0.x/comparison.md">Milvus 2.0</a>。</li>
<li>发表了一篇 SIGMOD 论文：<a href="https://dl.acm.org/doi/abs/10.1145/3448016.3457550">Milvus: A Purpose-Built Vector Data Management System（向量数据管理系统）</a>。</li>
<li>目前，我们在全球拥有 10,000 多名社区成员和 220 多名贡献者。</li>
<li>采用 Milvus 的<a href="https://milvus.io/">企业用户超过 1000 家</a>。其中不乏行业领导者。</li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Milvus_10000_star_timeline_3sec_de1a7c906a.gif" alt="Timeline gif" class="doc-image" id="timeline-gif" />
   </span> <span class="img-wrapper"> <span>时间轴 gif</span> </span></p>
<p>所有这一切都离不开每一位贡献者。感谢你们的拉取请求、问题报告、电子邮件、会议以及分享你们对 Milvus 的了解。你们都为 Milvus 的进步发挥着宝贵的作用。</p>
<h2 id="Special-event" class="common-anchor-header">特别活动<button data-href="#Special-event" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在这个特殊的里程碑上，我们准备了一份小小的答谢礼物--<a href="https://assets.zilliz.com/10_K_stars_2b2e0e0b36.png">一张可下载的桌面壁纸</a>。希望您喜欢！</p>
<p>如果您能帮助我们<a href="https://twitter.com/milvusio">宣传，</a>那就更好了！❤️</p>


Milvus 的一小步 - 10,000 颗星

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/deep_dive_5_5e9175c7f7.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<blockquote>
<p>本文由<a href="https://github.com/xige-16">Xi Ge</a>撰写，<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">Angela Ni</a> 译。</p>
</blockquote>
<p>在上一篇文章中，我们已经谈到了 Milvus 中的<a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md">数据插入和数据持久性</a>。在本文中，我们将继续讲解 Milvus 中的<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">其他组件</a>是如何交互完成实时数据查询的。</p>
<p><em>下面列出了开始之前的一些有用资源。我们建议首先阅读这些资源，以便更好地理解本篇文章的主题。</em></p>
<ul>
<li><a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">深入了解 Milvus 架构</a></li>
<li><a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md#Data-Model">Milvus 数据模型</a></li>
<li><a href="https://milvus.io/docs/v2.0.x/four_layers.md">Milvus 各组件的角色和功能</a></li>
<li><a href="https://milvus.io/blog/deep-dive-3-data-processing.md">Milvus 中的数据处理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md">Milvus 中的数据插入和数据持久化</a></li>
</ul>
<h2 id="Load-data-to-query-node" class="common-anchor-header">向查询节点加载数据<button data-href="#Load-data-to-query-node" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在执行查询之前，必须先将数据加载到查询节点。</p>
<p>加载到查询节点的数据有两类：来自<a href="https://milvus.io/docs/v2.0.x/four_layers.md#Log-broker">日志代理</a>的流数据和来自<a href="https://milvus.io/docs/v2.0.x/four_layers.md#Object-storage">对象存储</a>（下文也称为持久存储）的历史数据。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/flowchart_b1c51dfdaa.png" alt="Flowchart" class="doc-image" id="flowchart" />
   </span> <span class="img-wrapper"> <span>流程图</span> </span></p>
<p>数据协调器负责处理不断插入 Milvus 的流数据。当 Milvus 用户调用<code translate="no">collection.load()</code> 加载一个 Collections 时，查询协调器将查询数据协调器，以了解哪些片段已被持久化存储及其对应的检查点。检查点是一个标记，表示检查点之前的持久化片段会被消耗，而检查点之后的片段不会被消耗。</p>
<p>然后，查询协调器根据数据协调器提供的信息输出分配策略：按段或按通道分配。段分配器负责将持久存储（批量数据）中的段分配给不同的查询节点。例如，在上图中，段分配器将段 1 和段 3（S1、S3）分配给查询节点 1，将段 2 和段 4（S2、S4）分配给查询节点 2。通道分配器为不同的查询节点分配日志代理中的多个数据操作<a href="https://milvus.io/docs/v2.0.x/data_processing.md#Data-insertion">通道</a>（DMChannels）。例如，在上图中，信道分配器将查询节点 1 分配给信道 1 (Ch1)，将查询节点 2 分配给信道 2 (Ch2)。</p>
<p>在这种分配策略下，每个查询节点都会加载段数据并相应地监视信道。在图像中的查询节点 1 中，历史数据（批量数据）通过分配的 S1 和 S3 从持久存储中加载。同时，查询节点 1 通过订阅日志代理中的通道 1 来加载增量数据（流数据）。</p>
<h2 id="Data-management-in-query-node" class="common-anchor-header">查询节点的数据管理<button data-href="#Data-management-in-query-node" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>查询节点需要管理历史数据和增量数据。历史数据存储在<a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md#Sealed-segment">密封段</a>中，而增量数据存储在<a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md#Growing-segment">增长段</a>中。</p>
<h3 id="Historical-data-management" class="common-anchor-header">历史数据管理</h3><p>历史数据管理主要有两个考虑因素：负载平衡和查询节点故障切换。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/load_balance_c77e22bb5c.png" alt="Load balance" class="doc-image" id="load-balance" />
   </span> <span class="img-wrapper"> <span>负载平衡</span> </span></p>
<p>例如，如图所示，查询节点 4 比其他查询节点分配了更多的密封分段。这很可能使查询节点 4 成为瓶颈，拖慢整个查询过程。为了解决这个问题，系统需要将查询节点 4 中的几个网段分配给其他查询节点。这就是所谓的负载平衡。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Query_node_failover_3278c0e307.png" alt="Query node failover" class="doc-image" id="query-node-failover" />
   </span> <span class="img-wrapper"> <span>查询节点故障转移</span> </span></p>
<p>另一种可能的情况如上图所示。其中一个节点（查询节点 4）突然宕机。在这种情况下，需要将负载（分配给查询节点 4 的数据段）转移到其他工作的查询节点，以确保查询结果的准确性。</p>
<h3 id="Incremental-data-management" class="common-anchor-header">增量数据管理</h3><p>查询节点监视 DMChannels 以接收增量数据。在此过程中引入了流程图。它首先过滤所有数据插入信息。这是为了确保只加载指定分区中的数据。Milvus 中的每个 Collections 都有一个相应的通道，该通道由该 Collections 中的所有分区共享。因此，如果 Milvus 用户只需要加载某个分区中的数据，就需要使用流程图来过滤插入的数据。否则，Collection 中所有分区的数据都将加载到查询节点。</p>
<p>经过过滤后，增量数据被插入到不断增长的分段中，并进一步传递到服务器时间节点。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/flow_graph_dc58651367.png" alt="Flowgraph" class="doc-image" id="flowgraph" />
   </span> <span class="img-wrapper"> <span>流程图</span> </span></p>
<p>在数据插入过程中，每个插入信息都会分配一个时间戳。在上图所示的 DMChannel 中，数据按从左到右的顺序插入。第一条插入信息的时间戳是 1，第二条是 2，第三条是 6。 第四条红色标记的信息不是插入信息，而是时间戳信息。这表示时间戳小于该时间戳的插入数据已经在日志代理中。换句话说，在该时间戳信息之后插入的数据，其时间戳值都应大于该时间戳。例如，在上图中，当查询节点感知到当前时间刻度为 5 时，这意味着所有时间戳值小于 5 的插入信息都被加载到了查询节点。</p>
<p>服务器时间节点每次从插入节点接收到一个时间戳后，都会提供一个更新的<code translate="no">tsafe</code> 值。<code translate="no">tsafe</code> 表示安全时间，在这个时间点之前插入的所有数据都可以被查询。举例来说，如果<code translate="no">tsafe</code> = 9，那么时间戳小于 9 的插入数据都可以被查询。</p>
<h2 id="Real-time-query-in-Milvus" class="common-anchor-header">Milvus 中的实时查询<button data-href="#Real-time-query-in-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 中的实时查询是通过查询信息实现的。查询信息通过代理插入日志代理。然后，查询节点通过查看日志代理中的查询通道获取查询信息。</p>
<h3 id="Query-message" class="common-anchor-header">查询信息</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/query_message_4d57814f47.png" alt="Query message" class="doc-image" id="query-message" />
   </span> <span class="img-wrapper"> <span>查询信息</span> </span></p>
<p>查询信息包括以下有关查询的关键信息：</p>
<ul>
<li><code translate="no">msgID</code>:消息 ID，系统分配的查询消息 ID。</li>
<li><code translate="no">collectionID</code>:要查询的 Collections ID（如果用户指定）。</li>
<li><code translate="no">execPlan</code>:执行计划主要用于查询中的属性过滤。</li>
<li><code translate="no">service_ts</code>:服务时间戳将与上述<code translate="no">tsafe</code> 一起更新。服务时间戳表示服务的时间点。在<code translate="no">service_ts</code> 之前插入的所有数据都可供查询。</li>
<li><code translate="no">travel_ts</code>:旅行时间戳指定过去的时间范围。查询将在<code translate="no">travel_ts</code> 指定的时间段内进行。</li>
<li><code translate="no">guarantee_ts</code>:保证时间戳指定查询需要在其后进行的时间段。只有当<code translate="no">service_ts</code> &gt;<code translate="no">guarantee_ts</code> 时，才会进行查询。</li>
</ul>
<h3 id="Real-time-query" class="common-anchor-header">实时查询</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/query_process_7f676972d8.png" alt="Query process" class="doc-image" id="query-process" />
   </span> <span class="img-wrapper"> <span>查询过程</span> </span></p>
<p>收到查询信息后，Milvus 首先判断当前服务时间<code translate="no">service_ts</code> 是否大于查询信息中的保证时间戳<code translate="no">guarantee_ts</code> 。如果是，则执行查询。查询将在历史数据和增量数据上并行执行。由于流数据和批处理数据之间可能会有数据重叠，因此需要执行一个名为 "局部缩减 "的操作来过滤掉多余的查询结果。</p>
<p>但是，如果当前服务时间小于新插入查询信息的保证时间戳，查询信息将成为未解决信息，等待处理，直到服务时间大于保证时间戳。</p>
<p>查询结果最终会推送到结果通道。代理从该通道获取查询结果。同样，代理也会进行 "全局还原"，因为它从多个查询节点接收结果，而且查询结果可能是重复的。</p>
<p>为确保代理在向 SDK 返回所有查询结果之前已收到所有查询结果，结果信息还将保留一份信息记录，包括已搜索的密封段、已搜索的 DMChannels 和全局密封段（所有查询节点上的所有段）。只有同时满足以下两个条件，系统才能断定代理已收到所有查询结果：</p>
<ul>
<li>所有结果信息中记录的所有搜索密封段的总和大于全局密封段、</li>
<li>Collections 中的所有 DMChannels 都被查询。</li>
</ul>
<p>最终，代理将 "全局还原 "后的最终结果返回给 Milvus SDK。</p>
<h2 id="About-the-Deep-Dive-Series" class="common-anchor-header">关于深入研究系列<button data-href="#About-the-Deep-Dive-Series" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.0<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">正式宣布全面上市</a>，我们精心策划了这个 Milvus 深度剖析系列博客，对 Milvus 架构和源代码进行深入解读。本系列博客涉及的主题包括</p>
<ul>
<li><a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">Milvus 架构概述</a></li>
<li><a href="https://milvus.io/blog/deep-dive-2-milvus-sdk-and-api.md">应用程序接口和 Python SDK</a></li>
<li><a href="https://milvus.io/blog/deep-dive-3-data-processing.md">数据处理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md">数据管理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-5-real-time-query.md">实时查询</a></li>
<li><a href="https://milvus.io/blog/deep-dive-7-query-expression.md">标量执行引擎</a></li>
<li><a href="https://milvus.io/blog/deep-dive-6-oss-qa.md">质量保证系统</a></li>
<li><a href="https://milvus.io/blog/deep-dive-8-knowhere.md">向量执行引擎</a></li>
</ul>


使用 Milvus 向量数据库进行实时查询

向量数据库中的数据插入和数据持久性

向量数据库如何处理数据？

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220322_175856_e8e7bea7dc.png" alt="Cover image" class="doc-image" id="cover-image" />
   </span> <span class="img-wrapper"> <span>封面图片</span> </span></p>
<p>作者：<a href="https://github.com/XuanYang-cn">杨璇</a></p>
<h2 id="Background" class="common-anchor-header">背景介绍<button data-href="#Background" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>下图描述了 SDK 与 Milvus 之间通过 gRPC 进行的交互。想象一下，Milvus 是一个黑盒子。协议缓冲区（Protocol Buffer）用于定义服务器的接口及其携带的信息结构。因此，黑盒子 Milvus 中的所有操作都是由协议 API 定义的。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/SDK_10c9673111.png" alt="Interaction" class="doc-image" id="interaction" />
   </span> <span class="img-wrapper"> <span>交互</span> </span></p>
<h2 id="Milvus-Protocol-API" class="common-anchor-header">Milvus 协议应用程序接口<button data-href="#Milvus-Protocol-API" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 协议 API 由<code translate="no">milvus.proto</code> 、<code translate="no">common.proto</code> 和<code translate="no">schema.proto</code> 组成，它们是以<code translate="no">.proto</code> 为后缀的协议缓冲区文件。为确保正常操作，SDK 必须通过这些协议缓冲文件与 Milvus 交互。</p>
<h3 id="milvusproto" class="common-anchor-header">milvus.proto</h3><p><code translate="no">milvus.proto</code> 是 Milvus 协议 API 的重要组成部分，因为它定义了 ，进一步定义了 Milvus 的所有 RPC 接口。<code translate="no">MilvusService</code></p>
<p>以下代码示例显示了<code translate="no">CreatePartitionRequest</code> 接口。它有两个主要字符串类型参数<code translate="no">collection_name</code> 和<code translate="no">partition_name</code> ，根据这两个参数，您可以启动分区创建请求。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/code_d5f034d58d.png" alt="CreatePartitionRequest" class="doc-image" id="createpartitionrequest" />
   </span> <span class="img-wrapper"> <span>创建分区请求</span> </span></p>
<p>请查看<a href="https://github.com/milvus-io/milvus-proto/blob/44f59db22b27cc55e4168c8e53b6e781c010a713/proto/milvus.proto">PyMilvus GitHub 代码库中</a>第 19 行的协议示例。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/create_partition_938691f07f.png" alt="Example" class="doc-image" id="example" />
   </span> <span class="img-wrapper"> <span>示例</span> </span></p>
<p>您可以在此处找到<code translate="no">CreatePartitionRequest</code> 的定义。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220321_112254_4ec4f35bd3.png" alt="Definition" class="doc-image" id="definition" />
   </span> <span class="img-wrapper"> <span>定义</span> </span></p>
<p>欢迎希望使用不同编程语言开发 Milvus 功能或 SDK 的贡献者通过 RPC 找到 Milvus 提供的所有接口。</p>
<h3 id="commonproto" class="common-anchor-header">common.proto</h3><p><code translate="no">common.proto</code> 定义了常见的信息类型，包括 , 和 。<code translate="no">ErrorCode</code> <code translate="no">Status</code></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220321_112303_eaafc432a8.png" alt="common.proto" class="doc-image" id="common.proto" />
   </span> <span class="img-wrapper"> <span>common.proto</span> </span></p>
<h3 id="schemaproto" class="common-anchor-header">schema.proto</h3><p><code translate="no">schema.proto</code> 定义了参数中的 Schema。以下代码示例是 。<code translate="no">CollectionSchema</code></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220321_112313_df4ebe36e7.png" alt="schema.proto" class="doc-image" id="schema.proto" />
   </span> <span class="img-wrapper"> <span>schema.proto</span> </span></p>
<p><code translate="no">milvus.proto</code>、<code translate="no">common.proto</code> 和<code translate="no">schema.proto</code> 共同构成了 Milvus 的 API，代表了所有可以通过 RPC 调用的操作符。</p>
<p>如果深入研究源代码并仔细观察，你会发现当调用<code translate="no">create_index</code> 等接口时，它们实际上调用了多个 RPC 接口，如<code translate="no">describe_collection</code> 和<code translate="no">describe_index</code> 。Milvus 的许多对外接口都是多个 RPC 接口的组合。</p>
<p>了解了 RPC 的行为之后，您就可以通过组合为 Milvus 开发新的功能。我们非常欢迎您发挥想象力和创造力，为 Milvus 社区做出贡献。</p>
<h2 id="PyMilvus-20" class="common-anchor-header">PyMilvus 2.0<button data-href="#PyMilvus-20" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="Object-relational-mapping-ORM" class="common-anchor-header">对象关系映射（ORM）</h3><p>简而言之，对象关系映射（ORM）是指当您操作本地对象时，这种操作将影响服务器上的相应对象。PyMilvus ORM 风格 API 具有以下特点：</p>
<ol>
<li>它直接操作对象。</li>
<li>它隔离了服务逻辑和数据访问细节。</li>
<li>它隐藏了实现的复杂性，你可以在不同的 Milvus 实例中运行相同的脚本，而无需考虑它们的部署方式或实现。</li>
</ol>
<h3 id="ORM-style-API" class="common-anchor-header">ORM 式应用程序接口</h3><p>ORM 风格 API 的精髓之一在于对 Milvus 连接的控制。例如，你可以为多个 Milvus 服务器指定别名，并仅通过别名连接或断开它们。你甚至可以删除本地服务器地址，并通过特定连接精确控制某些对象。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220321_112320_d5ff08a582.png" alt="Control Connection" class="doc-image" id="control-connection" />
   </span> <span class="img-wrapper"> <span>控制连接</span> </span></p>
<p>ORM 风格 API 的另一个特点是，经过抽象后，所有操作都可以直接对对象执行，包括 Collection、分区和索引。</p>
<p>你可以通过获取一个现有的 Collections 对象或创建一个新的 Collections 对象来抽象一个 Collections 对象。你还可以使用连接别名为特定对象分配一个 Milvus 连接，这样就可以在本地对这些对象进行操作符。</p>
<p>要创建分区对象，可以用其父级 Collections 对象来创建，也可以像创建 Collections 对象一样来创建。这些方法也可用于索引对象。</p>
<p>在这些分区或索引对象存在的情况下，你可以通过它们的父集合对象来获取它们。</p>
<h2 id="About-the-Deep-Dive-Series" class="common-anchor-header">关于深入研究系列<button data-href="#About-the-Deep-Dive-Series" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>随着 Milvus 2.0<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">正式宣布全面上市</a>，我们精心策划了这个 Milvus 深度剖析系列博客，对 Milvus 架构和源代码进行深入解读。本系列博客涉及的主题包括</p>
<ul>
<li><a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">Milvus 架构概述</a></li>
<li><a href="https://milvus.io/blog/deep-dive-2-milvus-sdk-and-api.md">应用程序接口和 Python SDK</a></li>
<li><a href="https://milvus.io/blog/deep-dive-3-data-processing.md">数据处理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-4-data-insertion-and-data-persistence.md">数据管理</a></li>
<li><a href="https://milvus.io/blog/deep-dive-5-real-time-query.md">实时查询</a></li>
<li><a href="https://milvus.io/blog/deep-dive-7-query-expression.md">标量执行引擎</a></li>
<li><a href="https://milvus.io/blog/deep-dive-6-oss-qa.md">质量保证系统</a></li>
<li><a href="https://milvus.io/blog/deep-dive-8-knowhere.md">向量执行引擎</a></li>
</ul>


Milvus Python SDK 和 API 简介

为可扩展的相似性搜索建立向量数据库

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Attu_3ff9a76156.png" alt="Binlog Cover Image" class="doc-image" id="binlog-cover-image" />
   </span> <span class="img-wrapper"> <span>Binlog 封面图片</span> </span></p>
<p><a href="https://github.com/czhen-zilliz">陈震</a>撰稿，<a href="https://github.com/LocoRichard">王立晨</a>誊写。</p>
<p style="font-size: 12px;color: #4c5a67">点击<a href="https://zilliz.com/blog/manage-your-milvus-vector-database-with-one-click-simplicity">此处</a>查看原文。</p> 
<p>面对快速增长的非结构化数据处理需求，Milvus 2.0脱颖而出。它是一款面向人工智能的向量数据库系统，专为海量生产场景而设计。除了这些 Milvus SDK 和 Milvus CLI（Milvus 的命令行界面）之外，有没有一种工具能让用户更直观地操作 Milvus 呢？答案是肯定的。Zilliz 发布了一款专门针对 Milvus 的图形用户界面--Attu。在本文中，我们将逐步向您展示如何使用 Attu 进行向量相似性搜索。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/map_aa1cda30d4.png" alt="Attu island" class="doc-image" id="attu-island" />
   </span> <span class="img-wrapper"> <span>Attu 岛</span> </span></p>
<p>与 Milvus CLI 的简单易用相比，Attu 的功能更多：</p>
<ul>
<li>适用于 Windows 操作系统、macOS 和 Linux 操作系统的安装程序；</li>
<li>直观的图形用户界面，更易于使用 Milvus；</li>
<li>涵盖 Milvus 的主要功能；</li>
<li>可扩展自定义功能的插件；</li>
<li>完整的系统拓扑信息，便于理解和管理 Milvus 实例。</li>
</ul>
<h2 id="Installation" class="common-anchor-header">安装<button data-href="#Installation" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>你可以在<a href="https://github.com/zilliztech/attu/releases">GitHub</a> 上找到 Attu 的最新版本。Attu 提供适用于不同操作系统的可执行安装程序。它是一个开源项目，欢迎大家为其贡献力量。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/installation_bbe62873af.png" alt="Installation" class="doc-image" id="installation" />
   </span> <span class="img-wrapper"> <span>安装</span> </span></p>
<p>您也可以通过 Docker 安装 Attu。</p>
<pre><code translate="no" class="language-shell">docker run -p <span class="hljs-number">8000</span>:<span class="hljs-number">3000</span> -e <span class="hljs-variable constant_">HOST_URL</span>=<span class="hljs-attr">http</span>:<span class="hljs-comment">//{ attu IP }:8000 -e MILVUS_URL={milvus server IP}:19530 zilliz/attu:latest</span>
<button class="copy-code-btn"></button></code></pre>
<p><code translate="no">attu IP</code> 是 Attu 运行环境的 IP 地址， 是 Milvus 运行环境的 IP 地址。<code translate="no">milvus server IP</code> </p>
<p>成功安装 Attu 后，在界面中输入 Milvus IP 和端口，即可启动 Attu。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/connect_1fde46d9d5.png" alt="Connect Milvus with Attu" class="doc-image" id="connect-milvus-with-attu" />
   </span> <span class="img-wrapper"> <span>用 Attu 连接 Milvus</span> </span></p>
<h2 id="Feature-overview" class="common-anchor-header">功能概览<button data-href="#Feature-overview" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/overview_591e230514.png" alt="Overview page" class="doc-image" id="overview-page" />
   </span> <span class="img-wrapper"> <span>概述页面</span> </span></p>
<p>Attu 界面由<strong>概述</strong>页、<strong>Collection</strong>页、<strong>向量搜索</strong>页和<strong>系统视图</strong>页组成，分别对应左侧导航面板上的四个图标。</p>
<p><strong>概览</strong>页面显示已加载的 Collections。而<strong>Collection</strong>页面则列出所有 Collection，并显示它们是否已加载或释放。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/collection_42656fe308.png" alt="Collection page" class="doc-image" id="collection-page" />
   </span> <span class="img-wrapper"> <span>Collections 页面</span> </span></p>
<p><strong>向量搜索</strong>和<strong>系统视图</strong>页面是 Attu 的插件。本博客的最后一部分将介绍插件的概念和用法。</p>
<p>你可以在向量<strong>搜索</strong>页面进行向量相似性搜索。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/vector_search_be7365687c.png" alt="Vector Search page" class="doc-image" id="vector-search-page" />
   </span> <span class="img-wrapper"> <span>向量搜索页面</span> </span></p>
<p>在<strong>系统视图</strong>页面，你可以查看 Milvus 的拓扑结构。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/system_view_e1df15023d.png" alt="System View page" class="doc-image" id="system-view-page" />
   </span> <span class="img-wrapper"> <span>系统视图页面</span> </span></p>
<p>你还可以通过点击节点来查看每个节点的详细信息。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/node_view_5bbc25f9b2.png" alt="Node view" class="doc-image" id="node-view" />
   </span> <span class="img-wrapper"> <span>节点视图</span> </span></p>
<h2 id="Demonstration" class="common-anchor-header">演示<button data-href="#Demonstration" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>让我们用一个测试数据集来探索 Attu。</p>
<p>请查看我们的<a href="https://github.com/zilliztech/attu/tree/main/examples">GitHub 仓库</a>，获取以下测试中使用的数据集。</p>
<p>首先，创建一个名为 test 的 Collection，其中包含以下四个字段：</p>
<ul>
<li>字段名称：id，主键字段</li>
<li>字段名称：向量，向量字段，浮点型向量，维度：128</li>
<li>字段名称：品牌，标量字段，Int64</li>
<li>字段名称：颜色，标量字段，Int64</li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/create_collection_95dfa15354.png" alt="Create a collection" class="doc-image" id="create-a-collection" />
   </span> <span class="img-wrapper"> <span>创建 Collections</span> </span></p>
<p>创建成功后加载 Collections 以进行搜索。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/load_collection_fec39171df.png" alt="Load the collection" class="doc-image" id="load-the-collection" />
   </span> <span class="img-wrapper"> <span>加载 Collections</span> </span></p>
<p>现在您可以在 "<strong>概览</strong>"页面检查新创建的 Collections。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/check_collection_163b05477e.png" alt="Check the collection" class="doc-image" id="check-the-collection" />
   </span> <span class="img-wrapper"> <span>检查 Collections</span> </span></p>
<p>将测试数据集导入 Milvus。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/import_data_1_f73d71be85.png" alt="Import data" class="doc-image" id="import-data" />
   </span> <span class="img-wrapper"> <span>导入数据</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/import_data_2_4b3c3c3c25.png" alt="Import data" class="doc-image" id="import-data" />
   </span> <span class="img-wrapper"> <span>导入数据</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/import_data_3_0def4e8550.png" alt="Import data" class="doc-image" id="import-data" />
   </span> <span class="img-wrapper"> <span>导入数据</span> </span></p>
<p>在 "概览 "或 "集合 "页面点击集合名称，进入查询界面，检查导入的数据。</p>
<p>添加过滤器，指定表达式<code translate="no">id != 0</code> ，单击<strong>应用过滤器</strong>，然后单击<strong>查询</strong>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/query_data_24d9f71ccc.png" alt="Query data" class="doc-image" id="query-data" />
   </span> <span class="img-wrapper"> <span>查询数据</span> </span></p>
<p>您会发现所有 50 个实体条目都已成功导入。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/query_result_bcbbd17084.png" alt="Query result" class="doc-image" id="query-result" />
   </span> <span class="img-wrapper"> <span>查询结果</span> </span></p>
<p>让我们试试向量相似性搜索。</p>
<p>从<code translate="no">search_vectors.csv</code> 中复制一个向量并将其粘贴到<strong>向量值字</strong>段中。选择 Collections 和字段。点击<strong>搜索</strong>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/search_data_5af3a1db53.png" alt="Search data" class="doc-image" id="search-data" />
   </span> <span class="img-wrapper"> <span>搜索数据</span> </span></p>
<p>然后可以查看搜索结果。无需编译任何脚本，就能轻松使用 Milvus 进行搜索。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/search_result_961886efab.png" alt="Search result" class="doc-image" id="search-result" />
   </span> <span class="img-wrapper"> <span>搜索结果</span> </span></p>
<p>最后，让我们查看<strong>系统视图</strong>页面。</p>
<p>通过封装在 Milvus Node.js SDK 中的 Metrics API，您可以查看系统状态、节点关系和节点状态。</p>
<p>作为 Attu 的独家功能，系统概览页面包含完整的系统拓扑图。点击每个节点，即可查看其状态（每 10 秒刷新一次）。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/topological_graph_d0c5c17586.png" alt="Milvus node topological graph" class="doc-image" id="milvus-node-topological-graph" />
   </span> <span class="img-wrapper"> <span>Milvus 节点拓扑图</span> </span></p>
<p>点击每个节点可进入<strong>节点列表视图</strong>。您可以查看协调节点的所有子节点。通过排序，您可以快速识别 CPU 或内存使用率高的节点，并找到系统问题所在。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/node_list_64fc610a8d.png" alt="Milvus node list" class="doc-image" id="milvus-node-list" />
   </span> <span class="img-wrapper"> <span>Milvus 节点列表</span> </span></p>
<h2 id="Whats-more" class="common-anchor-header">更多信息<button data-href="#Whats-more" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>如前所述，<strong>向量搜索</strong>和<strong>系统视图</strong>页面是 Attu 的插件。我们鼓励用户根据自己的应用场景在 Attu 中开发自己的插件。在源代码中，有一个专门为插件代码而建的文件夹。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/plugins_a2d98e4e5b.png" alt="Plugins" class="doc-image" id="plugins" />
   </span> <span class="img-wrapper"> <span>插件</span> </span></p>
<p>您可以参考任何一个插件，了解如何构建插件。通过设置以下配置文件，即可将插件添加到 Attu。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/add_plugins_e3ef53cc0d.png" alt="Add plugins to Attu" class="doc-image" id="add-plugins-to-attu" />
   </span> <span class="img-wrapper"> <span>向 Attu 添加插件</span> </span></p>
<p>详细说明可参阅<a href="https://github.com/zilliztech/attu/tree/main/doc">Attu GitHub Repo</a>和<a href="https://milvus.io/docs/v2.0.x/attu.md">Milvus 技术文档</a>。</p>
<p>Attu 是一个开源项目。欢迎所有贡献。如果您在使用 Attu 时遇到任何问题，也可以<a href="https://github.com/zilliztech/attu/issues">提交问题</a>。</p>
<p>我们衷心希望 Attu 能为您带来更好的 Milvus 用户体验。如果您喜欢 Attu，或对使用有任何反馈意见，请填写 Attu<a href="https://wenjuan.feishu.cn/m/cfm?t=suw4QnODU1ui-ok7r">用户调查表</a>，帮助我们优化 Attu，以获得更好的用户体验。</p>


一键式轻松管理 Milvus 向量数据库

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Load_balance_b2f35a5577.png" alt="Binlog Cover Image" class="doc-image" id="binlog-cover-image" />
   </span> <span class="img-wrapper"> <span>Binlog 封面图片</span> </span></p>
<p>作者：<a href="https://github.com/xige-16">Xi Ge</a></p>
<p>在之前的博客文章中，我们陆续介绍了 Milvus 2.0 中的 Deletion、Bitset 和 Compaction 功能。在本系列文章的最后，我们想和大家分享负载均衡（Load Balance）背后的设计，它是 Milvus 分布式集群的一个重要功能。</p>
<h2 id="Implementation" class="common-anchor-header">实现<button data-href="#Implementation" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>查询节点中缓冲的片段数量和大小不同，各查询节点的搜索性能也可能不同。最糟糕的情况可能是，几个查询节点在搜索大量数据时已经筋疲力尽，而新创建的查询节点却因为没有分段而处于闲置状态，从而造成 CPU 资源的大量浪费和搜索性能的大幅下降。</p>
<p>为避免出现这种情况，查询协调器（query coordinator）被编程为根据节点的内存使用情况向每个查询节点平均分配数据段。因此，CPU 资源在各节点上的消耗是均等的，从而大大提高了搜索性能。</p>
<h3 id="Trigger-automatic-load-balance" class="common-anchor-header">触发自动负载平衡</h3><p>根据配置<code translate="no">queryCoord.balanceIntervalSeconds</code> 的默认值，查询协调器每 60 秒检查一次所有查询节点的 RAM 使用情况（百分比）。如果满足以下任一条件，查询协调器就会开始平衡各查询节点的查询负载：</p>
<ol>
<li>群集中任何查询节点的内存使用率大于<code translate="no">queryCoord.overloadedMemoryThresholdPercentage</code> （默认值：90）；</li>
<li>或任意两个查询节点的内存使用量差值的绝对值大于<code translate="no">queryCoord.memoryUsageMaxDifferencePercentage</code> （默认值：30）。</li>
</ol>
<p>数据段从源查询节点传输到目标查询节点后，还应同时满足以下两个条件：</p>
<ol>
<li>目标查询节点的内存使用量不大于<code translate="no">queryCoord.overloadedMemoryThresholdPercentage</code> （默认值：90）；</li>
<li>负载平衡后，源查询节点和目标查询节点的内存使用量差值的绝对值小于负载平衡前的差值。</li>
</ol>
<p>满足上述条件后，查询协调器将继续平衡各节点的查询负载。</p>
<h2 id="Load-balance" class="common-anchor-header">负载平衡<button data-href="#Load-balance" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>当负载平衡被触发时，查询协调器首先将目标数据段加载到目标查询节点。此时，两个查询节点都会根据任何搜索请求返回目标数据段的搜索结果，以保证结果的完整性。</p>
<p>目的地查询节点成功加载目标网段后，查询协调器会向查询频道发布<code translate="no">sealedSegmentChangeInfo</code> 。如下图所示，<code translate="no">onlineNodeID</code> 和<code translate="no">onlineSegmentIDs</code> 分别表示加载段的查询节点和加载的段，<code translate="no">offlineNodeID</code> 和<code translate="no">offlineSegmentIDs</code> 分别表示需要释放段的查询节点和要释放的段。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220228_145413_f253cec15b.png" alt="sealedSegmentChangeInfo" class="doc-image" id="sealedsegmentchangeinfo" />
   </span> <span class="img-wrapper"> <span>密封的分段更改信息</span> </span></p>
<p>收到<code translate="no">sealedSegmentChangeInfo</code> 后，源查询节点将释放目标网段。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/20220228_145436_2604bc57a5.png" alt="Load Balance Workflow" class="doc-image" id="load-balance-workflow" />
   </span> <span class="img-wrapper"> <span>负载平衡工作流程</span> </span></p>
<p>源查询节点释放目标网段后，整个流程就成功了。这样，各查询节点的查询负载就达到了平衡，即所有查询节点的 RAM 使用量都不大于<code translate="no">queryCoord.overloadedMemoryThresholdPercentage</code> ，并且负载平衡后源查询节点和目标查询节点的 RAM 使用量差值的绝对值小于负载平衡前的差值。</p>
<h2 id="Whats-next" class="common-anchor-header">下一步是什么？<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 2.0 新功能系列博客中，我们将介绍新功能的设计。阅读本系列博客的更多内容！</p>
<ul>
<li><a href="https://milvus.io/blog/2022-02-07-how-milvus-deletes-streaming-data-in-distributed-cluster.md">Milvus 如何删除分布式集群中的流数据</a></li>
<li><a href="https://milvus.io/blog/2022-2-21-compact.md">Milvus 如何压缩数据？</a></li>
<li><a href="https://milvus.io/blog/2022-02-28-how-milvus-balances-query-load-across-nodes.md">Milvus 如何平衡各节点的查询负载？</a></li>
<li><a href="https://milvus.io/blog/2022-2-14-bitset.md">Bitset 如何实现向量相似性搜索的多功能性？</a></li>
</ul>
<p>这是 Milvus 2.0 新功能系列博客的压轴文章。继本系列之后，我们计划推出一个新的 Milvus<a href="https://milvus.io/blog/deep-dive-1-milvus-architecture-overview.md">深度</a>系列，介绍 Milvus 2.0 的基本架构。敬请期待。</p>


Milvus 如何平衡各节点的查询负载？

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Compact_173a08ec1c.png" alt="Binlog Cover Image" class="doc-image" id="binlog-cover-image" />
   </span> <span class="img-wrapper"> <span>Binlog 封面图片</span> </span></p>
<p>作者：<a href="https://github.com/sunby">孙冰怡</a>、<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a></p>
<p>随着 Milvus 2.0 GA 的<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">正式发布</a>，一系列新功能得到了支持。其中，"压缩 "是可以帮助你节省存储空间的新功能之一。</p>
<p>压缩指的是将小片段合并为大片段并清理逻辑删除数据的过程。换句话说，压缩通过清除 binlog 中已删除或过期的实体来减少磁盘空间的使用。它是一项后台任务，由<a href="https://milvus.io/docs/v2.0.x/four_layers.md#Data-coordinator-data-coord">数据协调器</a>触发，并由 Milvus 中的<a href="https://milvus.io/docs/v2.0.x/four_layers.md#Data-node">数据节点</a>执行。</p>
<p>本文将剖析 Milvus 中压缩的概念和实现。</p>
<h2 id="What-is-compaction" class="common-anchor-header">什么是压实？<button data-href="#What-is-compaction" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在深入探讨如何在 Milvus 2.0 中实现压实的细节之前，搞清楚什么是 Milvus 中的压实至关重要。</p>
<p>更多的时候，作为 Milvus 的用户，你可能已经被硬盘空间使用率越来越高所困扰。另一个问题是，少于 1 024 行的数据段不会被编入索引，只能支持暴力搜索来处理查询。自动刷新或用户强制刷新造成的小分段可能会影响查询效率。</p>
<p>因此，为了解决上述两个问题，帮助减少磁盘使用量和提高查询效率，Milvus 支持压缩。</p>
<p><a href="https://github.com/google/leveldb">LevelDB</a>和<a href="http://rocksdb.org/">RocksDB</a>等数据库会将数据追加到排序字符串表（SSTables）中。每次查询的平均磁盘读取次数会随着 SSTables 数量的增加而增加，从而导致查询效率低下。为了减少读取放大并释放硬盘空间，这些数据库会将 SSTables 压缩成一个。压缩过程在后台自动运行。</p>
<p>同样，Milvus 也会将插入和删除的数据追加到<a href="https://github.com/milvus-io/milvus/blob/master/docs/developer_guides/chap08_binlog.md">binlog</a> 中。随着 binlog 数量的增加，会占用更多的硬盘空间。为了释放硬盘空间，Milvus 会压缩已删除和已插入数据的 binlog。如果一个实体被插入，但后来又被删除，那么一旦压缩，它就不再存在于记录数据插入或删除的 binlog 中。此外，Milvus 还压缩<a href="https://milvus.io/docs/v2.0.x/glossary.md#Segment">段</a>--Milvus 为保存插入数据而自动创建的数据文件。</p>
<h2 id="How-to-configure-compaction" class="common-anchor-header">如何配置压缩？<button data-href="#How-to-configure-compaction" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 的压缩配置主要涉及两个参数：<code translate="no">dataCoord.enableCompaction</code> 和<code translate="no">common.retentionDuration</code> 。</p>
<p><code translate="no">dataCoord.enableCompaction</code> 指定是否启用压实。其默认值为 。<code translate="no">true</code></p>
<p><code translate="no">common.retentionDuration</code> 指定不运行压实的时间段。单位为秒。压缩数据时，所有删除的实体都将无法使用时间旅行进行搜索。因此，如果计划使用时间旅行进行搜索，就必须指定一段压缩不运行且不影响已删除数据的时间。为确保使用时间旅行搜索的结果准确，Milvus 会保留在 指定的时间段内操作的数据。也就是说，在这段时间内操作的数据不会被压缩。详情请参阅 "<code translate="no">common.retentionDuration</code><a href="https://milvus.io/docs/v2.0.x/timetravel.md">使用时间旅行搜索"</a>。</p>
<p>Milvus 默认启用压缩。如果您禁用了压实，但后来又想手动启用它，可以按照以下步骤操作：</p>
<ol>
<li>调用<code translate="no">collection.compact()</code> 方法手动触发全局压实进程。但请注意，此操作符可能需要很长时间。</li>
<li>调用该方法后，将返回一个压缩 ID。调用<code translate="no">collection.get_compaction_state()</code> 方法可查看压实状态。</li>
</ol>
<p>启用压缩后，它会在后台自动运行。由于压实过程可能需要很长时间，因此会异步处理压实请求以节省时间。</p>
<h2 id="How-to-implement-compaction" class="common-anchor-header">如何实现压缩？<button data-href="#How-to-implement-compaction" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 Milvus 中，您可以手动或自动实施压实。</p>
<p>手动压缩 binlog 或分段不需要满足任何触发条件。因此，如果手动调用压实，无论如何都会对 binlog 或数据段进行压实。</p>
<p>但是，如果要启用自动压缩，则需要满足某些压缩触发条件，系统才会压缩段或 binlog。</p>
<p>一般来说，Milvus 可以压缩两种类型的对象：binglog 和数据段。</p>
<h2 id="Binlog-compaction" class="common-anchor-header">二进制日志压缩<button data-href="#Binlog-compaction" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>binlog 是一个二进制日志，或者说是段中的一个较小的单元，它记录并处理对 Milvus 向量数据库中的数据所做的更新和更改。一个数据段的数据会被持久保存在多个 binlog 中。在 Milvus 中，二进制日志压缩涉及两种类型的二进制日志：插入二进制日志和三角二进制日志。</p>
<p>删除数据时会生成 Delta binlog，而插入 binlog 会在以下三种情况下生成。</p>
<ul>
<li>当插入的数据被附加时，数据段达到大小上限，并自动刷新到磁盘。</li>
<li>DataCoord 会自动刷新长时间未封存的数据段。</li>
<li>一些 API（如<code translate="no">collection.num_entities</code> 、<code translate="no">collection.load()</code> 等）会自动调用 flush 将段写入磁盘。</li>
</ul>
<p>因此，binlog 压缩，顾名思义，指的是压缩段内的 binlog。更具体地说，在 binlog 压缩过程中，所有未保留的 delta binlog 和插入 binlog 都会被压缩。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/binlog_compaction_d7f8f910c8.png" alt="Binlog compaction" class="doc-image" id="binlog-compaction" />
   </span> <span class="img-wrapper"> <span>二进制日志压缩</span> </span></p>
<p>当一个数据段被刷新到磁盘，或 Milvus 因长时间未运行压缩而请求全局压缩时，至少需要满足以下两个条件之一，才能触发自动压缩：</p>
<ol>
<li>delta binlog 中的行数超过总行数的 20%。</li>
<li>delta binlog 的大小超过 10 MB。</li>
</ol>
<h2 id="Segment-compaction" class="common-anchor-header">段压缩<button data-href="#Segment-compaction" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><a href="https://milvus.io/docs/v2.0.x/glossary.md#Segment">段</a>是 Milvus 自动创建的用于保存插入数据的数据文件。Milvus 有两种类型的数据段：生长数据段和密封数据段。</p>
<p>成长段不断接收新插入的数据，直到被密封。密封段不再接收任何新数据，并将被刷新到对象存储空间，留下的新数据将被插入到新创建的增长段中。</p>
<p>因此，段压缩指的是压缩多个密封段。更具体地说，在段压缩过程中，小段被压缩成大段。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/segment_compaction_92eecc0e55.jpeg" alt="Segment compaction" class="doc-image" id="segment-compaction" />
   </span> <span class="img-wrapper"> <span>分段压实</span> </span></p>
<p>压缩后生成的每个分段都不能超过分段大小的上限，默认为 512 MB。请阅读<a href="https://milvus.io/docs/v2.0.x/system_configuration.md">系统配置</a>，了解如何修改段大小的上限。</p>
<p>当数据段刷新到磁盘，或 Milvus 因长时间未运行压缩而请求全局压缩时，需要满足以下条件才能触发自动压缩：</p>
<ul>
<li>段小于 0.5 *<code translate="no">MaxSegmentSize</code> 多于 10。</li>
</ul>
<h2 id="Whats-next" class="common-anchor-header">下一步是什么？<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>了解了 Milvus 压缩的基础知识后，下一步该做什么？目前，在<code translate="no">milvus.yaml</code> 文件中还没有配置压缩的所有参数，计划生成策略也相对比较基本。有兴趣的话，就来为 Milvus<a href="https://github.com/milvus-io">这个开源项目</a>做贡献吧！</p>
<p>此外，在 2.0 新功能系列博客中，我们将介绍新功能的设计。阅读本系列博客的更多内容！</p>
<ul>
<li><a href="https://milvus.io/blog/2022-02-07-how-milvus-deletes-streaming-data-in-distributed-cluster.md">Milvus 如何在分布式集群中删除流数据</a></li>
<li><a href="https://milvus.io/blog/2022-2-21-compact.md">Milvus 如何压缩数据？</a></li>
<li><a href="https://milvus.io/blog/2022-02-28-how-milvus-balances-query-load-across-nodes.md">Milvus 如何平衡各节点的查询负载？</a></li>
<li><a href="https://milvus.io/blog/2022-2-14-bitset.md">Bitset 如何实现向量相似性搜索的多功能性？</a></li>
</ul>
<h2 id="About-the-author" class="common-anchor-header">关于作者<button data-href="#About-the-author" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>孙斌义，Milvus 项目高级软件工程师，上海交通大学软件工程硕士。他主要负责开发 Milvus 2.0 中与存储相关的组件。他的兴趣领域是数据库和分布式系统。他是开源项目的忠实粉丝，也是一位美食家，业余时间喜欢玩电子游戏和阅读。</p>


如何在 Milvus 中压缩数据？

<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Bitset_cd54487e7b.png" alt="Bitset Cover Image" class="doc-image" id="bitset-cover-image" />
   </span> <span class="img-wrapper"> <span>Bitset 封面图片</span> </span></p>
<p>作者：<a href="https://github.com/cydrain">蔡玉东</a>、<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">倪安琪</a>。</p>
<p>随着 Milvus 2.0 的<a href="https://milvus.io/blog/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">发布</a>，矢量数据库的各种<a href="https://milvus.io/blog/2022-1-27-milvus-2-0-a-glimpse-at-new-features.md">新的基本功能</a>也一并推出。在这些新功能中，<a href="https://milvus.io/docs/v2.0.x/timetravel_ref.md">时间旅行</a>、属性过滤和<a href="https://milvus.io/blog/2022-02-07-how-milvus-deletes-streaming-data-in-distributed-cluster.md">删除操作</a>是相关联的，因为这三个功能是通过一个共同的机制--比特集--来实现的。</p>
<p>因此，本文旨在阐明 Milvus 中比特集的概念，并通过三个例子解释它是如何支持删除操作、时间旅行和属性过滤的。</p>
<h2 id="What-is-bitset" class="common-anchor-header">什么是比特集？<button data-href="#What-is-bitset" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>比特集是由比特数（"0 "和 "1"）组成的数组，可用来表示某些数据信息。与用 Ints、floats 或 chars 存储数据相比，使用比特集可以紧凑、高效地存储某些类型的数据。比特集基于<a href="https://milvus.io/docs/v2.0.x/boolean.md">布尔逻辑</a>工作，根据<a href="https://milvus.io/docs/v2.0.x/boolean.md">布尔逻辑</a>，输出值要么有效要么无效，通常分别用 "1 "和 "0 "表示。1 "代表有效，"0 "代表无效。由于比特集具有很高的效率，可以节省存储空间，因此还可以用来实现属性过滤、删除操作、时间旅行等多种功能。</p>
<p>从 0.7.0 版开始，为了实现<a href="https://milvus.io/blog/deleting-data-in-milvus.md">删除功能</a>，Milvus 引入了 bitset 的概念。更具体地说，比特集用于标记段中的每一行是否被删除。已删除的实体在相应的比特集中标记为 "1"，因此在搜索或查询时将不会计算已删除的实体。</p>
<p>在 Milvus 2.0 版本中，比特集的应用得到了扩展，可以实现更多的功能，如属性过滤和时间旅行。比特集的一般原则保持不变。也就是说，如果一个实体在相应的比特集中被标记为 "1"，那么在搜索或查询时该实体将被忽略。在 Milvus 中，比特集用于实现 3 个功能：</p>
<ul>
<li>属性过滤</li>
<li>数据删除</li>
<li>时间旅行查询</li>
</ul>
<h2 id="How-does-bitset-work-in-Milvus" class="common-anchor-header">比特集在 Milvus 中是如何工作的？<button data-href="#How-does-bitset-work-in-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>下面的示例用于说明比特集在 Milvus 中的工作原理。</p>
<h3 id="Prerequisites" class="common-anchor-header">前提条件</h3><p>假设有一个包含八个实体的段，一系列数据操作语言（DML）事件按下图所示顺序发生。</p>
<ul>
<li>其中四个实体（其<code translate="no">primary_keys</code> 分别为 [1、2、3、4]）在时间戳<code translate="no">ts</code> 等于 100 时被插入。</li>
<li>其余四个实体（其<code translate="no">primary_keys</code> 分别为 [5、6、7、8]）在时间戳<code translate="no">ts</code> 等于 200 时插入。</li>
<li>当时间戳<code translate="no">ts</code> 等于 300 时，删除<code translate="no">primary_keys</code> 为 [7, 8] 的实体。</li>
<li>只有<code translate="no">primary_keys</code> 为 [1, 3, 5, 7] 的实体才满足属性筛选条件。</li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/UML_1_0a3605808c.jpg" alt="DML events" class="doc-image" id="dml-events" />
   </span> <span class="img-wrapper"> <span>DML 事件</span> </span></p>
<h3 id="Case-one" class="common-anchor-header">案例一</h3><p>假设用户为<code translate="no">time_travel</code> 设置的值是 150。换句话说，当<code translate="no">ts</code> = 150 时，用户对存储在 Milvus 中的数据进行查询。比特集生成过程如图 1 所示。</p>
<p>在初始过滤阶段，<code translate="no">filter_bitset</code> 的结果应该是[1, 0, 1, 0, 1, 0, 1, 0]，因为实体[1, 3, 5, 7]是有效的过滤结果，并在比特集中标记为 "1"。然而，当<code translate="no">ts</code> 等于 150 时，实体 [4, 5, 6, 7] 甚至没有被插入向量数据库。因此，无论过滤条件如何，这四个实体都应标记为 "0"。现在比特集的结果应该是 [1, 0, 1, 0, 0, 0, 0, 0]。由于在 Milvus 中，比特集计算的一般原则是在搜索或查询过程中忽略比特集中标记为 "1 "的实体，因此时间旅行和属性过滤后的比特集结果需要翻转，以便与删除比特图相结合。<code translate="no">filter_bitset</code> 的翻转结果应为 [0，1，0，1，1，1，1]。</p>
<p>至于删除位图<code translate="no">del_bitset</code> ，初始值应为 [0, 0, 0, 0, 0, 0, 1, 1]。但是，实体 7 和实体 8 在<code translate="no">ts</code> 为 300 时才会删除。因此，当<code translate="no">ts</code> 为 150 时，实体 7 和 8 仍然有效。因此，时间旅行后的<code translate="no">del_bitset</code> 值应该是 [0，0，0，0，0，0，0，0]。</p>
<p>现在，经过时间旅行和属性过滤后，我们有了两个比特集： <code translate="no">filter_bitset</code> [0，1，0，1，1，1，1] 和<code translate="no">del_bitset</code> [0，0，0，0，0，0，0]。  用二进制逻辑操作符 "OR "组合这两个比特集。<code translate="no">result_bitset</code> 的最终值是 [0，1，0，1，1，1，1]。也就是说，在接下来的搜索或查询阶段，将只计算实体 1 和实体 3。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/bitset_figure1_1b5852f7a7.jpeg" alt="Figure 1" class="doc-image" id="figure-1" />
   </span> <span class="img-wrapper"> <span>图 1</span> </span></p>
<h3 id="Case-two" class="common-anchor-header">案例二</h3><p>假设用户为<code translate="no">time_travel</code> 设置的值是 250。换句话说，当<code translate="no">ts</code> = 250 时，用户对存储在 Milvus 中的数据进行查询。比特集生成过程如图 2 所示。</p>
<p>与第一种情况一样，初始属性过滤阶段的结果<code translate="no">filter_bitset</code> 应该是[1, 0, 1, 0, 1, 0, 1, 0]。</p>
<p>当<code translate="no">ts</code>= 250 时，所有实体 [1, 2, 3, 4, 5, 6, 7, 8] 都被插入到向量数据库中。因此，之前<code translate="no">filter_bitset</code> 的结果保持不变。同样，我们需要翻转<code translate="no">filter_bitset</code> 的结果，就会得到 [0, 1, 0, 1, 0, 1, 0, 1]。</p>
<p>至于删除比特集<code translate="no">del_bitset</code> ，初始值应该是 [0, 0, 0, 0, 0, 0, 1, 1]。但是，实体 7 和实体 8 在<code translate="no">ts</code> 为 300 时才被删除。因此，当<code translate="no">ts</code> 为 250 时，实体 7 和 8 仍然有效。因此，时间旅行后的<code translate="no">del_bitset</code> 值应该是 [0，0，0，0，0，0，0，0]。</p>
<p>现在，经过时间旅行和属性过滤后，我们有了两个比特集： <code translate="no">filter_bitset</code> [0，1，0，1，0，1，0，1] 和<code translate="no">del_bitset</code> [0，0，0，0，0，0，0]。  用二进制逻辑操作符 "OR "组合这两个比特集。<code translate="no">result_bitset</code> 的最终值是 [0，1，0，1，0，1，0，1]。也就是说，在接下来的搜索或查询阶段，将只计算实体 [1, 3, 5, 7]。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/bitset_figure2_7cbaa7c719.jpeg" alt="Figure 2" class="doc-image" id="figure-2" />
   </span> <span class="img-wrapper"> <span>图 2</span> </span></p>
<h3 id="Case-three" class="common-anchor-header">案例三</h3><p>假设用户为<code translate="no">time_travel</code> 设置的值是 350。换句话说，当<code translate="no">ts</code> = 350 时，用户对存储在 Milvus 中的数据进行查询。比特集生成过程如图 3 所示。</p>
<p>与情况一和情况二相同，初始属性过滤阶段的结果<code translate="no">filter_bitset</code> 是 [0, 1, 0, 1, 0, 1, 0, 1]。</p>
<p>当<code translate="no">ts</code>= 350 时，所有实体 [1, 2, 3, 4, 5, 6, 7, 8] 都被插入到向量数据库中。因此，<code translate="no">filter_bitset</code> 的最终翻转结果是 [0，1，0，1，0，1，0，1]，与情况二相同。</p>
<p>至于删除比特集<code translate="no">del_bitset</code> ，由于<code translate="no">ts</code>= 350 时实体 7 和 8 已被删除，因此<code translate="no">del_bitset</code> 的结果应该是 [0, 0, 0, 0, 0, 0, 1, 1]。</p>
<p>现在，经过时间旅行和属性过滤后，我们有了两个比特集： <code translate="no">filter_bitset</code> [0, 1, 0, 1, 0, 1, 0, 1] 和<code translate="no">del_bitset</code> [0, 0, 0, 0, 0, 0, 1, 1]。  用二进制逻辑操作符 "OR "组合这两个比特集。<code translate="no">result_bitset</code> 的最终值是 [0，1，0，1，0，1，1]。也就是说，在接下来的搜索或查询阶段，将只计算实体 [1, 3, 5]。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/bitset_figure3_dd46a6aecf.jpeg" alt="Figure 3" class="doc-image" id="figure-3" />
   </span> <span class="img-wrapper"> <span>图 3</span> </span></p>
<h2 id="Whats-next" class="common-anchor-header">下一步是什么？<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 2.0 新功能系列博客中，我们将介绍新功能的设计。阅读本系列博客的更多内容！</p>
<ul>
<li><a href="https://milvus.io/blog/2022-02-07-how-milvus-deletes-streaming-data-in-distributed-cluster.md">Milvus 如何在分布式集群中删除流数据</a></li>
<li><a href="https://milvus.io/blog/2022-2-21-compact.md">Milvus 如何压缩数据？</a></li>
<li><a href="https://milvus.io/blog/2022-02-28-how-milvus-balances-query-load-across-nodes.md">Milvus 如何平衡各节点的查询负载？</a></li>
<li><a href="https://milvus.io/blog/2022-2-14-bitset.md">Bitset 如何实现向量相似性搜索的多功能性？</a></li>
</ul>


Bitset 如何实现向量相似性搜索的多功能性

<custom-h1>Milvus 如何在分布式集群中删除流数据</custom-h1><p>Milvus 2.0 具有统一的批处理和流处理功能以及云原生架构，在开发 DELETE 功能的过程中面临着比其前身更大的挑战。得益于其先进的存储-计算分解设计和灵活的发布/订阅机制，我们可以自豪地宣布，我们实现了这一目标。在 Milvus 2.0 中，你可以用主键删除给定 Collections 中的一个实体，这样被删除的实体就不会再出现在搜索或查询的结果中。</p>
<p>请注意，Milvus 中的 DELETE 操作指的是逻辑删除，而物理数据清理则发生在数据压缩过程中。逻辑删除不仅能大大提高受 I/O 速度限制的搜索性能，还有利于数据恢复。在时间旅行功能的帮助下，逻辑删除的数据仍然可以恢复。</p>
<h2 id="Usage" class="common-anchor-header">使用方法<button data-href="#Usage" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>让我们先试试 Milvus 2.0 中的 DELETE 函数。(以下示例在 Milvus 2.0.0 上使用 PyMilvus 2.0.0）。</p>
<pre><code translate="no" class="language-python"><span class="hljs-keyword">from</span> pymilvus <span class="hljs-keyword">import</span> connections, utility, Collection, DataType, FieldSchema, CollectionSchema
<span class="hljs-comment"># Connect to Milvus</span>
connections.connect(
    alias=<span class="hljs-string">&quot;default&quot;</span>, 
    host=<span class="hljs-string">&#x27;x.x.x.x&#x27;</span>, 
    port=<span class="hljs-string">&#x27;19530&#x27;</span>
)
<span class="hljs-comment"># Create a collection with Strong Consistency level</span>
pk_field = FieldSchema(
    name=<span class="hljs-string">&quot;id&quot;</span>, 
    dtype=DataType.INT64, 
    is_primary=<span class="hljs-literal">True</span>, 
)
vector_field = FieldSchema(
    name=<span class="hljs-string">&quot;vector&quot;</span>, 
    dtype=DataType.FLOAT_VECTOR, 
    dim=<span class="hljs-number">2</span>
)
schema = CollectionSchema(
    fields=[pk_field, vector_field], 
    description=<span class="hljs-string">&quot;Test delete&quot;</span>
)
collection_name = <span class="hljs-string">&quot;test_delete&quot;</span>
collection = Collection(
    name=collection_name, 
    schema=schema, 
    using=<span class="hljs-string">&#x27;default&#x27;</span>, 
    shards_num=<span class="hljs-number">2</span>,
    consistency_level=<span class="hljs-string">&quot;Strong&quot;</span>
)
<span class="hljs-comment"># Insert randomly generated vectors</span>
<span class="hljs-keyword">import</span> random
data = [
    [i <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">100</span>)],
    [[random.random() <span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">2</span>)] <span class="hljs-keyword">for</span> _ <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">100</span>)],
]
collection.insert(data)
<span class="hljs-comment"># Query to make sure the entities to delete exist</span>
collection.load()
expr = <span class="hljs-string">&quot;id in [2,4,6,8,10]&quot;</span>
pre_del_res = collection.query(
    expr,
    output_fields = [<span class="hljs-string">&quot;id&quot;</span>, <span class="hljs-string">&quot;vector&quot;</span>]
)
<span class="hljs-built_in">print</span>(pre_del_res)
<span class="hljs-comment"># Delete the entities with the previous expression</span>
collection.delete(expr)
<span class="hljs-comment"># Query again to check if the deleted entities exist</span>
post_del_res = collection.query(
    expr,
    output_fields = [<span class="hljs-string">&quot;id&quot;</span>, <span class="hljs-string">&quot;vector&quot;</span>]
)
<span class="hljs-built_in">print</span>(post_del_res)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Implementation" class="common-anchor-header">执行<button data-href="#Implementation" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 Milvus 实例中，数据节点主要负责将流数据（日志代理中的日志）打包为历史数据（日志快照）并自动刷新到对象存储中。查询节点在完整数据（即流数据和历史数据）上执行搜索请求。</p>
<p>为了充分利用集群中并行节点的数据写入能力，Milvus 采用了基于主键散列的分片策略，将写入操作平均分配给不同的工作节点。也就是说，代理会将实体的数据处理语言（DML）消息（即请求）路由到相同的数据节点和查询节点。这些信息通过 DML 通道发布，并由数据节点和查询节点分别消费，从而共同提供搜索和查询服务。</p>
<h3 id="Data-node" class="common-anchor-header">数据节点</h3><p>收到数据 INSERT 消息后，数据节点会将数据插入一个不断增长的段，这是为接收内存中的流数据而创建的新段。如果数据行数或增长段的持续时间达到阈值，数据节点就会将其封存，以防止任何数据进入。然后，数据节点会将包含历史数据的密封段刷新到对象存储中。与此同时，数据节点会根据新数据的主键生成一个 Bloom 过滤器，并将其与密封段一起冲入对象存储区，同时将 Bloom 过滤器作为包含段统计信息的统计二进制日志（binlog）的一部分保存起来。</p>
<blockquote>
<p>bloom 过滤器是一种概率数据结构，由一个长的二进制向量和一系列随机映射函数组成。它可用于测试某个元素是否是某个集合的成员，但可能会返回假阳性匹配。           --维基百科</p>
</blockquote>
<p>当收到数据 DELETE 消息时，数据节点会缓冲相应分片中的所有 Bloom 过滤器，并将它们与消息中提供的主键进行匹配，以检索可能包含要删除的实体的所有分段（从增长的分段和封存的分段中）。在精确定位了相应的分段后，数据节点会将其缓冲到内存中，以生成记录删除操作的 Delta binlog，然后将这些 binlog 和分段一起刷新到对象存储中。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/data_node_2397ad70c3.png" alt="Data Node" class="doc-image" id="data-node" />
   </span> <span class="img-wrapper"> <span>数据节点</span> </span></p>
<p>由于一个分区只分配一个 DML 通道，因此群集中添加的其他查询节点将无法订阅该 DML 通道。为确保所有查询节点都能收到 DELETE 消息，数据节点会过滤 DML-Channel 中的 DELETE 消息，并将其转发到 Delta-Channel 以通知所有查询节点删除操作符。</p>
<h3 id="Query-node" class="common-anchor-header">查询节点</h3><p>从对象存储加载 Collections 时，查询节点首先会获取每个分片的检查点，该检查点标记了自上次刷新操作以来的 DML 操作。在检查点的基础上，查询节点会加载所有密封分段及其 Delta binlog 和 Bloom 过滤器。加载所有数据后，查询节点会订阅 DML 通道、Delta 通道和查询通道。</p>
<p>如果在 Collections 加载到内存后收到更多的数据 INSERT 消息，查询节点会首先根据消息精确定位增长的数据段，并更新内存中相应的 Bloom 过滤器，仅供查询使用。查询结束后，这些查询专用的 bloom 过滤器不会被刷新到对象存储中。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/query_node_a78b1d664f.png" alt="Query Node" class="doc-image" id="query-node" />
   </span> <span class="img-wrapper"> <span>查询节点</span> </span></p>
<p>如上所述，只有一定数量的查询节点可以从 DML 通道接收 DELETE 信息，这意味着只有它们可以执行不断增长的 DELETE 请求。对于那些订阅了 DML-Channel 的查询节点来说，它们首先会过滤成长段中的 DELETE 消息，通过将提供的主键与成长段中的查询专用 bloom 过滤器进行匹配来定位实体，然后在相应的段中记录删除操作。</p>
<p>不能订阅 DML 通道的查询节点只能处理密封网段上的搜索或查询请求，因为它们只能订阅 Delta 通道，并接收数据节点转发的 DELETE 消息。查询节点从 Delta-Channel 收集到密封网段中的所有 DELETE 消息后，通过将提供的主键与密封网段的 Bloom 过滤器进行匹配来定位实体，然后在相应的网段中记录删除操作。</p>
<p>最终，在搜索或查询时，查询节点会根据删除记录生成一个比特集，以省略已删除的实体，并在所有段中搜索剩余的实体，而不管段的状态如何。最后但并非最不重要的一点是，一致性级别会影响已删除数据的可见性。在强一致性级别下（如前面的代码示例所示），删除实体后立即不可见。如果采用有界一致性级别，则会有几秒钟的延迟，删除的实体才会不可见。</p>
<h2 id="Whats-next" class="common-anchor-header">下一步是什么？<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在 2.0 新功能系列博客中，我们将介绍新功能的设计。阅读本系列博客的更多内容！</p>
<ul>
<li><a href="https://milvus.io/blog/2022-02-07-how-milvus-deletes-streaming-data-in-distributed-cluster.md">Milvus 如何在分布式集群中删除流数据</a></li>
<li><a href="https://milvus.io/blog/2022-2-21-compact.md">Milvus 如何压缩数据？</a></li>
<li><a href="https://milvus.io/blog/2022-02-28-how-milvus-balances-query-load-across-nodes.md">Milvus 如何平衡各节点的查询负载？</a></li>
<li><a href="https://milvus.io/blog/2022-2-14-bitset.md">Bitset 如何实现向量相似性搜索的多功能性？</a></li>
</ul>


使用方法

Milvus 2.0 - 新功能一瞥

<p>亲爱的 Milvus 社区成员和朋友们：</p>
<p>在第一个候选发布版（RC）发布六个月后的今天，我们非常高兴地宣布 Milvus 2.0 正式发布<a href="https://milvus.io/docs/v2.0.x/release_notes.md#v200">（GA）</a>并投入生产！这是一段漫长的旅程，我们感谢社区贡献者、用户和 LF AI &amp; Data 基金会等所有帮助我们实现这一目标的人。</p>
<p>如今，处理数十亿高维数据的能力对于人工智能系统来说是一件大事，这是有充分理由的：</p>
<ol>
<li>与传统的结构化数据相比，非结构化数据占据了主导地位。</li>
<li>数据的新鲜度从未像现在这样重要。数据科学家渴望及时的数据解决方案，而不是传统的 T+1 折中方案。</li>
<li>成本和性能变得更加重要，但目前的解决方案与实际应用案例之间仍存在很大差距。 因此，Milvus 2.0 应运而生。Milvus 是一种有助于大规模处理高维数据的数据库。它专为云计算设计，能够在任何地方运行。如果您一直在关注我们发布的 RC 版本，就会知道我们花了很大力气使 Milvus 更稳定、更易于部署和维护。</li>
</ol>
<h2 id="Milvus-20-GA-now-offers" class="common-anchor-header">Milvus 2.0 GA 现在提供以下功能<button data-href="#Milvus-20-GA-now-offers" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><strong>实体删除</strong></p>
<p>作为一个数据库，Milvus 现在支持<a href="https://milvus.io/docs/v2.0.x/delete_data.md">按主键删除实体</a>，以后还将支持按表达式删除实体。</p>
<p><strong>自动负载平衡</strong></p>
<p>Milvus 现在支持插件负载平衡策略，以平衡每个查询节点和数据节点的负载。由于对计算和存储进行了分解，平衡只需几分钟即可完成。</p>
<p><strong>移交</strong></p>
<p>一旦通过刷新封存了不断增长的数据段，移交任务就会用索引历史数据段替换不断增长的数据段，从而提高搜索性能。</p>
<p><strong>数据压缩</strong></p>
<p>数据压缩是一项后台任务，用于将小分段合并为大分段，并清理逻辑删除数据。</p>
<p><strong>支持 Embeddings 和本地数据存储</strong></p>
<p>在 Milvus Standalone 模式下，我们只需进行少量配置，就能移除 etcd/MinIO 依赖。本地数据存储还可用作本地缓存，以避免将所有数据载入主内存。</p>
<p><strong>多语言 SDK</strong></p>
<p>除<a href="https://github.com/milvus-io/pymilvus">PyMilvus</a> 外，<a href="https://github.com/milvus-io/milvus-sdk-node">Node.js</a>、<a href="https://github.com/milvus-io/milvus-sdk-java">Java</a>和<a href="https://github.com/milvus-io/milvus-sdk-go">Go</a>SDK 现在也可随时使用。</p>
<p><strong>Milvus K8s 操作符</strong></p>
<p><a href="https://milvus.io/docs/v2.0.x/install_cluster-milvusoperator.md">Milvus Operator</a>提供了一个简便的解决方案，用于以可扩展和高可用的方式向目标<a href="https://kubernetes.io/">Kubernetes</a>集群部署和管理完整的 Milvus 服务栈，包括 Milvus 组件及其相关依赖项（如 etcd、Pulsar 和 MinIO）。</p>
<p><strong>帮助管理 Milvus 的工具</strong></p>
<p>我们要感谢<a href="https://zilliz.com/">Zilliz</a>提供的管理工具。我们现在有了<a href="https://milvus.io/docs/v2.0.x/attu.md">Attu</a> 和 Milvus<a href="https://milvus.io/docs/v2.0.x/cli_overview.md">_CLI</a>，前者允许我们通过直观的图形用户界面与 Milvus 交互，后者则是管理 Milvus 的命令行工具。</p>
<p>感谢所有 212 位贡献者，社区在过去 6 个月中完成了 6718 次提交，并关闭了大量稳定性和性能问题。在 2.0 GA 发布后，我们将很快发布稳定性和性能基准报告。</p>
<h2 id="Whats-next" class="common-anchor-header">下一步是什么？<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><strong>功能</strong></p>
<p>字符串类型支持将是 Milvus 2.1 的下一个杀手级功能。我们还将引入生存时间（TTL）机制和基本的 ACL 管理，以更好地满足用户需求。</p>
<p><strong>可用性</strong></p>
<p>我们正在重构查询协调调度机制，以支持每个段的多内存副本。有了多个活动副本，Milvus 可以支持更快的故障切换和投机执行，从而将停机时间缩短到几秒之内。</p>
<p><strong>性能</strong></p>
<p>性能基准测试结果将很快在我们的网站上公布。预计在接下来的版本中，性能将有显著提高。我们的目标是将较小数据集下的搜索延迟减半，并将系统吞吐量提高一倍。</p>
<p><strong>易于使用</strong></p>
<p>Milvus 设计用于在任何地方运行。在接下来的几个小版本中，我们将在 MacOS（M1 和 X86）和 ARM 服务器上支持 Milvus。我们还将提供嵌入式 PyMilvus，因此您只需<code translate="no">pip install</code> Milvus，而无需复杂的环境设置。</p>
<p><strong>社区管理</strong></p>
<p>我们将完善会员规则，明确贡献者角色的要求和责任。导师计划也正在开发中；对云原生数据库、向量搜索和/或社区治理感兴趣的人，请随时联系我们。</p>
<p>我们对 Milvus GA 的最新发布感到非常兴奋！我们将一如既往地乐于听取您的反馈意见。如果您遇到任何问题，请随时通过<a href="https://github.com/milvus-io/milvus">GitHub</a>或<a href="http://milvusio.slack.com/">Slack</a> 联系我们。</p>
<p><br/></p>
<p>致以最诚挚的问候、</p>
<p>栾晓帆</p>
<p>Milvus 项目维护者</p>
<p><br/></p>
<blockquote>
<p><em>编辑：<a href="https://github.com/claireyuw">Claire Yu</a></em></p>
</blockquote>


宣布 Milvus 2.0 全面上市

<p>本文由<a href="https://www.linkedin.com/in/yiyun-n-2aa713163/">Angela Ni</a> 翻译。</p>
<p>信息在我们的生活中无处不在。Meta（前身为 Facebook）、Instagram、Twitter 和其他社交媒体平台让信息流变得更加无处不在。因此，处理此类信息流的引擎已成为大多数系统架构的必备功能。然而，作为社交媒体平台和相关应用程序的用户，我想您一定被重复的文章、新闻、备忘录等内容困扰过。重复内容会阻碍信息检索过程，并导致糟糕的用户体验。</p>
<p>对于一个处理信息流的产品来说，如何找到一个灵活的数据处理器，将其无缝集成到系统架构中，从而对相同的新闻或广告进行重复处理，是开发人员的当务之急。</p>
<p>估值<a href="https://techcrunch.com/2021/09/15/news-aggregator-smartnews-raises-230-million-valuing-its-business-at-2-billion/">20 亿美元</a>的<a href="https://www.smartnews.com/en/">SmartNews</a> 是美国估值最高的新闻应用程序公司。值得注意的是，它曾经是开源向量数据库 Milvus 的用户，后来转变为 Milvus 项目的积极贡献者。</p>
<p>本文分享了 SmartNews 的故事，并讲述了它决定为 Milvus 项目做出贡献的原因。</p>
<h2 id="An-overview-of-SmartNews" class="common-anchor-header">SmartNews 概述<button data-href="#An-overview-of-SmartNews" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>SmartNews 成立于 2012 年，总部位于日本东京。SmartNews 开发的新闻应用程序在日本市场一直<a href="https://www.businessinsider.com/guides/smartnews-free-news-app-2018-9">名列前茅</a>。SmartNews 是<a href="https://about.smartnews.com/en/2019/06/12/smartnews-builds-global-momentum-with-over-500-us-growth-new-executives-and-three-new-offices/">增长最快的</a>新闻应用程序，在美国市场也拥有<a href="https://about.smartnews.com/en/2018/07/21/smartnews-reaches-more-than-10-million-monthly-active-users-in-the-united-states-and-japan/">很高的用户粘度</a>。根据<a href="https://www.appannie.com/en/">APP Annie</a> 的统计数据，截至 2021 年 7 月底，SmartNews 的月平均会话时长在所有新闻应用程序中排名第一，超过 AppleNews 和 Google News 的累计会话时长。</p>
<p>随着用户基数和黏性的快速增长，SmartNews 在推荐机制和人工智能算法方面面临更多挑战。这些挑战包括在大规模机器学习（ML）中利用海量离散特征、利用向量相似性搜索加速非结构化数据查询等。</p>
<p>2021 年初，SmartNews 的动态广告算法团队向人工智能基础架构团队提出了需要优化广告召回和查询功能的请求。经过两个月的研究，AI 基础架构工程师舒决定使用支持多索引和相似度指标、在线数据更新的开源向量数据库 Milvus。Milvus 受到全球千余家机构的信赖。</p>
<h2 id="Advertisement-recommendation-powered-by-vector-similarity-search" class="common-anchor-header">由向量相似性搜索驱动的广告推荐<button data-href="#Advertisement-recommendation-powered-by-vector-similarity-search" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>SmartNews 广告系统采用了开源向量数据库 Milvus，可从 10 million 规模的数据集中匹配并向用户推荐动态广告。通过这种方式，SmartNews 可以在用户数据和广告数据这两个以前无法匹配的数据集之间建立映射关系。2021 年第二季度，Shu 成功在 Kubernetes 上部署了 Milvus 1.0。了解有关如何<a href="https://milvus.io/docs">部署 Milvus</a> 的更多信息。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/image1_2a88ed162f.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>图像</span> </span></p>
<p>Milvus 1.0 成功部署后，第一个使用 Milvus 的项目是 SmartNews 广告团队发起的广告召回项目。在初始阶段，广告数据集的规模为百万级。同时，P99 延迟被严格控制在 10 毫秒以内。</p>
<p>2021 年 6 月，舒畅和算法团队的同事们将 Milvus 应用到更多业务场景中，尝试数据聚合和在线数据/索引实时更新。</p>
<p>至此，Milvus 这个开源向量数据库已经在 SmartNews 的广告推荐等多个业务场景中得到应用。</p>
<h2 id="From-a-user-to-an-active-contributor" class="common-anchor-header"><strong>从用户到积极贡献者</strong><button data-href="#From-a-user-to-an-active-contributor" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在将 Milvus 集成到 Smartnews 产品架构中时，Shu 和其他开发人员提出了热重载、条目 TTL（time-to-live）、条目更新/替换等功能要求。这些也是 Milvus 社区许多用户所希望的功能。因此，SmartNews 人工智能基础架构团队负责人 Dennis Zhao 决定开发并向社区贡献热重载功能。Dennis 认为："SmartNews 团队一直受益于 Milvus 社区，因此，如果我们有东西可以与社区分享，我们更愿意贡献出来。"</p>
<p>数据重载支持在运行代码的同时进行代码编辑。在数据重载的帮助下，开发人员不再需要在断点处停止或重启应用程序。相反，他们可以直接编辑代码并实时查看结果。</p>
<p>7 月下旬，SmartNews 的工程师 Yusup 提出了利用<a href="https://milvus.io/docs/v2.0.x/collection_alias.md#Collection-Alias">Collections 别名</a>实现热重载的想法。</p>
<p>创建 Collections 别名指的是为集合指定别名。一个 Collection 可以有多个别名。不过，一个别名最多对应一个 Collection。简单地类比一下 Collection 和储物柜。储物柜和 Collections 一样，都有自己的编号和位置，而且始终保持不变。不过，你可以随时从储物柜中放入或取出不同的东西。同样，Collection 的名称是固定的，但集合中的数据却是动态的。您可以随时插入或删除 Collections 中的向量，因为在 Milvus<a href="https://milvus.io/docs/v2.0.x/release_notes.md#v200-PreGA">的预 GA 版本</a>中支持数据删除。</p>
<p>就 SmartNews 广告业务而言，随着新动态广告向量的生成，近 1 亿个向量会被插入或更新。对此有几种解决方案：</p>
<ul>
<li>解决方案 1：先删除旧数据，再插入新数据。</li>
<li>解决方案 2：为新数据创建新的 Collections。</li>
<li>解决方案 3：使用 Collections 别名。</li>
</ul>
<p>对于解决方案 1，最直接的缺点之一就是非常耗时，尤其是当要更新的数据集非常庞大时。更新一个亿级别的数据集一般需要几个小时。</p>
<p>至于解决方案 2，问题在于新的 Collections 无法立即用于搜索。也就是说，Collection 在加载过程中是无法搜索的。另外，Milvus 不允许两个 Collection 使用相同的 Collection 名称。切换到新的 Collections 总是需要用户手动修改客户端代码。也就是说，用户每次需要在 Collections 之间切换时，都必须修改参数<code translate="no">collection_name</code> 的值。</p>
<p>解决方案 3 将是灵丹妙药。您只需在新的 Collections 中插入新数据，并使用 Collections 别名即可。这样，每次需要切换集合进行搜索时，只需交换集合别名即可。您无需额外修改代码。该解决方案为您省去了前两个解决方案中提到的麻烦。</p>
<p>Yusup 从这个要求出发，帮助整个 SmartNews 团队了解 Milvus 架构。一个半月后，Milvus 项目收到了 Yusup 关于热重载的 PR。而后，伴随着 Milvus 2.0.0-RC7 的发布，这一功能正式上线。</p>
<p>目前，人工智能基础架构团队正在牵头部署 Milvus 2.0，并将所有数据从 Milvus 1.0 逐步迁移到 2.0。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/image2_96c064a627.png" alt="img_collection alias" class="doc-image" id="img_collection-alias" />
   </span> <span class="img-wrapper"> <span>图像集合别名</span> </span></p>
<p>支持 Collections 别名可以大大提升用户体验，尤其是对于那些用户请求量极大的大型互联网公司。来自 Milvus 社区的数据工程师李成龙帮助搭建了 Milvus 与 Smartnews 之间的桥梁，他说："Collection alias 功能源于 Milvus 用户 SmartNews 的真实业务需求。而 SmartNews 向 Milvus 社区贡献了代码。这种互惠行为是开源精神的典范：来自社区，为了社区。我们希望看到更多像 SmartNews 这样的贡献者，共同建设一个更加繁荣的 Milvus 社区。"</p>
<p>"目前，部分广告业务采用 Milvus 作为离线向量数据库。Milvus 2.0 正式发布在即，我们希望可以利用 Milvus 构建更可靠的系统，为更多业务场景提供实时服务。" Dennis 说。</p>
<blockquote>
<p>更新：Milvus 2.0 现已全面上市！<a href="/blog/zh/2022-1-25-annoucing-general-availability-of-milvus-2-0.md">了解更多</a></p>
</blockquote>


SmartNews 的故事--从 Milvus 用户到积极贡献者

<p>对于 Milvus 这个开源项目来说，2021 年是令人惊叹的一年。我想借此机会感谢 Milvus 的所有贡献者和用户，以及合作伙伴，感谢他们为如此出色的一年做出的贡献。</p>
<p><strong>今年给我留下最深刻印象的时刻之一是 Milvus 2.0 的发布。在我们开始这个项目之前，只有少数社区成员相信我们能提供世界上最先进的向量数据库，但现在我可以自豪地说，Milvus 2.0 GA 已经可以投入生产了。</strong></p>
<p>我们已经在为 2022 年迎接一系列令人兴奋的新挑战而努力，但我认为庆祝一下我们去年迈出的几大步会很有趣。以下是其中几项：</p>
<h2 id="Community-Growth" class="common-anchor-header">社区发展<button data-href="#Community-Growth" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>首先，这里有一份来自 GitHub 和 Slack 的社区统计摘要。截至 2021 年 12 月底：</p>
<ul>
<li><p><strong>贡献者</strong>从 2020 年 12 月的 121<strong>人</strong>增加到 2021 年 12 月的 209<strong>人</strong>（增长 172）</p></li>
<li><p><strong>星级</strong>从 2020 年 12 月的 4828 个增加到 2021 年 12 月的 9090 个（增长 188）</p></li>
<li><p><strong>叉子</strong>从 2020 年 12 月的 756 个增加到 2021 年 12 月的 1383 个（增长 182）</p></li>
<li><p><strong>Slack 成员</strong>从 2020 年 12 月的 541 人增加到 2021 年 12 月的 1233 人（增长 227）</p></li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_1_e94deb087f.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>img</span> </span></p>
<h2 id="Community-Governance-and-Advocacy" class="common-anchor-header">社区管理与宣传<button data-href="#Community-Governance-and-Advocacy" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>2019 年 10 月 Milvus 首次开源时，我们的团队和社区规模都比较小，因此项目自然主要由几个核心团队成员进行治理。但从那时起，社区有了显著的发展，我们意识到需要一个更好的系统来管理项目，这样才能更有效地欢迎新的贡献者。</p>
<p>因此，我们在 2021 年任命了 5 位新的维护者，负责跟踪正在进行的工作和报告的问题，确保它们得到及时审查和合并。这五位维护者的 GitHub ID 分别是：@栾小凡；@丛其霞；@scsven；@czs007；@闫亮567。如果您的 PR 需要帮助，请随时联系这些维护者。</p>
<p>我们还启动了<a href="https://milvus.io/community/milvus_advocate.md">Milvus 倡导者计划</a>，欢迎更多的人加入我们，分享你的经验，为社区成员提供帮助，并获得认可作为回报。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_2_835f379fb0.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>图片</span> </span></p>
<p>(图片：Milvus GitHub 贡献者，使用 dynamicwebpaige 的<a href="https://github.com/dynamicwebpaige/nanowrimo-2021/blob/main/15_VS_Code_contributors.ipynb">项目</a>制作 )</p>
<h2 id="Milvus-Project-Announcements-and-Milestones" class="common-anchor-header">Milvus 项目公告和里程碑<button data-href="#Milvus-Project-Announcements-and-Milestones" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ol>
<li><strong>版本发布数：14</strong></li>
</ol>
<ul>
<li><a href="https://milvus.io/blog/Whats-Inside-Milvus-1.0.md">Milvus 1.0 版本发布</a></li>
<li><a href="https://milvus.io/blog/milvus2.0-redefining-vector-database.md">Milvus 2.0 RC 版发布</a></li>
<li><a href="https://milvus.io/docs/v2.0.x/release_notes.md#v200-PreGA">Milvus 2.0 发布 PreGA 版</a></li>
</ul>
<ol>
<li><strong>Milvus 2.0.0 GA 支持的 SDK</strong></li>
</ol>
<ul>
<li><p>PyMilvus (可用)</p></li>
<li><p>Go SDK（可用）</p></li>
<li><p>Java SDK（可用）</p></li>
<li><p>Node.js SDK（可用）</p></li>
<li><p>C++ SDK（开发中）</p></li>
</ul>
<ol start="3">
<li><strong>推出新的 Milvus 工具：</strong></li>
</ol>
<ul>
<li><a href="https://github.com/zilliztech/milvus_cli#community">Milvus_CLI</a>（Milvus 命令行）</li>
<li><a href="https://github.com/zilliztech/attu">Attu</a>（Milvus 管理图形用户界面）</li>
<li><a href="https://github.com/milvus-io/milvus-operator">Milvus K8s 操作符</a></li>
</ul>
<ol start="4">
<li><p><strong><a href="https://lfaidata.foundation/blog/2021/06/23/lf-ai-data-foundation-announces-graduation-of-milvus-project/">Milvus 成为 LF 人工智能与数据基金会的毕业项目。</a></strong></p></li>
<li><p><strong><a href="https://www.cs.purdue.edu/homes/csjgwang/pubs/SIGMOD21_Milvus.pdf">Milvus: A Purpose-Built Vector Data Management System（Milvus：一种专用矢量数据管理系统</a>)<a href="https://www.cs.purdue.edu/homes/csjgwang/pubs/SIGMOD21_Milvus.pdf">在 SIGMOD'2021 上发表。</a></strong></p></li>
<li><p><strong><a href="https://discuss.milvus.io/">Milvus 社区论坛启动。</a></strong></p></li>
</ol>
<h2 id="Community-Events" class="common-anchor-header">社区活动<button data-href="#Community-Events" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>今年，我们主办和参加了许多活动，使我们的全球社区成员能够在当前 Covid-19 的情况下会面（主要是虚拟会面）。我们总共参加和主办了 21 次会议：</p>
<ul>
<li>6 次技术会议</li>
<li>7 次 Milvus 办公时间</li>
<li>34 次网络研讨会</li>
<li>3 次线下聚会</li>
</ul>
<p>我们计划在 2022 年举办更多活动。如果您想参加附近的活动，请查看社区论坛中的 "<a href="https://discuss.milvus.io/c/events-and-meetups/13">活动和聚会</a>"类别，了解即将举办的活动及其地点。如果您想成为我们未来活动的发言人或主持人，请通过<a href="mailto:community@milvus.io">community@milvus.io</a> 联系我们。</p>
<h2 id="Looking-Ahead-to-2022--Roadmap--Announcement" class="common-anchor-header">展望 2022 年--路线图和公告<button data-href="#Looking-Ahead-to-2022--Roadmap--Announcement" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><strong>社区：</strong></p>
<ol>
<li>完善 Milvus 项目成员资格，吸引/选举更多维护者和提交者，共同建设社区。</li>
<li>启动导师计划，为希望加入社区并做出贡献的新人提供更多帮助。</li>
<li>改善社区文档管理，包括<strong>技术文档、用户指南和社区文档</strong>。2022 年，希望我们的社区成员能一起完成《Milvus 手册》，让大家更好地学习如何使用 Milvus。</li>
<li>加强与其他开源社区的合作与互动，包括上游人工智能社区以及 Milvus 依赖的 Kubernetes、MinIO、etcd 和 Pulsar 等社区。</li>
<li>通过召开更多定期的 SIG 会议，变得更加社区化。除了目前正在运行的 SIG-pymilvus，我们计划在 2022 年成立更多的 SIG。</li>
</ol>
<p><strong>Milvus 项目：</strong></p>
<ol>
<li>性能调整</li>
</ol>
<p>卓越的性能一直是用户选择 Milvus 的重要原因。2022 年，我们计划启动性能优化项目，将吞吐量和延迟至少提高一倍。我们还计划引入内存复制来提高吞吐量和小数据集下的系统稳定性，并支持 GPU 来加速索引构建和在线服务。</p>
<ol start="2">
<li>功能</li>
</ol>
<p>Milvus 2.0 已经支持向量/标量混合搜索、实体删除和时间旅行等功能。我们计划在下两个主要版本中支持以下功能：</p>
<ul>
<li>支持更丰富的数据类型：字符串、Blob、地理空间等。</li>
<li>基于角色的访问控制</li>
<li>主键重复数据删除</li>
<li>支持向量上的范围搜索（距离 &lt; 0.8 时的搜索）</li>
<li>支持有源 API 和其他语言 SDK</li>
</ul>
<ol start="3">
<li>易用性</li>
</ol>
<p>未来一年，我们计划开发多种工具，帮助更好地部署和管理 Milvus。</p>
<ul>
<li><p>Milvus up：  这是一个部署组件，可帮助用户在没有 K8s 集群的离线环境中启动 Milvus。它还有助于部署监控、跟踪和其他 Milvus 开发。</p></li>
<li><p>Attu - 我们将继续改进我们的集群管理系统 Attu。我们计划增加健康诊断和索引优化等功能。</p></li>
<li><p>Milvus DM：数据迁移工具，用于将向量从其他数据库或文件迁移到 Milvus。我们将首先支持 FAISS、HNSW、Milvus 1.0/2.0，然后支持 MySQL 和 Elasticsearch 等其他数据库。</p></li>
</ul>
<h2 id="About-the-author" class="common-anchor-header">关于作者<button data-href="#About-the-author" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>栾晓帆，Zilliz合伙人兼工程总监，LF人工智能与数据基金会技术顾问委员会成员。曾先后就职于甲骨文美国总部和软件定义存储创业公司Hedvig。他曾加入阿里巴巴云数据库团队，负责 NoSQL 数据库 HBase 和 Lindorm 的开发。栾先生拥有康奈尔大学电子计算机工程硕士学位。</p>


2021 年的 Milvus - 年度回顾

<p>在信息爆炸的时代，我们无时无刻不在产生语音、图像、视频和其他非结构化数据。我们该如何高效地分析这些海量数据呢？神经网络的出现使得非结构化数据可以以向量的形式嵌入，而 Milvus 数据库作为一款基础数据服务软件，可以帮助完成向量数据的存储、搜索和分析。</p>
<p>但如何才能快速使用Milvus向量数据库呢？</p>
<p>一些用户抱怨API很难记忆，希望能有简单的命令行来操作Milvus数据库。</p>
<p>我们非常高兴地向大家介绍Milvus_CLI，一个专门用于Milvus向量数据库的命令行工具。</p>
<p>Milvus_CLI 是 Milvus 方便的数据库 CLI，支持使用 shell 中的交互式命令进行数据库连接、数据导入、数据导出和向量计算。最新版本的 Milvus_CLI 具有以下功能。</p>
<ul>
<li><p>支持所有平台，包括 Windows、Mac 和 Linux</p></li>
<li><p>支持使用 pip 进行在线和离线安装</p></li>
<li><p>可移植，可在任何地方使用</p></li>
<li><p>基于针对 Python 的 Milvus SDK 构建</p></li>
<li><p>包含帮助文档</p></li>
<li><p>支持自动完成</p></li>
</ul>
<h2 id="Installation" class="common-anchor-header">安装<button data-href="#Installation" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>你可以在线或离线安装 Milvus_CLI。</p>
<h3 id="Install-MilvusCLI-online" class="common-anchor-header">在线安装 Milvus_CLI</h3><p>运行以下命令，使用 pip 在线安装 Milvus_CLI。需要 Python 3.8 或更高版本。</p>
<pre><code translate="no">pip install milvus-cli
<button class="copy-code-btn"></button></code></pre>
<h3 id="Install-MilvusCLI-offline" class="common-anchor-header">离线安装 Milvus_CLI</h3><p>要离线安装 Milvus_CLI，请先从发布页面<a href="https://github.com/milvus-io/milvus_cli/releases">下载</a>最新的压缩包。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_af0e832119.png" alt="1.png" class="doc-image" id="1.png" />
   </span> <span class="img-wrapper"> <span>1.png</span> </span></p>
<p>下载完 tar 包后，运行以下命令安装 Milvus_CLI。</p>
<pre><code translate="no">pip install milvus_cli-&lt;version&gt;.tar.gz
<button class="copy-code-btn"></button></code></pre>
<p>Milvus_CLI 安装完成后，运行<code translate="no">milvus_cli</code> 。出现<code translate="no">milvus_cli &gt;</code> 提示表示命令行已准备就绪。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_b50f5d2a5a.png" alt="2.png" class="doc-image" id="2.png" />
   </span> <span class="img-wrapper"> <span>2.png</span> </span></p>
<p>如果使用的是带有 M1 芯片的 Mac 或没有 Python 环境的 PC，可以选择使用便携式应用程序。要做到这一点，请在与您的操作系统相对应的发布页面上<a href="https://github.com/milvus-io/milvus_cli/releases">下载</a>一个文件，在该文件上运行<code translate="no">chmod +x</code> 使其可执行，然后在该文件上运行<code translate="no">./</code> 以运行它。</p>
<h4 id="Example" class="common-anchor-header"><strong>示例</strong></h4><p>下面的示例使<code translate="no">milvus_cli-v0.1.8-fix2-macOS</code> 可执行并运行它。</p>
<pre><code translate="no"><span class="hljs-built_in">sudo</span> <span class="hljs-built_in">chmod</span> +x milvus_cli-v0.1.8-fix2-macOS
./milvus_cli-v0.1.8-fix2-macOS
<button class="copy-code-btn"></button></code></pre>
<h2 id="Usage" class="common-anchor-header">使用方法<button data-href="#Usage" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="Connect-to-Milvus" class="common-anchor-header">连接 Milvus</h3><p>在连接 Milvus 之前，确保服务器上安装了 Milvus。更多信息，请参阅<a href="https://milvus.io/docs/v2.0.x/install_standalone-docker.md">安装 Milvus Standalone</a>或<a href="https://milvus.io/docs/v2.0.x/install_cluster-docker.md">安装 Milvus Cluster</a>。</p>
<p>如果 Milvus 安装在默认端口的本地主机上，请运行<code translate="no">connect</code> 。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/3_f950d3739a.png" alt="3.png" class="doc-image" id="3.png" />
   </span> <span class="img-wrapper"> <span>3.png</span> </span></p>
<p>否则，请使用 Milvus 服务器的 IP 地址运行以下命令。以下示例使用<code translate="no">172.16.20.3</code> 作为 IP 地址，使用<code translate="no">19530</code> 作为端口号。</p>
<pre><code translate="no">connect -h 172.16.20.3
<button class="copy-code-btn"></button></code></pre>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/4_9ff2db9855.png" alt="4.png" class="doc-image" id="4.png" />
   </span> <span class="img-wrapper"> <span>4.png</span> </span></p>
<h3 id="Create-a-collection" class="common-anchor-header">创建 Collections</h3><p>本节介绍如何创建 Collections。</p>
<p>Collections 由实体组成，类似于 RDBMS 中的表。更多信息请参见<a href="https://milvus.io/docs/v2.0.x/glossary.md">术语表</a>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/5_95a88c1cbf.png" alt="5.png" class="doc-image" id="5.png" />
   </span> <span class="img-wrapper"> <span>5.png</span> </span></p>
<h4 id="Example" class="common-anchor-header">示例</h4><p>下面的示例创建了一个名为<code translate="no">car</code> 的 Collection。<code translate="no">car</code> 集合有四个字段，分别是<code translate="no">id</code>,<code translate="no">vector</code>,<code translate="no">color</code> 和<code translate="no">brand</code> 。主键字段是<code translate="no">id</code> 。更多信息，请参阅<a href="https://milvus.io/docs/v2.0.x/cli_commands.md#create-collection">创建 Collection</a>。</p>
<pre><code translate="no">create collection -c car -f <span class="hljs-built_in">id</span>:INT64:primary_field -f vector:FLOAT_VECTOR:<span class="hljs-number">128</span> -f color:INT64:color -f brand:INT64:brand -p <span class="hljs-built_in">id</span> -a -d <span class="hljs-string">&#x27;car_collection&#x27;</span>
<button class="copy-code-btn"></button></code></pre>
<h3 id="List-collections" class="common-anchor-header">列出集合</h3><p>运行以下命令，列出此 Milvus 实例中的所有 Collections。</p>
<pre><code translate="no">list collections
<button class="copy-code-btn"></button></code></pre>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/6_1331f4c8bc.png" alt="6.png" class="doc-image" id="6.png" />
   </span> <span class="img-wrapper"> <span>6.png</span> </span></p>
<p>运行以下命令检查<code translate="no">car</code> Collection 的详细信息。</p>
<pre><code translate="no">describe collection -c car 
<button class="copy-code-btn"></button></code></pre>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/7_1d70beee54.png" alt="7.png" class="doc-image" id="7.png" />
   </span> <span class="img-wrapper"> <span>7.png</span> </span></p>
<h3 id="Calculate-the-distance-between-two-vectors" class="common-anchor-header">计算两个向量之间的距离</h3><p>运行以下命令将数据导入<code translate="no">car</code> Collections。</p>
<pre><code translate="no"><span class="hljs-keyword">import</span> -c car <span class="hljs-string">&#x27;https://raw.githubusercontent.com/zilliztech/milvus_cli/main/examples/import_csv/vectors.csv&#x27;</span>
<button class="copy-code-btn"></button></code></pre>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/8_7609a4359a.png" alt="8.png" class="doc-image" id="8.png" />
   </span> <span class="img-wrapper"> <span>8.png</span> </span></p>
<p>运行<code translate="no">query</code> ，并在提示时输入<code translate="no">car</code> 作为 Collections 名称，输入<code translate="no">id&gt;0</code> 作为查询表达式。如下图所示，符合条件的实体 ID 将被返回。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/9_f0755589f6.png" alt="9.png" class="doc-image" id="9.png" />
   </span> <span class="img-wrapper"> <span>9.png</span> </span></p>
<p>运行<code translate="no">calc</code> 并在提示时输入适当的值，以计算向量数组之间的距离。</p>
<h3 id="Delete-a-collection" class="common-anchor-header">删除 Collections</h3><p>运行以下命令删除<code translate="no">car</code> Collections。</p>
<pre><code translate="no"><span class="hljs-keyword">delete</span> collection -c car
<button class="copy-code-btn"></button></code></pre>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/10_16b2b01935.png" alt="10.png" class="doc-image" id="10.png" />
   </span> <span class="img-wrapper"> <span>10.png</span> </span></p>
<h2 id="More" class="common-anchor-header">更多信息<button data-href="#More" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus_CLI 不限于上述功能。运行<code translate="no">help</code> 查看 Milvus_CLI 包含的所有命令及相关说明。运行<code translate="no">&lt;command&gt; --help</code> 查看指定命令的详细信息。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/11_5f31ccb1e8.png" alt="11.png" class="doc-image" id="11.png" />
   </span> <span class="img-wrapper"> <span>11.png</span> </span></p>
<p><strong>另请参阅：</strong></p>
<p>Milvus Docs 下的<a href="https://milvus.io/docs/v2.0.x/cli_commands.md">Milvus_CLI 命令参考</a></p>
<p>我们希望 Milvus_CLI 能够帮助您轻松使用 Milvus 向量数据库。我们将继续优化 Milvus_CLI，并欢迎您的贡献。</p>
<p>如果您有任何问题，请随时在 GitHub 上<a href="https://github.com/zilliztech/milvus_cli/issues">提交问题</a>。</p>


开始使用 Milvus_CLI

Milvus 云可扩展性向量数据库的发展历程

<p>近年来，随着人们对知识产权侵权意识的不断增强，知识产权保护问题成为人们关注的焦点。最引人注目的是跨国科技巨头<a href="https://en.wikipedia.org/wiki/Apple_Inc._litigation">苹果公司</a>（Apple Inc.除了这些最臭名昭著的案件外，苹果公司还在 2009 年以商标侵权为由对澳大利亚连锁超市<a href="https://www.smh.com.au/business/apple-bites-over-woolworths-logo-20091005-ghzr.html">Woolworths Limited 的商标申请提出异议</a>。  苹果公司公司认为，澳大利亚品牌的徽标（一个风格化的 &quot;w&quot;）与他们自己的苹果徽标相似。因此，苹果公司对 Woolworths 申请销售带有该标志的一系列产品（包括电子设备）提出异议。故事的结局是伍尔沃斯修改了徽标，苹果撤回了反对意见。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Logo_of_Woolworths_b04ece5b20.png" alt="Logo of Woolworths.png" class="doc-image" id="logo-of-woolworths.png" />
   </span> <span class="img-wrapper"> <span>伍尔沃斯的徽标.png</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Logo_of_Apple_Inc_181e5bd5f8.png" alt="Logo of Apple Inc.png" class="doc-image" id="logo-of-apple-inc.png" />
   </span> <span class="img-wrapper"> <span>苹果公司的徽标.png</span> </span></p>
<p>随着品牌文化意识的不断增强，公司正在密切关注任何可能损害其知识产权（IP）的威胁。知识产权侵权包括</p>
<ul>
<li>版权侵权</li>
<li>专利侵权</li>
<li>商标侵权</li>
<li>外观设计侵权</li>
<li>抢注</li>
</ul>
<p>上述苹果公司与伍尔沃斯公司之间的纠纷主要涉及商标侵权，准确地说，是两家公司的商标形象相似。为了避免成为另一个伍尔沃斯，无论是在商标申请之前，还是在商标申请审查期间，详尽的商标近似检索都是申请人的关键步骤。最常见的方法是在<a href="https://tmsearch.uspto.gov/search/search-information">美国专利商标局（USPTO）数据库</a>中进行检索，该数据库包含所有有效和无效的商标注册和申请。尽管用户界面并不迷人，但这一搜索过程也因其基于文本的性质而存在很大缺陷，因为它依赖文字和商标设计代码（设计特征的手工注释标签）来搜索图像。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/image_8_b2fff6ca11.png" alt="8.png" class="doc-image" id="8.png" />
   </span> <span class="img-wrapper"> <span>8.png</span> </span></p>
<p>因此，本文意在展示如何利用开源向量数据库<a href="https://milvus.io">Milvus</a> 建立一个高效的基于图像的商标相似性搜索系统。</p>
<h2 id="A-vector-similarity-search-system-for-trademarks" class="common-anchor-header">商标向量相似性搜索系统<button data-href="#A-vector-similarity-search-system-for-trademarks" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>要建立商标向量相似性搜索系统，需要经过以下步骤：</p>
<ol>
<li>准备一个庞大的商标数据集。系统可能会使用这样<a href="https://developer.uspto.gov/product/trademark-24-hour-box-and-supplemental">的</a>数据集）。</li>
<li>使用数据集和数据驱动模型或人工智能算法训练图像特征提取模型。</li>
<li>使用步骤 2 中训练好的模型或算法将徽标转换成向量。</li>
<li>在开源向量数据库 Milvus 中存储向量并进行向量相似性搜索。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/trademark_system_e9700df555.png" alt="Nike.png" class="doc-image" id="nike.png" />
   </span> <span class="img-wrapper"> <span>耐克.png</span> </span></p>
<p>在下面的章节中，让我们仔细了解一下构建商标向量相似性搜索系统的两个主要步骤：使用人工智能模型进行图像特征提取，以及使用 Milvus 进行向量相似性搜索。在我们的案例中，我们使用卷积神经网络（CNN）VGG16 提取图像特征并将其转换为嵌入向量。</p>
<h3 id="Using-VGG16-for-image-feature-extraction" class="common-anchor-header">使用 VGG16 提取图像特征</h3><p><a href="https://medium.com/@mygreatlearning/what-is-vgg16-introduction-to-vgg16-f2d63849f615">VGG16</a>是为大规模图像识别而设计的卷积神经网络。该模型在图像识别中速度快、精度高，可应用于各种尺寸的图像。以下是 VGG16 架构的两幅图示。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/vgg16_layers_9e621f62cc.png" alt="9.png" class="doc-image" id="9.png" />
   </span> <span class="img-wrapper"> <span>9.png</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/vgg16_architecture_992614e882.png" alt="10.png" class="doc-image" id="10.png" />
   </span> <span class="img-wrapper"> <span>10.png</span> </span></p>
<p>VGG16 模型，顾名思义，是一个有 16 层的 CNN。包括 VGG16 和 VGG19 在内的所有 VGG 模型都包含 5 个 VGG 块，每个 VGG 块中都有一个或多个卷积层。在每个块的末端，连接一个最大池化层，以减小输入图像的大小。每个卷积层内的核数相同，但每个 VGG 块内的核数加倍。因此，模型中的内核数量从第一个区块的 64 个增长到第四和第五个区块的 512 个。所有卷积核的<em>大小</em>都是<em>33，而池化核的大小都是 22</em>。这有利于保留输入图像的更多信息。</p>
<p>因此，在这种情况下，VGG16 是一种适合海量数据集图像识别的模型。你可以使用 Python、Tensorflow 和 Keras 在 VGG16 的基础上训练图像特征提取模型。</p>
<h3 id="Using-Milvus-for-vector-similarity-search" class="common-anchor-header">使用 Milvus 进行向量相似性搜索</h3><p>使用 VGG16 模型提取图像特征并将徽标图像转换为嵌入向量后，您需要从海量数据集中搜索相似向量。</p>
<p>Milvus 是一个云原生数据库，具有高扩展性和高弹性的特点。此外，作为一个数据库，它还能确保数据的一致性。对于这样一个商标相似性搜索系统来说，最新的商标注册等新数据会实时上传到系统中。而这些新上传的数据需要立即可供搜索。因此，本文采用了开源向量数据库 Milvus 来进行向量相似性搜索。</p>
<p>在插入徽标向量时，可以根据<a href="https://en.wikipedia.org/wiki/International_(Nice)_Classification_of_Goods_and_Services">国际（尼斯）商品和服务分类（</a>一种用于注册商标的商品和服务分类系统）在 Milvus 中为不同类型的徽标向量创建 Collections。例如，您可以在 Milvus 中将一组服装品牌徽标向量插入名为 &quot;服装 &quot;的 Collections 中，并将另一组技术品牌徽标向量插入名为 &quot;技术 &quot;的不同 Collections 中。通过这样做，您可以大大提高向量相似性搜索的效率和速度。</p>
<p>Milvus 不仅支持向量相似性搜索的多种索引，还提供丰富的 API 和工具，为 DevOps 提供便利。下图是<a href="https://milvus.io/docs/v2.0.x/architecture_overview.md">Milvus 架构</a>示意图。您可以通过阅读 Milvus 的<a href="https://milvus.io/docs/v2.0.x/overview.md">介绍</a>了解更多信息。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/milvus_architecture_ea45a5ab53.png" alt="11.png" class="doc-image" id="11.png" />
   </span> <span class="img-wrapper"> <span>11.png</span> </span></p>
<h2 id="Looking-for-more-resources" class="common-anchor-header">寻找更多资源？<button data-href="#Looking-for-more-resources" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p>使用 Milvus 为其他应用场景构建更多向量相似性搜索系统：</p>
<ul>
<li><a href="https://milvus.io/blog/dna-sequence-classification-based-on-milvus.md">基于 Milvus 的 DNA 序列分类</a></li>
<li><a href="https://milvus.io/blog/audio-retrieval-based-on-milvus.md">基于 Milvus 的音频检索</a></li>
<li><a href="https://milvus.io/blog/building-video-search-system-with-milvus.md">构建视频搜索系统的 4 个步骤</a></li>
<li><a href="https://milvus.io/blog/building-intelligent-chatbot-with-nlp-and-milvus.md">利用NLP和Milvus构建智能质量保证系统</a></li>
<li><a href="https://milvus.io/blog/molecular-structure-similarity-with-milvus.md">加速新药发现</a></li>
</ul></li>
<li><p>参与我们的开源社区：</p>
<ul>
<li>在<a href="https://bit.ly/307b7jC">GitHub</a> 上查找 Milvus 或为其做出贡献。</li>
<li>通过<a href="https://bit.ly/3qiyTEk">论坛</a>与社区互动。</li>
<li>在<a href="https://bit.ly/3ob7kd8">Twitter</a> 上与我们联系。</li>
</ul></li>
</ul>


Milvus 在知识产权保护领域：利用 Milvus 建立商标相似性检索系统

<p>为了帮助您快速上手开源向量数据库 Milvus，我们在 GitHub 上发布了另一个附属开源项目<a href="https://github.com/milvus-io/bootcamp">Milvus Bootcamp</a>。Milvus Bootcamp 不仅提供用于基准测试的脚本和数据，还包括使用 Milvus 构建一些 MVP（最小可行产品）的项目，例如反向图像搜索系统、视频分析系统、QA 聊天机器人或推荐系统。您可以在 Milvus Bootcamp 中学习如何在充满非结构化数据的世界中应用向量相似性搜索，并获得一些实践经验。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_5b60157b4d.png" alt="2.png" class="doc-image" id="2.png" />
   </span> <span class="img-wrapper"> <span>2.png</span> </span></p>
<p>我们为 Milvus Bootcamp 中的项目提供前端和后端服务。不过，我们最近决定将采用的网络框架从 Flask 改为 FastAPI。</p>
<p>本文旨在解释我们改变 Milvus Bootcamp 所采用的 Web 框架的动机，说明我们为什么选择 FastAPI 而不是 Flask。</p>
<h2 id="Web-frameworks-for-Python" class="common-anchor-header">Python 的网络框架<button data-href="#Web-frameworks-for-Python" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Web 框架指的是软件包或模块的 Collections。它是一套用于网络开发的软件架构，可以让您编写网络应用程序或服务，并省去了处理协议、套接字或进程/线程管理等底层细节的麻烦。使用网络框架可以大大减少开发网络应用程序的工作量，因为您只需将代码 "插入 "到框架中，而无需额外关注数据缓存、数据库访问和数据安全验证等问题。有关 Python Web 框架的更多信息，请参见<a href="https://wiki.python.org/moin/WebFrameworks">Web 框架</a>。</p>
<p>Python Web 框架有多种类型。主流的有 Django、Flask、Tornado 和 FastAPI。</p>
<h3 id="Flask" class="common-anchor-header">Flask</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/3_1abd170939.png" alt="3.png" class="doc-image" id="3.png" />
   </span> <span class="img-wrapper"> <span>3.png</span> </span></p>
<p><a href="https://flask.palletsprojects.com/en/2.0.x/">Flask</a>是专为 Python 设计的轻量级微型框架，其核心简单易用，可让您开发自己的网络应用程序。此外，Flask 内核还具有可扩展性。因此，Flask 支持按需扩展不同的功能，以满足您在网络应用程序开发过程中的个性化需求。也就是说，通过 Flask 中的各种插件库，您可以开发出功能强大的网站。</p>
<p>Flask 具有以下特点：</p>
<ol>
<li>Flask 是一个微框架，不依赖其他特定工具或第三方库的组件来提供共享功能。Flask 没有数据库抽象层，也不需要表单验证。不过，Flask 具有很强的可扩展性，支持以类似于 Flask 本身实现的方式添加应用程序功能。相关的扩展包括对象关系映射器、表单验证、上传处理、开放验证技术以及一些为网络框架设计的常用工具。</li>
<li>Flask 是一个基于<a href="https://wsgi.readthedocs.io/">WSGI</a>（Web 服务器网关接口）的网络应用程序框架。WSGI 是一个连接网络服务器与网络应用程序或 Python 语言定义的框架的简单接口。</li>
<li>Flask 包括两个核心函数库：<a href="https://www.palletsprojects.com/p/werkzeug">Werkzeug</a>和<a href="https://www.palletsprojects.com/p/jinja">Jinja2</a>。Werkzeug 是一个 WSGI 工具包，它实现了请求、响应对象和实用功能，让您可以在其基础上构建网络框架。Jinja2 是一个流行的 Python 全功能模板引擎。它完全支持 Unicode，具有一个可选但被广泛采用的集成沙箱执行环境。</li>
</ol>
<h3 id="FastAPI" class="common-anchor-header">FastAPI</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/4_05cb0dac4e.png" alt="4.png" class="doc-image" id="4.png" />
   </span> <span class="img-wrapper"> <span>4.png</span> </span></p>
<p><a href="https://fastapi.tiangolo.com/">FastAPI</a>是一个现代 Python 网络应用程序框架，具有与 Go 和 NodeJS 相同的高性能。FastAPI 的核心基于<a href="https://www.starlette.io/">Starlette</a>和<a href="https://pydantic-docs.helpmanual.io/">Pydantic</a>。Starlette 是一个轻量级<a href="https://asgi.readthedocs.io/">ASGI</a>（异步服务器网关接口）框架工具包，用于构建高性能的<a href="https://docs.python.org/3/library/asyncio.html">Asyncio</a>服务。Pydantic 是一个基于 Python 类型提示定义数据验证、序列化和文档的库。</p>
<p>FastAPI 具有以下特点：</p>
<ol>
<li>FastAPI 是一个基于 ASGI 的网络应用框架，ASGI 是连接网络协议服务和 Python 应用程序的异步网关协议接口。FastAPI 可以处理各种常见的协议类型，包括 HTTP、HTTP2 和 WebSocket。</li>
<li>FastAPI 基于 Pydantic，后者提供了检查接口数据类型的功能。您无需额外验证接口参数，也无需编写额外的代码来验证参数是否为空或数据类型是否正确。使用 FastAPI 可以有效避免代码中的人为错误，提高开发效率。</li>
<li>FastAPI 支持<a href="https://swagger.io/specification/">OpenAPI</a>（以前的 Swagger）和<a href="https://www.redoc.com/">Redoc</a> 两种格式的文档。因此，作为用户，您无需花费额外时间编写额外的接口文档。FastAPI 提供的 OpenAPI 文档如下截图所示。</li>
</ol>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/5_d91d34cb0f.png" alt="5.png" class="doc-image" id="5.png" />
   </span> <span class="img-wrapper"> <span>5.png</span> </span></p>
<h3 id="Flask-Vs-FastAPI" class="common-anchor-header">Flask 与 FastAPI</h3><p>下表展示了 Flask 和 FastAPI 在多个方面的不同之处。</p>
<table>
<thead>
<tr><th></th><th><strong>FastAPI</strong></th><th><strong>Flask</strong></th></tr>
</thead>
<tbody>
<tr><td><strong>接口网关</strong></td><td>ASGI</td><td>WSGI</td></tr>
<tr><td><strong>异步框架</strong></td><td>✅</td><td>❌</td></tr>
<tr><td><strong>性能</strong></td><td>更快</td><td>较慢</td></tr>
<tr><td><strong>交互式文档</strong></td><td>OpenAPI、Redoc</td><td>无</td></tr>
<tr><td><strong>数据验证</strong></td><td>✅</td><td>❌</td></tr>
<tr><td><strong>开发成本</strong></td><td>较低</td><td>较高</td></tr>
<tr><td><strong>易用性</strong></td><td>较低</td><td>较高</td></tr>
<tr><td><strong>灵活性</strong></td><td>灵活性较低</td><td>更灵活</td></tr>
<tr><td><strong>社区</strong></td><td>较小</td><td>更活跃</td></tr>
</tbody>
</table>
<h2 id="Why-FastAPI" class="common-anchor-header">为什么选择FastAPI？<button data-href="#Why-FastAPI" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在决定为 Milvus Bootcamp 中的项目选择哪个 Python 网络应用框架之前，我们研究了几个主流框架，包括 Django、Flask、FastAPI、Tornado 等等。由于 Milvus Bootcamp 中的项目可以为您提供参考，因此我们优先考虑采用最轻量级、最灵巧的外部框架。根据这一原则，我们将选择范围缩小到 Flask 和 FastAPI。</p>
<p>您可以在上一节中看到这两种网络框架的比较。下面将详细解释我们在 Milvus Bootcamp 的项目中选择 FastAPI 而不是 Flask 的动机。原因有以下几点：</p>
<h3 id="1-Performance" class="common-anchor-header">1.性能</h3><p>Milvus Bootcamp 中的大多数项目都是围绕反向图片搜索系统、QA 聊天机器人、文本搜索引擎构建的，这些项目都对实时数据处理有很高的要求。因此，我们需要一个性能卓越的框架，而这正是 FastAPI 的一大亮点。因此，从系统性能的角度出发，我们决定选择FastAPI。</p>
<h3 id="2-Efficiency" class="common-anchor-header">2.高效性</h3><p>使用 Flask 时，需要在每个接口中编写数据类型验证代码，以便系统判断输入数据是否为空。然而，FastAPI 通过支持自动数据类型验证，可以避免系统开发过程中的人为编码错误，大大提高开发效率。Bootcamp 的定位是一种培训资源。这意味着我们使用的代码和组件必须直观、高效。为此，我们选择了 FastAPI 来提高系统效率，增强用户体验。</p>
<h3 id="3-Asynchronous-framework" class="common-anchor-header">3.异步框架</h3><p>FastAPI 本身就是一个异步框架。最初，我们发布了反向图像搜索、视频分析、QA 聊天机器人和分子相似性搜索四个<a href="https://zilliz.com/milvus-demos?isZilliz=true">演示</a>。在这些演示中，您可以上传数据集，系统会立即提示 &quot;收到请求&quot;。数据上传到演示系统后，您会收到另一个提示 &quot;数据上传成功&quot;。这是一个异步过程，需要一个支持该功能的框架。FastAPI 本身就是一个异步框架。为了统一 Milvus 的所有资源，我们决定在 Milvus Bootcamp 和 Milvus 演示版中采用同一套开发工具和软件。因此，我们将框架从 Flask 改为 FastAPI。</p>
<h3 id="4-Automatic-interactive-documents" class="common-anchor-header">4.自动交互文档</h3><p>按照传统方式，当你写完服务器端的代码时，你需要额外编写一个文档来创建一个界面，然后使用<a href="https://www.postman.com/">Postman</a>等工具进行 API 测试和调试。那么，如果你只想快速入门 Milvus Bootcamp 中项目的网络服务器端开发部分，而不需要编写额外的代码来创建接口，该怎么办呢？FastAPI 可以解决这个问题。通过提供 OpenAPI 文档，FastAPI 可以为您省去测试或调试 API 以及与前端团队合作开发用户界面的麻烦。有了 FastAPI，您仍然可以快速试用已构建的应用程序，其界面自动而直观，无需额外的编码工作。</p>
<h3 id="5-User-friendliness" class="common-anchor-header">5.用户友好性</h3><p>FastAPI 更易于使用和开发，因此您可以更加关注项目本身的具体实施。无需在开发网络框架上花费太多时间，您可以将更多精力放在了解 Milvus Bootcamp 中的项目上。</p>
<h2 id="Recap" class="common-anchor-header">总结<button data-href="#Recap" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Flask 和 FlastAPI 各有利弊。作为一个新兴的 Web 应用程序框架，FlastAPI 的核心是建立在 Starlette 和 Pydantic 这两个成熟的工具包和库之上。FastAPI 是一个具有高性能的异步框架。它的灵巧性、可扩展性和对自动数据类型验证的支持，以及其他许多强大的功能，促使我们采用 FastAPI 作为 Milvus Bootcamp 项目的框架。</p>
<p>请注意，如果您想在生产中构建向量相似性搜索系统，应根据自己的应用场景选择合适的框架。</p>
<h2 id="About-the-author" class="common-anchor-header">关于作者<button data-href="#About-the-author" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>李云梅，Zilliz数据工程师，毕业于华中科技大学计算机科学专业。加入Zilliz后，她一直致力于为开源项目Milvus探索解决方案，并帮助用户将Milvus应用于实际场景。她的主要研究方向是 NLP 和推荐系统，并希望在这两个领域进一步加深研究。她喜欢独处和阅读。</p>
<h2 id="Looking-for-more-resources" class="common-anchor-header">寻找更多资源？<button data-href="#Looking-for-more-resources" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p>开始使用 Milvus 构建人工智能系统，并通过阅读我们的教程获得更多实践经验！</p>
<ul>
<li><a href="https://milvus.io/blog/2021-10-10-milvus-helps-analys-vedios.md">它是什么？她是谁？Milvus 帮助智能分析视频</a></li>
<li><a href="https://milvus.io/blog/2021-09-26-onnx.md">使用 ONNX 和 Milvus 结合人工智能模型进行图像搜索</a></li>
<li><a href="https://milvus.io/blog/dna-sequence-classification-based-on-milvus.md">基于 Milvus 的 DNA 序列分类</a></li>
<li><a href="https://milvus.io/blog/audio-retrieval-based-on-milvus.md">基于 Milvus 的音频检索</a></li>
<li><a href="https://milvus.io/blog/building-video-search-system-with-milvus.md">构建视频搜索系统的 4 个步骤</a></li>
<li><a href="https://milvus.io/blog/building-intelligent-chatbot-with-nlp-and-milvus.md">利用 NLP 和 Milvus 构建智能 QA 系统</a></li>
<li><a href="https://milvus.io/blog/molecular-structure-similarity-with-milvus.md">加速新药发现</a></li>
</ul></li>
<li><p>参与我们的开源社区：</p>
<ul>
<li>在<a href="https://bit.ly/307b7jC">GitHub</a> 上查找 Milvus 或为其做出贡献。</li>
<li>通过<a href="https://bit.ly/3qiyTEk">论坛</a>与社区互动。</li>
<li>在<a href="https://bit.ly/3ob7kd8">Twitter</a> 上与我们联系。</li>
</ul></li>
</ul>


为什么选择 FastAPI 而不是 Flask？

使用 Milvus 搭配 PaddlePaddle 加速推荐系统中候选对象的生成

<p>本教程介绍如何在 Windows 环境下运行 Milvus 2.0。如果你想使用 Windows 开始使用 Milvus 2.0，或者只是因为环境限制不得不在 Windows 上运行 Milvus，本教程可以作为一个很好的参考。本文由<a href="https://github.com/matrixji">@matrixji</a> 原创写作。</p>
<p>在 Windows 上运行 Milvus 2.0 有两种方法：</p>
<ul>
<li><a href="#Compile-from-source-code">从源代码编译</a></li>
<li><a href="#Install-from-the-binary-package">从二进制包安装</a></li>
</ul>
<h2 id="Compile-from-source-code" class="common-anchor-header">从源代码编译<button data-href="#Compile-from-source-code" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="Prerequisites" class="common-anchor-header">前提条件</h3><p>在 Windows 上编译 Milvus 2.0 之前，需要安装 MinGW64/MSYS 工具链。安装指南请参见<a href="https://www.msys2.org/">MSYS2</a>。本教程中的编译在 MSYS2 MinGW 64 位的外壳中完成。您可以运行<code translate="no">$ pacman -Su</code> 更新工具链。</p>
<p>我们还建议您运行<code translate="no">$ pacman -S git</code> 安装 git。</p>
<h3 id="Step-1-Clone-code" class="common-anchor-header">步骤 1.克隆代码</h3><p>运行以下命令克隆<strong>matrixji/milvus</strong>代码库中<strong>windows-dev</strong>分支的代码。目前，所有提交都可以在<strong>windows-dev</strong> 中追踪到，它每周都会从上游主分支<a href="https://github.com/milvus-io/milvus"><strong>milvus-io/milvus 中</strong></a>重新发布提交。</p>
<pre><code translate="no" class="language-python">$ git <span class="hljs-built_in">clone</span> git@github.com:matrixji/milvus.git -b windows-dev
<button class="copy-code-btn"></button></code></pre>
<h3 id="Step-2-Compile-Milvus" class="common-anchor-header">第 2 步编译 Milvus</h3><h4 id="1-Install-dependencies-and-toolchain" class="common-anchor-header">1.安装依赖项和工具链</h4><p>运行以下命令安装所需的依赖项和工具链。安装完成后，需要重新启动 MinGW/MYSY shell，以确保正确应用某些工具的配置。</p>
<pre><code translate="no" class="language-python">$ <span class="hljs-built_in">cd</span> milvus
$ scripts/install_deps_msys.sh
<button class="copy-code-btn"></button></code></pre>
<h4 id="2-Compile-Milvus" class="common-anchor-header">2.编译 Milvus</h4><p>运行以下命令编译并打包 Milvus。</p>
<pre><code translate="no" class="language-python">$ make
$ sh scripts/package_windows.sh
<button class="copy-code-btn"></button></code></pre>
<p>如果编译成功，您将在<code translate="no">windows_package</code> 子目录下找到一个压缩文件。该压缩文件包含运行<code translate="no">milvus.exe</code> 的所有文件，包括<code translate="no">minio.exe</code> 和<code translate="no">etcd.exe</code> 。</p>
<div class="alert note">
Milvus 2.0 采用 Go 语言开发。您可能需要配置<a href='https://goproxy.cn/'>Goproxy</a>以安装第三方模块。</div>
<h2 id="Install-from-the-binary-package" class="common-anchor-header">从二进制包安装<button data-href="#Install-from-the-binary-package" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>你也可以从<a href="https://github.com/matrixji/milvus/releases">Releases - matrixji/milvus</a> 下载已经编译好的二进制包。每个版本的前缀都是<strong>windows-test-</strong>，例如<strong>windows-test-v8</strong>。找到你想要的版本并下载相应的压缩包。</p>
<h3 id="Step-1-Start-Milvus" class="common-anchor-header">步骤 1.启动 Milvus</h3><h4 id="1-Unzip-the-package" class="common-anchor-header">1.解压压缩包</h4><p>解压压缩包后，你会发现<code translate="no">milvus</code> 目录，其中包含所有需要的文件。</p>
<h4 id="2-Start-a-MinIO-service" class="common-anchor-header">2.启动 MinIO 服务</h4><p>双击<code translate="no">run_minio.bat</code> 文件，以默认配置启动 MinIO 服务。数据将存储在子目录<code translate="no">s3data</code> 中。</p>
<h4 id="3-Start-an-etcd-service" class="common-anchor-header">3.启动 etcd 服务</h4><p>双击<code translate="no">run_etcd.bat</code> 文件，按默认配置启动 etcd 服务。</p>
<h4 id="4-Start-Milvus-service" class="common-anchor-header">4.启动 Milvus 服务</h4><p>双击<code translate="no">run_milvus.bat</code> 文件，启动 Milvus 服务。</p>
<h3 id="Step-2-Run-hellomilvuspy" class="common-anchor-header">步骤 2.运行<code translate="no">hello_milvus.py</code></h3><p>启动 Milvus 服务后，可以通过运行<code translate="no">hello_milvus.py</code> 进行测试。更多信息，请参阅 "<a href="https://milvus.io/docs/v2.0.x/example_code.md">你好 Milvus"</a>。</p>
<h2 id="Engage-with-our-open-source-community" class="common-anchor-header">参与我们的开源社区：<button data-href="#Engage-with-our-open-source-community" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li>在<a href="https://bit.ly/3khejQB">GitHub</a> 上查找 Milvus 或为其做出贡献。</li>
<li>通过<a href="https://bit.ly/307HVsY">论坛</a>与社区互动。</li>
<li>在<a href="https://bit.ly/3wn5aek">Twitter</a> 上与我们联系。</li>
</ul>


在 Windows 上运行 Milvus 2.0

<custom-h1>结束 - Milvus 2021 黑客节</custom-h1><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Blog_cover_a6ce8748d7.jpeg" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>图片</span> </span></p>
<p>黑客节已经结束，但对开源项目的贡献却没有结束！</p>
<p>整个 10 月份，我们的仓库中共收到来自<strong>36 个贡献者</strong>（不包括我们的核心团队）的<strong>44 个拉动请求</strong>（PR）。虽然 Milvus 社区是第一年参加 Hacktoberfest，但参与人数超出了我们的预期，这表明开源精神的意识在不断增强。</p>
<p>我们希望每一个参与这次活动的人都能在这个过程中获得一些开源、社区的实践经验或知识，以及有用的技术技能。</p>
<p>在这篇文章中，我们想邀请你一起庆祝我们的成就，以及如何在Hacktoberfest之后继续为Milvus做出贡献。</p>
<h2 id="📣-Shout-out-to-our-contributors" class="common-anchor-header"><strong>向我们的贡献者致敬：</strong><button data-href="#📣-Shout-out-to-our-contributors" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在今年的黑客节期间，Milvus 项目仓库<strong>合并了 44 个拉请求</strong>！这对各方来说都是一项巨大的成就。大家干得好！🎉</p>
<p><a href="https://github.com/parthiv11">parthiv11</a>、<a href="https://github.com/joremysh">joremysh</a>、<a href="https://github.com/noviicee">noviicee</a>、<a href="https://github.com/Biki-das">Biki-das</a>、<a href="https://github.com/Nadyamilona">Nadyamilona</a>、<a href="https://github.com/ashish4arora">ashish4arora</a>、<a href="https://github.com/Dhruvacube">Dhruvacube</a>、<a href="https://github.com/iamartyaa">iamartyaa</a>、<a href="https://github.com/RafaelDSS">RafaelDSS</a>、<a href="https://github.com/kartikcho">kartikcho</a>、<a href="https://github.com/daniel-shuy">GuyKh</a>、<a href="https://github.com/daniel-shuy">Deep1Shikha</a>、<a href="https://github.com/shreemaan-abhishek">shreemaan-abhishek</a>、<a href="https://github.com/daniel-shuy">daniel</a> <a href="https://github.com/shreemaan-abhishek">-</a> <a href="https://github.com/daniel-shuy">shuy</a>、<a href="https://github.com/Hard-Coder05">Hard-Coder05</a>、<a href="https://github.com/sapora1">sapora1</a>、<a href="https://github.com/Rutam21">Rutam21</a>、<a href="https://github.com/idivyanshbansal">idivyanshbansal</a>、<a href="https://github.com/Mihir501">Mihir501</a>、<a href="https://github.com/Ayushchaudhary-Github">YushChaudhary</a>、<a href="https://github.com/sreyan-ghosh">sreyan-ghosh</a>、<a href="https://github.com/chiaramistro">chiaramistro</a>、<a href="https://github.com/appledora">appledora</a>、<a href="https://github.com/luisAzcuaga">luisAzcuaga</a>、<a href="https://github.com/matteomessmer">matteomessmer</a>、<a href="https://github.com/Nadyamilona">Nadyamilona</a>、<a href="https://github.com/Tititesouris">Tititesouris</a>、<a href="https://github.com/amusfq">amusfq</a>、<a href="https://github.com/matrixji">matrixji</a>&amp;<a href="https://github.com/zamanmub">GeneralZman</a></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/_80b0d87746.png" alt="image-20211110180357460" class="doc-image" id="image-20211110180357460" />
   </span> <span class="img-wrapper"> <span>image-20211110180357460</span> </span></p>
<h3 id="Here-are-some-extraordinary-Milvus-Hacktoberfest-2021-contributions" class="common-anchor-header">以下是一些非同寻常的 Milvus 黑客节 2021 贡献：</h3><p><strong>⚙️ 新功能</strong></p>
<p><a href="https://github.com/milvus-io/milvus/issues/7706">跨平台编译和运行 Milvus</a>，作者：<a href="https://github.com/matrixji">matrixji</a></p>
<p><strong>(顶级贡献者 🏆 )</strong></p>
<p><strong>📝 文档</strong></p>
<ul>
<li><a href="https://github.com/milvus-io/bootcamp/issues/720">将 Hello Milvus (example_code.md) 翻译为任何语言</a>，作者：<a href="https://github.com/chiaramistro">chiaramistro</a>,<a href="https://github.com/appledora">appledora</a>,<a href="https://github.com/luisAzcuaga">luisAzcuaga</a>,<a href="https://github.com/matteomessmer">matteomessmer</a>,<a href="https://github.com/Nadyamilona">Nadyamilona</a>,<a href="https://github.com/Tititesouris">Tititesouris</a>&amp;<a href="https://github.com/amusfq">amusfq</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/issues/720">在 example_code.md 中添加 NodeJS 示例</a>by<a href="https://github.com/GuyKh">GuyKh</a></li>
<li><a href="https://github.com/milvus-io/milvus-docs/pull/921/files">翻译 upgrade.md</a>并<a href="https://github.com/milvus-io/milvus-docs/pull/892">添加和翻译《用户指南》中的参数至 CN</a>by<a href="https://github.com/joremysh">joremysh</a></li>
<li><a href="https://github.com/milvus-io/milvus-docs/pull/753">将 tutorials/dna_sequence_classification.md 翻译成 CN</a>&amp;<a href="https://github.com/milvus-io/milvus-docs/pull/752">将 reference/schema/collection_schema.md 翻译成 CN</a>by<a href="https://github.com/daniel-shuy">daniel-shuy</a></li>
</ul>
<p><strong>🚀训练营</strong></p>
<ul>
<li><a href="https://github.com/milvus-io/bootcamp/pull/858">增强 Jupyter Notebook 的图像哈希搜索教程 </a>，作者：<a href="https://github.com/zamanmub">generalZman</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/pull/792">修复 reverse_image_search 的 TOPK 错误</a>，作者：<a href="https://github.com/RafaelDSS">RafaelDSS</a></li>
</ul>
<p><strong>🐍 PyMilvus</strong></p>
<ul>
<li><a href="https://github.com/milvus-io/pymilvus/issues/741">更新 GitHub 问题表单 </a>（多个 repos），作者<a href="https://github.com/Hard-Coder05">Hard-Coder05</a></li>
</ul>
<h3 id="Share-your-feedback-with-us" class="common-anchor-header">与我们分享您的反馈！</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/h3_412b0f649b.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>图像</span> </span></p>
<p>非常欢迎您与我们分享您参加 Milvus Hacktoberfest 2021 的经历！无论是博文、推特（@milvusio）还是在我们的<a href="https://discuss.milvus.io/c/hacktoberfest/9">论坛</a>上发帖，我们都将不胜感激！</p>
<h2 id="Whats-Next" class="common-anchor-header">下一步计划？<button data-href="#Whats-Next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="👩‍💻-Code--Documentation" class="common-anchor-header"><strong>👩‍💻</strong> <strong>代码和文档</strong></h3><p>如果你对 Milvus 的了解有限，你可以先通过贡献到<a href="https://github.com/milvus-io/pymilvus">pymilvus</a>或<a href="https://github.com/milvus-io/milvus-docs">docs</a>仓库来熟悉社区是如何工作的。您还可以查找<strong>#goodfirstissue</strong>或<strong>#helpwanted</strong> 等标签。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/h4_f18c9b6c2c.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>图片</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/h5_a4f90c24a8.png" alt="img" class="doc-image" id="img" />
   </span> <span class="img-wrapper"> <span>图片</span> </span></p>
<p>如果您有任何关于贡献的问题，可以随时在论坛的<strong>贡献者</strong>类别下向社区提问：https://discuss.milvus.io/t/things-you-need-to-know-before-you-get-started/64。</p>
<h3 id="🏆-Be-a-Milvus-Advocate" class="common-anchor-header">成为 Milvus 倡导者</h3><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/advocate_1052d8249a.jpg" alt="image-20211110180730866" class="doc-image" id="image-20211110180730866" />
   </span> <span class="img-wrapper"> <span>image-20211110180730866</span> </span></p>
<p>与社区分享您的经验和心得；提出改进意见；回答问题并帮助 Milvus 论坛上的其他成员等。您可以通过多种方式参与社区活动，我们在下面列出了几个例子，但我们欢迎任何形式的贡献：</p>
<ul>
<li><p><strong>演示和解决方案：</strong>向 Milvus 用户展示如何在特定场景中利用平台（如音乐推荐系统）。可在<a href="https://github.com/milvus-io/bootcamp">Milvus Bootcamp</a> 中获取示例。</p></li>
<li><p><strong>博客文章、用户故事或白皮书：</strong>撰写高质量的内容，清晰准确地解释 Milvus 的技术细节。</p></li>
<li><p><strong>技术讲座/现场直播：</strong>举办讲座或现场直播，帮助提高人们对 Milvus 的认识。</p></li>
<li><p><strong>其他：</strong>任何对 Milvus 及其开源社区的发展起到积极作用的内容都将被视为合格内容。</p></li>
</ul>
<p>更多详情，请阅读： https://milvus.io/community/milvus_advocate.md</p>
<p>最后，再次感谢你们参加今年的 Hacktoberfest，让我们成为你们的导师和学生。感谢<a href="https://hacktoberfest.digitalocean.com/">Digital Ocean</a>主办了又一年的精彩活动。下次再见！</p>
<p>编码快乐</p>
<p>Milvus 社区团队</p>


结束了2021 年 Milvus 黑客节

<p><em>宗玉芬，Zilliz 测试开发工程师，毕业于华中科技大学，获计算机技术硕士学位。她目前从事 Milvus 向量数据库的质量保证工作，包括但不限于接口集成测试、SDK 测试、Benchmark 测试等。于芬热衷于Milvus测试和开发中的问题解决，是混沌工程理论和故障演练实践的忠实粉丝。</em></p>
<h2 id="Background" class="common-anchor-header">背景介绍<button data-href="#Background" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在使用 Milvus 向量数据库时，需要修改默认配置以满足不同场景的需求。之前，有 Milvus 用户分享过《<a href="/blog/zh/2021-10-22-apply-configuration-changes-on-milvus-2.md">如何修改使用 Docker Compose 部署的 Milvus 的配置</a>》。而在本文中，我想与大家分享如何修改部署在 Kubernetes 上的 Milvus 的配置。</p>
<h2 id="Modify-configuration-of-Milvus-on-Kubernetes" class="common-anchor-header">修改 Milvus 在 Kubernetes 上的配置<button data-href="#Modify-configuration-of-Milvus-on-Kubernetes" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>你可以根据想要修改的配置参数选择不同的修改方案。所有 Milvus 配置文件都存储在<strong>milvus/configs</strong> 下。在 Kubernetes 上安装 Milvus 时，本地会添加一个 Milvus Helm Chart 资源库。通过运行<code translate="no">helm show values milvus/milvus</code> ，你可以检查可直接用 Chart 修改的参数。对于可通过 Chart 修改的参数，可使用<code translate="no">--values</code> 或<code translate="no">--set</code> 传递参数。更多信息，请参阅<a href="https://artifacthub.io/packages/helm/milvus/milvus">Milvus Helm Chart</a>和<a href="https://helm.sh/docs/">Helm</a>。</p>
<p>如果您希望修改的参数不在列表中，可以按照以下说明操作。</p>
<p>在以下步骤中，要修改<strong>/milvus/configs/advanced/root_coord.yaml</strong>中的参数<code translate="no">rootcoord.dmlChannelNum</code> ，以作示范。Kubernetes 上 Milvus 的配置文件管理是通过 ConfigMap 资源对象实现的。要修改参数，应首先更新相应 Chart 版本的 ConfigMap 对象，然后修改相应 pod 的部署资源文件。</p>
<p>请注意，此方法仅适用于修改已部署的 Milvus 应用程序的参数。要在部署前修改<strong>/milvus/configs/advanced/*.yaml</strong>中的参数，需要重新开发 Milvus Helm Chart。</p>
<h3 id="Modify-ConfigMap-YAML" class="common-anchor-header">修改 ConfigMap YAML</h3><p>如下图所示，你在 Kubernetes 上运行的 Milvus 发行版对应一个与发行版同名的 ConfigMap 对象。ConfigMap 对象的<code translate="no">data</code> 部分只包括<strong>Milvus.yaml</strong> 中的配置。要更改<strong>root_coord.yaml</strong> 中的<code translate="no">rootcoord.dmlChannelNum</code> ，必须将<strong>root_coord.yaml</strong>中的参数添加到 ConfigMap YAML 中的<code translate="no">data</code> 部分，并更改特定参数。</p>
<pre><code translate="no">kind: ConfigMap
apiVersion: v1
metadata:
  name: milvus-chaos
  ...
data:
  milvus.yaml: &gt;
    ......
  root_coord.yaml: |
    rootcoord:
      dmlChannelNum: 128
      maxPartitionNum: 4096
      minSegmentSizeToEnableIndex: 1024
      <span class="hljs-built_in">timeout</span>: 3600 <span class="hljs-comment"># time out, 5 seconds</span>
      timeTickInterval: 200 <span class="hljs-comment"># ms</span>
<button class="copy-code-btn"></button></code></pre>
<h3 id="Modify-Deployment-YAML" class="common-anchor-header">修改部署 YAML</h3><p>存储在 ConfigMap 中的数据可以在 configMap 类型的卷中引用，然后由在 pod 中运行的容器化应用程序消耗。要将 pod 引向新的配置文件，必须修改需要加载<strong>root_coord.yaml</strong> 中配置的 pod 模板。具体来说，您需要在部署 YAML 的<code translate="no">spec.template.spec.containers.volumeMounts</code> 部分下添加挂载声明。</p>
<p>以 rootcoord pod 的部署 YAML 为例，在<code translate="no">.spec.volumes</code> 部分指定了名为<strong>milvus-config</strong>的<code translate="no">configMap</code> 类型卷。在<code translate="no">spec.template.spec.containers.volumeMounts</code> 部分，卷被声明为将 Milvus 发行版的 milvus<strong>.yaml</strong>挂载到<strong>/milvus/configs/milvus.yaml 上</strong>。同样，您只需专门为 rootcoord 容器添加一个 mount 声明，将<strong>root_coord.yaml</strong>挂载到<strong>/milvus/configs/advanced/root_coord.yaml</strong> 上，这样容器就能访问新的配置文件了。</p>
<pre><code translate="no" class="language-yaml">spec:
  replicas: 1
  selector:
    ......
  template:
    metadata:
      ...
    spec:
      volumes:
        - name: milvus-config
          configMap:
            name: milvus-chaos
            defaultMode: 420
      containers:
        - name: rootcoord
          image: <span class="hljs-string">&#x27;milvusdb/milvus-dev:master-20210906-86afde4&#x27;</span>
          args:
            ...
          ports:
            ...
          resources: {}
          volumeMounts:
            - name: milvus-config
              readOnly: <span class="hljs-literal">true</span>
              mountPath: /milvus/configs/milvus.yaml
              subPath: milvus.yaml
            - name: milvus-config
              readOnly: <span class="hljs-literal">true</span>
              mountPath: /milvus/configs/advanced/`root_coord.yaml
              subPath: root_coord.yaml
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File
          imagePullPolicy: IfNotPresent
      restartPolicy: Always
      terminationGracePeriodSeconds: 30
      dnsPolicy: ClusterFirst
      securityContext: {}
      schedulerName: default-scheduler
<button class="copy-code-btn"></button></code></pre>
<h3 id="Verify-the-result" class="common-anchor-header">验证结果</h3><p>kubelet 会在每次定期同步时检查挂载的 ConfigMap 是否是新的。当卷中消耗的 ConfigMap 更新时，投影的密钥也会自动更新。当新 pod 再次运行时，您可以验证 pod 中的修改是否成功。下面分享了检查参数<code translate="no">rootcoord.dmlChannelNum</code> 的命令。</p>
<pre><code translate="no" class="language-bash">$ kctl <span class="hljs-built_in">exec</span> -ti milvus-chaos-rootcoord-6f56794f5b-xp2zs -- sh
<span class="hljs-comment"># cd configs/advanced</span>
<span class="hljs-comment"># pwd</span>
/milvus/configs/advanced
<span class="hljs-comment"># ls</span>
channel.yaml  common.yaml  data_coord.yaml  data_node.yaml  etcd.yaml  proxy.yaml  query_node.yaml  root_coord.yaml
<span class="hljs-comment"># cat root_coord.yaml</span>
rootcoord:
  dmlChannelNum: 128
  maxPartitionNum: 4096
  minSegmentSizeToEnableIndex: 1024
  <span class="hljs-built_in">timeout</span>: 3600 <span class="hljs-comment"># time out, 5 seconds</span>
  timeTickInterval: 200 <span class="hljs-comment"># ms</span>
<span class="hljs-comment"># exit</span>
<button class="copy-code-btn"></button></code></pre>
<p>以上就是在 Kubernetes 上部署的 Milvus 中修改高级配置的方法。Milvus 的未来版本将把所有配置整合到一个文件中，并支持通过 Helm 图表更新配置。但在此之前，我希望这篇文章能作为临时解决方案帮到你。</p>
<h2 id="Engage-with-our-open-source-community" class="common-anchor-header">加入我们的开源社区：<button data-href="#Engage-with-our-open-source-community" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p>在<a href="https://bit.ly/307b7jC">GitHub</a> 上查找或为 Milvus 做贡献。</p></li>
<li><p>通过<a href="https://bit.ly/3qiyTEk">论坛</a>与社区互动。</p></li>
<li><p>在<a href="https://bit.ly/3ob7kd8">Twitter</a> 上与我们联系。</p></li>
</ul>


如何修改 Milvus 高级配置

简介

<custom-h1>技术分享：使用Docker Compose在Milvus 2.0上应用配置变更</custom-h1><p><em>贾晶晶，Zilliz 数据工程师，毕业于西安交通大学计算机专业。加入Zilliz后，主要从事数据预处理、AI模型部署、Milvus相关技术研究，以及帮助社区用户实现应用场景。她很有耐心，喜欢与社区伙伴交流，喜欢听音乐和看动漫。</em></p>
<p>作为Milvus的常客，我对新发布的Milvus 2.0 RC非常期待。根据官方网站上的介绍，Milvus 2.0 似乎在很大程度上超越了它的前辈们。我迫不及待地想亲自体验一下。</p>
<p>我确实试了。  然而，当我真正接触到 Milvus 2.0 时，我发现我无法像使用 Milvus 1.1.1 那样轻松地修改 Milvus 2.0 中的配置文件。我无法在使用 Docker Compose 启动的 Milvus 2.0 docker 容器中修改配置文件，甚至强行修改也不会生效。后来，我了解到 Milvus 2.0 RC 在安装后无法检测到配置文件的更改。未来的稳定版将修复这个问题。</p>
<p>在尝试了不同的方法之后，我找到了一种可靠的方法来应用对 Milvus 2.0 单机版和集群版配置文件的更改，具体方法如下。</p>
<p>请注意，必须在使用 Docker Compose 重启 Milvus 之前更改所有配置。</p>
<h2 id="Modify-configuration-file-in-Milvus-standalone" class="common-anchor-header">修改 Milvus 单机版的配置文件<button data-href="#Modify-configuration-file-in-Milvus-standalone" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>首先，你需要<a href="https://github.com/milvus-io/milvus/blob/master/configs/milvus.yaml">下载</a>一份<strong>milvus.yaml</strong>文件到本地设备。</p>
<p>然后，你可以更改文件中的配置。例如，可以将日志格式改为<code translate="no">.json</code>.</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_1_ee4a16a3ee.png" alt="1.1.png" class="doc-image" id="1.1.png" />
   </span> <span class="img-wrapper"> <span>1.1.png</span> </span></p>
<p>修改了<strong>Milvus.yaml</strong>文件后，还需要<a href="https://github.com/milvus-io/milvus/blob/master/deployments/docker/standalone/docker-compose.yml">下载</a>并修改用于独立运行的<strong>docker-compose</strong>.<strong>yaml</strong>文件，将本地到 Milvus.yaml 的路径映射到<code translate="no">volumes</code> 部分下配置文件<code translate="no">/milvus/configs/milvus.yaml</code> 对应的 docker 容器路径上。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_2_5e7c73708c.png" alt="1.2.png" class="doc-image" id="1.2.png" />
   </span> <span class="img-wrapper"> <span>1.2.png</span> </span></p>
<p>最后，使用<code translate="no">docker-compose up -d</code> 启动 Milvus Standalone，检查修改是否成功。例如，运行<code translate="no">docker logs</code> 检查日志格式。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_3_a0406df3ab.png" alt="1.3.png" class="doc-image" id="1.3.png" />
   </span> <span class="img-wrapper"> <span>1.3.png</span> </span></p>
<h2 id="Modify-configuration-file-in-Milvus-cluster" class="common-anchor-header">修改 Milvus 集群的配置文件<button data-href="#Modify-configuration-file-in-Milvus-cluster" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>首先，<a href="https://github.com/milvus-io/milvus/blob/master/configs/milvus.yaml">下载</a>并根据需要修改<strong>milvus.yaml</strong>文件。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_4_758b182846.png" alt="1.4.png" class="doc-image" id="1.4.png" />
   </span> <span class="img-wrapper"> <span>1.4.png</span> </span></p>
<p>然后，你需要<a href="https://github.com/milvus-io/milvus/blob/master/deployments/docker/cluster/docker-compose.yml">下载</a>并修改集群的<strong>docker-compose.yml</strong>文件，将<strong>milvus.yaml</strong>的本地路径映射到所有组件中配置文件的相应路径上，即根坐标、数据坐标、数据节点、查询坐标、查询节点、索引坐标、索引节点和代理。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_5_80e15811b8.png" alt="1.5.png" class="doc-image" id="1.5.png" />
   </span> <span class="img-wrapper"> <span>1.5.png</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_6_b2f3e4e47f.png" alt="1.6.png" class="doc-image" id="1.6.png" />
   </span> <span class="img-wrapper"> <span>1.6.png</span> </span> <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_7_4d1eb5e1e5.png" alt="1.7.png" class="doc-image" id="1.7.png" /></span> <span class="img-wrapper">1 </span>.<span class="img-wrapper">7 </span>.<span class="img-wrapper"> <span>png</span> </span></p>
<p>最后，可以使用<code translate="no">docker-compose up -d</code> 启动 Milvus 集群，检查修改是否成功。</p>
<h2 id="Change-log-file-path-in-configuration-file" class="common-anchor-header">更改配置文件中的日志文件路径<button data-href="#Change-log-file-path-in-configuration-file" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>首先，<a href="https://github.com/milvus-io/milvus/blob/master/configs/milvus.yaml">下载</a> <strong>Milvus.yaml</strong>文件，并将<code translate="no">rootPath</code> 部分修改为你期望在 Docker 容器中存储日志文件的目录。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_8_e3bdc4843f.png" alt="1.8.png" class="doc-image" id="1.8.png" />
   </span> <span class="img-wrapper"> <span>1.8.png</span> </span></p>
<p>之后，为 Milvus<a href="https://github.com/milvus-io/milvus/blob/master/deployments/docker/standalone/docker-compose.yml">单机版</a>或<a href="https://github.com/milvus-io/milvus/blob/master/deployments/docker/cluster/docker-compose.yml">集群</a>下载相应的<strong>docker-compose.yml</strong>文件。</p>
<p>对于单机版，你需要将本地的<strong>milvus.yaml</strong>路径映射到配置文件<code translate="no">/milvus/configs/milvus.yaml</code> 对应的 docker 容器路径上，并将本地的日志文件目录映射到你之前创建的 Docker 容器目录上。</p>
<p>对于集群，你需要在每个组件中映射这两个路径。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_9_22d8929d92.png" alt="1.9.png" class="doc-image" id="1.9.png" />
   </span> <span class="img-wrapper"> <span>1.9.png</span> </span></p>
<p>最后，使用<code translate="no">docker-compose up -d</code> 启动 Milvus Standalone 或集群，查看日志文件是否修改成功。</p>


技术分享：使用 Docker Compose 在 Milvus 2.0 上应用配置更改

<custom-h1>利用 Milvus 向量数据库构建视频分析系统</custom-h1><p><em>陈诗雨，Zilliz 数据工程师，毕业于西安电子科技大学计算机专业。加入Zilliz以来，她一直在探索Milvus在音视频分析、分子式检索等多个领域的解决方案，极大地丰富了社区的应用场景。目前，她正在探索更多有趣的解决方案。业余时间，她喜欢运动和阅读。</em></p>
<p>上周末看《<em>逍遥法外》</em>时，我觉得在哪里见过扮演保安巴迪的演员，但却想不起他的任何作品。我满脑子都是 "这家伙是谁？"我很确定我见过那张脸，却又极力想记起他的名字。类似的情况还有，有一次我看到视频中的男主角在喝一种我以前很喜欢的饮料，但我最终还是想不起品牌名称。</p>
<p>答案就在我的舌尖上，但我的大脑却感觉完全卡住了。</p>
<p>看电影时，舌尖（TOT）现象让我抓狂。要是有一个视频反向图像搜索引擎就好了，它能让我找到视频并分析视频内容。之前，<a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/reverse_image_search/quick_deploy">我用 Milvus</a> 构建了一个<a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/reverse_image_search/quick_deploy">反向图像搜索引擎</a>。考虑到视频内容分析与图像分析有某种相似之处，我决定在 Milvus 的基础上建立一个视频内容分析引擎。</p>
<h2 id="Object-detection" class="common-anchor-header">对象检测<button data-href="#Object-detection" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="Overview" class="common-anchor-header">概述</h3><p>在进行分析之前，首先要检测视频中的物体。有效、准确地检测视频中的物体是这项任务的主要挑战。这也是自动驾驶、可穿戴设备和物联网等应用的一项重要任务。</p>
<p>从传统的图像处理算法发展到深度神经网络（DNN），当今用于物体检测的主流模型包括 R-CNN、FRCNN、SSD 和 YOLO。本专题介绍的基于 milvus 的深度学习视频分析系统可以智能、快速地检测物体。</p>
<h3 id="Implementation" class="common-anchor-header">实施</h3><p>要检测和识别视频中的物体，系统首先要从视频中提取帧，并使用物体检测法检测帧图像中的物体；其次，从检测到的物体中提取特征向量；最后，根据特征向量对物体进行分析。</p>
<ul>
<li>帧提取</li>
</ul>
<p>视频分析通过帧提取转换为图像分析。目前，帧提取技术已经非常成熟。FFmpeg 和 OpenCV 等程序支持以指定间隔提取帧。本文将介绍如何使用 OpenCV 从视频中每秒提取帧。</p>
<ul>
<li>对象检测</li>
</ul>
<p>物体检测是指在提取的帧中查找物体，并根据物体的位置提取其截图。如下图所示，我们检测到了一辆自行车、一条狗和一辆汽车。本主题将介绍如何使用常用于物体检测的 YOLOv3 来检测物体。</p>
<ul>
<li>特征提取</li>
</ul>
<p>特征提取是指将机器难以识别的非结构化数据转换为特征向量。例如，可以利用深度学习模型将图像转换为多维特征向量。目前，最流行的图像识别人工智能模型包括 VGG、GNN 和 ResNet。本主题将介绍如何使用 ResNet-50 从检测到的物体中提取特征。</p>
<ul>
<li>向量分析</li>
</ul>
<p>将提取的特征向量与库向量进行比较，并返回最相似向量的对应信息。对于大规模特征向量数据集来说，计算是一个巨大的挑战。本专题介绍如何使用 Milvus 分析特征向量。</p>
<h2 id="Key-technologies" class="common-anchor-header">关键技术<button data-href="#Key-technologies" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="OpenCV" class="common-anchor-header">OpenCV</h3><p>开源计算机视觉库（OpenCV）是一个跨平台的计算机视觉库，它为图像处理和计算机视觉提供了许多通用算法。OpenCV 常用于计算机视觉领域。</p>
<p>下面的示例展示了如何使用 OpenCV 和 Python 以指定的时间间隔捕获视频帧并将其保存为图像。</p>
<pre><code translate="no" class="language-python"><span class="hljs-keyword">import</span> cv2 
<span class="hljs-built_in">cap</span> = cv2.VideoCapture(file_path)   
framerate = <span class="hljs-built_in">cap</span>.get(cv2.CAP_PROP_FPS)   
allframes = <span class="hljs-type">int</span>(cv2.VideoCapture.get(<span class="hljs-built_in">cap</span>, <span class="hljs-type">int</span>(cv2.CAP_PROP_FRAME_COUNT)))  
success, image = <span class="hljs-built_in">cap</span>.read() 
cv2.imwrite(file_name, image)
<button class="copy-code-btn"></button></code></pre>
<h3 id="YOLOv3" class="common-anchor-header">YOLOv3</h3><p>You Only Look Once, Version 3（YOLOv3 [5]）是近年来提出的一种单阶段物体检测算法。与精度相同的传统物体检测算法相比，YOLOv3 的速度快一倍。本主题中提到的 YOLOv3 是 PaddlePaddle [6] 的增强版。它采用多种优化方法，推理速度更快。</p>
<h3 id="ResNet-50" class="common-anchor-header">ResNet-50</h3><p>ResNet [7] 因其简单实用而成为 2015 年 ILSVRC 图像分类的冠军。作为许多图像分析方法的基础，ResNet 被证明是专门用于图像检测、分割和识别的流行模型。</p>
<h3 id="Milvus" class="common-anchor-header">Milvus</h3><p><a href="https://milvus.io/">Milvus</a>是一个云原生的开源向量数据库，用于管理机器学习模型和神经网络生成的 Embeddings 向量。它广泛应用于计算机视觉、自然语言处理、计算化学、个性化推荐系统等场景。</p>
<p>以下程序介绍了 Milvus 的工作原理。</p>
<ol>
<li>通过使用深度学习模型将非结构化数据转换为特征向量，并导入 Milvus。</li>
<li>Milvus 对特征向量进行存储和索引。</li>
<li>Milvus 返回与用户查询向量最相似的向量。</li>
</ol>
<h2 id="Deployment" class="common-anchor-header">部署<button data-href="#Deployment" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>现在，您对基于 Milvus 的视频分析系统有了一定的了解。如下图所示，系统主要由两部分组成。</p>
<ul>
<li><p>红色箭头表示数据导入过程。使用 ResNet-50 从图像数据集中提取特征向量，并将特征向量导入 Milvus。</p></li>
<li><p>黑色箭头表示视频分析流程。首先，从视频中提取帧并将帧保存为图像。其次，使用 YOLOv3 检测和提取图像中的物体。然后，使用 ResNet-50 从图像中提取特征向量。最后，Milvus 通过相应的特征向量搜索并返回对象信息。</p></li>
</ul>
<p>更多信息，请参阅<a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/video_similarity_search/object_detection">Milvus Bootcamp：视频物体检测系统</a>。</p>
<p><strong>数据导入</strong></p>
<p>数据导入过程非常简单。将数据转换成 2,048 维向量，然后将向量导入 Milvus。</p>
<pre><code translate="no" class="language-python">vector = image_encoder.execute(filename)
entities = [vector]
collection.insert(data=entities)
<button class="copy-code-btn"></button></code></pre>
<p><strong>视频分析</strong></p>
<p>如上所述，视频分析过程包括捕捉视频帧、检测每帧中的物体、从物体中提取向量、用欧氏距离（L2）度量计算向量相似度，以及使用 Milvus 搜索结果。</p>
<pre><code translate="no" class="language-python">images = extract_frame(filename, 1, prefix)   
detector = Detector()   
run(detector, DATA_PATH)       
vectors = get_object_vector(image_encoder, DATA_PATH)
search_params = {<span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;L2&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nprobe&quot;</span>: 10}}
results = collection.search(vectors, param=search_params, <span class="hljs-built_in">limit</span>=10)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Conclusion" class="common-anchor-header">结论<button data-href="#Conclusion" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>目前，80% 以上的数据都是非结构化数据。随着人工智能的快速发展，越来越多的深度学习模型被开发出来用于分析非结构化数据。物体检测和图像处理等技术在学术界和工业界都取得了巨大突破。在这些技术的推动下，越来越多的人工智能平台满足了实际需求。</p>
<p>本专题所讨论的视频分析系统就是利用可以快速分析视频内容的 Milvus 构建的。</p>
<p>作为一个开源向量数据库，Milvus 支持使用各种深度学习模型提取特征向量。Milvus 与 Faiss、NMSLIB 和 Annoy 等库集成，提供了一套直观的 API，支持根据场景切换索引类型。此外，Milvus 还支持标量过滤，提高了召回率和搜索灵活性。Milvus 已应用于图像处理、计算机视觉、自然语言处理、语音识别、推荐系统和新药研发等多个领域。</p>
<h2 id="References" class="common-anchor-header">参考文献<button data-href="#References" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>[1] A. D. Bagdanov、L. Ballan、M. Bertini、A. Del Bimbo。"体育视频数据库中的商标匹配与检索"。多媒体信息检索国际研讨会论文集》，ACM，2007 年。https://www.researchgate.net/publication/210113141_Trademark_matching_and_retrieval_in_sports_video_databases。</p>
<p>[2] J. Kleban, X. Xie, W.-Y.Ma."自然场景中标识检测的空间金字塔挖掘"。IEEE 国际会议，2008 年。https://ieeexplore.ieee.org/document/4607625</p>
<p>[3] R. Boia、C. Florea、L. Florea、R. Dogaru。"使用同构类图进行自然图像中的徽标定位和识别"。机器视觉与应用 27 (2), 2016. https://link.springer.com/article/10.1007/s00138-015-0741-7</p>
<p>[4] R. Boia、C. Florea、L. Florea."用于徽标检测的类原型中的椭圆漂移聚集"。BMVC, 2015. http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=5C87F52DE38AB0C90F8340DFEBB841F7?doi=10.1.1.707.9371&amp;rep=rep1&amp;type=pdf</p>
<p>[5] https://arxiv.org/abs/1804.02767</p>
<p>[6] https://paddlepaddle.org.cn/modelbasedetail/yolov3</p>
<p>[7] https://arxiv.org/abs/1512.03385</p>


对象检测

<custom-h1>Milvus 将参加 2021 黑客节</custom-h1><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Hacktoberfest_89c929cace.png" alt="hacktoberfestCover" class="doc-image" id="hacktoberfestcover" />
   </span> <span class="img-wrapper"> <span>黑客节封面</span> </span></p>
<p><strong>为人工智能应用赋能的向量数据库Milvus今天宣布参加由DigitalOcean主办的第八届年度黑客节（Hacktoberfest）活动！</strong></p>
<p>2014年，DigitalOcean发起了<a href="https://hacktoberfest.digitalocean.com/">Hacktoberfest</a>活动，旨在庆祝开源软件项目。经过多年的发展，该活动的参与者已从数十人稳步增长到数千人。  今年，这项为期一个月的活动有望发展到超过20万名活跃参与者！</p>
<p>从 10 月 1 日开始，从经验丰富的开发人员到学生，从代码新手、技术作家到用户体验设计师，每个人都可以为开源社区做出贡献，发展自己的技能，并赢得限量版礼品等奖励。</p>
<h2 id="Everyone-is-welcome" class="common-anchor-header">欢迎所有人<button data-href="#Everyone-is-welcome" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>为 Milvus 项目做贡献的方式有很多--你不必是代码界的超级明星，也可以做出贡献！事实上，您甚至不需要广泛的背景或一长串技能就能为项目出力。你是一名出色的作家或编辑吗？  你喜欢制作图形或插图吗？  以下是您可以在活动期间做出贡献的几种方式，以及供新贡献者解决的 GitHub "问题 "列表！</p>
<p><a href="https://discuss.milvus.io/t/join-hacktoberfest-2021-with-us/72#how-to-participate-1">点击此处</a>查看详情。</p>
<h2 id="Contribute-get-noticed--earn-swag" class="common-anchor-header">贡献力量，获得关注，赢得礼品<button data-href="#Contribute-get-noticed--earn-swag" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/swag_cae44023e8.png" alt="swag" class="doc-image" id="swag" />
   </span> <span class="img-wrapper"> <span>礼品</span> </span></p>
<p>当然，为开源或开源概念做贡献本质上是利他主义的体现，但一些很酷的礼品也无妨。我们还准备了独家贴纸、T恤、键盘和一架无人机！详情请查看我们的<a href="https://discuss.milvus.io/t/join-hacktoberfest-2021-with-us/72#prizes-8">论坛页面</a>。</p>
<p>DigitalOcean也会为参与者提供礼品，请查看Hacktoberfest官方网站上的规则。</p>
<h2 id="Whats-next" class="common-anchor-header">下一步计划<button data-href="#Whats-next" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p>我们最近举办了一次关于黑客节的虚拟问答电话会议。  您可以<a href="https://www.youtube.com/watch?v=cHjSTEHoiF8">在此</a>查看录音。</p></li>
<li><p>要参加活动，我们建议从我们的 Milvus.io 黑客节页面开始，查看<a href="https://hacktoberfest.com/">"快速入门 "指南</a></p></li>
<li><p>查看我们的<a href="https://github.com/milvus-io">GitHub 仓库</a>（并给我们一颗星）！</p></li>
<li><p>查看我们为参与者精心策划的<a href="https://github.com/milvus-io/milvus/issues?q=is%3Aopen+is%3Aissue+label%3AHacktoberfest">"问题 "</a>列表，帮助您成为摇滚明星！</p></li>
</ul>
<h2 id="Helpful-links" class="common-anchor-header">有用链接<button data-href="#Helpful-links" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p><a href="https://hacktoberfest.com/"><strong>Milvus x Hactoberfest 活动页面</strong></a></p></li>
<li><p><a href="https://discuss.milvus.io/c/hacktoberfest/9"><strong>Milvus 讨论论坛</strong></a>- 加入我们的 Milvus 论坛，了解 Milvus 发布的最新信息，与其他用户互动，并在活动期间提问。</p></li>
<li><p><strong>在<a href="https://twitter.com/milvusio">Twitter</a>上关注我们</strong>，如果您的贡献在活动期间被突出显示，您就可以获得特殊的礼品！</p></li>
</ul>


欢迎所有人

<custom-h1>使用 ONNX 和 Milvus 结合人工智能模型进行图像搜索</custom-h1><p>开放神经网络交换（ONNX）是一种用于表示机器学习模型的开放格式。自 2017 年开源以来，ONNX 已发展成为人工智能的标准，为机器学习和深度学习模型提供了构建模块。ONNX 定义了一种通用文件格式，使人工智能开发人员能够使用各种框架、工具、运行时和编译器来使用模型，有助于提高人工智能界的创新速度。</p>
<p>Milvus 是一个开源向量数据库，具有高度灵活性、可靠性和极快的速度。它支持矢量的添加、删除、更新和近乎实时的搜索。Milvus 拥有一整套直观的应用程序接口，支持多个广泛采用的索引库（如 Faiss、NMSLIB 和 Annoy），简化了特定场景的索引选择。Milvus 使用简单，已在全球数百家组织和机构中得到应用，包括图像、音频和视频搜索、推荐、聊天机器人、新药搜索等。</p>
<p>本文将介绍如何基于 ONNX 和 Milvus 使用多种模型进行图像搜索。它以 VGG16 和 ResNet50 模型为例，利用 ONNX 运行不同的人工智能模型生成特征向量，最后在 Milvus 中执行特征向量检索，返回相似图像。</p>
<h2 id="Process-Models-with-ONNX" class="common-anchor-header">用 ONNX 处理模型<button data-href="#Process-Models-with-ONNX" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>人工智能模型之间可以轻松交换 ONNX 格式。例如，TensorFlow 模型可以转换为 ONNX 格式，并在 Caffe 环境中运行。在本例中，我们将 Keras 框架下预训练的 ResNet50 模型转换为 ONNX 格式，然后调用 ONNX 格式的 VGG16 模型来分析不同的模型。</p>
<pre><code translate="no" class="language-python"><span class="hljs-keyword">from</span> keras.applications.resnet50 <span class="hljs-keyword">import</span> ResNet50
<span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

<span class="hljs-comment"># load keras-resnet50 model and save as a floder</span>
model_resnet50 = ResNet50(include_top=<span class="hljs-literal">False</span>, pooling=<span class="hljs-string">&#x27;max&#x27;</span>, weights=<span class="hljs-string">&#x27;imagenet&#x27;</span>)
tf.saved_model.save(model_resnet50, <span class="hljs-string">&quot;keras_resnet50_model&quot;</span>)

<span class="hljs-comment"># convert resnet50 model to onnx</span>
! python -m tf2onnx.convert --saved-model <span class="hljs-string">&quot;keras_resnet50_model&quot;</span> --output <span class="hljs-string">&quot;onnx_resnet50.onnx&quot;</span>
<button class="copy-code-btn"></button></code></pre>
<p>注：当我们使用接口<code translate="no">keras2onnx.convert_keras(model, model.name)</code> 转换模型时，它会返回错误信息<code translate="no">AttributeError:'KerasTensor' object has no attribute'graph'</code> 。然后，我们可以根据 Stack Overflow 上的解决方案，使用 Python 的 Bash 命令进行转换。</p>
<h2 id="Extract-Feature-Vectors-using-Models" class="common-anchor-header">使用模型提取特征向量<button data-href="#Extract-Feature-Vectors-using-Models" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>将 ResNet50 模型转换为 ONNX 格式后，可以直接通过推理提取图片的特征向量。注意：提取后需要对特征向量进行归一化处理。</p>
<pre><code translate="no" class="language-python"><span class="hljs-comment"># get the image vectors with onnx model</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">get_onnx_vectors</span>(<span class="hljs-params">onnx_model, img_path</span>):
    img = image.load_img(img_path, target_size=(<span class="hljs-number">224</span>, <span class="hljs-number">224</span>))
    x = image.img_to_array(img)
    x = np.expand_dims(x, axis=<span class="hljs-number">0</span>)
    x = preprocess_input(x)
    
    sess = onnxruntime.InferenceSession(onnx_model)
    x = x <span class="hljs-keyword">if</span> <span class="hljs-built_in">isinstance</span>(x, <span class="hljs-built_in">list</span>) <span class="hljs-keyword">else</span> [x]
    feed = <span class="hljs-built_in">dict</span>([(<span class="hljs-built_in">input</span>.name, x[n]) <span class="hljs-keyword">for</span> n, <span class="hljs-built_in">input</span> <span class="hljs-keyword">in</span> <span class="hljs-built_in">enumerate</span>(sess.get_inputs())])
    feat = sess.run(<span class="hljs-literal">None</span>, feed)[<span class="hljs-number">0</span>]
    
    norm_feat = feat[<span class="hljs-number">0</span>] / LA.norm(feat[<span class="hljs-number">0</span>])
    norm_feat = [i.item() <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> norm_feat]
    <span class="hljs-keyword">return</span> norm_feat
<button class="copy-code-btn"></button></code></pre>
<p>使用 ONNX 格式的 VGG16 模型处理图像数据：</p>
<pre><code translate="no" class="language-python"><span class="hljs-comment"># generate vectors with ResNet50 and VGG16 ONNX model</span>
2vec_resnet = get_onnx_vectors(<span class="hljs-string">&quot;onnx_resnet50.onnx&quot;</span>, <span class="hljs-string">&quot;./pic/example.jpg&quot;</span>)
3vec_vgg = get_onnx_vectors(<span class="hljs-string">&quot;onnx_vgg16.onnx&quot;</span>, <span class="hljs-string">&quot;./pic/example.jpg&quot;</span>)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Store-Vector-Data" class="common-anchor-header">存储向量数据<button data-href="#Store-Vector-Data" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>图片等非结构化数据无法直接由计算机处理，但可以通过人工智能模型转换成向量，然后由计算机进行分析。Milvus 向量数据库旨在为海量非结构化数据分析提供动力。它可以存储向量数据，并进行近乎实时的分析。首先，在 Milvus 中创建相应模型的 Collections，然后插入图像向量。</p>
<pre><code translate="no" class="language-python"><span class="hljs-keyword">from</span> milvus <span class="hljs-keyword">import</span> *

<span class="hljs-comment"># create collections in Milvus</span>
milvus.create_collection(resnet_collection_param)
milvus.create_collection(vgg_collection_param)

<span class="hljs-comment"># insert data to Milvus and return ids</span>
status, resnet_ids = milvus.insert(resnet_collection_name, resnet_vectors)
status, vgg_ids = milvus.insert(vgg_collection_name, vgg_vectors)
<button class="copy-code-btn"></button></code></pre>
<p>数据插入成功后，Milvus 会返回向量对应的 ID，然后我们就可以通过 ID 查找图片了。由于本例中使用的 Milvus 1.1 不支持标量过滤（Milvus 2.0 现已支持），因此使用 Redis 来存储向量 ID 和图片路径的键值。</p>
<pre><code translate="no" class="language-python"><span class="hljs-keyword">import</span> redis
<span class="hljs-keyword">def</span> <span class="hljs-title function_">img_ids_to_redis</span>(<span class="hljs-params">img_directory, res_ids</span>):
  <span class="hljs-keyword">for</span> img, ids <span class="hljs-keyword">in</span> <span class="hljs-built_in">zip</span>(images, res_ids):
    redis.<span class="hljs-built_in">set</span>(ids, img)
<button class="copy-code-btn"></button></code></pre>
<h2 id="Search-for-Similar-Images" class="common-anchor-header">搜索相似图片<button data-href="#Search-for-Similar-Images" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>存储数据后，我们可以检索向量。Milvus 支持多种距离计算方法，包括欧氏距离、内积距离和汉明距离。本文的图像相似性搜索采用 Milvus 中向量间的欧氏距离计算，返回相似向量 ID，然后在 Redis 中找到 ID 对应的图像。</p>
<pre><code translate="no" class="language-python"><span class="hljs-comment"># search in Milvus and return the similarly results with ids</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">search_in_milvus</span>(<span class="hljs-params">collection_name, search_vector</span>):
    status, results = milvus.search(collection_name, TOP_K, [search_vector])
    <span class="hljs-built_in">print</span>(status)
    re_ids = [x.<span class="hljs-built_in">id</span> <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> results[<span class="hljs-number">0</span>]]
    re_distance = [x.distance <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> results[<span class="hljs-number">0</span>]]
    <span class="hljs-keyword">return</span> re_ids, re_distance
    
<span class="hljs-comment"># get the images according the result ids</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">get_sim_imgs</span>(<span class="hljs-params">collection_name, search_vector</span>):
    ids, distance = search_in_milvus(collection_name, search_vector)
    img = [red.get(i).decode(<span class="hljs-string">&quot;utf-8&quot;</span>) <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> ids]
    <span class="hljs-keyword">return</span> ids, distance, img
<button class="copy-code-btn"></button></code></pre>
<p>本文以 VGG16 和 ResNet50 模型为例，展示了通过 ONNX 处理多个模型，并将多个模型与 Milvus 结合进行相似向量检索，从而得到相似图像。以上两个模型基于 Keras 框架，可以快速提取特征向量。从 Notebook 中可以看到，虽然 Milvus 基于这两个模型在 COCO 数据集上搜索图片的结果相似，但它们的欧氏距离并不相同。您还可以尝试使用其他数据集来比较这两种模型的搜索结果。</p>
<p>Milvus 是一个高性能、高可用性的向量数据库，可用于处理从海量非结构化数据中生成的特征向量。有关更多解决方案，请参阅<a href="https://github.com/milvus-io/bootcamp">Milvus Bootcamp</a>。</p>
<h2 id="References" class="common-anchor-header">参考资料<button data-href="#References" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ol>
<li>https://github.com/onnx/onnx</li>
<li>https://onnx.ai/</li>
<li>https://milvus.io/cn/</li>
<li>https://github.com/milvus-io/bootcamp</li>
</ol>
<h3 id="About-author" class="common-anchor-header">关于作者</h3><p>陈诗雨，Zilliz数据工程师，毕业于西安电子科技大学计算机专业。加入 Zilliz 后，她一直在探索 Milvus 在各个领域的解决方案，如音视频分析、分子式检索等，极大地丰富了社区的应用场景。目前，她正在探索更多有趣的解决方案。业余时间，她喜欢运动和阅读。</p>


用 ONNX 处理模型

DiskANN，基于磁盘的 ANNS 解决方案，在十亿规模数据集上实现高召回率和高 QPS

项目概述

<custom-h1>基于 Milvus 的 DNA 序列分类</custom-h1><blockquote>
<p>作者：顾梦佳，Zilliz 数据工程师，毕业于麦吉尔大学，获信息学硕士学位。她的兴趣包括人工智能应用和向量数据库的相似性搜索。作为开源项目 Milvus 的社区成员，她提供并改进了多种解决方案，如推荐系统和 DNA 序列分类模型。她喜欢挑战，从不放弃！</p>
</blockquote>
<custom-h1>简介</custom-h1><p>DNA 序列在学术研究和实际应用中都是一个热门概念，如基因溯源、物种鉴定和疾病诊断。各行各业都在渴求更智能、更高效的研究方法，人工智能尤其在生物和医学领域备受关注。越来越多的科学家和研究人员正在为生物信息学中的机器学习和深度学习做出贡献。为了使实验结果更有说服力，一种常见的方法是增加样本量。与基因组学大数据的合作也为现实中的应用案例带来了更多可能性。然而，传统的序列比对有其局限性，<a href="https://www.frontiersin.org/articles/10.3389/fbioe.2020.01032/full#h5">不适合大数据</a>。为了减少现实中的取舍，向量化是 DNA 序列大数据集的一个不错选择。</p>
<p>开源向量数据库<a href="https://milvus.io/docs/v2.0.x/overview.md">Milvus</a>对海量数据非常友好。它能够存储核酸序列的向量，并进行高效检索。它还有助于降低生产或研究成本。基于 Milvus 的 DNA 序列分类系统只需几毫秒就能完成基因分类。此外，它比机器学习中其他常见的分类器显示出更高的准确性。</p>
<custom-h1>数据处理</custom-h1><p>编码遗传信息的基因由一小段 DNA 序列组成，其中包括 4 个核苷酸碱基 [A、C、G、T]。人类基因组中约有 3 万个基因，近 30 亿个 DNA 碱基对，每个碱基对有 2 个对应碱基。为了支持不同的用途，DNA 序列可分为不同的类别。为了降低成本，使长 DNA 序列数据更易于使用，<a href="https://en.wikipedia.org/wiki/K-mer#:~:text=Usually%2C%20the%20term%20k%2Dmer,total%20possible%20k%2Dmers%2C%20where">K-mer </a>被引入到数据预处理中。同时，它使 DNA 序列数据更接近于纯文本。此外，向量化数据还能加快数据分析或机器学习的计算速度。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_a7469e9eac.png" alt="1.png" class="doc-image" id="1.png" />
   </span> <span class="img-wrapper"> <span>1.png</span> </span></p>
<p><strong>k-mer</strong></p>
<p>k-mer 方法常用于 DNA 序列预处理。它从原始序列的每个碱基开始提取长度为 k 的一小段，从而将长度为 s 的长序列转换为长度为 k 的 (s-k+1) 短序列。调整 k 值可以提高模型性能。短序列列表更易于数据读取、特征提取和向量化。</p>
<p><strong>向量化</strong></p>
<p>DNA 序列以文本的形式进行向量化。经过 k-mer 转换的序列会变成短序列列表，看起来就像句子中的单个单词列表。因此，大多数自然语言处理模型也应适用于 DNA 序列数据。类似的方法也可应用于模型训练、特征提取和编码。由于每个模型都有自己的优点和缺点，因此模型的选择取决于数据的特征和研究目的。例如，词袋模型 CountVectorizer 通过直接标记化实现特征提取。它对数据长度没有限制，但返回的结果在相似性比较方面不太明显。</p>
<custom-h1>Milvus 演示</custom-h1><p>Milvus 可以轻松管理非结构化数据，并在平均几毫秒的延迟内从数以万亿计的向量中调出最相似的结果。它的相似性搜索基于近似近邻（ANN）搜索算法。这些亮点使 Milvus 成为管理 DNA 序列向量的最佳选择，从而促进了生物信息学的发展和应用。</p>
<p>下面的演示展示了如何利用 Milvus 建立 DNA 序列分类系统。<a href="https://www.kaggle.com/nageshsingh/dna-sequence-dataset">实验数据集 </a>包括 3 种生物和 7 个基因家族。所有数据都通过 k-mers 转换为短序列列表。然后，系统利用预先训练好的 CountVectorizer 模型，将序列数据编码成向量。下面的流程图描述了系统结构以及插入和搜索过程。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_ebd89660f6.png" alt="1.png" class="doc-image" id="1.png" />
   </span> <span class="img-wrapper"> <span>1.png</span> </span></p>
<p>在<a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/dna_sequence_classification">Milvus 启动营中</a>试用这个演示。</p>
<p>在 Milvus 中，系统创建 Collections 并将 DNA 序列的相应向量插入 Collections（或启用分区）。收到查询请求后，Milvus 将返回输入 DNA 序列向量与数据库中最相似结果之间的距离。输入序列的类别和 DNA 序列之间的相似性可通过结果中的向量距离来确定。</p>
<pre><code translate="no"><span class="hljs-comment"># Insert vectors to Milvus collection (partition &quot;human&quot;)</span>
DNA_human = collection.insert([human_ids, human_vectors], partition_name=<span class="hljs-string">&#x27;human&#x27;</span>)
<span class="hljs-comment"># Search topK results (in partition &quot;human&quot;) for test vectors</span>
res = collection.search(test_vectors, <span class="hljs-string">&quot;vector_field&quot;</span>, search_params, limit=topK, partition_names=[<span class="hljs-string">&#x27;human&#x27;</span>])
<span class="hljs-keyword">for</span> results <span class="hljs-keyword">in</span> res:
    res_ids = results.ids <span class="hljs-comment"># primary keys of topK results</span>
    res_distances = results.distances <span class="hljs-comment"># distances between topK results &amp; search input</span>
<button class="copy-code-btn"></button></code></pre>
<p><strong>DNA 序列分类</strong>在 Milvus 中搜索最相似的 DNA 序列可以暗示未知样本的基因家族，从而了解其可能的功能。<a href="https://www.nature.com/scitable/topicpage/gpcr-14047471/"> 如果某个序列被归类为 GPCR，那么它很可能对人体功能有影响。 </a>在这个演示中，Milvus 成功地使系统识别了所搜索的人类 DNA 序列的基因家族。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/3_1616da5bb0.png" alt="3.png" class="doc-image" id="3.png" />
   </span> <span class="img-wrapper"> <span>3.png</span> </span> <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/4_d719b22fc7.png" alt="4.png" class="doc-image" id="4.png" /><span>4.png</span> </span></p>
<p><strong>基因相似性</strong></p>
<p>生物体之间的平均 DNA 序列相似度说明了它们的基因组之间有多接近。该演示分别在人类数据中搜索与黑猩猩和狗最相似的 DNA 序列。然后计算并比较平均内积距离（黑猩猩为 0.97，狗为 0.70），证明黑猩猩与人类共享的相似基因多于狗。有了更复杂的数据和系统设计，Milvus 能够支持更高层次的基因研究。</p>
<pre><code translate="no">search_params = {<span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;IP&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nprobe&quot;</span>: <span class="hljs-number">20</span>}}
<button class="copy-code-btn"></button></code></pre>
<p><strong>性能</strong></p>
<p>演示用 80% 的人类样本数据（共 3629 个）训练分类模型，并将剩余数据作为测试数据。它比较了使用 Milvus 的 DNA 序列分类模型与使用 Mysql 和 5 种常用机器学习分类器的模型的性能。基于 Milvus 的模型在准确性上优于同类产品。</p>
<pre><code translate="no"><span class="hljs-keyword">from</span> sklearn.<span class="hljs-property">model_selection</span> <span class="hljs-keyword">import</span> train_test_split
X, y = human_sequence_kmers, human_labels
X_train, X_test, y_train, y_test = <span class="hljs-title function_">train_test_split</span>(X, y, test_size=<span class="hljs-number">0.2</span>, random_state=<span class="hljs-number">42</span>)
<button class="copy-code-btn"></button></code></pre>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_6541a7dec6.png" alt="1.png" class="doc-image" id="1.png" />
   </span> <span class="img-wrapper"> <span>1.png</span> </span></p>
<custom-h1>进一步探索</custom-h1><p>随着大数据技术的发展，DNA序列的向量化将在基因研究和实践中发挥更加重要的作用。结合生物信息学的专业知识，相关研究可以进一步受益于 DNA 序列向量化的参与。因此，Milvus 可以在实践中呈现更好的效果。根据不同的场景和用户需求，Milvus 驱动的相似性搜索和距离计算显示出巨大的潜力和多种可能性。</p>
<ul>
<li><strong>研究未知序列</strong>：<a href="https://iopscience.iop.org/article/10.1088/1742-6596/1453/1/012071/pdf">一些研究人员认为，向量化可以压缩 DNA 序列数据。</a>同时，研究未知 DNA 序列的结构、功能和进化所需的工作量也更少。Milvus 可以存储和检索大量的 DNA 序列向量，而不会失去准确性。</li>
<li><strong>适应设备</strong>：受限于传统的序列比对算法，相似性搜索几乎无法从设备<a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7884812/">（</a><a href="https://mjeer.journals.ekb.eg/article_146090.html">CPU</a><a href="https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7884812/">/GPU</a>）的改进中获益。Milvus 既支持普通 CPU 计算，也支持 GPU 加速，通过近似近邻算法解决了这一问题。</li>
<li><strong>检测病毒并追踪来源</strong>：<a href="https://www.nature.com/articles/s41586-020-2012-7?fbclid=IwAR2hxnXb9nLWgA8xexEoNrCNH8WHqvHhhbN38aSm48AaH6fTzGMB1BLljf4">科学家们比较了基因组序列，发现可能源自蝙蝠的 COVID19 病毒属于 SARS-COV</a>。根据这一结论，研究人员可以扩大样本量，以获得更多证据和模式。</li>
<li><strong>诊断疾病</strong>：在临床上，医生可以比较患者和健康人群的 DNA 序列，找出导致疾病的变异基因。可以通过适当的算法提取特征并对这些数据进行编码。Milvus 能够返回向量之间的距离，这些距离可以与疾病数据相关联。除了辅助疾病诊断，该应用还有助于启发<a href="https://www.frontiersin.org/articles/10.3389/fgene.2021.680117/full">靶向治疗</a>的研究。</li>
</ul>
<custom-h1>进一步了解 Milvus</custom-h1><p>Milvus 是一款强大的工具，能够为大量人工智能和向量相似性搜索应用提供动力。要了解有关该项目的更多信息，请查看以下资源：</p>
<ul>
<li>阅读我们的<a href="https://milvus.io/blog">博客</a>。</li>
<li>在<a href="https://milvusio.slack.com/join/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ#/shared-invite/email">Slack</a> 上与我们的开源社区互动。</li>
<li>在<a href="https://github.com/milvus-io/milvus/">GitHub</a> 上使用或贡献世界上最流行的向量数据库。</li>
<li>使用我们的新<a href="https://github.com/milvus-io/bootcamp">启动训练营</a>快速测试和部署人工智能应用。</li>
</ul>


基于 Milvus 的 DNA 序列分类

<custom-h1>论文阅读 ｜ HM-ANN：当ANNS遇到异质内存</custom-h1><p><a href="https://proceedings.neurips.cc/paper/2020/file/788d986905533aba051261497ecffcbb-Paper.pdf">HM-ANN: Efficient Billion-Point Nearest Neighbor Search on Heterogenous Memory</a>》是一篇被2020年神经信息处理系统会议<a href="https://nips.cc/Conferences/2020">（NeurIPS 2020</a>）录用的研究论文。本文提出了一种基于图的相似性搜索新算法，称为 HM-ANN。该算法同时考虑了现代硬件环境下的内存异构性和数据异构性。HM-ANN 无需压缩技术就能在单台机器上实现十亿规模的相似性搜索。异构内存（HM）是速度快但容量小的动态随机存取内存（DRAM）和速度慢但容量大的持久内存（PMem）的结合。HM-ANN 实现了较低的搜索延迟和较高的搜索精度，尤其是当数据集无法放入 DRAM 时。与最先进的近似近邻（ANN）搜索解决方案相比，该算法具有明显优势。</p>
<custom-h1>研究动机</custom-h1><p>由于 DRAM 容量有限，ANN 搜索算法从一开始就在查询准确性和查询延迟之间进行了根本性的权衡。要在 DRAM 中存储索引以实现快速查询访问，就必须限制数据点的数量或存储压缩向量，而这两者都会损害搜索精度。基于图形的索引（如分层导航小世界，HNSW）在查询运行时性能和查询准确性方面更胜一筹。不过，在十亿规模的数据集上操作时，这些索引也会消耗 1-TiB 级别的 DRAM。</p>
<p>还有其他变通方法可以避免让 DRAM 以原始格式存储十亿规模的数据集。当数据集过大，单机内存无法容纳时，就会使用压缩方法，例如对数据集的点进行乘积量化。但由于量化过程中会损失精确度，使用压缩数据集的这些索引的召回率通常很低。Subramanya 等人[1]探索利用固态硬盘（SSD），通过一种名为 "Disk-ANN "的方法，在一台机器上实现十亿规模的 ANN 搜索，其中原始数据集存储在 SSD 上，压缩表示存储在 DRAM 上。</p>
<custom-h1>异构内存简介</custom-h1><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/image_32_d26cfa9480.png" alt="1.png" class="doc-image" id="1.png" />
   </span> <span class="img-wrapper"> <span>1.png</span> </span></p>
<p>异构存储器（HM）是速度快但容量小的 DRAM 和速度慢但容量大的 PMem 的组合。DRAM 是每个现代服务器中都有的普通硬件，其访问速度相对较快。新的 PMem 技术（如英特尔® Optane™ DC 持久内存模块）弥补了基于 NAND 闪存（固态硬盘）和 DRAM 之间的差距，消除了 I/O 瓶颈。PMem 像固态硬盘一样耐用，像内存一样可由 CPU 直接寻址。Renen 等人[2]发现，在配置的实验环境中，PMem 的读取带宽比 DRAM 低 2.6 倍，写入带宽低 7.5 倍。</p>
<custom-h1>HM-ANN 设计</custom-h1><p>HM-ANN 是一种精确、快速的十亿尺度 ANN 搜索算法，无需压缩即可在单机上运行。HM-ANN 的设计概括了 HNSW 的理念，其分层结构与 HM 自然契合。HNSW 由多层组成--只有第 0 层包含整个数据集，其余每一层都包含其下一层的元素子集。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_25a1836e8b.png" alt="2.png" class="doc-image" id="2.png" />
   </span> <span class="img-wrapper"> <span>2.png</span> </span></p>
<ul>
<li>上层的元素只包含数据集的子集，只占用整个存储空间的一小部分。这一观察结果使它们成为放置在 DRAM 中的合适候选对象。这样，HM-ANN 上的大部分搜索都将发生在上层，从而最大限度地利用 DRAM 的快速访问特性。然而，在 HNSW 的情况下，大部分搜索发生在底层。</li>
<li>最底层承载着整个数据集，因此适合放在 PMem 中。 由于访问第 0 层的速度较慢，因此最好每次查询只访问一小部分，并降低访问频率。</li>
</ul>
<h2 id="Graph-Construction-Algorithm" class="common-anchor-header">图构建算法<button data-href="#Graph-Construction-Algorithm" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/3_dd9627c753.png" alt="3.png" class="doc-image" id="3.png" />
   </span> <span class="img-wrapper"> <span>3.png</span> </span></p>
<p>HM-ANN 构建的关键思路是创建高质量的上层，以便为第 0 层的搜索提供更好的导航。 因此，大部分内存访问发生在 DRAM 中，而 PMem 中的访问则会减少。为了实现这一点，HM-ANN 的构建算法分为自上而下的插入阶段和自下而上的提升阶段。</p>
<p>自上而下的插入阶段在最底层放置到 PMem 上时，构建一个可导航的小世界图。</p>
<p>自下而上的提升阶段则在不损失太多精度的情况下，从底层提升枢轴点，形成放置在 DRAM 上的上层。如果在第 1 层创建了第 0 层元素的高质量投影，那么第 0 层的搜索只需几跳就能找到查询的精确近邻。</p>
<ul>
<li>HM-ANN 不使用 HNSW 的随机选择晋升，而是使用高度数晋升策略，将第 0 层中度数最高的元素晋升到第 1 层。对于更高的层，HM-ANN 会根据晋升率将高程度节点晋升到上一层。</li>
<li>HM-ANN 将更多节点从第 0 层提升到第 1 层，并为第 1 层的每个元素设置更大的最大邻居数。上层的节点数由可用的 DRAM 空间决定。由于第 0 层不存储在 DRAM 中，因此增加存储在 DRAM 中的每一层的密度可以提高搜索质量。</li>
</ul>
<h2 id="Graph-Seach-Algorithm" class="common-anchor-header">图搜索算法<button data-href="#Graph-Seach-Algorithm" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/4_a5a7f29c93.png" alt="4.png" class="doc-image" id="4.png" />
   </span> <span class="img-wrapper"> <span>4.png</span> </span></p>
<p>搜索算法包括两个阶段：快速内存搜索和带预取功能的并行 0 层搜索。</p>
<h3 id="Fast-memory-search" class="common-anchor-header">快速内存搜索</h3><p>与 HNSW 相同，DRAM 中的搜索从最顶层的入口点开始，然后从顶层到第 2 层执行 1-greedy 搜索。为了缩小第 0 层的搜索空间，HM-ANN 在第 1 层执行搜索，搜索预算为<code translate="no">efSearchL1</code> ，这限制了第 1 层候选列表的大小。而 HNSW 只使用一个入口点，因此 HM-ANN 对 0 层和 1 层之间的间隙处理得比其他两层之间的间隙更特殊。</p>
<h3 id="Parallel-layer-0-search-with-prefetching" class="common-anchor-header">带有预取功能的第 0 层并行搜索</h3><p>在底层，HM-ANN 将上述来自第 1 层搜索的候选者平均分配，并将其视为入口点，用线程执行并行多起始 1 贪婪搜索。每次搜索的前几名候选者会被收集起来，以找到最佳候选者。众所周知，从第 1 层向下搜索到第 0 层正好是进入 PMem，并行搜索隐藏了 PMem 的延迟，并充分利用了内存带宽，从而在不增加搜索时间的情况下提高了搜索质量。</p>
<p>HM-ANN 在 DRAM 中实现了一个软件管理的缓冲区，以便在内存访问之前从 PMem 中预取数据。在搜索第 1 层时，HM-ANN 会异步将<code translate="no">efSearchL1</code> 中候选元素的邻近元素和第 1 层中邻近元素的连接从 PMem 复制到缓冲区。在第 0 层搜索时，部分待访问数据已经预置在 DRAM 中，从而隐藏了访问 PMem 的延迟，缩短了查询时间。这符合 HM-ANN 的设计目标，即大部分内存访问发生在 DRAM 中，减少 PMem 中的内存访问。</p>
<custom-h1>评估</custom-h1><p>本文进行了广泛的评估。所有实验均在装有 Intel Xeon Gold 6252 CPU@2.3GHz 的机器上进行。它使用 DDR4（96GB）作为快速内存，Optane DC PMM（1.5TB）作为慢速内存。评估了五个数据集：BIGANN、DEEP1B、SIFT1M、DEEP1M 和 GIST1M。十亿量级测试包括以下方案：基于十亿量级量化的方法（IMI+OPQ 和 L&amp;C）、基于非压缩的方法（HNSW 和 NSG）。</p>
<h2 id="Billion-scale-algorithm-comparison" class="common-anchor-header">十亿尺度算法比较<button data-href="#Billion-scale-algorithm-comparison" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/5_4297db66a9.png" alt="5.png" class="doc-image" id="5.png" />
   </span> <span class="img-wrapper"> <span>5.png</span> </span></p>
<p>表 1 比较了不同基于图的索引的构建时间和存储量。HNSW 的构建时间最短，HM-ANN 比 HNSW 多花 8%的时间。在整个存储使用方面，HM-ANN 索引比 HSNW 大 5-13%，因为它将更多节点从 0 层提升到了 1 层。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/6_f363e64d3f.png" alt="6.png" class="doc-image" id="6.png" />
   </span> <span class="img-wrapper"> <span>6.png</span> </span></p>
<p>图 1 分析了不同索引的查询性能。图 1(a)和(b)显示，HM-ANN 在 1 毫秒内实现了 &gt; 95% 的前 1 级召回率。图 1 © 和 (d) 显示，HM-ANN 在 4 毫秒内获得了 &gt; 90% 的前 100 条召回率。与其他所有方法相比，HM-ANN 的延迟与召回率性能最佳。</p>
<h2 id="Million-scale-algorithm-comparison" class="common-anchor-header">百万级别算法比较<button data-href="#Million-scale-algorithm-comparison" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/7_a5c23de240.png" alt="7.png" class="doc-image" id="7.png" />
   </span> <span class="img-wrapper"> <span>7.png</span> </span></p>
<p>图 2 分析了纯 DRAM 设置下不同索引的查询性能。HNSW、NSG 和 HM-ANN 利用 DRAM 中的三个百万级别数据集进行了评估。HM-ANN 的查询性能仍然优于 HNSW。原因在于，要达到 99% 的召回率目标，HM-ANN 的距离计算总数（平均 850 次/查询）低于 HNSW（平均 900 次/查询）。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/image_33_f99d31f322.png" alt="8.png" class="doc-image" id="8.png" />
   </span> <span class="img-wrapper"> <span>8.png</span> </span></p>
<h2 id="Effectiveness-of-high-degree-promotion" class="common-anchor-header">高阶推广的效果<button data-href="#Effectiveness-of-high-degree-promotion" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>图 3 比较了相同配置下的随机推广和高程度推广策略。百度推广的效果优于基线推广。在达到 95%、99% 和 99.5% 的召回目标时，高程度推广的速度分别是随机推广的 1.8 倍、4.3 倍和 3.9 倍。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/image_34_3af47e0842.png" alt="10.png" class="doc-image" id="10.png" />
   </span> <span class="img-wrapper"> <span>10.png</span> </span></p>
<h2 id="Performance-benefit-of-memory-management-techniques" class="common-anchor-header">内存管理技术的性能优势<button data-href="#Performance-benefit-of-memory-management-techniques" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>图 5 包含 HNSW 和 HM-ANN 之间的一系列步骤，以显示 HM-ANN 的每项优化是如何促进其改进的。BP 代表建立索引时的自下而上推广。PL0 代表并行 0 层搜索，而 DP 代表从 PMem 到 DRAM 的数据预取。HM-ANN 的搜索性能一步步得到提升。</p>
<custom-h1>结论</custom-h1><p>一种名为 HM-ANN 的新型基于图的索引和搜索算法，将基于图的 ANN 的分层设计与 HM 的内存异构性相映射。评估表明，HM-ANN 在十亿点数据集中属于最先进的新索引。</p>
<p>我们注意到学术界和工业界都在关注在持久存储设备上建立索引的趋势。为了减轻 DRAM 的压力，Disk-ANN [1] 是一种建立在 SSD 上的索引，其吞吐量明显低于 PMem。 然而，HM-ANN 的建立仍然需要数天时间，与 Disk-ANN 相比没有巨大差异。我们相信，如果我们能更谨慎地利用 PMem 的特性，例如注意 PMem 的粒度（256 字节）和使用流指令绕过缓存线，就有可能优化 HM-ANN 的构建时间。我们还相信，未来会有更多使用耐用存储设备的方法被提出。</p>
<custom-h1>参考文献</custom-h1><p>[1]:Suhas Jayaram Subramanya and Devvrit and Rohan Kadekodi and Ravishankar Krishaswamy and Ravishankar Krishaswamy：DiskANN：单节点快速精确的十亿点近邻搜索，NIPS，2019</p>
<p><a href="https://www.microsoft.com/en-us/research/publication/diskann-fast-accurate-billion-point-nearest-neighbor-search-on-a-single-node/">DiskANN：在单节点上实现快速精确的十亿点近邻搜索 - 微软研究院</a></p>
<p><a href="https://papers.nips.cc/paper/2019/hash/09853c7fb1d3f8ee67a61b6bf4a7f8e6-Abstract.html">DiskANN：单节点上的快速精确十亿点近邻搜索</a></p>
<p>[2]:Alexander van Renen 和 Lukas Vogel 和 Viktor Leis 和 Thomas Neumann 和 Alfons Kemper：Persistent Memory I/O Primitives, CoRR &amp; DaMoN, 2019</p>
<p><a href="https://dl.acm.org/doi/abs/10.1145/3329785.3329930">https://dl.acm.org/doi/abs/10.1145/3329785.3329930</a></p>
<p><a href="https://arxiv.org/abs/1904.01614">持久内存 I/O 基元</a></p>


论文阅读｜HM-ANN 当 ANNS 遇到异构存储器

<custom-h1>Milvus 2.0：重新定义向量数据库</custom-h1><p>2018 年 10 月，我们为 Milvus 写下第一行代码，这一切恍如昨日。2021 年 3 月，在经过全球 1000 多位用户测试的 19 次迭代后，我们推出了 Milvus 1.0，这是我们第一个获得长期支持的正式版本。作为全球最受欢迎的开源向量数据库，Milvus 1.0 成功解决了向量管理中的一些基本问题，如 CRUD 操作和数据持久性。然而，随着新场景和新需求的出现，我们开始意识到还有很多问题有待解决。本文回顾了我们在过去三年中的观察结果、Milvus 2.0 预计要解决的挑战，以及 Milvus 2.0 被认为是解决这些挑战的更好方案的原因。 要了解有关 Milvus 2.0 的更多信息，请查阅 Milvus 2.<a href="https://milvus.io/docs/v2.0.x/release_notes.md">0 发行说明</a>。</p>
<h2 id="Challenges-Milvus-1x-is-faced-with" class="common-anchor-header">Milvus 1.x 面临的挑战<button data-href="#Challenges-Milvus-1x-is-faced-with" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p><strong>数据孤岛：</strong>Milvus 1.0 只能处理非结构化数据生成的向量嵌入，对标量查询几乎不提供支持。其设计中对数据存储的分解导致数据重复，增加了应用程序开发的复杂性，而向量和标量数据之间的混合搜索由于缺乏统一的优化器，效果并不理想。</p>
<p><strong>及时性与效率之间的两难选择：</strong>Milvus 1.0 是一个接近实时的系统，它依靠定期或强制刷新来保证数据的可见性。这种方法在多个层面上增加了流数据处理的复杂性和不确定性。此外，虽然这种批量插入的方法据说可以提高处理效率，但仍然会消耗大量资源。因此，需要采用批量加载方法。</p>
<p><strong>缺乏可扩展性和弹性：</strong>Milvus 1.0 依赖分片中间件解决方案 Mishards 实现可扩展性，并依赖网络附加存储（NAS）实现数据持久性。这种建立在共享存储基础上的经典架构对整体可扩展性贡献不大，原因如下：</p>
<ol>
<li>Mishards 只支持一个写节点，无法扩展。</li>
<li>Mishards 中读取节点的扩展是通过基于哈希的一致路由来实现的。虽然一致散列很容易实现，也有助于解决数据分布均匀性的问题，但它在数据调度方面不够灵活，无法解决数据大小与计算能力不匹配的问题。</li>
<li>Milvus 1.0 依赖 MySQL 来管理元数据，但 Standalone MySQL 服务器能够处理的查询和数据集大小相当有限。</li>
</ol>
<p><strong>缺乏高可用性：</strong>我们的一个观察结果是，Milvus 的大多数用户都倾向于可用性而非一致性，而 Milvus 1.x 缺乏内存复制和灾难恢复等能力，在高可用性方面不太达标。因此，我们正在探索牺牲一定程度的准确性来实现更高可用性的可能性。</p>
<p><strong>成本过高：</strong>Milvus 1.0 依赖 NAS 进行数据持久化，其成本通常是本地存储或对象存储的十倍。由于向量搜索严重依赖计算资源和内存，其高昂的成本很可能成为进一步探索大规模数据集或复杂业务场景的障碍。</p>
<p><strong>不直观的用户体验：</strong></p>
<ol>
<li>复杂的分布式部署会产生高昂的操作符。</li>
<li>没有精心设计的图形用户界面（GUI）。</li>
<li>不直观的应用程序接口已成为开发应用程序的阻力。</li>
</ol>
<p>是继续使用补丁，还是从头开始，这是一个大问题。Milvus 之父 Charles Xie 认为，正如许多传统汽车制造商永远无法逐步转向特斯拉一样，Milvus 要想蓬勃发展，就必须成为非结构化数据处理和分析领域的游戏规则改变者。正是这种信念促使我们启动了Milvus 2.0，一个经过重构的云原生向量数据库。</p>
<h2 id="The-Making-of-Milvus-20" class="common-anchor-header">Milvus 2.0 的制作过程<button data-href="#The-Making-of-Milvus-20" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="Design-principles" class="common-anchor-header">设计原则</h3><p>作为我们的下一代云原生向量数据库，Milvus 2.0 围绕以下三个原则构建：</p>
<p><strong>云原生优先：</strong>我们认为，只有支持存储和计算分离的架构才能按需扩展，并充分利用云的弹性优势。我们还想提请大家注意 Milvus 2.0 的微服务设计，其特点是读写分离，增量数据和历史数据分离，CPU 密集型、内存密集型和 IO 密集型任务分离。微服务有助于为不断变化的异构工作负载优化资源分配。</p>
<p><strong>日志即数据：</strong>在 Milvus 2.0 中，日志代理是系统的主干：所有数据插入和更新操作都必须通过日志代理，工作节点通过订阅和消费日志来执行 CRUD 操作。这种设计将数据持久性和闪回等核心功能下移到存储层，从而降低了系统的复杂性，而日志发布子（log pub-sub）则使系统更加灵活，更适合未来的扩展。</p>
<p><strong>统一的批处理和流处理：</strong>Milvus 2.0 实现了统一的 Lambda 架构，整合了增量数据和历史数据的处理。与 Kappa 架构相比，Milvus 2.0 引入了日志回填功能，将日志快照和索引存储在对象存储中，提高了故障恢复效率和查询性能。为了将无界（流）数据分解为有界窗口，Milvus 采用了新的水印机制，按照写入时间或事件时间将流数据切分成多个消息包，并维护时间轴供用户按时间查询。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_0_image_1_59d7316324.png" alt="2.0 image 1.png" class="doc-image" id="2.0-image-1.png" />
   </span> <span class="img-wrapper"> <span>2.0 图片 1.png</span> </span></p>
<h3 id="System-architecture" class="common-anchor-header">系统架构</h3><p>如上所述，Milvus 2.0 的设计严格遵循存储与计算分离、控制面与数据面分离的原则。系统分为四层：访问层、协调者服务、工作节点和存储。</p>
<p><strong>访问层：</strong>接口：访问层是系统的前端层，也是用户的终端。它负责转发请求和收集结果。</p>
<p><strong>协调器服务：</strong>协调器服务为工作节点分配任务，是系统的大脑。协调器有四种类型：根协调器（root coordinator）、数据协调器（data coordinator）、查询协调器（query coordinator）和索引协调器（index coordinator）。</p>
<p><strong>工作节点：</strong>手臂和腿。工作节点是哑执行器，它们遵从协调器服务的指令，并响应访问层的读/写请求。有三种类型的工作节点：数据节点、查询节点和索引节点。</p>
<p><strong>存储：</strong>骨架。存储有三种类型：元存储、日志代理和对象存储。</p>
<ul>
<li>元存储由 etcd 实现，用于存储协调器服务的 Collections 和检查点等元数据。</li>
<li>日志代理由 Pulsar 实现，主要用于存储增量日志和实现可靠的异步通知。</li>
<li>对象存储由 MinIO 或 S3 实现，主要用于存储日志快照和索引文件。</li>
</ul>
<p>以下是 Milvus 2.0 的系统架构图：<span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_0_image_2_2cc7d7fc9c.png" alt="2.0 image 2.png" class="doc-image" id="2.0-image-2.png" />2.0 image 2.png </span></p>
<h3 id="Key-features" class="common-anchor-header">主要特点</h3><p>数据库的运行成本不仅涉及运行时的资源消耗，还包括潜在的学习成本和操作维护成本。实际上，数据库越方便用户使用，就越有可能节省这些潜在成本。从 Milvus 发布日历的第一天起，易用性就一直被放在我们的首要位置，而最新的 Milvus 2.0 在降低这些成本方面也有不少亮点。</p>
<h4 id="Always-online" class="common-anchor-header">始终在线</h4><p>数据可靠性和服务可持续性是数据库的基本要求，我们的策略是 &quot;低故障、小故障、常故障&quot;。</p>
<ul>
<li>"廉价故障 "指的是存储和计算分离，这使得节点故障恢复的处理简单易行、成本低廉。</li>
<li>"小故障 "指的是 "分而治之 "策略，即让每个协调器服务只处理一小部分读/写/增量/历史数据，从而简化设计的复杂性。</li>
<li>"经常失败 "指的是引入混沌测试，即在测试环境中使用故障注入来模拟硬件故障和依赖性失效等情况，从而加速错误发现。</li>
</ul>
<h4 id="Hybrid-search-between-scalar-and-vector-data" class="common-anchor-header">标量数据和向量数据之间的混合搜索</h4><p>为了发挥结构化数据和非结构化数据之间的协同作用，Milvus 2.0 同时支持标量数据和向量数据，并实现了它们之间的混合搜索。混合搜索可帮助用户找到符合筛选条件的近似近邻。目前，Milvus 支持关系操作，如 EQUAL、GREATER THAN 和 LESS THAN，以及逻辑操作，如 NOT、AND、OR 和 IN。</p>
<h4 id="Tunable-consistency" class="common-anchor-header">可调整的一致性</h4><p>作为一个遵守 PACELC 定理的分布式数据库，Milvus 2.0 必须在一致性与可用性和延迟之间进行权衡。在大多数情况下，在生产中过分强调数据一致性可能会矫枉过正，因为允许一小部分数据不可见对整体召回影响不大，但却能显著提高查询性能。尽管如此，我们仍然认为，<em>强、有界僵化和会话</em>等一致性级别都有其独特的应用。因此，Milvus 支持请求级别的可调一致性。以测试为例，用户可能需要<em>强</em>一致性来确保测试结果绝对正确。</p>
<h4 id="Time-travel" class="common-anchor-header">时间旅行</h4><p>数据工程师经常需要进行数据回滚，以修复脏数据和代码错误。传统数据库通常通过快照甚至数据重整来实现数据回滚。这可能会带来过高的开销和维护成本。Milvus 为所有数据插入和删除操作维护时间轴，用户可以在查询中指定时间戳，以检索指定时间点的数据视图。通过时间旅行，Milvus 还能实现轻量级数据备份或数据克隆。</p>
<h4 id="ORM-Python-SDK" class="common-anchor-header">对象关系映射（ORM）Python SDK</h4><p>对象关系映射（ORM）允许用户更多关注上层业务模型，而不是底层数据模型，使开发人员更容易管理 Collections、字段和程序之间的关系。为了缩小人工智能算法的概念验证（PoC）与生产部署之间的差距，我们设计了 PyMilvus ORM API，它可以与嵌入式库、独立部署、分布式集群甚至云服务协同工作。通过一套统一的 API，我们为用户提供了一致的用户体验，并降低了代码迁移或调整成本。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_0_image_3_55394d6e80.png" alt="2.0 image 3.png" class="doc-image" id="2.0-image-3.png" />
   </span> <span class="img-wrapper"> <span>2.0 图像 3.png</span> </span></p>
<h4 id="Supporting-tools" class="common-anchor-header">支持工具</h4><ul>
<li>Milvus Insight 是 Milvus 的图形用户界面，提供集群状态管理、元管理和数据查询等实用功能。Milvus Insight 的源代码也将作为独立项目开源。我们正在寻找更多的贡献者加入这一行列。</li>
<li>开箱即用的体验（OOBE），更快的部署：Milvus 2.0 可以使用 Helm 或 docker-compose 进行部署。</li>
<li>Milvus 2.0 使用开源时间序列数据库 Prometheus 来存储性能和监控数据，并使用开放式可观察性平台 Grafana 来实现指标可视化。</li>
</ul>
<h2 id="Looking-to-the-future" class="common-anchor-header">展望未来<button data-href="#Looking-to-the-future" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>回顾过去，我们认为基于大数据+人工智能应用的系统架构过于复杂。如何让 Milvus 更好用，一直是 Milvus 社区的首要任务。今后，Milvus 项目将重点关注以下几个方面：</p>
<p><strong>DB for AI：</strong>除了基本的 CRUD 功能外，Milvus 作为一个数据库系统，还需要有更智能的查询优化器、更强大的数据查询功能和更全面的数据管理功能。我们下一阶段的工作重点将放在 Milvus 2.0 中尚未提供的数据操作语言（DML）功能和数据类型上，包括增加删除和更新操作、支持字符串数据类型等。</p>
<p><strong>DB 的人工智能：</strong>对索引类型、系统配置、用户工作量和硬件类型等参数进行旋钮式调整会使 Milvus 的使用复杂化，应尽量避免。我们已着手分析系统负载和收集数据的访问频率，并计划在未来引入自动调整功能，以降低学习成本。</p>
<p><strong>成本优化：</strong>向量检索面临的最大挑战是需要在有限的时间内处理大规模数据集。这既是 CPU 密集型的，也是内存密集型的。在物理层引入 GPU 和 FPGA 异构硬件加速可以大大降低 CPU 的开销。我们还在开发一种磁盘和内存混合 ANN 索引算法，以便在内存有限的情况下实现海量数据集的高性能查询。更重要的是，我们正在评估 ScaNN 和 NGT 等现有开源向量索引算法的性能。</p>
<p><strong>易用性：</strong>Milvus 通过提供集群管理工具、多种语言的 SDK、部署工具、操作符工具等，不断提高其易用性。</p>
<p>要了解有关 Milvus 发布计划的更多信息，请查看<a href="https://milvus.io/docs/v2.0.x/roadmap.md">Milvus 路线图</a>。</p>
<p>感谢所有 Milvus 社区贡献者，没有他们就没有 Milvus 2.0。欢迎向 Milvus 社区<a href="https://github.com/milvus-io/milvus">提交问题</a>或<a href="https://github.com/milvus-io/milvus">贡献您的代码</a>！</p>
<p><br/></p>
<p><em>关于作者</em></p>
<p><em>栾晓帆现任 Zilliz 工程总监，负责 Milvus 项目的研发工作。他拥有 7 年的工作经验，专注于构建数据库/存储系统。从康奈尔大学毕业后，他曾先后就职于甲骨文公司、海德维格公司和阿里巴巴云。</em></p>


Milvus 2.0 重新定义向量数据库

<custom-h1>利用唯品会和 Milvus 构建个性化商品推荐系统</custom-h1><p>随着互联网数据规模的爆炸式增长，一方面，当前主流电商平台的商品数量和品类不断增加，另一方面，用户寻找所需商品的难度也在激增。</p>
<p><a href="https://www.vip.com/">唯品会</a>是中国领先的在线品牌折扣零售商。公司以低于零售价的大幅折扣向全国消费者提供高品质的流行品牌产品。为了优化顾客的购物体验，公司决定根据用户查询的关键词和用户画像建立一个个性化搜索推荐系统。</p>
<p>电子商务搜索推荐系统的核心功能是从大量商品中检索出合适的商品，并根据用户的搜索意图和偏好将其展示给用户。在此过程中，系统需要计算商品与用户搜索意图和偏好的相似度，并将相似度最高的 TopK 商品推荐给用户。</p>
<p>产品信息、用户搜索意图和用户偏好等数据都是非结构化数据。我们曾尝试使用搜索引擎 Elasticsearch（ES）的 CosineSimilarity(7.x) 计算此类数据的相似度，但这种方法存在以下缺点。</p>
<ul>
<li><p>计算响应时间长--从数百万个条目中检索 TopK 结果的平均延迟时间约为 300 毫秒。</p></li>
<li><p>ES 索引的维护成本高--商品特征向量和其他相关数据都使用同一套索引，这几乎不利于索引构建，但会产生海量数据。</p></li>
</ul>
<p>我们尝试开发自己的本地敏感哈希插件，以加速 ES 的余弦相似度（CosineSimilarity）计算。虽然加速后性能和吞吐量有了明显提高，但 100 多毫秒的延迟仍然难以满足实际在线产品检索的要求。</p>
<p>经过深入研究，我们决定使用开源向量数据库Milvus，与常用的单机版Faiss相比，它具有支持分布式部署、多语言SDK、读写分离等优势。</p>
<p>利用各种深度学习模型，我们将海量非结构化数据转化为特征向量，并将向量导入Milvus。借助 Milvus 的优异性能，我们的电商搜索推荐系统可以高效地查询到与目标向量相似的 TopK 向量。</p>
<h2 id="Overall-Architecture" class="common-anchor-header">整体架构<button data-href="#Overall-Architecture" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>![架构](https://assets.zilliz.com/1_01551e7b2b.jpg &quot;架构。)如图所示，系统整体架构主要由两部分组成。</p>
<ul>
<li><p>写入流程：将深度学习模型生成的项目特征向量（以下简称项目向量）规范化后写入 MySQL。然后，MySQL 使用数据同步工具（ETL）读取处理后的物品特征向量，并将其导入向量数据库 Milvus。</p></li>
<li><p>读取过程：搜索服务根据用户查询关键词和用户画像获取用户偏好特征向量（以下简称用户向量），查询 Milvus 中的相似向量并调用 TopK 物品向量。</p></li>
</ul>
<p>Milvus 支持增量数据更新和整体数据更新。每次增量更新都要删除现有的项目向量并插入新的项目向量，这意味着每个新更新的 Collections 都要重新索引。它更适合读取较多、写入较少的情况。因此，我们选择了整体数据更新方法。此外，分批写入多个分区的全部数据只需几分钟，相当于近乎实时更新。</p>
<p>Milvus 写节点执行所有写操作，包括创建数据 Collections、建立索引、插入向量等，并以写域名向公众提供服务。Milvus 读节点执行所有读操作，并以只读域名向公众提供服务。</p>
<p>当前版本的 Milvus 不支持切换 Collections 别名，而我们引入了 Redis，可以在多个整个数据 Collections 之间无缝切换别名。</p>
<p>读取节点只需从 MySQL、Milvus 和 GlusterFS 分布式文件系统中读取现有的元数据信息和向量数据或索引，因此可以通过部署多个实例来横向扩展读取能力。</p>
<h2 id="Implementation-Details" class="common-anchor-header">实施细节<button data-href="#Implementation-Details" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="Data-Update" class="common-anchor-header">数据更新</h3><p>数据更新服务不仅包括写入向量数据，还包括向量的数据量检测、索引构建、索引预加载、别名控制等。整体流程如下。<span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_6052b01334.jpg" alt="Process" class="doc-image" id="process" /><span>流程</span> </span></p>
<ol>
<li><p>假设在构建整个数据之前，CollectionA 向公众提供数据服务，正在使用的整个数据都指向 CollectionA (<code translate="no">redis key1 = CollectionA</code>)。构建整个数据的目的是创建一个新的 CollectionsB。</p></li>
<li><p>商品数据检查 - 检查 MySQL 表中商品数据的项目编号，将商品数据与 CollectionA 中的现有数据进行比较。可根据数量或百分比设置警报。如果未达到设置的数量（百分比），则不会构建整个数据，视为本次构建操作失败，触发警报；一旦达到设置的数量（百分比），则开始整个数据构建过程。</p></li>
<li><p>开始构建整个数据 - 初始化正在构建的整个数据的别名，并更新 Redis。更新后，正在构建的整个数据的别名将指向 CollectionB (<code translate="no">redis key2 = CollectionB</code>)。</p></li>
<li><p>创建新的整个 Collections - 确定 CollectionB 是否存在。如果存在，则先删除它，然后再创建新的。</p></li>
<li><p>数据批量写入 - 使用 modulo 操作计算每个商品数据的分区 ID 与自己的 ID，并将多个分区的数据批量写入新创建的 Collections。</p></li>
<li><p>建立和预加载索引--为新的 Collections 创建索引 (<code translate="no">createIndex()</code>)。索引文件存储在分布式存储服务器 GlusterFS 中。系统会自动模拟对新 Collection 的查询，并预载索引进行查询预热。</p></li>
<li><p>Collections 数据检查--检查新 Collection 中数据的条目数，将数据与现有 Collection 进行比较，并根据数量和百分比设置警报。如果未达到设定的数量（百分比），则不会切换 Collection，并将构建过程视为失败，触发警报。</p></li>
<li><p>切换 Collections - 别名控制。更新 Redis 后，正在使用的整个数据别名将被定向到 CollectionB (<code translate="no">redis key1 = CollectionB</code>)，原来的 Redis key2 将被删除，并完成构建过程。</p></li>
</ol>
<h3 id="Data-Recall" class="common-anchor-header">数据调用</h3><p>多次调用 Milvus 分区数据，计算根据用户查询关键词和用户画像得到的用户向量与物品向量之间的相似度，合并后返回 TopK 物品向量。整体工作流程示意图如下：<span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/3_93518602b1.jpg" alt="workflow" class="doc-image" id="workflow" /><span>工作流程</span> </span>下表列出了该流程中涉及的主要服务。可以看出，调用 TopK 向量的平均延迟时间约为 30 毫秒。</p>
<table>
<thead>
<tr><th><strong>服务</strong></th><th><strong>角色</strong></th><th><strong>输入参数</strong></th><th><strong>输出参数</strong></th><th><strong>响应延迟</strong></th></tr>
</thead>
<tbody>
<tr><td>获取用户向量</td><td>获取用户向量</td><td>用户信息 + 查询</td><td>用户向量</td><td>10 毫秒</td></tr>
<tr><td>Milvus 搜索</td><td>计算向量相似度并返回 TopK 结果</td><td>用户向量</td><td>项目向量</td><td>10 ms</td></tr>
<tr><td>调度逻辑</td><td>并发结果调用和合并</td><td>多通道调用的项目向量和相似度得分</td><td>前 K 个项目</td><td>10 ms</td></tr>
</tbody>
</table>
<p><strong>执行过程：</strong></p>
<ol>
<li>根据用户查询关键词和用户画像，通过深度学习模型计算出用户向量。</li>
<li>从 Redis currentInUseKeyRef 获取整个被使用数据的 Collections 别名，并获取 Milvus CollectionName。这个过程是数据同步服务，即在整个数据更新后将别名切换到 Redis。</li>
<li>Milvus 与用户向量并发异步调用，获取同一 Collections 不同分区的数据，Milvus 会计算用户向量与项目向量的相似度，并返回每个分区中的 TopK 相似项目向量。</li>
<li>合并每个分区返回的 TopK 项向量，并按照相似度距离的倒序排列结果，相似度距离使用 IP 内积计算（向量之间的距离越大，相似度越高）。最终返回 TopK 项目向量。</li>
</ol>
<h2 id="Looking-Ahead" class="common-anchor-header">展望未来<button data-href="#Looking-Ahead" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>目前，基于 Milvus 的向量搜索可以稳定地应用于推荐场景的搜索，它的高性能给了我们在模型维度和算法选择上更大的发挥空间。</p>
<p>Milvus 作为中间件将在更多场景中发挥关键作用，包括主站搜索的召回和全场景推荐。</p>
<p>Milvus 未来最值得期待的三个功能如下。</p>
<ul>
<li>集合别名切换逻辑 - 无需外部组件即可协调集合间的切换。</li>
<li>过滤机制--Milvus v0.11.0 单机版仅支持 ES DSL 过滤机制。新发布的 Milvus 2.0 支持标量过滤和读写分离。</li>
<li>对 Hadoop Distributed File System (HDFS) 的存储支持 - 我们正在使用的 Milvus v0.10.6 只支持 POSIX 文件接口，我们部署了支持 FUSE 的 GlusterFS 作为存储后端。不过，从性能和易于扩展的角度来看，HDFS 是一个更好的选择。</li>
</ul>
<h2 id="Lessons-Learned-and-Best-Practices" class="common-anchor-header">经验教训和最佳实践<button data-href="#Lessons-Learned-and-Best-Practices" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ol>
<li>对于以读取操作为主的应用，读写分离部署可以显著提高处理能力，改善性能。</li>
<li>Milvus Java 客户端缺乏重新连接机制，因为召回服务使用的 Milvus 客户端常驻内存中。我们必须建立自己的连接池，通过心跳测试确保 Java 客户端与服务器之间的连接可用。</li>
<li>Milvus 上偶尔会出现查询缓慢的情况。这是由于新 Collections 的预热不足造成的。通过模拟对新 Collections 的查询，将索引文件加载到内存中，实现索引预热。</li>
<li>nlist 是索引构建参数，nprobe 是查询参数。您需要根据业务场景，通过压力测试实验获得合理的阈值，以平衡检索性能和准确性。</li>
<li>对于静态数据场景，先将所有数据导入 Collections，之后再建立索引会更有效率。</li>
</ol>


整体架构

<custom-h1>基于 Milvus 的音频检索</custom-h1><p>声音是一种信息密集的数据类型。虽然在视频内容时代，音频可能会让人感觉过时，但它仍然是许多人的主要信息来源。尽管听众人数长期下降，2020 年仍有 83% 的 12 岁及以上美国人在一周内收听地面（AM/FM）广播（低于 2019 年的 89%）。相反，在过去二十年里，在线音频的听众人数稳步上升，<a href="https://www.journalism.org/fact-sheet/audio-and-podcasting/">据皮尤研究中心</a>的同一项<a href="https://www.journalism.org/fact-sheet/audio-and-podcasting/">研究</a>显示，62%的美国人每周都会收听某种形式的在线音频。</p>
<p>作为一种波，声音有四个特性：频率、振幅、波形和持续时间。在音乐术语中，这些属性被称为音高、动态、音调和持续时间。声音还能帮助人类和其他动物感知和了解我们所处的环境，为周围环境中物体的位置和移动提供背景线索。</p>
<p>作为一种信息载体，音频可分为三类：</p>
<ol>
<li><strong>语音：</strong>由文字和语法组成的交流媒介。通过语音识别算法，可以将语音转换为文本。</li>
<li><strong>音乐：</strong>声乐和/或器乐声音的组合，由旋律、和声、节奏和音色组成。音乐可以用乐谱来表示。</li>
<li><strong>波形：</strong>将模拟声音数字化后得到的数字音频信号。波形可代表语音、音乐、自然或合成声音。</li>
</ol>
<p>音频检索可用于搜索和实时监控在线媒体，以打击侵犯知识产权的行为。它还在音频数据的分类和统计分析中发挥着重要作用。</p>
<h2 id="Processing-Technologies" class="common-anchor-header">处理技术<button data-href="#Processing-Technologies" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>语音、音乐和其他一般声音各有特点，需要不同的处理方法。通常，音频被分为包含语音和不包含语音的两组：</p>
<ul>
<li>语音音频由自动语音识别技术处理。</li>
<li>非语音音频，包括音乐音频、音效和数字化语音信号，则使用音频检索系统进行处理。</li>
</ul>
<p>本文重点介绍如何使用音频检索系统处理非语音音频数据。本文不涉及语音识别</p>
<h3 id="Audio-feature-extraction" class="common-anchor-header">音频特征提取</h3><p>特征提取是音频检索系统中最重要的技术，因为它可以进行音频相似性搜索。音频特征提取方法分为两类：</p>
<ul>
<li>传统的音频特征提取模型，如高斯混合模型（GMM）和隐马尔可夫模型（HMM）；</li>
<li>基于深度学习的音频特征提取模型，如递归神经网络（RNN）、长短期记忆（LSTM）网络、编码-解码框架、注意力机制等。</li>
</ul>
<p>基于深度学习的模型的错误率比传统模型低一个数量级，因此正逐渐成为音频信号处理领域的核心技术。</p>
<p>音频数据通常由提取的音频特征表示。检索过程搜索和比较的是这些特征和属性，而不是音频数据本身。因此，音频相似性检索的有效性在很大程度上取决于特征提取的质量。</p>
<p>本文采用<a href="https://github.com/qiuqiangkong/audioset_tagging_cnn">大规模预训练的音频模式识别音频神经网络（PANNs）</a>来提取特征向量，其平均准确率（mAP）为 0.439（Hershey et al.，2017）。</p>
<p>提取音频数据的特征向量后，我们可以使用 Milvus 实现高性能的特征向量分析。</p>
<h3 id="Vector-similarity-search" class="common-anchor-header">向量相似性搜索</h3><p><a href="https://milvus.io/">Milvus</a>是一个云原生的开源向量数据库，专为管理机器学习模型和神经网络生成的 Embeddings 向量而构建。它广泛应用于计算机视觉、自然语言处理、计算化学、个性化推荐系统等场景。</p>
<p>下图描述了使用 Milvus 进行相似性搜索的一般流程：<span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/how_does_milvus_work_6926180543.png" alt="how-does-milvus-work.png" class="doc-image" id="how-does-milvus-work.png" /><span>how-does-milvus-work.png</span> </span></p>
<ol>
<li>深度学习模型将非结构化数据转换为特征向量，然后插入 Milvus。</li>
<li>Milvus 对这些特征向量进行存储和索引。</li>
<li>根据请求，Milvus 会搜索并返回与查询向量最相似的向量。</li>
</ol>
<h2 id="System-overview" class="common-anchor-header">系统概述<button data-href="#System-overview" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>音频检索系统主要由两部分组成：插入（黑线）和搜索（红线）。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/audio_retrieval_system_663a911c95.png" alt="audio-retrieval-system.png" class="doc-image" id="audio-retrieval-system.png" />
   </span> <span class="img-wrapper"> <span>音频检索系统.png</span> </span></p>
<p>本项目中使用的样本数据集包含开源游戏声音，代码详见<a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/audio_similarity_search">Milvus bootcamp</a>。</p>
<h3 id="Step-1-Insert-data" class="common-anchor-header">步骤 1：插入数据</h3><p>以下是使用预训练的 PANNs 推理模型生成音频嵌入并将其插入 Milvus 的示例代码，Milvus 会为每个向量嵌入分配一个唯一的 ID。</p>
<pre><code translate="no"><span class="hljs-number">1</span> wav_name, vectors_audio = get_audio_embedding(audio_path)  
<span class="hljs-number">2</span> <span class="hljs-keyword">if</span> vectors_audio:    
<span class="hljs-number">3</span>     embeddings.<span class="hljs-built_in">append</span>(vectors_audio)  
<span class="hljs-number">4</span>     wav_names.<span class="hljs-built_in">append</span>(wav_name)  
<span class="hljs-number">5</span> ids_milvus = insert_vectors(milvus_client, table_name, embeddings)  
<span class="hljs-number">6</span> 
<button class="copy-code-btn"></button></code></pre>
<p>然后将返回的<strong>ids_milvus</strong>与其他相关信息（如<strong>wav_name</strong>）一起存储到 MySQL 数据库中，以备后续处理。</p>
<pre><code translate="no">1 get_ids_correlation(ids_milvus, wav_name)  
2 load_data_to_mysql(conn, cursor, table_name)    
3  
<button class="copy-code-btn"></button></code></pre>
<h3 id="Step-2-Audio-search" class="common-anchor-header">步骤 2：音频搜索</h3><p>Milvus 利用 PANNs 推理模型计算预先存储的特征向量与从查询音频数据中提取的输入特征向量之间的内积距离，并返回相似特征向量的<strong>ids_milvus</strong>，这些特征向量与搜索到的音频数据相对应。</p>
<pre><code translate="no"><span class="hljs-number">1</span> _, vectors_audio = get_audio_embedding(audio_filename)    
<span class="hljs-number">2</span> results = search_vectors(milvus_client, table_name, [vectors_audio], METRIC_TYPE, TOP_K)  
<span class="hljs-number">3</span> ids_milvus = [x.<span class="hljs-built_in">id</span> <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> results[<span class="hljs-number">0</span>]]  
<span class="hljs-number">4</span> audio_name = search_by_milvus_ids(conn, cursor, ids_milvus, table_name)    
<span class="hljs-number">5</span>
<button class="copy-code-btn"></button></code></pre>
<h2 id="API-reference-and-demo" class="common-anchor-header">应用程序接口参考和演示<button data-href="#API-reference-and-demo" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="API" class="common-anchor-header">应用程序接口</h3><p>该音频检索系统采用开源代码构建。其主要功能是插入和删除音频数据。在浏览器中输入<strong>127.0.0.1:<port></strong>/docs，即可查看所有 API。</p>
<h3 id="Demo" class="common-anchor-header">演示</h3><p>我们在线提供基于 Milvus 的音频检索系统的<a href="https://zilliz.com/solutions">现场演示</a>，您可以使用自己的音频数据进行试用。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/audio_search_demo_cae60625db.png" alt="audio-search-demo.png" class="doc-image" id="audio-search-demo.png" />
   </span> <span class="img-wrapper"> <span>音频搜索演示.png</span> </span></p>
<h2 id="Conclusion" class="common-anchor-header">结论<button data-href="#Conclusion" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>生活在大数据时代，人们发现生活中充斥着各种各样的信息。要想更好地理解这些信息，传统的文本检索早已不能胜任。当今的信息检索技术迫切需要检索各种非结构化数据类型，如视频、图像和音频。</p>
<p>计算机难以处理的非结构化数据，可以利用深度学习模型转换成特征向量。这种转换后的数据可以很容易地被机器处理，使我们能够以前人无法做到的方式分析非结构化数据。Milvus 是一个开源向量数据库，可以高效处理人工智能模型提取的特征向量，并提供各种常见的向量相似性计算。</p>
<h2 id="References" class="common-anchor-header">参考文献<button data-href="#References" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Hershey, S., Chaudhuri, S., Ellis, D.P., Gemmeke, J.F., Jansen, A., Moore, R.C., Plakal, M., Platt, D., Saurous, R.A., Seybold, B. and Slaney, M., 2017, March.用于大规模音频分类的 CNN 架构。In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp.</p>
<h2 id="Dont-be-a-stranger" class="common-anchor-header">不要成为陌生人<button data-href="#Dont-be-a-stranger" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li><p>在<a href="https://github.com/milvus-io/milvus/">GitHub</a> 上查找或为 Milvus 投稿。</p></li>
<li><p>通过<a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">Slack</a> 与社区互动。</p></li>
<li><p>在<a href="https://twitter.com/milvusio">Twitter</a> 上与我们联系。</p></li>
</ul>


处理技术

<custom-h1>MilMil：由 Milvus 驱动的常见问题聊天机器人，回答有关 Milvus 的问题</custom-h1><p>最近，开源社区创建了 MilMil--一个由 Milvus 用户创建、为 Milvus 用户服务的 Milvus 常见问题解答聊天机器人。MilMil 可全天候访问 Mil<a href="https://milvus.io/">vus.io</a>，回答有关世界上最先进的开源向量数据库 Milvus 的常见问题。</p>
<p>这个问题解答系统不仅能帮助更快地解决 Milvus 用户遇到的常见问题，还能根据用户提交的问题发现新的问题。MilMil 的数据库包含了自 2019 年该项目首次以开源许可证发布以来用户提出的问题。问题存储在两个 Collections 中，一个用于 Milvus 1.x 及更早版本，另一个用于 Milvus 2.0。</p>
<p>MilMil 目前只有英语版本。</p>
<h2 id="How-does-MilMil-work" class="common-anchor-header">MilMil 是如何工作的？<button data-href="#How-does-MilMil-work" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>MilMil 依靠<em>Sentence-transformers/paraphrase-mpnet-base-v2</em>模型获得常见问题数据库的向量表示，然后利用 Milvus 进行向量相似性检索，返回语义相似的问题。</p>
<p>首先，使用自然语言处理（NLP）模型 BERT 将常见问题数据转换为语义向量。然后将嵌入向量插入 Milvus，并为每个嵌入向量分配一个唯一的 ID。最后，问题和答案连同其向量 ID 一起插入关系数据库 PostgreSQL。</p>
<p>当用户提交问题时，系统会使用 BERT 将其转换为特征向量。接下来，系统会在 Milvus 中搜索与查询向量最相似的五个向量，并检索它们的 ID。最后，与检索到的向量 ID 相对应的问题和答案将返回给用户。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/system_process_dca67a80a6.png" alt="system-process.png" class="doc-image" id="system-process.png" />
   </span> <span class="img-wrapper"> <span>系统进程.png</span> </span></p>
<p>请参阅 Milvus 训练营中的<a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/question_answering_system">问题解答系统</a>项目，探索用于构建人工智能聊天机器人的代码。</p>
<h2 id="Ask-MilMil-about-Milvus" class="common-anchor-header">向 MilMil 了解 Milvus<button data-href="#Ask-MilMil-about-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>要与 MilMil 聊天，请浏览<a href="https://milvus.io/">Milvus.io</a>上的任何页面并点击右下角的小鸟图标。在文本输入框中键入您的问题，然后点击发送。MilMil 会在几毫秒内回复您！此外，左上角的下拉列表可用于切换 Milvus 不同版本的技术文档。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/milvus_chatbot_icon_f3c25708ca.png" alt="milvus-chatbot-icon.png" class="doc-image" id="milvus-chatbot-icon.png" />
   </span> <span class="img-wrapper"> <span>milvus-chatbot-icon.png</span> </span></p>
<p>提交问题后，机器人会立即返回三个与查询问题语义相似的问题。您可以点击 "查看答案 "浏览问题的潜在答案，或点击 "查看更多 "查看与您的搜索相关的更多问题。如果没有合适的答案，请点击 "在此输入您的反馈"，提出您的问题并附上电子邮件地址。来自 Milvus 社区的帮助将很快到达！</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/chatbot_UI_0f4a7655d4.png" alt="chatbot_UI.png" class="doc-image" id="chatbot_ui.png" />
   </span> <span class="img-wrapper"> <span>聊天机器人用户界面</span> </span></p>
<p>试试 MilMil，让我们知道你的想法。我们欢迎所有问题、意见或任何形式的反馈。</p>
<h2 id="Dont-be-a-stranger" class="common-anchor-header">不要成为陌生人<button data-href="#Dont-be-a-stranger" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li>在<a href="https://github.com/milvus-io/milvus/">GitHub</a> 上查找或为 Milvus 投稿。</li>
<li>通过<a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">Slack</a> 与社区互动。</li>
<li>在<a href="https://twitter.com/milvusio">Twitter</a> 上与我们联系。</li>
</ul>


MilMil 一个由 Milvus 支持的常见问题聊天机器人，可回答有关 Milvus 的问题

<custom-h1>利用 Milvus 2.0 Bootcamp 快速测试和部署向量搜索解决方案</custom-h1><p>随着 Milvus 2.0 的发布，团队对 Milvus<a href="https://github.com/milvus-io/bootcamp">引导营</a>进行了改造。经过改进的新版 Bootcamp 为各种用例和部署提供了更新的指南和更易于理解的代码示例。此外，新版本还针对<a href="https://milvus.io/blog/milvus2.0-redefining-vector-database.md">Milvus 2.0 进行了更新，Milvus 2.0</a> 是世界上最先进的向量数据库的重构版本。</p>
<h3 id="Stress-test-your-system-against-1M-and-100M-dataset-benchmarks" class="common-anchor-header">根据 100 万和 1 亿数据集基准对系统进行压力测试</h3><p><a href="https://github.com/milvus-io/bootcamp/tree/master/benchmark_test">基准目录</a>包含 100 万和 1 亿向量基准测试，可显示系统对不同大小数据集的反应。</p>
<p><br/></p>
<h3 id="Explore-and-build-popular-vector-similarity-search-solutions" class="common-anchor-header">探索和构建流行的向量相似性搜索解决方案</h3><p><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions">解决方案目录</a>包含最常用的向量相似性搜索用例。每个用例都包含一个笔记本解决方案和一个 docker 可部署解决方案。使用案例包括</p>
<ul>
<li><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/reverse_image_search">图像相似性搜索</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/video_similarity_search">视频相似性搜索</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/audio_similarity_search">音频相似性搜索</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/recommendation_system">推荐系统</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/molecular_similarity_search">分子搜索</a></li>
<li><a href="https://github.com/milvus-io/bootcamp/tree/master/solutions/question_answering_system">问题解答系统</a></li>
</ul>
<p><br/></p>
<h3 id="Quickly-deploy-a-fully-built-application-on-any-system" class="common-anchor-header">在任何系统上快速部署完全构建的应用程序</h3><p>快速部署解决方案是 docker 化的解决方案，允许用户在任何系统上部署完全构建的应用程序。这些解决方案是简短演示的理想选择，但与笔记本相比，需要额外的定制和理解工作。</p>
<p><br/></p>
<h3 id="Use-scenario-specific-notebooks-to-easily-deploy-pre-configured-applications" class="common-anchor-header">使用特定场景笔记本轻松部署预配置应用程序</h3><p>笔记本包含一个部署 Milvus 的简单示例，以解决给定用例中的问题。每个示例都可以从头到尾运行，无需管理文件或配置。每个笔记本还易于遵循和修改，使它们成为其他项目的理想基础文件。</p>
<p><br/></p>
<h3 id="Image-similarity-search-notebook-example" class="common-anchor-header">图像相似性搜索笔记本示例</h3><p>图像相似性搜索是许多不同技术（包括自动驾驶汽车识别物体）背后的核心理念之一。本示例介绍了如何使用 Milvus 轻松构建计算机视觉程序。</p>
<p>本笔记本围绕三个方面展开：</p>
<ul>
<li>Milvus 服务器</li>
<li>Redis 服务器（用于元数据存储）</li>
<li>预训练的 Resnet-18 模型。</li>
</ul>
<h4 id="Step-1-Download-required-packages" class="common-anchor-header">第 1 步：下载所需软件包</h4><p>首先下载本项目所需的所有软件包。本笔记本中的表格列出了要使用的软件包。</p>
<pre><code translate="no">pip install -r requirements.txt
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-2-Server-startup" class="common-anchor-header">第 2 步：启动服务器</h4><p>安装软件包后，启动服务器并确保两者运行正常。请务必按照正确的说明启动<a href="https://milvus.io/docs/v2.0.x/install_standalone-docker.md">Milvus</a>和<a href="https://hub.docker.com/_/redis">Redis</a>服务器。</p>
<h4 id="Step-3-Download-project-data" class="common-anchor-header">第 3 步：下载项目数据</h4><p>默认情况下，本笔记本会提取 VOCImage 数据片段作为示例，但只要遵循笔记本顶部的文件结构，任何包含图像的目录都可以使用。</p>
<pre><code translate="no">! gdown <span class="hljs-string">&quot;https://drive.google.com/u/1/uc?id=1jdudBiUu41kL-U5lhH3ari_WBRXyedWo&amp;export=download&quot;</span>
! tar -xf <span class="hljs-string">&#x27;VOCdevkit.zip&#x27;</span>
! <span class="hljs-built_in">rm</span> <span class="hljs-string">&#x27;VOCdevkit.zip&#x27;</span>
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-4-Connect-to-the-servers" class="common-anchor-header">第 4 步：连接服务器</h4><p>在本例中，服务器运行在本地主机的默认端口上。</p>
<pre><code translate="no">connections.<span class="hljs-title function_">connect</span>(host=<span class="hljs-string">&quot;127.0.0.1&quot;</span>, port=<span class="hljs-number">19537</span>)
red = redis.<span class="hljs-title class_">Redis</span>(host = <span class="hljs-string">&#x27;127.0.0.1&#x27;</span>, port=<span class="hljs-number">6379</span>, db=<span class="hljs-number">0</span>)
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-5-Create-a-collection" class="common-anchor-header">第 5 步：创建 Collections</h4><p>启动服务器后，在 Milvus 中创建一个用于存储所有向量的 Collection。在本例中，维度大小设置为 512，即 resnet-18 输出的大小，相似度指标设置为欧氏距离 (L2)。Milvus 支持多种不同的<a href="https://milvus.io/docs/v2.0.x/metric.md">相似度量</a>。</p>
<pre><code translate="no">collection_name = <span class="hljs-string">&quot;image_similarity_search&quot;</span>
dim = <span class="hljs-number">512</span>
default_fields = [
    schema.FieldSchema(name=<span class="hljs-string">&quot;id&quot;</span>, dtype=DataType.INT64, is_primary=<span class="hljs-literal">True</span>, auto_id=<span class="hljs-literal">True</span>),
    schema.FieldSchema(name=<span class="hljs-string">&quot;vector&quot;</span>, dtype=DataType.FLOAT_VECTOR, dim=dim)
]
default_schema = schema.CollectionSchema(fields=default_fields, description=<span class="hljs-string">&quot;Image test collection&quot;</span>)
collection = Collection(name=collection_name, schema=default_schema)
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-6-Build-an-index-for-the-collection" class="common-anchor-header">第 6 步：为 Collections 建立索引</h4><p>Collections 制作完成后，为其建立索引。本例中使用的是 IVF_SQ8 索引。该索引需要 "nlist "参数，该参数告诉 Milvus 在每个数据文件（段）中建立多少个聚类。不同的<a href="https://milvus.io/docs/v2.0.x/index.md">索引</a>需要不同的参数。</p>
<pre><code translate="no">default_index = {<span class="hljs-string">&quot;index_type&quot;</span>: <span class="hljs-string">&quot;IVF_SQ8&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nlist&quot;</span>: <span class="hljs-number">2048</span>}, <span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;L2&quot;</span>}
collection.<span class="hljs-title function_">create_index</span>(field_name=<span class="hljs-string">&quot;vector&quot;</span>, index_params=default_index)
collection.<span class="hljs-title function_">load</span>()
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-7-Set-up-model-and-data-loader" class="common-anchor-header">第 7 步：设置模型和数据加载器</h4><p>建立 IVF_SQ8 索引后，设置神经网络和数据加载器。本例中使用的预训练 pytorch resnet-18 没有最后一层，该层会压缩向量进行分类，可能会丢失有价值的信息。</p>
<pre><code translate="no">model = torch.hub.load(<span class="hljs-string">&#x27;pytorch/vision:v0.9.0&#x27;</span>, <span class="hljs-string">&#x27;resnet18&#x27;</span>, pretrained=<span class="hljs-literal">True</span>)
encoder = torch.nn.Sequential(*(<span class="hljs-built_in">list</span>(model.children())[:-<span class="hljs-number">1</span>]))
<button class="copy-code-btn"></button></code></pre>
<p>需要对数据集和数据加载器进行修改，使其能够对图像进行预处理和批处理，同时提供图像的文件路径。这可以通过稍加修改的 torchvision 数据加载器来实现。在预处理方面，由于 resnet-18 模型是在特定尺寸和数值范围内训练的，因此需要对图像进行裁剪和归一化处理。</p>
<pre><code translate="no">dataset = ImageFolderWithPaths(data_dir, transform=transforms.Compose([
                                                transforms.Resize(256),
                                                transforms.CenterCrop(224),
                                                transforms.ToTensor(),
                                                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]))

dataloader = torch.utils.data.DataLoader(dataset, num_workers=0, batch_si
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-8-Insert-vectors-into-the-collection" class="common-anchor-header">步骤 8：将向量插入 Collections</h4><p>收集设置完成后，就可以处理图像并将其加载到创建的 Collections 中。首先由数据加载器提取图像并通过 resnet-18 模型运行。然后将生成的向量 Embeddings 插入 Milvus，Milvus 会为每个向量返回一个唯一的 ID。然后将向量 ID 和图像文件路径作为键值对插入 Redis 服务器。</p>
<pre><code translate="no">steps = <span class="hljs-built_in">len</span>(dataloader)
step = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> inputs, labels, paths <span class="hljs-keyword">in</span> dataloader:
    <span class="hljs-keyword">with</span> torch.no_grad():
        output = encoder(inputs).squeeze()
        output = output.numpy()

    mr = collection.insert([output.tolist()])
    ids = mr.primary_keys
    <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-built_in">len</span>(ids)):
        red.<span class="hljs-built_in">set</span>(<span class="hljs-built_in">str</span>(ids[x]), paths[x])
    <span class="hljs-keyword">if</span> step%<span class="hljs-number">5</span> == <span class="hljs-number">0</span>:
        <span class="hljs-built_in">print</span>(<span class="hljs-string">&quot;Insert Step: &quot;</span> + <span class="hljs-built_in">str</span>(step) + <span class="hljs-string">&quot;/&quot;</span> + <span class="hljs-built_in">str</span>(steps))
    step += <span class="hljs-number">1</span>
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-9-Conduct-a-vector-similarity-search" class="common-anchor-header">步骤 9：进行向量相似性搜索</h4><p>将所有数据插入 Milvus 和 Redis 后，就可以执行实际的向量相似性搜索了。在本例中，从 Redis 服务器中随机抽取三张图片进行向量相似性搜索。</p>
<pre><code translate="no">random_ids = [<span class="hljs-built_in">int</span>(red.randomkey()) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">3</span>)]
search_images = [x.decode(<span class="hljs-string">&quot;utf-8&quot;</span>) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> red.mget(random_ids)]
<button class="copy-code-btn"></button></code></pre>
<p>这些图像首先经过与步骤 7 中发现的相同的预处理，然后通过 resnet-18 模型推送。</p>
<pre><code translate="no">transform_ops = transforms.Compose([
                transforms.Resize(<span class="hljs-number">256</span>),
                transforms.CenterCrop(<span class="hljs-number">224</span>),
                transforms.ToTensor(),
                transforms.Normalize(mean=[<span class="hljs-number">0.485</span>, <span class="hljs-number">0.456</span>, <span class="hljs-number">0.406</span>], std=[<span class="hljs-number">0.229</span>, <span class="hljs-number">0.224</span>, <span class="hljs-number">0.225</span>])])

embeddings = [transform_ops(Image.<span class="hljs-built_in">open</span>(x)) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> search_images]
embeddings = torch.stack(embeddings, dim=<span class="hljs-number">0</span>)

<span class="hljs-keyword">with</span> torch.no_grad():
    embeddings = encoder(embeddings).squeeze().numpy()
<button class="copy-code-btn"></button></code></pre>
<p>然后利用得到的向量 Embeddings 进行搜索。首先，设置搜索参数，包括要搜索的 Collections 名称、nprobe（要搜索的集群数量）和 top_k（返回向量的数量）。在本例中，搜索速度应该很快。</p>
<pre><code translate="no">search_params = {<span class="hljs-string">&quot;metric_type&quot;</span>: <span class="hljs-string">&quot;L2&quot;</span>, <span class="hljs-string">&quot;params&quot;</span>: {<span class="hljs-string">&quot;nprobe&quot;</span>: 32}}
start = time.time()
results = collection.search(embeddings, <span class="hljs-string">&quot;vector&quot;</span>, param=search_params, <span class="hljs-built_in">limit</span>=3, <span class="hljs-built_in">expr</span>=None)
end = time.time() - start
<button class="copy-code-btn"></button></code></pre>
<h4 id="Step-10-Image-search-results" class="common-anchor-header">步骤 10：图像搜索结果</h4><p>查询返回的向量 ID 用于查找相应的图像。然后使用 Matplotlib 显示图像搜索结果。<br/></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/pic1_c8652c7fae.png" alt="pic1.png" class="doc-image" id="pic1.png" />
   </span> <span class="img-wrapper"> <span>pic1.png</span> </span> <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/pic2_355b054161.png" alt="pic2.png" class="doc-image" id="pic2.png" /><span>pic2.png</span> </span> <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/pic3_01780c6aac.png" alt="pic3.png" class="doc-image" id="pic3.png" /><span>pic3.png</span> </span></p>
<p><br/></p>
<h3 id="Learn-how-to-deploy-Milvus-in-different-enviroments" class="common-anchor-header">了解如何在不同环境中部署 Milvus</h3><p>新启动训练营的<a href="https://github.com/milvus-io/bootcamp/tree/master/deployments">部署部分</a>包含在不同环境和设置中使用 Milvus 的所有信息。它包括部署 Milvus、将 Kubernetes 与 Milvus 结合使用、负载平衡等。每个环境都有详细的步骤指南，解释如何让 Milvus 在其中工作。</p>
<p><br/></p>
<h3 id="Dont-be-a-stranger" class="common-anchor-header">不要成为陌生人</h3><ul>
<li>阅读我们的<a href="https://zilliz.com/blog">博客</a>。</li>
<li>在<a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">Slack</a> 上与我们的开源社区互动。</li>
<li>在<a href="https://github.com/milvus-io/milvus">Github</a> 上使用或贡献世界上最流行的向量数据库 Milvus。</li>
</ul>


利用 Milvus 2.0 Bootcamp 快速测试和部署向量搜索解决方案

<custom-h1>使用 Milvus 构建衣橱和服装规划应用程序</custom-h1><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_1_5f239a8d48.png" alt="stylepedia-1.png" class="doc-image" id="stylepedia-1.png" />
   </span> <span class="img-wrapper"> <span>stylepedia-1.png</span> </span></p>
<p><a href="http://www.mozat.com/home">Mozat</a>成立于 2003 年，总部位于新加坡，在中国和沙特阿拉伯设有办事处。该公司专门从事社交媒体、通讯和生活方式应用程序的开发。<a href="https://stylepedia.com/">Stylepedia</a>是 Mozat 开发的一款衣橱应用程序，可帮助用户发现新风格，并与其他热衷时尚的人建立联系。它的主要功能包括整理数字衣橱、个性化风格推荐、社交媒体功能，以及用于查找与网上或现实生活中所见类似物品的图片搜索工具。</p>
<p><a href="https://milvus.io">Milvus</a>用于支持 Stylepedia 中的图片搜索系统。该应用可处理三种类型的图片：用户图片、产品图片和时尚照片。每张图片可以包含一个或多个项目，从而使每次查询更加复杂。图像搜索系统必须准确、快速、稳定，这样才能发挥作用，为在应用程序中添加服装建议和时尚内容推荐等新功能奠定坚实的技术基础。</p>
<h2 id="System-overview" class="common-anchor-header">系统概述<button data-href="#System-overview" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_system_process_8e7e2ab3e4.png" alt="stylepedia-system-process.png" class="doc-image" id="stylepedia-system-process.png" />
   </span> <span class="img-wrapper"> <span>stylepedia 系统流程.png</span> </span></p>
<p>图片搜索系统分为离线和在线两部分。</p>
<p>离线时，图片被矢量化并插入矢量数据库（Milvus）。在数据工作流程中，相关的产品图片和时尚照片通过对象检测和特征提取模型转换成 512 维的特征向量。然后对向量数据进行索引并添加到向量数据库中。</p>
<p>在线查询图像数据库，并将类似图像返回给用户。与离线部分类似，查询图像通过对象检测和特征提取模型进行处理，以获得特征向量。利用特征向量，Milvus 搜索 TopK 相似向量并获得其对应的图像 ID。最后，经过后处理（过滤、排序等），返回与查询图像相似的图像 Collections。</p>
<h2 id="Implementation" class="common-anchor-header">实施<button data-href="#Implementation" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>实现过程分为四个模块：</p>
<ol>
<li>服装检测</li>
<li>特征提取</li>
<li>向量相似性搜索</li>
<li>后处理</li>
</ol>
<h3 id="Garment-detection" class="common-anchor-header">服装检测</h3><p>在服装检测模块中，使用了基于锚点的单阶段目标检测框架<a href="https://pytorch.org/hub/ultralytics_yolov5/">YOLOv5</a> 作为目标检测模型，因为它体积小，推理实时。它提供四种模型尺寸（YOLOv5s/m/l/x），每种具体尺寸各有利弊。较大的模型性能会更好（精度更高），但需要更多的计算能力，运行速度也更慢。由于本例中的物体都是相对较大的物品，而且容易检测，因此使用最小的模型 YOLOv5s 就足够了。</p>
<p>每张图像中的衣物都会被识别并裁剪出来，作为后续处理中使用的特征提取模型输入。同时，物体检测模型还根据预定义的类别（上衣、外衣、裤子、裙子、连衣裙和连衣裙）预测服装分类。</p>
<h3 id="Feature-extraction" class="common-anchor-header">特征提取</h3><p>相似性搜索的关键是特征提取模型。裁剪后的衣服图像被嵌入 512 维浮点向量，以机器可读的数字数据格式表示其属性。采用<a href="https://github.com/Joon-Park92/Survey_of_Deep_Metric_Learning">深度度量学习（DML）</a>方法，以<a href="https://arxiv.org/abs/1905.11946">EfficientNet</a>作为骨干模型。</p>
<p>公因子学习旨在训练基于 CNN 的非线性特征提取模块（或编码器），以减小同一类样本对应的特征向量之间的距离，增大不同类样本对应的特征向量之间的距离。在这种情况下，同一类样本指的是同一件衣服。</p>
<p>在均匀扩展网络宽度、深度和分辨率时，EfficientNet 同时考虑了速度和精度。EfficientNet-B4 被用作特征提取网络，最终全连接层的输出是进行向量相似性搜索所需的图像特征。</p>
<h3 id="Vector-similarity-search" class="common-anchor-header">向量相似性搜索</h3><p>Milvus 是一个开源的向量数据库，支持创建、读取、更新和删除（CRUD）操作，以及对万亿字节数据集进行近乎实时的搜索。在 Stylepedia 中，它被用于大规模向量相似性搜索，因为它具有高弹性、高稳定性、高可靠性和快如闪电的特点。Milvus 扩展了广泛使用的向量索引库（Faiss、NMSLIB、Annoy 等）的功能，并提供了一套简单直观的应用程序接口，允许用户针对给定场景选择理想的索引类型。</p>
<p>考虑到场景要求和数据规模，Stylepedia 的开发人员使用了 Milvus Distributed 与 HNSW 索引搭配的仅 CPU 版本。建立了两个索引 Collections，一个用于产品，另一个用于时尚照片，以支持不同的应用功能。每个 Collections 根据检测和分类结果进一步分为六个分区，以缩小搜索范围。Milvus 能在几毫秒内对数千万向量进行搜索，在提供最佳性能的同时，还能保持较低的开发成本并最大限度地减少资源消耗。</p>
<h3 id="Post-processing" class="common-anchor-header">后处理</h3><p>为了提高图像检索结果与查询图像之间的相似度，我们使用颜色过滤和关键标签（袖长、衣长、领子样式等）过滤来筛选出不合格的图像。此外，我们还使用了一种图像质量评估算法，以确保首先向用户展示质量较高的图像。</p>
<h2 id="Application" class="common-anchor-header">应用<button data-href="#Application" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><h3 id="User-uploads-and-image-search" class="common-anchor-header">用户上传和图片搜索</h3><p>用户可以拍摄自己的服装照片并上传到 Stylepedia 电子衣橱，然后检索与他们上传的照片最相似的产品图片。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_search_results_0568e20dc0.png" alt="stylepedia-search-results.png" class="doc-image" id="stylepedia-search-results.png" />
   </span> <span class="img-wrapper"> <span>stylepedia-search-results.png</span> </span></p>
<h3 id="Outfit-suggestions" class="common-anchor-header">服装建议</h3><p>通过在 Stylepedia 数据库中进行相似度搜索，用户可以找到包含特定时尚单品的时尚照片。这些单品可能是某人正在考虑购买的新服装，也可能是他自己的 Collections 中可以有不同穿法或搭配的单品。然后，通过对经常与之搭配的单品进行聚类，就能生成服装搭配建议。例如，一件黑色机车夹克可以搭配多种单品，如一条黑色紧身牛仔裤。然后，用户可以浏览在所选公式中出现这种搭配的相关时尚照片。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_jacket_outfit_e84914da9e.png" alt="stylepedia-jacket-outfit.png" class="doc-image" id="stylepedia-jacket-outfit.png" />
   </span> <span class="img-wrapper"> <span>stylepedia-jacket-outfit.png</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_jacket_snapshot_25f53cc09b.png" alt="stylepedia-jacket-snapshot.png" class="doc-image" id="stylepedia-jacket-snapshot.png" />
   </span> <span class="img-wrapper"> <span>stylepedia-jacket-snapshot.png</span> </span></p>
<h3 id="Fashion-photograph-recommendations" class="common-anchor-header">时尚照片推荐</h3><p>系统根据用户的浏览历史、喜好和数字衣橱内容计算相似度，并提供用户可能感兴趣的定制时尚照片推荐。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_user_wardrobe_6770c856b9.png" alt="stylepedia-user-wardrobe.png" class="doc-image" id="stylepedia-user-wardrobe.png" />
   </span> <span class="img-wrapper"> <span>stylepedia-user-wardrobe.png</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/stylepedia_streetsnap_rec_901601a34d.png" alt="stylepedia-streetsnap-rec.png" class="doc-image" id="stylepedia-streetsnap-rec.png" />
   </span> <span class="img-wrapper"> <span>stylepedia-streetsnap-rec.png</span> </span></p>
<p>通过结合深度学习和计算机视觉方法，Mozat 利用 Milvus 构建了一个快速、稳定、准确的图像相似性搜索系统，为 Stylepedia 应用程序中的各种功能提供动力。</p>
<h2 id="Dont-be-a-stranger" class="common-anchor-header">不做陌生人<button data-href="#Dont-be-a-stranger" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><ul>
<li>在<a href="https://github.com/milvus-io/milvus/">GitHub</a> 上查找或贡献 Milvus。</li>
<li>通过<a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">Slack</a> 与社区互动。</li>
<li>在<a href="https://twitter.com/milvusio">Twitter</a> 上与我们联系。</li>
</ul>


系统概述

<custom-h1>基于 JuiceFS 构建 Milvus 集群</custom-h1><p>开源社区之间的合作是一件神奇的事情。充满热情、智慧和创造力的志愿者们不仅让开源解决方案不断创新，他们还努力将不同的工具以有趣而有用的方式结合在一起。<a href="https://milvus.io/">Milvus</a> 是世界上最流行的向量数据库，而<a href="https://github.com/juicedata/juicefs">JuiceFS</a> 则是专为云原生环境设计的共享文件系统，它们在各自的开源社区中本着这种精神联合在一起。本文将解释什么是 JuiceFS、如何基于 JuiceFS 共享文件存储构建 Milvus 集群，以及用户使用该解决方案可以期待的性能。</p>
<h2 id="What-is-JuiceFS" class="common-anchor-header"><strong>什么是 JuiceFS？</strong><button data-href="#What-is-JuiceFS" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>JuiceFS 是一个高性能、开源的分布式 POSIX 文件系统，可以构建在 Redis 和 S3 的基础上。它专为云原生环境设计，支持管理、分析、归档和备份任何类型的数据。JuiceFS 常用于解决大数据难题、构建人工智能（AI）应用以及收集日志。该系统还支持多个客户端之间的数据共享，并可直接用作 Milvus 中的共享存储。</p>
<p>数据及其相应的元数据分别持久化到对象存储和<a href="https://redis.io/">Redis</a>后，JuiceFS 就成了一个无状态中间件。通过标准的文件系统接口，不同的应用程序可以无缝对接，从而实现数据共享。JuiceFS 依靠开源内存数据存储 Redis 来存储元数据。之所以使用 Redis，是因为它能保证原子性并提供高性能的元数据操作。所有数据都通过 JuiceFS 客户端存储在对象存储中。架构图如下：</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/juicefs_architecture_2023b37a4e.png" alt="juicefs-architecture.png" class="doc-image" id="juicefs-architecture.png" />
   </span> <span class="img-wrapper"> <span>juicefs-architecture.png</span> </span></p>
<h2 id="Build-a-Milvus-cluster-based-on-JuiceFS" class="common-anchor-header"><strong>基于 JuiceFS 构建 Milvus 集群</strong><button data-href="#Build-a-Milvus-cluster-based-on-JuiceFS" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>使用 JuiceFS 构建的 Milvus 集群（见下面的架构图）通过使用集群分片中间件 Mishards 对上游请求进行拆分，从而将请求级联到其子模块。插入数据时，Mishards 将上游请求分配给 Milvus 写节点，后者将新插入的数据存储在 JuiceFS 中。读取数据时，Mishards 通过 Milvus 读节点将数据从 JuiceFS 加载到内存中进行处理，然后从上游的子服务收集并返回结果。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/milvus_cluster_built_with_juicefs_3a43cd262c.png" alt="milvus-cluster-built-with-juicefs.png" class="doc-image" id="milvus-cluster-built-with-juicefs.png" />
   </span> <span class="img-wrapper"> <span>Milvus-cluster-built-with-juicefs.png</span> </span></p>
<h3 id="Step-1-Launch-MySQL-service" class="common-anchor-header"><strong>步骤 1：启动 MySQL 服务</strong></h3><p>在群集中的<strong>任意</strong>节点上启动 MySQL 服务。有关详细信息，请参阅<a href="https://milvus.io/docs/v1.1.0/data_manage.md">使用 MySQL 管理元数据</a>。</p>
<h3 id="Step-2-Create-a-JuiceFS-file-system" class="common-anchor-header"><strong>第 2 步：创建 JuiceFS 文件系统</strong></h3><p>为演示目的，使用预编译的二进制 JuiceFS 程序。为你的系统下载正确的<a href="https://github.com/juicedata/juicefs/releases">安装包</a>，并按照《JuiceFS<a href="https://github.com/juicedata/juicefs-quickstart">快速入门指南》</a>了解详细的安装说明。要创建 JuiceFS 文件系统，首先要为元数据存储设置一个 Redis 数据库。对于公共云部署，建议将 Redis 服务托管在与应用程序相同的云上。此外，为 JuiceFS 设置对象存储。本例中使用的是 Azure Blob Storage，但 JuiceFS 支持几乎所有对象服务。请选择最适合您的应用场景需求的对象存储服务。</p>
<p>配置好 Redis 服务和对象存储后，格式化一个新文件系统并将 JuiceFS 挂载到本地目录：</p>
<pre><code translate="no">1 $  <span class="hljs-built_in">export</span> AZURE_STORAGE_CONNECTION_STRING=<span class="hljs-string">&quot;DefaultEndpointsProtocol=https;AccountName=XXX;AccountKey=XXX;EndpointSuffix=core.windows.net&quot;</span>
2 $ ./juicefs format \
3     --storage wasb \
4     --bucket https://&lt;container&gt; \
5     ... \
6     localhost <span class="hljs-built_in">test</span> <span class="hljs-comment">#format</span>
7 $ ./juicefs mount -d localhost ~/jfs  <span class="hljs-comment">#mount</span>
8
<button class="copy-code-btn"></button></code></pre>
<blockquote>
<p>如果 Redis 服务器不在本地运行，请将 localhost 替换为以下地址：<code translate="no">redis://&lt;user:password&gt;@host:6379/1</code> 。</p>
</blockquote>
<p>安装成功后，JuiceFS 会返回共享存储页面<strong>/root/jfs</strong>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/installation_success_9d05279ecd.png" alt="installation-success.png" class="doc-image" id="installation-success.png" />
   </span> <span class="img-wrapper"> <span>安装成功.png</span> </span></p>
<h3 id="Step-3-Start-Milvus" class="common-anchor-header"><strong>第 3 步：启动 Milvus</strong></h3><p>集群中的所有节点都应安装 Milvus，每个 Milvus 节点都应配置读或写权限。只有一个 Milvus 节点可以配置为写节点，其余的必须是读节点。首先，在 Milvus 系统配置文件<strong>server_config.yaml</strong> 中设置<code translate="no">cluster</code> 和<code translate="no">general</code> 部分的参数：</p>
<p><strong>部分</strong> <code translate="no">cluster</code></p>
<table>
<thead>
<tr><th style="text-align:left"><strong>参数</strong></th><th style="text-align:left"><strong>说明</strong></th><th style="text-align:left"><strong>配置</strong></th></tr>
</thead>
<tbody>
<tr><td style="text-align:left"><code translate="no">enable</code></td><td style="text-align:left">是否启用群集模式</td><td style="text-align:left"><code translate="no">true</code></td></tr>
<tr><td style="text-align:left"><code translate="no">role</code></td><td style="text-align:left">Milvus 部署角色</td><td style="text-align:left"><code translate="no">rw</code>/<code translate="no">ro</code></td></tr>
</tbody>
</table>
<p><strong>部分</strong> <code translate="no">general</code></p>
<pre><code translate="no"><span class="hljs-comment"># meta_uri is the URI for metadata storage, using MySQL (for Milvus Cluster). Format: mysql://&lt;username:password&gt;@host:port/database</span>
general:
  timezone: UTC+8
  meta_uri: mysql://root:milvusroot@host:3306/milvus
<button class="copy-code-btn"></button></code></pre>
<p>安装过程中，配置的 JuiceFS 共享存储路径设置为<strong>/root/jfs/milvus/db</strong>。</p>
<pre><code translate="no">1 <span class="hljs-built_in">sudo</span> docker run -d --name milvus_gpu_1.0.0 --gpus all \
2 -p 19530:19530 \
3 -p 19121:19121 \
4 -v /root/jfs/milvus/db:/var/lib/milvus/db \  <span class="hljs-comment">#/root/jfs/milvus/db is the shared storage path</span>
5 -v /home/<span class="hljs-variable">$USER</span>/milvus/conf:/var/lib/milvus/conf \
6 -v /home/<span class="hljs-variable">$USER</span>/milvus/logs:/var/lib/milvus/logs \
7 -v /home/<span class="hljs-variable">$USER</span>/milvus/wal:/var/lib/milvus/wal \
8 milvusdb/milvus:1.0.0-gpu-d030521-1ea92e
9
<button class="copy-code-btn"></button></code></pre>
<p>安装完成后，启动 Milvus 并确认其已正常启动。 最后，在群集中的<strong>任意</strong>节点上启动 Mishards 服务。下图显示了 Mishards 的成功启动。有关详细信息，请参阅 GitHub<a href="https://github.com/milvus-io/bootcamp/tree/new-bootcamp/deployments/juicefs">教程</a>。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/mishards_launch_success_921695d3a8.png" alt="mishards-launch-success.png" class="doc-image" id="mishards-launch-success.png" />
   </span> <span class="img-wrapper"> <span>mishards-launch-success.png</span> </span></p>
<h2 id="Performance-benchmarks" class="common-anchor-header"><strong>性能基准</strong><button data-href="#Performance-benchmarks" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>共享存储解决方案通常由网络附加存储（NAS）系统实现。常用的 NAS 系统类型包括网络文件系统（NFS）和服务器消息块（SMB）。公共云平台通常提供与这些协议兼容的托管存储服务，如亚马逊弹性文件系统（EFS）。</p>
<p>与传统的 NAS 系统不同，JuiceFS 是基于用户空间文件系统（FUSE）实现的，所有数据读写都直接在应用程序端进行，从而进一步减少了访问延迟。JuiceFS 还有其他 NAS 系统所不具备的独特功能，如数据压缩和缓存。</p>
<p>基准测试表明，JuiceFS 比 EFS 具有更大的优势。在元数据基准测试中（图 1），JuiceFS 的每秒 I/O 操作符（IOPS）比 EFS 高出 10 倍。此外，I/O 吞吐量基准测试（图 2）显示，JuiceFS 在单任务和多任务情况下的性能均优于 EFS。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/performance_benchmark_1_b7fcbb4439.png" alt="performance-benchmark-1.png" class="doc-image" id="performance-benchmark-1.png" />
   </span> <span class="img-wrapper"> <span>性能基准-1.png</span> </span></p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/performance_benchmark_2_e311098123.png" alt="performance-benchmark-2.png" class="doc-image" id="performance-benchmark-2.png" />
   </span> <span class="img-wrapper"> <span>性能基准-2.png</span> </span></p>
<p>此外，基准测试表明，基于 JuiceFS 的 Milvus 集群的首次查询检索时间（或将新插入的数据从磁盘加载到内存的时间）平均仅为 0.032 秒，这表明数据几乎是瞬间从磁盘加载到内存的。在这项测试中，首次查询检索时间是使用 100 万行 128 维向量数据，以 100k 为一批，每隔 1 到 8 秒插入一次来测量的。</p>
<p>JuiceFS 是一个稳定可靠的共享文件存储系统，基于 JuiceFS 构建的 Milvus 集群既能提供高性能，又能提供灵活的存储容量。</p>
<h2 id="Learn-more-about-Milvus" class="common-anchor-header"><strong>了解有关 Milvus 的更多信息</strong><button data-href="#Learn-more-about-Milvus" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 是一款强大的工具，能够为大量人工智能和向量相似性搜索应用提供动力。要了解有关该项目的更多信息，请查看以下资源：</p>
<ul>
<li>阅读我们的<a href="https://zilliz.com/blog">博客</a>。</li>
<li>在<a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">Slack</a> 上与我们的开源社区互动。</li>
<li>在<a href="https://github.com/milvus-io/milvus/">GitHub</a> 上使用或贡献世界上最流行的向量数据库。</li>
<li>使用我们新的<a href="https://github.com/milvus-io/bootcamp">Bootcamp</a> 快速测试和部署人工智能应用。</li>
</ul>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/writer_bio_changjian_gao_68018f7716.png" alt="writer bio-changjian gao.png" class="doc-image" id="writer-bio-changjian-gao.png" />
   </span> <span class="img-wrapper"> <span>writer bio-changjian gao.png</span> </span> <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/writer_bio_jingjing_jia_a85d1c2e3b.png" alt="writer bio-jingjing jia.png" class="doc-image" id="writer-bio-jingjing-jia.png" /><span>writer bio-jingjing jia.png</span> </span></p>


什么是 JuiceFS？

<custom-h1>在搜狐新闻应用程序中构建智能新闻推荐系统</custom-h1><p><a href="https://www.socialmediatoday.com/news/new-research-shows-that-71-of-americans-now-get-news-content-via-social-pl/593255/">71%的美国人</a>从社交平台获得新闻推荐，个性化内容已迅速成为人们发现新媒体的方式。无论是搜索特定主题，还是与推荐内容互动，用户所看到的一切都经过算法优化，以提高点击率（CTR）、参与度和相关性。搜狐是一家在纳斯达克上市的中国在线媒体、视频、搜索和游戏集团。它利用由<a href="https://zilliz.com/">Zilliz</a> 构建的开源向量数据库<a href="https://milvus.io/">Milvus</a>，在其新闻应用内构建了一个语义向量搜索引擎。本文介绍了该公司如何利用用户资料对个性化内容推荐进行长期微调，从而提高用户体验和参与度。</p>
<h2 id="Recommending-content-using-semantic-vector-search" class="common-anchor-header">使用语义向量搜索推荐内容<button data-href="#Recommending-content-using-semantic-vector-search" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>搜狐新闻的用户档案是根据浏览历史记录建立的，并在用户搜索新闻内容并与之互动时进行调整。搜狐的推荐系统使用语义向量搜索来查找相关新闻文章。该系统的工作原理是根据用户的浏览历史记录识别出一组用户可能感兴趣的标签。然后，该系统会快速搜索相关文章，并根据受欢迎程度（以平均点击率衡量）对结果进行排序，然后再提供给用户。</p>
<p>仅《纽约时报》一天就发布<a href="https://www.theatlantic.com/technology/archive/2016/05/how-many-stories-do-newspapers-publish-per-day/483845/">230 篇内容</a>，由此可见，一个有效的推荐系统必须能够处理大量的新内容。接收大量新闻需要毫秒级的相似性搜索和每小时将标签与新内容进行匹配。搜狐之所以选择 Milvus，是因为它能高效、准确地处理海量数据集，减少搜索过程中的内存占用，并支持高性能部署。</p>
<h2 id="Understanding-a-news-recommendation-system-workflow" class="common-anchor-header">了解新闻推荐系统的工作流程<button data-href="#Understanding-a-news-recommendation-system-workflow" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>搜狐基于语义向量搜索的内容推荐依赖于深度结构化语义模型（DSSM），该模型使用两个神经网络将用户查询和新闻文章表示为向量。该模型计算两个语义向量的余弦相似度，然后将最相似的一批新闻发送到推荐候选池。接下来，根据预估点击率对新闻文章进行排序，并向用户展示预估点击率最高的文章。</p>
<h3 id="Encoding-news-articles-into-semantic-vectors-with-BERT-as-service" class="common-anchor-header">利用 BERT-as-service 将新闻文章编码为语义向量</h3><p>为了将新闻文章编码成语义向量，系统使用了<a href="https://github.com/hanxiao/bert-as-service.git">BERT-as-service</a>工具。在使用该模型时，如果任何一篇内容的字数超过 512，嵌入过程中就会出现信息丢失。为帮助克服这一问题，系统首先提取摘要并将其编码为 768 维语义向量。然后从每篇新闻文章中提取两个最相关的主题，并根据主题 ID 确定相应的预训练主题向量（200 维）。接着将主题向量拼接到从文章摘要中提取的 768 维语义向量中，形成 968 维语义向量。</p>
<p>新内容不断通过 Kafta 输入，并在插入 Milvus 数据库之前被转换成语义向量。</p>
<h3 id="Extracting-semantically-similar-tags-from-user-profiles-with-BERT-as-service" class="common-anchor-header">利用 BERT-as-service 从用户资料中提取语义相似的标签</h3><p>模型的其他神经网络是用户语义向量。根据兴趣、搜索查询和浏览历史，从用户资料中提取语义相似的标签（如冠状病毒、covid、COVID-19、大流行、新型毒株、肺炎）。获取的标签列表按权重排序，前 200 个标签被分为不同的语义组。每个语义组内标签的排列组合用于生成新的标签短语，然后通过 BERT-as-service 将其编码为语义向量。</p>
<p>对于每个用户配置文件，标签短语集都有<a href="https://github.com/baidu/Familia">相应的主题集</a>，这些<a href="https://github.com/baidu/Familia">主题集用</a>权重标记，表示用户的兴趣水平。从所有相关主题中选出前两个主题，由机器学习（ML）模型进行编码，拼接成相应的标签语义向量，形成一个 968 维的用户语义向量。即使系统为不同的用户生成了相同的标签，但标签及其对应主题的权重不同，以及每个用户的主题向量之间存在明确的差异，确保了推荐的唯一性</p>
<p>通过计算从用户资料和新闻文章中提取的语义向量的余弦相似度，系统能够进行个性化的新闻推荐。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Sohu01_1e466fe0c3.jpg" alt="Sohu01.jpg" class="doc-image" id="sohu01.jpg" />
   </span> <span class="img-wrapper"> <span>搜狐01.jpg</span> </span></p>
<h3 id="Computing-new-semantic-user-profile-vectors-and-inserting-them-to-Milvus" class="common-anchor-header">计算新的语义用户资料向量并将其插入 Milvus</h3><p>语义用户资料向量每天计算一次，前 24 小时的数据在第二天晚上处理。向量被单独插入 Milvus，并通过查询流程运行，为用户提供相关的新闻结果。新闻内容本身具有时事性，因此需要每小时进行计算，以生成当前的新闻提要，其中包含预测点击率高且与用户相关的内容。新闻内容还按日期进行分区排序，每天清除旧新闻。</p>
<h3 id="Decreasing-semantic-vector-extraction-time-from-days-to-hours" class="common-anchor-header">将语义向量提取时间从几天缩短到几小时</h3><p>使用语义向量检索内容需要每天将数千万个标签短语转换成语义向量。这是一个耗时的过程，即使在图形处理器（GPU）上运行，也需要数天才能完成。为了克服这一技术问题，必须对之前嵌入的语义向量进行优化，这样当相似的标签短语浮出水面时，就能直接检索到相应的语义向量。</p>
<p>现有标签短语集的语义向量会被存储起来，而每天生成的新标签短语集会被编码成 MinHash 向量。<a href="https://milvus.io/docs/v1.1.1/metric.md">雅卡德距离</a>用于计算新标签词组的 MinHash 向量与保存的标签词组向量之间的相似度。如果 Jaccard 距离超过了预先设定的阈值，则这两个集合被认为是相似的。如果达到了相似度阈值，新短语就可以利用以前嵌入的语义信息。测试表明，在大多数情况下，0.8 以上的距离应能保证足够的准确性。</p>
<p>通过这一过程，上述数千万向量的每日转换时间从数天缩短到两小时左右。虽然根据具体项目的要求，其他存储语义向量的方法可能更合适，但在 Milvus 数据库中使用 Jaccard 距离计算两个标签短语之间的相似度，仍然是一种在各种情况下高效、准确的方法。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/Sohu02_d50fccc538.jpg" alt="Sohu02.jpg" class="doc-image" id="sohu02.jpg" />
   </span> <span class="img-wrapper"> <span>搜狐02.jpg</span> </span></p>
<h2 id="Overcoming-bad-cases-of-short-text-classification" class="common-anchor-header">克服短文本分类的 "坏情况<button data-href="#Overcoming-bad-cases-of-short-text-classification" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>在对新闻文本进行分类时，与长篇新闻相比，短篇新闻可提取的特征较少。正因为如此，当不同长度的内容在同一个分类器中运行时，分类算法就会失效。Milvus 通过搜索语义相似、得分可靠的多条长文本分类信息，然后使用投票机制修改短文本分类，从而帮助解决这一问题。</p>
<h3 id="Identifying-and-resolving-misclassified-short-text" class="common-anchor-header">识别和解决分类错误的短文本</h3><p>对每篇新闻文章进行精确分类对于提供有用的内容推荐至关重要。由于短新闻文章的特征较少，对不同长度的新闻使用相同的分类器会导致短文本分类的错误率较高。人工标注对于这项任务来说太慢且不准确，因此 BERT-as-service 和 Milvus 被用来快速识别成批被错误分类的短文，正确地重新分类，然后将成批数据作为语料库，针对这一问题进行训练。</p>
<p>BERT-as-service 用于将分类器得分大于 0.9 的共计 500 万篇长篇新闻文章编码为语义向量。将长文本文章插入 Milvus 后，再将短文本新闻编码成语义向量。每个短新闻语义向量用于查询 Milvus 数据库，获得与目标短新闻余弦相似度最高的前 20 篇长新闻。如果在语义相似度最高的前 20 篇长新闻中，有 18 篇出现在相同的分类中，且与查询的短新闻不同，则短新闻分类被认为是不正确的，必须进行调整以与这 18 篇长新闻保持一致。</p>
<p>这一过程可快速识别并纠正不准确的短文分类。随机抽样统计显示，短文分类纠正后，文本分类的总体准确率超过 95%。通过利用高置信度长文本的分类来纠正短文本的分类，大多数不良分类情况都能在短时间内得到纠正。这也为训练短文本分类器提供了良好的语料库。</p>
<p>![Sohu03.jpg](https://assets.zilliz.com/Sohu03_a43074cf5f.jpg "发现短文分类 "坏案例 "的流程图")</p>
<h2 id="Milvus-can-power-real-time-news-content-recommendation-and-more" class="common-anchor-header">Milvus 可为实时新闻内容推荐等提供动力<button data-href="#Milvus-can-power-real-time-news-content-recommendation-and-more" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>Milvus 极大地提高了搜狐新闻推荐系统的实时性能，同时也增强了识别短文分类错误的效率。如果您有兴趣了解 Milvus 及其各种应用：</p>
<ul>
<li>阅读我们的<a href="https://zilliz.com/blog">博客</a>。</li>
<li>在<a href="https://join.slack.com/t/milvusio/shared_invite/zt-e0u4qu3k-bI2GDNys3ZqX1YCJ9OM~GQ">Slack</a> 上与我们的开源社区互动。</li>
<li>在<a href="https://github.com/milvus-io/milvus/">GitHub</a> 上使用或贡献世界上最流行的向量数据库。</li>
<li>使用我们的新<a href="https://github.com/milvus-io/bootcamp">启动训练营</a>快速测试和部署人工智能应用。</li>
</ul>


使用语义向量搜索推荐内容

<custom-h1>通过依赖解耦和测试容器化将编译速度提高 2.5 倍</custom-h1><p>复杂的内部和外部依赖关系会在整个开发过程中不断演变，编译环境（如操作系统或硬件架构）的变化也会导致编译时间延长。以下是在大型人工智能或 MLOps 项目中可能遇到的常见问题：</p>
<p><strong>编译时间过长</strong>- 代码集成每天都要进行数百次。在有数十万行代码的情况下，即使是很小的改动也可能导致通常需要一个或多个小时才能完成的全面编译。</p>
<p><strong>复杂的编译环境</strong>- 项目代码需要在不同的环境下进行编译，这涉及到不同的操作系统（如 CentOS 和 Ubuntu）、底层依赖（如 GCC、LLVM 和 CUDA）以及硬件架构。在特定环境下进行的编译通常无法在不同环境下运行。</p>
<p><strong>复杂的依赖关系</strong>- 项目编译涉及 30 多个组件间和第三方依赖关系。项目开发经常会导致依赖关系发生变化，不可避免地会造成依赖关系冲突。依赖项之间的版本控制非常复杂，更新依赖项的版本很容易影响其他组件。</p>
<p><strong>第三方依赖</strong>库<strong>下载缓慢或失败</strong>- 网络延迟或第三方依赖库不稳定会导致资源下载缓慢或访问失败，严重影响代码集成。</p>
<p>通过解耦依赖关系和实施测试容器化，我们在开发开源嵌入式相似性搜索项目<a href="https://milvus.io/">Milvus</a> 时，成功地将平均编译时间缩短了 60%。</p>
<p><br/></p>
<h3 id="Decouple-the-dependencies-of-the-project" class="common-anchor-header">解耦项目的依赖关系</h3><p>项目编译通常涉及大量内部和外部组件依赖。项目的依赖关系越多，管理起来就越复杂。随着软件的发展，更改或移除依赖关系以及识别这样做的影响会变得更加困难和昂贵。在整个开发过程中都需要定期维护，以确保依赖关系正常运行。 维护不善、复杂的依赖关系或有问题的依赖关系可能会导致冲突，从而减缓或阻碍开发。在实践中，这可能意味着滞后的资源下载、对代码集成产生负面影响的访问故障等。解耦项目依赖关系可以减少缺陷，缩短编译时间，加快系统测试，避免对软件开发造成不必要的拖累。</p>
<p>因此，我们建议对项目的依赖关系进行解耦：</p>
<ul>
<li>拆分具有复杂依赖关系的组件</li>
<li>使用不同的版本库进行版本管理。</li>
<li>使用配置文件管理版本信息、编译选项、依赖关系等。</li>
<li>将配置文件添加到组件库中，以便在项目迭代时更新。</li>
</ul>
<p><strong>组件间的编译优化</strong>--根据依赖关系和配置文件中记录的编译选项拉取并编译相关组件。标记并打包二进制编译结果和相应的清单文件，然后上传到你的私有资源库。如果未对组件或其依赖的组件进行更改，则根据清单文件回放其编译结果。对于网络延迟或第三方依赖库不稳定等问题，可尝试建立内部版本库或使用镜像版本库。</p>
<p>优化组件之间的编译</p>
<p>1.创建依赖关系图 - 使用组件库中的配置文件创建依赖关系图。使用依赖关系检索上游和下游依赖组件的版本信息（Git 分支、标签和 Git 提交 ID）和编译选项等。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/1_949dffec32.png" alt="1.png" class="doc-image" id="1.png" />
   </span> <span class="img-wrapper"> <span>1.png</span> </span></p>
<p>2<strong>.检查依赖关系</strong>--针对组件之间出现的循环依赖关系、版本冲突和其他问题生成警报。</p>
<p>3<strong>.扁平化依赖关系</strong>--通过深度优先搜索（DFS）对依赖关系进行排序，并将具有重复依赖关系的组件前置合并，形成依赖关系图。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/2_45130c55e4.png" alt="2.png" class="doc-image" id="2.png" />
   </span> <span class="img-wrapper"> <span>2.png</span> </span></p>
<p>4.使用 MerkleTree 算法生成哈希值（根哈希值），其中包含基于版本信息、编译选项等的每个组件的依赖关系。结合组件名称等信息，该算法可为每个组件生成唯一标签。</p>
<p>
  
   <span class="img-wrapper"> <img translate="no" src="https://assets.zilliz.com/3_6a4fcdf4e3.png" alt="3.png" class="doc-image" id="3.png" />
   </span> <span class="img-wrapper"> <span>3.png</span> </span></p>
<p>5.根据组件的唯一标签信息，检查私有软件仓库中是否存在相应的编译存档。如果检索到编译存档，则解压缩以获取播放清单文件；如果没有，则编译组件，标记生成的编译对象文件和清单文件，并上传到私有资源库。</p>
<p><br/></p>
<p><strong>在组件内实施编译优化</strong>- 选择特定语言的编译缓存工具来缓存编译对象文件，并将其上传到你的私有资源库中。对于 C/C++ 编译，可选择 CCache 等编译缓存工具来缓存 C/C++ 编译中间文件，然后在编译后将本地 CCache 缓存归档。此类编译缓存工具只需在编译后逐一缓存已更改的代码文件，并复制未更改代码文件的编译组件，使其直接参与最终编译。 组件内的编译优化包括以下步骤：</p>
<ol>
<li>在 Dockerfile 中添加必要的编译依赖。使用 Hadolint 对 Dockerfile 执行合规性检查，确保映像符合 Docker 的最佳实践。</li>
<li>根据项目冲刺版本（版本+构建）、操作系统等信息镜像编译环境。</li>
<li>运行镜像编译环境容器，并将镜像 ID 作为环境变量传输到容器中。下面是获取镜像 ID 的命令示例："docker inspect ' - type=image' - format '{{.ID}}' repository/build-env:v0.1-centos7"。</li>
<li>选择合适的编译缓存工具：输入要集成和编译代码的包含器，并在私有资源库中检查是否存在合适的编译缓存。如果有，请下载并解压到指定目录。所有组件编译完成后，编译缓存工具生成的缓存将根据项目版本和映像 ID 打包并上传到您的私有资源库。</li>
</ol>
<p><br/></p>
<h3 id="Further-compilation-optimization" class="common-anchor-header">进一步编译优化</h3><p>我们最初构建的版本占用了太多的磁盘空间和网络带宽，部署时间长，因此我们采取了以下措施：</p>
<ol>
<li>选择最精简的基础镜像以减小镜像大小，如 alpine、busybox 等。</li>
<li>减少图像层数。尽可能重复使用依赖关系。用"&amp;&amp;"合并多个命令。</li>
<li>清理图像生成过程中的中间产品。</li>
<li>尽可能使用图像缓存来构建图像。</li>
</ol>
<p>随着我们项目的不断推进，磁盘使用率和网络资源开始随着编译缓存的增加而飙升，而一些编译缓存却未得到充分利用。于是，我们做出了以下调整：</p>
<p><strong>定期清理缓存文件</strong>- 定期检查私有资源库（例如使用脚本），清理一段时间没有更改或下载次数不多的缓存文件。</p>
<p><strong>选择性编译缓存</strong>- 仅缓存需要资源的编译，跳过缓存不需要太多资源的编译。</p>
<p><br/></p>
<h3 id="Leveraging-containerized-testing-to-reduce-errors-improve-stability-and-reliability" class="common-anchor-header">利用容器化测试减少错误，提高稳定性和可靠性</h3><p>代码必须在不同的环境中编译，其中涉及各种操作系统（如 CentOS 和 Ubuntu）、底层依赖（如 GCC、LLVM 和 CUDA）以及特定的硬件架构。在特定环境下成功编译的代码在不同环境下会失败。通过在容器内运行测试，测试过程变得更快、更准确。</p>
<p>容器化可确保测试环境的一致性，并确保应用程序按预期运行。容器化测试方法将测试打包为镜像容器，并构建一个真正隔离的测试环境。我们的测试人员发现这种方法非常有用，最终将编译时间缩短了 60%。</p>
<p><strong>确保一致的编译环境</strong>- 由于编译后的产品对系统环境的变化非常敏感，因此在不同的操作系统中可能会出现未知的错误。我们必须根据编译环境的变化对编译后的产品缓存进行标记和归档，但它们很难归类。因此，我们引入了容器化技术来统一编译环境，以解决此类问题。</p>
<p><br/></p>
<h3 id="Conclusion" class="common-anchor-header">结论</h3><p>本文通过分析项目依赖关系，介绍了组件之间和组件内部编译优化的不同方法，为构建稳定高效的持续代码集成提供了思路和最佳实践。这些方法有助于解决复杂依赖关系导致的代码集成缓慢问题，统一容器内部的操作以保证环境的一致性，并通过回放编译结果和使用编译缓存工具缓存中间编译结果来提高编译效率。</p>
<p>上述做法使项目的编译时间平均缩短了 60%，大大提高了代码集成的整体效率。今后，我们将继续在组件之间和组件内部进行并行编译，以进一步缩短编译时间。</p>
<p><br/></p>
<p><em>本文采用了以下资料来源：</em></p>
<ul>
<li>"将源代码树与构建级组件解耦</li>
<li><a href="https://dev.to/brpaz/factors-to-consider-when-adding-third-party-dependencies-to-a-project-46hf">"在项目中添加第三方依赖关系时应考虑的因素</a></li>
<li><a href="https://queue.acm.org/detail.cfm?id=3344149">"软件依赖关系的生存</a></li>
<li><a href="https://www.cc.gatech.edu/~beki/t1.pdf">"理解依赖关系：软件开发中的协调挑战研究</a></li>
</ul>
<p><br/></p>
<h3 id="About-the-author" class="common-anchor-header">关于作者</h3><p>张志峰，Zilliz.com 高级 DevOps 工程师，从事开源向量数据库 Milvus 的开发工作，同时也是中国 LF 开源软件大学授权讲师。他拥有广州软件工程职业技术学院物联网专业学士学位。他的职业生涯主要参与和领导 CI/CD、DevOps、IT 基础架构管理、Cloud-Native 工具包、容器化和编译流程优化等领域的项目。</p>


通过依赖解耦和测试容器化将编译速度提高 2.5 倍

<custom-h1>走进 Milvus 1.1.0</custom-h1><p><a href="https://github.com/milvus-io">Milvus</a>是一个正在进行中的开源软件 (OSS) 项目，致力于构建世界上最快、最可靠的向量数据库。得益于开源社区的长期支持和 Zilliz 的赞助，Milvus v1.1.0 中的新功能是众多更新中的第一个。这篇博客文章介绍了 Milvus v1.1.0 包含的新功能、改进和错误修复。</p>
<p><strong>跳转到</strong></p>
<ul>
<li><a href="#new-features">新功能</a></li>
<li><a href="#improvements">改进</a></li>
<li><a href="#bug-fixes">错误修复</a></li>
</ul>
<p><br/></p>
<h2 id="New-features" class="common-anchor-header">新功能<button data-href="#New-features" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>与其他开放源码软件项目一样，Milvus 也是一个不断进步的项目。我们努力倾听用户和开源社区的意见，优先考虑最重要的功能。最新更新版本 Milvus v1.1.0 提供了以下新功能：</p>
<h3 id="Specify-partitions-with-getentitybyid-method-calls" class="common-anchor-header">使用<code translate="no">get_entity_by_id()</code> 方法调用指定分区</h3><p>为了进一步加速向量相似性搜索，Milvus 1.1.0 现在支持从指定分区检索向量。一般来说，Milvus 支持通过指定的向量 ID 查询向量。在 Milvus 1.0 中，调用方法<code translate="no">get_entity_by_id()</code> 会搜索整个 Collections，这对于大型数据集来说会比较耗时。从下面的代码中我们可以看到，<code translate="no">GetVectorsByIdHelper</code> 使用<code translate="no">FileHolder</code> 结构来循环查找特定的向量。</p>
<pre><code translate="no">std::vector&lt;meta::CollectionSchema&gt; collection_array; 
 <span class="hljs-type">auto</span> <span class="hljs-variable">status</span> <span class="hljs-operator">=</span> meta_ptr_-&gt;ShowPartitions(collection.collection_id_, collection_array); 
  
 collection_array.push_back(collection); 
 status = meta_ptr_-&gt;FilesByTypeEx(collection_array, file_types, files_holder); 
 <span class="hljs-keyword">if</span> (!status.ok()) { 
     std::<span class="hljs-type">string</span> <span class="hljs-variable">err_msg</span> <span class="hljs-operator">=</span> <span class="hljs-string">&quot;Failed to get files for GetVectorByID: &quot;</span> + status.message(); 
     LOG_ENGINE_ERROR_ &lt;&lt; err_msg; 
     <span class="hljs-keyword">return</span> status; 
 } 
  
 <span class="hljs-keyword">if</span> (files_holder.HoldFiles().empty()) { 
     LOG_ENGINE_DEBUG_ &lt;&lt; <span class="hljs-string">&quot;No files to get vector by id from&quot;</span>; 
     <span class="hljs-keyword">return</span> Status(DB_NOT_FOUND, <span class="hljs-string">&quot;Collection is empty&quot;</span>); 
 } 
  
 cache::CpuCacheMgr::GetInstance()-&gt;PrintInfo(); 
 status = GetVectorsByIdHelper(id_array, vectors, files_holder); 
DBImpl::GetVectorsByIdHelper(const IDNumbers&amp; id_array, std::vector&lt;engine::VectorsData&gt;&amp; vectors, 
                              meta::FilesHolder&amp; files_holder) { 
     <span class="hljs-comment">// attention: this is a copy, not a reference, since the files_holder.UnMarkFile will change the array internal </span>
     milvus::engine::meta::<span class="hljs-type">SegmentsSchema</span> <span class="hljs-variable">files</span> <span class="hljs-operator">=</span> files_holder.HoldFiles(); 
     LOG_ENGINE_DEBUG_ &lt;&lt; <span class="hljs-string">&quot;Getting vector by id in &quot;</span> &lt;&lt; files.size() &lt;&lt; <span class="hljs-string">&quot; files, id count = &quot;</span> &lt;&lt; id_array.size(); 
  
     <span class="hljs-comment">// sometimes not all of id_array can be found, we need to return empty vector for id not found </span>
     <span class="hljs-comment">// for example: </span>
     <span class="hljs-comment">// id_array = [1, -1, 2, -1, 3] </span>
     <span class="hljs-comment">// vectors should return [valid_vector, empty_vector, valid_vector, empty_vector, valid_vector] </span>
     <span class="hljs-comment">// the ID2RAW is to ensure returned vector sequence is consist with id_array </span>
     <span class="hljs-type">using</span> <span class="hljs-variable">ID2VECTOR</span> <span class="hljs-operator">=</span> std::map&lt;int64_t, VectorsData&gt;; 
     ID2VECTOR map_id2vector; 
  
     vectors.clear(); 
  
     <span class="hljs-type">IDNumbers</span> <span class="hljs-variable">temp_ids</span> <span class="hljs-operator">=</span> id_array; 
     <span class="hljs-keyword">for</span> (auto&amp; file : files) { 
<button class="copy-code-btn"></button></code></pre>
<p>但是，这个结构并没有经过<code translate="no">FilesByTypeEx()</code> 中任何分区的过滤。在 Milvus v1.1.0 中，系统可以向<code translate="no">GetVectorsIdHelper</code> 循环传递分区名称，这样<code translate="no">FileHolder</code> 就只包含指定分区的数据段。换句话说，如果你确切地知道用于搜索的向量属于哪个分区，就可以在<code translate="no">get_entity_by_id()</code> 方法调用中指定分区名称，从而加速搜索过程。</p>
<p>我们不仅修改了 Milvus 服务器层控制系统查询的代码，还更新了我们所有的 SDK（Python、Go、C++、Java 和 RESTful），增加了一个用于指定分区名称的参数。例如，在 pymilvus 中，<code translate="no">get_entity_by_id</code> <code translate="no">def get_entity_by_id(self, collection_name, ids, timeout=None)</code> 的定义更改为<code translate="no">def get_entity_by_id(self, collection_name, partition_tags=None, ids, timeout=None)</code> 。</p>
<p><br/></p>
<h3 id="Specify-partitions-with-deleteentitybyid-method-calls" class="common-anchor-header">使用<code translate="no">delete_entity_by_id()</code> 方法调用指定分区</h3><p>为了提高向量管理的效率，Milvus v1.1.0 现在支持在删除 Collections 中的向量时指定分区名称。在 Milvus 1.0 中，只能通过 ID 删除 Collections 中的向量。调用删除方法时，Milvus 会扫描集合中的所有向量。不过，在处理百万、十亿甚至万亿向量数据集时，只扫描相关分区的效率要高得多。与使用<code translate="no">get_entity_by_id()</code> 方法调用指定分区的新功能类似，我们使用相同的逻辑对 Milvus 代码进行了修改。</p>
<p><br/></p>
<h3 id="New-method-releasecollection" class="common-anchor-header">新方法<code translate="no">release_collection()</code></h3><p>为了释放 Milvus 用于在运行时加载 Collections 的内存，Milvus v1.1.0 中添加了一个新方法<code translate="no">release_collection()</code> ，用于从缓存中手动卸载特定的 Collections。</p>
<p><br/></p>
<h2 id="Improvements" class="common-anchor-header">改进<button data-href="#Improvements" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>虽然新功能通常都很流行，但改进已有功能也很重要。以下是与 Milvus v1.0 相比的升级和其他一般改进。</p>
<p><br/></p>
<h3 id="Improved-performance-of-getentitybyid-method-call" class="common-anchor-header">提高<code translate="no">get_entity_by_id()</code> 方法调用的性能</h3><p>下图是 Milvus v1.0 和 Milvus v1.1.0 的向量搜索性能比较：</p>
<blockquote>
<p>CPU：英特尔® 酷睿™ i7-8550U CPU @ 1.80GHz * 8<br/>段文件大小 = 1024 MB<br/>行数 = 1,000,000<br/>尺寸 = 128</p>
</blockquote>
<table>
<thead>
<tr><th style="text-align:center">查询 ID 编号</th><th style="text-align:center">v 1.0.0</th><th style="text-align:center">v1.1.0</th></tr>
</thead>
<tbody>
<tr><td style="text-align:center">10</td><td style="text-align:center">9 毫秒</td><td style="text-align:center">2 毫秒</td></tr>
<tr><td style="text-align:center">100</td><td style="text-align:center">149 毫秒</td><td style="text-align:center">19 ms</td></tr>
</tbody>
</table>
<p><br/></p>
<h3 id="Hnswlib-upgraded-to-v050" class="common-anchor-header">Hnswlib 升级至 v0.5.0</h3><p>Milvus 采用了多个广泛使用的索引库，包括 Faiss、NMSLIB、Hnswlib 和 Annoy，以简化为特定场景选择正确索引类型的过程。</p>
<p>在 Milvus 1.1.0 中，Hnswlib 已从 v0.3.0 升级到 v0.5.0，原因是在早期版本中发现了一个错误。此外，升级 Hnswlib 还提高了<code translate="no">addPoint()</code> 在索引构建中的性能。</p>
<p>一位 Zilliz 开发人员创建了一个拉取请求 (PR)，以改善 Hnswlib 在 Milvus 中构建索引时的性能。详情请参见<a href="https://github.com/nmslib/hnswlib/pull/298">PR #298</a>。</p>
<p>下图是 Hnswlib 0.5.0 与 PR 建议的<code translate="no">addPoint()</code> 性能比较：</p>
<blockquote>
<p>CPU：Intel® Core™ i7-8550U CPU @ 1.80GHz * 8<br/>数据集：sift_1M（行数 = 1000000，维数 = 128，空间 = L2</p>
</blockquote>
<table>
<thead>
<tr><th style="text-align:center"></th><th style="text-align:center">0.5.0</th><th style="text-align:center">PR-298</th></tr>
</thead>
<tbody>
<tr><td style="text-align:center">M = 16，ef_construction = 100</td><td style="text-align:center">274406 毫秒</td><td style="text-align:center">265631 ms</td></tr>
<tr><td style="text-align:center">M = 16, ef_construction = 200</td><td style="text-align:center">522411 毫秒</td><td style="text-align:center">499639 毫秒</td></tr>
</tbody>
</table>
<p><br/></p>
<h3 id="Improved-IVF-index-training-performance" class="common-anchor-header">改进的 IVF 索引训练性能</h3><p>创建索引包括训练、插入和将数据写入磁盘。Milvus 1.1.0 改进了索引构建的训练部分。下图是 Milvus 1.0 和 Milvus 1.1.0 的 IVF 索引训练性能比较：</p>
<blockquote>
<p>CPU：Intel® Core™ i7-8550U CPU @ 1.80GHz * 8<br/>数据集：sift_1m (row_count = 1000000, dim = 128, metric_type = L2)</p>
</blockquote>
<table>
<thead>
<tr><th style="text-align:center"></th><th style="text-align:center">v1.0.0 (ms)</th><th style="text-align:center">v1.1.0 (ms)</th></tr>
</thead>
<tbody>
<tr><td style="text-align:center">ivf_flat (nlist = 2048)</td><td style="text-align:center">90079</td><td style="text-align:center">81544</td></tr>
<tr><td style="text-align:center">ivf_pq (nlist = 2048, m=16)</td><td style="text-align:center">103535</td><td style="text-align:center">97115</td></tr>
<tr><td style="text-align:center">ivf_pq (nlist = 2048, m=32)</td><td style="text-align:center">108638</td><td style="text-align:center">104558</td></tr>
<tr><td style="text-align:center">ivf_flat (nlist = 4096)</td><td style="text-align:center">340643</td><td style="text-align:center">310685</td></tr>
<tr><td style="text-align:center">ivf_pq (nlist = 4096, m=16)</td><td style="text-align:center">351982</td><td style="text-align:center">323758</td></tr>
<tr><td style="text-align:center">ivf_pq (nlist = 4096, m=32)</td><td style="text-align:center">357359</td><td style="text-align:center">330887</td></tr>
</tbody>
</table>
<p><br/></p>
<h2 id="Bug-fixes" class="common-anchor-header">错误修正<button data-href="#Bug-fixes" class="anchor-icon" translate="no">
      <svg translate="no"
        aria-hidden="true"
        focusable="false"
        height="20"
        version="1.1"
        viewBox="0 0 16 16"
        width="16"
      >
        <path
          fill="#0092E4"
          fill-rule="evenodd"
          d="M4 9h1v1H4c-1.5 0-3-1.69-3-3.5S2.55 3 4 3h4c1.45 0 3 1.69 3 3.5 0 1.41-.91 2.72-2 3.25V8.59c.58-.45 1-1.27 1-2.09C10 5.22 8.98 4 8 4H4c-.98 0-2 1.22-2 2.5S3 9 4 9zm9-3h-1v1h1c1 0 2 1.22 2 2.5S13.98 12 13 12H9c-.98 0-2-1.22-2-2.5 0-.83.42-1.64 1-2.09V6.25c-1.09.53-2 1.84-2 3.25C6 11.31 7.55 13 9 13h4c1.45 0 3-1.69 3-3.5S14.5 6 13 6z"
        ></path>
      </svg>
    </button></h2><p>我们还修复了一些错误，使 Milvus 在管理向量数据集时更稳定、更高效。更多详情，请参阅 "<a href="https://milvus.io/docs/v1.1.0/release_notes.md#Fixed-issues">已修复问题</a>"。</p>


介绍 Milvus 2.5：全文搜索、更强大的元数据过滤功能和可用性改进！

如何开始使用 Milvus

Elasticsearch 已死，词法搜索万岁

使用 Milvus 2.5 开始混合语义/全文搜索

30,000+ VDB 工程师加入

如何开始使用 Milvus

Elasticsearch 已死，词法搜索万岁

使用 Milvus 2.5 开始混合语义/全文搜索

语义搜索与全文搜索：我要在 Milvus 2.5 中选择哪一个？

利用 Milvus 设计多租户 RAG：可扩展企业知识库的最佳实践

如何为 Milvus 做贡献：开发人员快速入门指南

HNSWlib 入门

加入 Milvus 办公时间，获得向量 DB 专家的支持！

Matryoshka Embeddings：多尺度的细节

问我任何关于 Milvus!

Zilliz Cloud

Hassle-free and 10x faster than Milvus

最有贡献的作者

Stefan Webb

David Wang

Jiang Chen