Llama B を使用したリポジトリ(PR) とのチャット

Tobi.A より

導入：

大規模なリポジトリを操作する場合、プル リクエスト (PR)、特に数千行のコードを含むリポジトリに対応し続けることは、大きな課題となる可能性があります。特定の変更の影響を理解する場合でも、大規模なアップデートに対処する場合でも、PR レビューはすぐに膨大な作業になる可能性があります。これに取り組むために、私はこれらの大規模な PR 内の変更を迅速かつ効率的に理解できるプロジェクトの構築に着手しました。

検索拡張生成 (RAG) と Langtrace の可観測性ツールを組み合わせて、大規模な PR のレビュー プロセスを簡素化することを目的としたツール「Chat with Repo(PRs)」を開発しました。さらに、Llama 3.1B のパフォーマンスを GPT-4o と比較して文書化しました。このプロジェクトを通じて、これらのモデルがコードの説明と要約をどのように処理するのか、また、このユースケースに最適な速度と精度のバランスを提供するモデルはどれなのかを調査しました。 

このブログで使用されているすべてのコードはここにあります

詳細に入る前に、このプロジェクトで使用されている主要なツールの概要を説明しましょう。
LLM サービス:

• OpenAI API
• Groq API
• Ollama (ローカル LLM 用)

埋め込みモデル:

• SentenceTransformers (特に 'all-mpnet-base-v2')

ベクターデータベース:

• FAISS (Facebook AI 類似性検索)

LLM 可観測性:

• エンドツーエンドのトレースとメトリクスのための Langtrace

リポジトリとのチャットの仕組み:

Chat with Repo(PRs) システムは、PR 分析用のシンプルな RAG アーキテクチャを実装しています。まず、GitHub の API を介して PR データを取り込み、トークン制限を管理するために大きなファイルをチャンク化します。これらのチャンクは SentenceTransformers を使用してベクトル化され、コード セマンティクスをキャプチャする高密度の埋め込みが作成されます。 FAISS インデックスにより、これらの埋め込みに対するサブリニア時間類似性検索が可能になります。クエリには同じ埋め込みプロセスが適用され、コード インデックスとのセマンティック マッチングが容易になります。取得されたチャンクは、選択された LLM (OpenAI、Groq、または Ollama 経由) の動的コンテキストを形成し、コンテキスト化された推論を実行します。このアプローチでは、ベクトル検索の効率と LLM の生成力の両方を活用し、さまざまな PR の複雑さに適応する微妙なコードの理解が可能になります。最後に、Langtrace の統合により、埋め込みと LLM 操作に対するきめ細かな可観測性が提供され、RAG パイプラインにおけるパフォーマンスのボトルネックと潜在的な最適化に関する洞察が提供されます。その主要なコンポーネントについて詳しく見ていきましょう。

チャンク化プロセス:

このシステムのチャンク化プロセスは、大規模なプル リクエストを管理しやすくコンテキストが豊富な部分に分割するように設計されています。このプロセスの中核は、IngestionService クラス、特に chunk_large_file メソッドと create_chunks_from_patch メソッドに実装されます。
PR が取り込まれると、各ファイルのパッチが個別に処理されます。 chunk_large_file メソッドは、大きなファイルを分割します:

def chunk_large_file(self, file_patch: str, chunk_size: int = config.CHUNK_SIZE) -> List[str]:
    lines = file_patch.split('\n')
    chunks = []
    current_chunk = []
    current_chunk_size = 0

    for line in lines:
        line_size = len(line)
        if current_chunk_size + line_size > chunk_size and current_chunk:
            chunks.append('\n'.join(current_chunk))
            current_chunk = []
            current_chunk_size = 0
        current_chunk.append(line)
        current_chunk_size += line_size

    if current_chunk:
        chunks.append('\n'.join(current_chunk))

    return chunks

このメソッドは、構成されたチャンク サイズに基づいてファイルを分割し、各チャンクがこの制限を超えないようにします。これは行ベースのアプローチであり、サイズ制約内でコードの論理単位を可能な限りまとめて維持しようとします。
ファイルがチャンクに分割されると、create_chunks_from_patch メソッドが各チャンクを処理します。このメソッドは、各チャンクをコンテキスト情報で強化します。

def create_chunks_from_patch(self, repo_info, pr_info, file_info, repo_explanation, pr_explanation):

    code_blocks = self.chunk_large_file(file_info['patch'])
    chunks = []

    for i, block in enumerate(code_blocks):
        chunk_explanation = self.generate_safe_explanation(f"Explain this part of the code and its changes: {block}")

        chunk = {
            "code": block,
            "explanations": {
                "repository": repo_explanation,
                "pull_request": pr_explanation,
                "file": file_explanation,
                "code": chunk_explanation
            },
            "metadata": {
                "repo": repo_info["name"],
                "pr_number": pr_info["number"],
                "file": file_info["filename"],
                "chunk_number": i + 1,
                "total_chunks": len(code_blocks),
                "timestamp": pr_info["updated_at"]
            }
        }
        chunks.append(chunk)

