Qodo-Embed-1代码嵌入模型测评

最近，我试用了 Qodo 的 Qodo-Embed-1，这是一个专为软件开发中的检索任务构建的最先进的代码嵌入模型。我对它的性能印象深刻，即使是较小的 1.5B 变体也表现得很好 🤏。

在这篇文章中，我将详细介绍以下主题：

代码嵌入是什么？

什么是 Qodo-Embed-1-1.5B？

模型核心能力

动手使用 Qodo-Embed-1-1.5B

但在我们开始之前，让我们先理解：

代码嵌入是什么？

代码嵌入将复杂的代码结构转换为数值向量，捕获代码的含义和功能。

简单来说，把代码嵌入看作是把你的代码转换为能够捕捉代码含义（而不仅仅是外观）的智能数字。

这就像 Google 地图给位置赋予 GPS 坐标（纬度、经度），代码嵌入给你的代码赋予一个向量（数字列表），这样机器就能理解和比较它。

例如，考虑这两个 Python 函数：

def add_numbers(a, b):
    return a + b

def sum_two_values(x, y):
    result = x + y
    return result

所以，如果两段代码做相似的事情，它们的嵌入在那个数字空间中会彼此接近，即使代码看起来不同。

什么是 Qodo-Embed-1-1.5B？

Qodo-Embed-1-1.5B 是一个轻量级（1.5B 参数）的最先进代码嵌入模型，专为软件开发领域的检索任务设计。

这个模型针对自然语言到代码以及代码到代码的检索进行了优化。

这个模型的核心能力：

🔍 代码搜索：支持在大型代码库中进行高效搜索

🧠 检索增强生成（RAG）：通过上下文理解增强代码生成

🤓 语义代码理解：捕捉代码片段之间的复杂关系

🌐 多语言支持：处理来自 9 种主要编程语言的代码（Python、C++、C#、Go、Java、JavaScript、PHP、Ruby、TypeScript）

📈 高维嵌入：生成丰富的 1536 维表示

如果你有兴趣了解更多信息，可以查看这个博客

动手使用 Qodo-Embed-1-1.5B

现在我们理解了什么是代码嵌入以及 Qodo-Embed-1-1.5B 能提供什么，

让我们深入了解如何开始使用这个模型，包含一些示例用例。

Qodo-Embed-1 有两种尺寸：

轻量版（1.5B）- Qodo-Embed-1-1.5B

中等版（7B）- Qodo-Embed-1-7B

你可以通过 Hugging Face Transformers 或 SentenceTransformers 库使用该模型。

# Install required libraries
pip install sentence-transformers

🔍 用例：句子相似度

让我们尝试通过相互比较来找到相似的句子。

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Load the model
model = SentenceTransformer("Qodo/Qodo-Embed-1-1.5B", trust_remote_code=True)

# Source sentence and comparison list
source_sentence = "That is a very happy person"
sentences_to_compare = [
    "That is a happy person",
    "That is a happy dog",
    "Today is a sunny day",
    "The man is joyful and smiling"
]

# Encode source and comparison sentences
source_embedding = model.encode([source_sentence])
comparison_embeddings = model.encode(sentences_to_compare)

# Compute cosine similarity (returns a 2D array)
similarity_scores = cosine_similarity(source_embedding, comparison_embeddings)[0]

# Find most similar sentence
most_similar_idx = int(np.argmax(similarity_scores))
most_similar_sentence = sentences_to_compare[most_similar_idx]
similarity_score = similarity_scores[most_similar_idx]

# Print results
print(f"Source Sentence: \"{source_sentence}\"")
print(f"Most Similar Sentence: \"{most_similar_sentence}\"")
print(f"Similarity Score: {similarity_score:.4f}")

这里发生了什么？🤔：

模型将每个句子转换成一个数字向量。

然后我们使用 cosine_similarity 来比较它们有多接近。

你会看到"That is a happy person"更相似于"That is a very happy person"。

✅ 预期输出：模型返回最相似的句子和相似度分数。注意：分数范围是 0 到 1，越高表示越相似。

