如何计算源代码文档相似度？如何检测源代码的共同作者归属概率？

Hey there! Let's dive into how to tackle code authorship attribution (figuring out the probability that a person or company wrote specific web/program code) by focusing on those unique "feature fingerprints" you mentioned—way smarter than just basic TF-IDF or embedding similarity.

These are the tiny, consistent habits that make a coder's work recognizable:

• Comment & Abbreviation Style: Think unique comment patterns (like // FIXME: J.D. with initials, or love for block comments explaining every edge case), go-to abbreviations (is it cfg or config? usr or user?), even tone (do they throw in emojis in comments or keep it super dry?). You can use regex to scrape comments and count frequency of specific shorthands or patterns.
• Folder & File Structure: Do they always stick tests in a top-level tests/ folder or nest them next to source files? Do they group utilities under helpers/ vs utils/? Are filenames always snake_case or PascalCase? Parse the project directory tree and turn this structure into a structured feature (like a hash of the directory hierarchy or a vector representing common folder names).
• Third-Party Tool Preferences: For web code, do they default to pnpm over npm? Backend projects—do they reach for Django ORM instead of SQLAlchemy? Even specific dependency versions (like always using Lodash v4.x) count. Pull data from package.json, requirements.txt, pom.xml, etc., to build a dependency preference profile.
• Code Element Ordering: How do they sort import statements? (Built-in libs first → third-party → local modules? Or alphabetical?) Do they put required function parameters before optional ones, or vice versa? Use AST (Abstract Syntax Tree) parsers to extract these structural patterns—ASTs let you dig into code structure without getting bogged down by variable names.

Forget one-size-fits-all NLP here—we need to combine these unique fingerprints:

• Convert each fingerprint dimension into a quantifiable feature: For example, comment style can be represented with n-gram counts, folder structure with a tree-based embedding, and dependency preferences with a one-hot encoded vector of common tools.
• Use multimodal feature fusion to combine all these into a single comprehensive vector. This way, you're not just looking at text—you're looking at the full "personality" of the code.
• For modeling, start with interpretable models like Random Forest or XGBoost (great for seeing which fingerprints are driving attribution). If you have limited author samples, try few-shot learning or contrastive learning to group similar fingerprint patterns together.

Once your model is trained:

• For unknown code, extract all its fingerprint features and compare it against your known author/company profiles.
• Output probability scores for each candidate—weighting higher-confidence features more heavily. For example, if a codebase uses a super rare comment pattern only seen in Company X's repos, that should bump up Company X's attribution probability significantly.
• Add a confidence metric too: If most fingerprints align with one author, give a high probability; if features are mixed, list top candidates with their respective scores.

内容的提问来源于stack exchange，提问作者Hendrik