LLM サービスを使用して、各コード ブロックの説明を生成します。
リポジトリ名、PR 番号、ファイル名、チャンク番号、タイムスタンプなどのメタデータが添付されます。
リポジトリやプル リクエストの説明など、より広範なコンテキストが含まれます。
このアプローチにより、各チャンクが単なるコードのスライスではなく、リッチでコンテキストを認識した単位になることが保証されます。

これには以下が含まれます:

• 実際のコードの変更
• それらの変更の説明
• ファイルレベルのコンテキスト
• PR レベルのコンテキスト
• リポジトリレベルのコンテキスト

埋め込みと類似性検索:

EmbeddingService クラスは、埋め込みの作成と類似性検索を処理します。
1.埋め込み作成:
各チャンクに対して、SentenceTransformer:
を使用して埋め込みを作成します。

text_to_embed = self.get_full_context(chunk)
embedding = self.model.encode([text_to_embed])[0]

埋め込みでは、コードの内容、コードの説明、ファイルの説明、PR の説明、リポジトリの説明が結合されます。
2.インデックス作成:
FAISS を使用してこれらの埋め込みのインデックスを作成します。

self.index.add(np.array([embedding]))

3.クエリ処理:
質問されると、クエリの埋め込みを作成し、類似性検索を実行します。

query_vector = self.model.encode([query])

D, I = self.index.search(query_vector, k)

4. Chunk Selection:
The system selects the top k chunks (default 3) with the highest similarity scores.
This captures both code structure and semantic meaning, allowing for relevant chunk retrieval even when queries don't exactly match code syntax. FAISS enables efficient similarity computations, making it quick to find relevant chunks in large repositories.

Langtrace Integration:

To ensure comprehensive observability and performance monitoring, we've integrated Langtrace into our "Chat with Repo(PRs)" application. Langtrace provides real-time tracing, evaluations, and metrics for our LLM interactions, vector database operations, and overall application performance.

Model Performance Evaluation: Llama 3.1 70b Open-Source vs. GPT-4o Closed-Source LLMs in Large-Scale Code Review:

To explore how open-source models compare to their closed-source counterparts in handling large PRs, I conducted a comparative analysis between Llama 3.1b (open-source) and GPT-4o (closed-source). The test case involved a significant update to the Langtrace's repository, with over 2,300 additions, nearly 200 deletions, 250 commits, and changes across 47 files. My goal was to quickly understand these specific changes and assess how each model performs in code review tasks.
Methodology:
I posed a set of technical questions related to the pull request (PR), covering:

• Specific code change explanations
• Broader architectural impacts
• Potential performance issues
• Compatibility concerns

Both models were provided with the same code snippets and contextual information. Their responses were evaluated based on:

• Technical accuracy
• Depth of understanding
• Ability to infer broader system impacts

Key Findings:

Code Understanding:

• Llama 3.1b performed well in understanding individual code changes, especially with workflow updates and React component changes.
• GPT-4o had a slight edge in connecting changes to the overall system architecture, such as identifying the ripple effect of modifying API routes on Prisma schema updates.

Knowledge of Frameworks:

• Both models demonstrated strong understanding of frameworks like React, Next.js, and Prisma.
• Llama 3.1b's versatility is impressive, particularly in web development knowledge, showing that open-source models are closing the gap on specialized domain expertise.

Architectural Insights:

• GPT-4o excelled in predicting the broader implications of local changes, such as how adjustments to token-counting methods could affect the entire application.
• Llama 3.1b, while precise in explaining immediate code impacts, was less adept at extrapolating these changes to system-wide consequences.

Handling Uncertainty:

• Both models appropriately acknowledged uncertainty when presented with incomplete data, which is crucial for reliable code review.
• Llama 3.1b's ability to express uncertainty highlights the progress open-source models have made in mimicking sophisticated reasoning.

Technical Detail vs. Broader Context:

• Llama 3.1b provided highly focused and technically accurate explanations for specific code changes.
• GPT-4o offered broader system context, though sometimes at the expense of missing finer technical details.

Question Comparison:

Below are examples of questions posed to both models, the expected output, and their respective answers:

Conclusion:

While GPT-4o remains stronger in broader architectural insights, Llama 3.1b's rapid progress and versatility in code comprehension make it a powerful option for code review. Open-source models are catching up quickly, and as they continue to improve, they could play a significant role in democratizing AI-assisted software development. The ability to tailor and integrate these models into specific development workflows could soon make them indispensable tools for reviewing, debugging, and managing large codebases.

We'd love to hear your thoughts! Join our community on Discord or reach out at support@langtrace.ai to share your experiences, insights, and suggestions. Together, we can continue advancing observability in LLM development and beyond.

Happy tracing!

有用的資源
Langtrace 入門 https://docs.langtrace.ai/introduction
Langtrace Twitter(X) https://x.com/langtrace_ai
Langtrace Linkedin https://www.linkedin.com/company/langtrace/about/
Langtrace 網站 https://langtrace.ai/
Langtrace Discord https://discord.langtrace.ai/
Langtrace Github https://github.com/Scale3-Labs/langtrace

以上がLlama B を使用したリポジトリ(PR) とのチャットの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。