Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Cás Úsáide: Leabaithe Cóid

Ceacht 8 as 18 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Thar cuardach
  2. Anailísíocht Stórtha
  3. Brath Dúbailtí
  4. Braislíú de réir Feidhmiúlachta
  5. Cúntóir Cóid Comhthéacsúil
  6. Méadrachtaí Cáilíochta Cóid
  7. Príomhphointí

Thar cuardach

Ní hamháin le haghaidh cuardaigh shéimeantigh atá leabaithe cóid. Osclaíonn siad feidhmchláir chun cinn: anailísíocht stórtha, braislíú, brath dúbailtí, agus cúntóirí forbartha. Sa cheacht seo, déanfaidh tú iniúchadh ar na cásanna úsáide seo le cód Python concreideach.

Tá tréith choiteann ag na ceithre chás úsáide seo: baineann siad úsáid as geoiméadracht an innéacs seachas ceist. Nuair a chuirtear do chomhaid i spás veicteoireach, insíonn a suíomhanna coibhneasta scéal faoin tionscadal féin: cad atá cosúil le cad, cad a athraítear, agus cad a sheasann amach.

Anailísíocht Stórtha

Déan anailís ar struchtúr séimeantach tionscadail chun tuiscint a fháil ar conas atá an cód eagraithe. Grúpálann K-Means comhaid i gcúig theaghlach bunaithe ar a ngaracht veicteoireach, gan féachaint ar an gcrann fillteáin ar chor ar bith. Is minic a bhíonn an toradh oideachasúil: ar thionscadal míshláintiúil, feicfidh tú comhaid ó fhillteáin an-éagsúla ag teacht le chéile sa bhraisle chéanna toisc go mbaineann siad leis an ábhar céanna i ndáiríre.

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

Deisíonn random_state=42 an tionscnaimh: gan é, thabharfadh dhá rith leantacha uimhreacha braisle éagsúla, rud a dhéanfadh sé dodhéanta anailísí a chur i gcomparáid le himeacht ama.

Brath Dúbailtí

Aithin cód atá dúbailte nó beagnach dúbailte i do bhunachar. Seachas uirlis bhratha chlasaiceach a dhéanann comparáid téacs, brathann an cur chuige seo dúbailtí athscríofa freisin—an comhad a cóipeáladh ó mhodúl amháin go ceann eile, a d’athainmníodh, le hathróga difriúla ach leis an loighic chéanna.

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

Tosaíonn an lúb inmheánach ag i + 1 chun gach péire a chur i gcomparáid uair amháin. Bí airdeallach ar an gcostas, áfach: tá an mhatrís cosúlachta cearnógach, agus thar roinnt mílte comhad beidh ort aistriú go hinnéacs garbh seachas ríomh uileghabhálach. Laghdú na tairsí ó 0.95 go 0.92 caitheann líon níos leithne le haghaidh dúbailtí athoibrithe, ar chostas roinnt dearbh-thoradh bréagach le sórtáil de láimh.

Braislíú de réir Feidhmiúlachta

Éilíonn K-Means go mbeadh a fhios agat líon na ngrúpaí roimh ré, rud nach bhfuil fíor go minic nuair a bhíonn tú ag teacht ar thionscadal. Pléann DBSCAN an teorainn seo: cinneann sé líon na ngrúpaí é féin agus, rud tábhachtach, ligeann sé do chomhad gan bheith in aon ghrúpa – sin brí an lipéid “Unclassified” sa chód thíos.

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

Tiontaíonn an comhshó trí 1 - cosine_similarity cosúlacht ina fhad, an formáid a bhfuil súil ag DBSCAN leis nuair a úsáidtear metric="precomputed". Ciallaíonn an paraiméadar eps=0.3 dá bhrí sin go bhfuil dhá chomhad ina gcomharsana ó chosúlacht chomhshínigh 0.7 ar aghaidh.

Cúntóir Cóid Comhthéacsúil

Tionólann an sampla deireanach seo na bloic thógála roimhe seo ina chóras RAG fíor le haghaidh cóid: cuardach ar chomhaid ábhartha, comhthéacs a thógáil, agus ansin glaoch ar an LLM. Scagann an tairseach 0.5 suas an sruth – is fearr dhá chomhad a thabhairt don mhúnla a bhaineann go díreach leis an gceist ná trí cinn, agus ceann acu as ábhar agus a chuirfidh amú air.

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)

Instealltar cosán an chomhaid mar thrácht os cionn gach blúire. Ní maisiúchán é seo: úsáideann an múnla é chun a fhoinse a lua, agus tá a fhios ag an bhforbróir a léann an freagra láithreach cá háit le dul lena fhíorú.

Méadrachtaí Cáilíochta Cóid

Ar deireadh, cabhraíonn leabaithe le fáil amach cad a sheasann amach mar rud neamhghnách. Ríomhann an fheidhm lárphointe an innéacs – “an meánchomhad” den tionscadal – agus tomhaiseann sí cé chomh fada agus a imíonn gach ceann uaidh. Léiríonn z-scór atá níos mó ná 2 comhad nach bhfuil cosúil le haon rud eile: uaireanta píosa cóid a ghineadh nó a cóipeáladh ón taobh amuigh, uaireanta an t-aon chomhad amháin a scríobhadh i seanstíl. I ngach cás, is hiarrthóir maith é le haghaidh athbhreithnithe.

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

Cuimhnigh nach gciallaíonn “neamhghnách” “droch-cháilíocht”. Tugann an uirlis liosta comhad duit le breathnú orthu, ní breithiúnas: is pointe tosaigh é le haghaidh athbhreithniú daonna, ní méadrach le taispeáint ar dheais cháilíochta riamh.

Príomhphointí

  • Cuireann leabaithe cóid braislíú uathoibríoch de réir feidhmiúlachta ar chumas
  • Úsáideann brath dúbailtí tairseach cosúlachta comhshínigh (0.92–0.95)
  • Comhcheanglaíonn cúntóir cóid cuardach séimeantach le LLM le haghaidh RAG cóid
  • Is féidir le comhaid neamhghnácha (eisceachtaí) cód a léiriú a d’fhéadfadh athbhreithniú a bheith ag teastáil uaidh
  • Is fearr DBSCAN ná K-Means nuair nach bhfuil a fhios líon na ngrúpaí