我尝试了 Qodo 的新嵌入模型 Qodo-Embed-1🤯

你好，开发者👋

最近，我试用了Qodo的Qodo-Embed-1，这是一个专为软件开发中的检索任务构建的全新先进代码嵌入模型。它的出色性能给我留下了深刻的印象，即使在较小的1.5B版本中也是如此🤏。

在本文中，我将详细介绍以下主题：

什么是代码嵌入？
Qodo-Embed-1-1.5B 是什么？
模型核心能力
亲身体验 Qodo-Embed-1-1.5B

让我们开始吧🚀

但是等等，在我们开始之前，让我们先了解一下：

什么是代码嵌入？

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

简单来说，代码嵌入就像将代码转换为智能数字，可以捕捉代码的含义，而不仅仅是它的外观。

就像谷歌地图为位置（latitude，longitude）提供 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比较它们的接近程度。
您会发现“那是一个幸福的人”与“那是一个非常幸福的人”更相似。

✅预期输出：模型返回最相似的句子和相似度分数
注意：分数范围从 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)

这里发生了什么？🤔

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

✅ 预期输出：该模型选择正确的基于 Flask 的代码片段，用于 RAG 管道中的代码增强。

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"]