Sembang Dengan Repos(PR) Menggunakan Llama B

Oleh Tobi.A

pengenalan:

Apabila bekerja dengan repositori yang besar, mengikuti permintaan tarik (PR)-terutamanya yang mengandungi beribu-ribu baris kod-boleh menjadi cabaran sebenar. Sama ada memahami kesan perubahan tertentu atau menavigasi melalui kemas kini besar-besaran, ulasan PR boleh menjadi hebat dengan cepat. Untuk menangani perkara ini, saya bercadang untuk membina projek yang membolehkan saya memahami dengan cepat dan cekap perubahan dalam PR yang besar ini.

Menggunakan Retrieval-Augmented Generation (RAG) digabungkan dengan alatan kebolehmerhatian Langtrace, saya membangunkan "Chat with Repo(PRs)"-alat yang bertujuan untuk memudahkan proses menyemak PR yang besar. Selain itu, saya mendokumenkan dan membandingkan prestasi Llama 3.1B dengan GPT-4o. Melalui projek ini, saya meneroka cara model ini mengendalikan penjelasan dan ringkasan kod, dan yang manakah menawarkan keseimbangan kelajuan dan ketepatan terbaik untuk kes penggunaan ini. 

Semua kod yang digunakan dalam blog ini boleh didapati di sini

Sebelum kita menyelami butirannya, mari kita gariskan alatan utama yang digunakan dalam projek ini:
Perkhidmatan LLM:

• API OpenAI
• API Groq
• Ollama (untuk LLM tempatan)

Model Benam:

• Pengubah Ayat (khususnya 'all-mpnet-base-v2')

Pangkalan Data Vektor:

• FAISS (Carian Kesamaan AI Facebook)

LLM Kebolehmerhatian:

• Langtrace untuk pengesanan dan metrik hujung ke hujung

Cara Sembang dengan Repo berfungsi:

Sistem Sembang dengan Repo(PR) melaksanakan seni bina RAG yang mudah untuk analisis PR. Ia bermula dengan menelan data PR melalui API GitHub, memotong fail besar untuk mengurus had token. Bongkahan ini divektorkan menggunakan SentenceTransformers, mencipta benam padat yang menangkap semantik kod. Indeks FAISS membolehkan carian persamaan masa sub-linear ke atas benam ini. Pertanyaan menjalani proses pembenaman yang sama, memudahkan pemadanan semantik terhadap indeks kod. Potongan yang diambil membentuk konteks dinamik untuk LLM yang dipilih (melalui OpenAI, Groq atau Ollama), yang kemudiannya melakukan inferens berkonteks. Pendekatan ini memanfaatkan kedua-dua kecekapan carian vektor dan kuasa penjanaan LLM, membolehkan pemahaman kod bernuansa yang menyesuaikan diri dengan pelbagai kerumitan PR. Akhir sekali, integrasi Langtrace memberikan kebolehmerhatian yang terperinci ke dalam pembenaman dan operasi LLM, menawarkan cerapan tentang kesesakan prestasi dan potensi pengoptimuman dalam saluran paip RAG. Mari kita mendalami komponen utamanya.

Proses Pecah:

Proses chunking dalam sistem ini direka bentuk untuk memecahkan permintaan tarik besar kepada bahagian yang boleh diurus dan kaya konteks. Teras proses ini dilaksanakan dalam kelas IngestionService, terutamanya dalam kaedah chunk_large_file dan create_chunks_from_patch.
Apabila PR diserap, setiap patch fail diproses secara individu. Kaedah chunk_large_file bertanggungjawab untuk membelah fail besar:

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

Kaedah ini membahagikan fail berdasarkan saiz bahagian yang dikonfigurasikan, memastikan setiap bahagian tidak melebihi had ini. Ia adalah pendekatan berasaskan baris yang cuba memastikan unit logik kod bersama-sama sebanyak mungkin dalam kekangan saiz.
Setelah fail dipecahkan kepada bahagian, kaedah create_chunks_from_patch memproses setiap bahagian. Kaedah ini memperkayakan setiap bahagian dengan maklumat kontekstual:

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)

Ia menjana penjelasan untuk setiap blok kod menggunakan perkhidmatan LLM.
Ia melampirkan metadata termasuk nama repositori, nombor PR, nama fail, nombor ketulan dan cap masa.
Ia termasuk konteks yang lebih luas seperti penjelasan repositori dan permintaan tarik.
Pendekatan ini memastikan bahawa setiap bahagian bukan hanya sekeping kod, tetapi unit yang kaya dan peka konteks:

Ini termasuk:

• Kod sebenar berubah
• Penjelasan tentang perubahan tersebut
• Konteks peringkat fail
• Konteks peringkat PR
• Konteks peringkat repositori

Pembenaman dan Carian Persamaan:

Kelas EmbeddingService mengendalikan penciptaan embeddings dan carian persamaan:
1. Penciptaan Benam:
Untuk setiap bahagian, kami membuat pembenaman menggunakan SentenceTransformer:

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

Pembenaman menggabungkan kandungan kod, penjelasan kod, penjelasan fail, penjelasan PR dan penjelasan repositori.
2. Pengindeksan:
Kami menggunakan FAISS untuk mengindeks benam ini:

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

3. Pemprosesan Pertanyaan:
Apabila soalan ditanya, kami membuat pembenaman untuk pertanyaan dan melakukan carian persamaan:

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!

Useful Resources
Getting started with Langtrace https://docs.langtrace.ai/introduction
Langtrace Twitter(X) https://x.com/langtrace_ai
Langtrace Linkedin https://www.linkedin.com/company/langtrace/about/
Langtrace Website https://langtrace.ai/
Langtrace Discord https://discord.langtrace.ai/
Langtrace Github https://github.com/Scale3-Labs/langtrace

Atas ialah kandungan terperinci Sembang Dengan Repos(PR) Menggunakan Llama B. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!