Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Případová studie: Vnoření kódu

Lekce 8 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Víc než jen vyhledávání
  2. Analýza repozitáře
  3. Detekce duplicit
  4. Shlukování podle funkcionality
  5. Kontextový asistent pro kód
  6. Metriky kvality kódu
  7. Klíčové poznatky

Víc než jen vyhledávání

Vnoření kódu neslouží pouze k sémantickému vyhledávání. Otevírají dveře pokročilým aplikacím: analýze repozitářů, shlukování, detekci duplicit a asistentům pro vývoj. V této lekci si tyto případy použití projdeš na konkrétních příkladech v Pythonu.

Tyto čtyři scénáře mají společného jmenovatele: využívají geometrii indexu místo dotazu. Jakmile jsou tvé soubory umístěny do vektorového prostoru, jejich vzájemné polohy vyprávějí příběh o samotném projektu: co se čemu podobá, co se opakuje a co vyčnívá.

Analýza repozitáře

Analyzuj sémantickou strukturu projektu, abys pochopil, jak je kód organizován. Algoritmus K-Means seskupí soubory do pěti rodin na základě jejich vektorové blízkosti, aniž by se kdy podíval na strom složek. Výsledek bývá často poučný: u nepřehledného projektu uvidíš, že soubory z velmi odlišných adresářů skončí ve stejném shluku, protože se ve skutečnosti zabývají stejným tématem.

import numpy as np
from sklearn.cluster import KMeans
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def analyze_repo(code_files, n_clusters=5):
    """Analyze the semantic structure of a repository."""
    # Encode all files
    inputs = [f["content"][:3000] for f in code_files]
    response = client.embeddings.create(
        model="codestral-embed",
        inputs=inputs,
    )
    embeddings = np.array([d.embedding for d in response.data])

    # K-Means Clustering
    kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
    labels = kmeans.fit_predict(embeddings)

    # Group files by cluster
    clusters = {}
    for i, label in enumerate(labels):
        if label not in clusters:
            clusters[label] = []
        clusters[label].append(code_files[i]["path"])

    return clusters

# Usage
clusters = analyze_repo(code_files, n_clusters=5)
for cluster_id, files in clusters.items():
    print(f"\nCluster {cluster_id} ({len(files)} files):")
    for f in files[:5]:
        print(f"  - {f}")

Parametr random_state=42 fixuje inicializaci: bez něj by dva po sobě jdoucí běhy vrátily různá čísla shluků, což by znemožnilo porovnávání analýz v čase.

Detekce duplicit

Identifikuj zdvojený nebo téměř zdvojený kód ve své bázi. Na rozdíl od klasických nástrojů pro detekci, které porovnávají text, tento přístup odhalí i přepsané duplicity – soubor zkopírovaný z jednoho modulu do druhého, přejmenovaný, s jinými proměnnými, ale stejnou logikou.

from sklearn.metrics.pairwise import cosine_similarity

def find_duplicates(code_files, embeddings, threshold=0.95):
    """Find pairs of near-identical files."""
    sim_matrix = cosine_similarity(embeddings)
    duplicates = []

    for i in range(len(code_files)):
        for j in range(i + 1, len(code_files)):
            if sim_matrix[i][j] >= threshold:
                duplicates.append({
                    "file_a": code_files[i]["path"],
                    "file_b": code_files[j]["path"],
                    "similarity": float(sim_matrix[i][j]),
                })

    # Sort by decreasing similarity
    duplicates.sort(key=lambda x: x["similarity"], reverse=True)
    return duplicates

# Find duplicates
dupes = find_duplicates(code_files, embeddings, threshold=0.92)
print(f"{len(dupes)} potential duplicate pairs found:")
for d in dupes[:10]:
    print(f"  {d['similarity']:.3f} : {d['file_a']} <-> {d['file_b']}")

Vnitřní smyčka začíná na i + 1, aby se každý pár porovnal pouze jednou. Měj však na paměti náklady: matice podobnosti je kvadratická a u více než několika tisíc souborů budeš muset přejít na přibližný index místo vyčerpávajícího výpočtu. Snížení prahu z 0,95 na 0,92 zachytí širší síť pro přepracované duplicity, za cenu několika falešně pozitivních výsledků, které budeš muset ručně vytřídit.

Shlukování podle funkcionality

K-Means vyžaduje, abys předem znal počet skupin, což je při objevování projektu zřídka případ. DBSCAN toto omezení řeší: sám určí počet skupin a co je klíčové, umožňuje, aby soubor nepatřil k žádné z nich – to je význam štítku „Unclassified“ (Nezařazeno) v níže uvedeném kódu.

from sklearn.cluster import DBSCAN