Source Sentence: "That is a very happy person"
Most Similar Sentence: "That is a happy person"
Similarity Score: 0.9795

🔍 用例：代码搜索

现在，我们将尝试通过自然语言查询从多个代码片段中找到特定的代码片段。

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

model = SentenceTransformer("Qodo/Qodo-Embed-1-1.5B", trust_remote_code=True)

snippets = [
    """def binary_search(arr, target):
    low, high = 0, len(arr)-1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1""",

    """def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]""",

    """def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev"""
]

query = "How to reverse a linked list in Python"
query_embedding = model.encode(query)
snippets_embeddings = model.encode(snippets)

similarities = cosine_similarity([query_embedding], snippets_embeddings)
most_similar_idx = np.argmax(similarities)

print("Most relevant code snippet:")
print(snippets[most_similar_idx])

这里发生了什么？🤔

我们对自然语言查询和多个代码片段进行编码。

模型使用余弦相似度识别哪个片段与查询最相关。

✅ 预期输出：模型正确识别 reverse_linked_list 函数是最相关的匹配项。

Most relevant code snippet:
def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev

🔍 用例示例：带上下文理解的 RAG

现在让我们测试模型的上下文理解能力

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qodo/Qodo-Embed-1-1.5B", trust_remote_code=True)

user_prompt = "Create a Flask route that accepts POST requests and returns JSON"
context_snippets = [
    """from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/submit', methods=['POST'])
def submit():
    data = request.get_json()
    return jsonify(data)
""",
    """from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/items")
def create_item(request: Request):
    return {"message": "Item received"}"""
]

prompt_embedding = model.encode(user_prompt)
context_embeddings = model.encode(context_snippets)
scores = cosine_similarity([prompt_embedding], context_embeddings)

best_match = context_snippets[np.argmax(scores)]
print("Context snippet to augment generation:")
print(best_match)

这里发生了什么？🤔

我们尝试根据提供的 prompt 检索最相关的上下文片段。

✅ 预期输出：模型为 RAG 流程中的代码增强选择正确的基于 Flask 的片段。

Context snippet to augment generation:
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/submit', methods=['POST'])
def submit():
    data = request.get_json()
    return jsonify(data)

🔍 用例示例：多语言支持

现在让我们测试模型是否能够识别不同的编程语言。

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Qodo/Qodo-Embed-1-1.5B", trust_remote_code=True)

queries = [
    "How to define a function in Java",
    "How to create a list in Ruby"
]

snippets = [
    """public void greet() {
    System.out.println("Hello World");
}""",
    """my_list = ["apple", "banana", "cherry"]"""
]

query_embeddings = model.encode(queries)
snippet_embeddings = model.encode(snippets)
scores = cosine_similarity(query_embeddings, snippet_embeddings)

for i, query in enumerate(queries):
    best_match = snippets[np.argmax(scores[i])]
    print(f"Best match for '{query}':\n{best_match}\n")

✅ 预期输出：每个查询都被匹配到正确的语言特定代码片段，验证了模型的多语言能力。

Best match for 'How to define a function in Java':
public void greet() {
    System.out.println("Hello World");
}

Best match for 'How to create a list in Ruby':
my_list = ["apple", "banana", "cherry"]

我使用的示例旨在展示核心能力，你可以为更复杂的检索工作流扩展它们，也可以用自己的想法进行实验！🙂

👉 你可以在我的 GitHub 仓库中找到所有这些代码片段，并自己尝试。

所以，在每个示例中，模型都提供了正确和准确的结果。即使它只有 1.5B 参数，它的性能也能与大 3 到 4 倍的模型相媲美。

如果你正在构建 RAG 流程、内部代码搜索工具，或者只是想用智能检索来丰富你的开发环境，这是值得尝试的模型。

感谢你阅读到这里。如果你觉得这篇文章有用，请点赞和分享这篇文章。其他人也可能会觉得它有用。💖

在 GitHub 和 LinkedIn 上与我联系

如需进一步行动，你可以考虑屏蔽该用户和/或举报滥用行为