Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Primer uporabe: Vdelave kode

Lekcija 8 od 18 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Onkraj iskanja
  2. Analiza repozitorija
  3. Zaznavanje podvajanj
  4. Gručenje po funkcionalnosti
  5. Kontekstualni pomočnik za kodo
  6. Metrike kakovosti kode
  7. Ključne ugotovitve

Onkraj iskanja

Vdelave kode niso namenjene le semantičnemu iskanju. Omogočajo napredne aplikacije: analizo repozitorijev, gručenje, zaznavanje podvajanj in pomočnike pri razvoju. V tej lekciji boš te primere uporabe raziskal s konkretno kodo Python.

Ti štirje primeri uporabe imajo skupno lastnost: izkoriščajo geometrijo indeksa namesto poizvedbe. Ko so tvoje datoteke postavljene v vektorski prostor, njihovi relativni položaji pripovedujejo zgodbo o samem projektu: kaj je podobno čemu, kaj se ponavlja in kaj izstopa.

Analiza repozitorija

Analiziraj semantično strukturo projekta, da razumeš, kako je koda organizirana. K-srednje vrednosti (K-Means) združi datoteke v pet družin na podlagi njihove vektorske bližine, ne da bi kdaj pogledal drevo map. Rezultat je pogosto poučen: pri neurejenem projektu boš videl, da se datoteke iz zelo različnih imenikov znajdejo v istem gruči, ker se dejansko ukvarjajo z isto temo.

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}")

Parameter random_state=42 fiksira inicializacijo: brez njega bi dva zaporedna zagona dala različne številke gruče, zaradi česar bi bilo nemogoče primerjati analize skozi čas.

Zaznavanje podvajanj

Prepoznaj podvojeno ali skoraj podvojeno kodo v svoji zbirki. Za razliko od klasičnega orodja za zaznavanje, ki primerja besedilo, ta pristop odkrije tudi prepisana podvajanja – datoteko, kopirano iz enega modula v drugega, preimenovano, z drugačnimi spremenljivkami, a enako logiko.

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']}")

Notranja zanka se začne pri i + 1, da se vsak par primerja le enkrat. Vendar bodi previden glede stroškov: matrika podobnosti je kvadratna in pri več kot nekaj tisoč datotekah boš moral preklopiti na približni indeks namesto na izčrpni izračun. Znižanje praga z 0,95 na 0,92 zajame širšo mrežo za predelana podvajanja, vendar za ceno nekaj lažno pozitivnih rezultatov, ki jih je treba ročno razvrstiti.

Gručenje po funkcionalnosti

K-srednje vrednosti zahtevajo, da vnaprej poznaš število skupin, kar je pri odkrivanju projekta redko slučaj. DBSCAN obravnava to omejitev: sam določi število skupin in, kar je ključno, omogoča, da datoteka ne pripada nobeni – kar je pomen oznake „Nerazvrščeno” v spodnji kodi.

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}")

Pretvorba z 1 - cosine_similarity spremeni podobnost v razdaljo, kar je format, ki ga DBSCAN pričakuje z metric="precomputed". Parameter eps=0.3 torej pomeni, da sta dve datoteki sosednji od kosinusne podobnosti 0,7 naprej.

Kontekstualni pomočnik za kodo

Ta zadnji primer združuje prejšnje gradnike v pravi sistem RAG za kodo: iskanje ustreznih datotek, gradnja konteksta in nato klic LLM. Prag 0,5 filtrira vnaprej – modelu je bolje dati dve datoteki, ki sta resnično povezani z vprašanjem, kot tri, od katerih je ena izven teme in ga bo zavajala.

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)

Pot do datoteke se vstavi kot komentar nad vsakim izsekom. To ni okrasno: model ga uporabi za navajanje virov, razvijalec, ki bere odgovor, pa takoj ve, kam iti preverit.

Metrike kakovosti kode

Nazadnje vdelave pomagajo odkriti, kaj izstopa kot nenavadno. Funkcija izračuna težišče indeksa – „povprečno datoteko” projekta – nato pa izmeri, kako zelo vsaka odstopa. Z-rezultat, večji od 2, signalizira datoteko, ki ne spominja na nič drugega: včasih gre za kos kode, generiran ali kopiran od zunaj, včasih preprosto za edino datoteko, napisano v starem slogu. V obeh primerih je dober kandidat za pregled.

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']}")

Ne pozabi, da „netipično” ne pomeni „slabo”. Orodje ti da seznam datotek za ogled, ne obsodbe: to je izhodišče za človeški pregled, nikoli metrika za prikaz na nadzorni plošči kakovosti.

Ključne ugotovitve

  • Vdelave kode omogočajo samodejno gručenje po funkcionalnosti
  • Zaznavanje podvajanj uporablja prag kosinusne podobnosti (0,92–0,95)
  • Pomočnik za kodo združuje semantično iskanje z LLM za kodo RAG
  • Netipične datoteke (odstopanja) lahko signalizirajo kodo, ki potrebuje pregled
  • DBSCAN je primernejši od K-srednjih vrednosti, ko število skupin ni znano