def cluster_by_functionality(code_files, embeddings, eps=0.3, min_samples=2):
    """Group code by functionality using DBSCAN."""
    # DBSCAN on cosine distances
    distance_matrix = 1 - cosine_similarity(embeddings)
    clustering = DBSCAN(eps=eps, min_samples=min_samples, metric="precomputed")
    labels = clustering.fit_predict(distance_matrix)

    # Organize by cluster
    groups = {}
    for i, label in enumerate(labels):
        group_name = f"Group {label}" if label >= 0 else "Unclassified"
        if group_name not in groups:
            groups[group_name] = []
        groups[group_name].append(code_files[i]["path"])

    return groups

groups = cluster_by_functionality(code_files, embeddings)
for name, files in groups.items():
    print(f"\n{name} ({len(files)} files):")
    for f in files[:3]:
        print(f"  - {f}")

Převod pomocí 1 - cosine_similarity změní podobnost na vzdálenost, což je formát, který DBSCAN očekává s parametrem metric="precomputed". Parametr eps=0.3 tedy znamená, že dva soubory jsou sousedy od kosinové podobnosti 0,7 výše.

Kontextový asistent pro kód

Tento poslední příklad skládá předchozí stavební kameny do skutečného systému RAG pro kód: vyhledání relevantních souborů, sestavení kontextu a následné volání LLM. Práh 0,5 filtruje dopředu – je lepší dát modelu dva soubory skutečně související s otázkou než tři, z nichž jeden je mimo téma a model zmátne.

def code_assistant(question, code_files, embeddings, top_k=3):
    """Find relevant code to answer a question."""
    # Encode the question
    response = client.embeddings.create(
        model="codestral-embed",
        inputs=[question],
    )
    query_emb = np.array(response.data[0].embedding)

    # Find the most relevant code
    sims = cosine_similarity([query_emb], embeddings)[0]
    top_indices = np.argsort(sims)[::-1][:top_k]

    context_parts = []
    for idx in top_indices:
        if sims[idx] > 0.5:  # Minimum threshold
            context_parts.append(
                f"# File: {code_files[idx]['path']}\n"
                f"{code_files[idx]['content'][:1500]}"
            )

    context = "\n\n---\n\n".join(context_parts)

    # Build the prompt for the LLM
    prompt = f"""Here is relevant code from our project:

{context}

Developer question: {question}

Answer based on the code above."""

    # Call the LLM with context
    chat_response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}],
    )

    return chat_response.choices[0].message.content

# Usage
answer = code_assistant(
    "How does authentication work in this project?",
    code_files,
    embeddings,
)
print(answer)

Cesta k souboru je vložena jako komentář nad každý úryvek. Není to jen ozdoba: model ji používá k citaci zdrojů a vývojář čtoucí odpověď okamžitě ví, kam se má jít podívat pro ověření.

Metriky kvality kódu

Nakonec vnoření pomáhají odhalit to, co vyčnívá jako neobvyklé. Funkce vypočítá centroid indexu – „průměrný soubor“ projektu – a poté změří, jak moc se od něj každý soubor liší. Z-skóre větší než 2 signalizuje soubor, který se ničemu jinému nepodobá: někdy jde o kód vygenerovaný nebo zkopírovaný zvenčí, jindy prostě o jediný soubor napsaný ve starém stylu. V obou případech je to dobrý kandidát na revizi.

def detect_outliers(code_files, embeddings, threshold=2.0):
    """Detect atypical code files."""
    # Calculate the centroid (mean vector)
    centroid = embeddings.mean(axis=0)

    # Distance of each file to the centroid
    distances = np.linalg.norm(embeddings - centroid, axis=1)

    # Files beyond N standard deviations
    mean_dist = distances.mean()
    std_dist = distances.std()

    outliers = []
    for i, dist in enumerate(distances):
        z_score = (dist - mean_dist) / std_dist
        if z_score > threshold:
            outliers.append({
                "path": code_files[i]["path"],
                "z_score": float(z_score),
            })

    outliers.sort(key=lambda x: x["z_score"], reverse=True)
    return outliers

outliers = detect_outliers(code_files, embeddings)
print(f"{len(outliers)} atypical files:")
for o in outliers:
    print(f"  z={o['z_score']:.2f} : {o['path']}")

Pamatuj, že „atypický“ neznamená „špatný“. Nástroj ti dává seznam souborů k prohlédnutí, nikoliv rozsudek: je to výchozí bod pro lidskou revizi, nikdy metrika pro zobrazení na dashboardu kvality.

Klíčové poznatky

  • Vnoření kódu umožňují automatické shlukování podle funkcionality
  • Detekce duplicit využívá práh kosinové podobnosti (0,92–0,95)
  • Asistent pro kód kombinuje sémantické vyhledávání s LLM pro kódové RAG
  • Atypické soubory (odlehlé hodnoty) mohou signalizovat kód potřebující revizi
  • DBSCAN je vhodnější než K-Means, když není znám počet skupin