[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6KF4P0183NWPTH33VG41NAC":3,"skill-same:01M6KF4P0183NWPTH33VG41NAC":51},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":24,"linkOnly":25,"markdownContent":26,"markdownBody":27,"frontMatter":28,"refName":29,"commitSha":30,"skillDirectory":31,"forksCount":32,"repositoryHtmlUrl":33,"repositoryHomepageUrl":34,"ownerHtmlUrl":35,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":36,"install":37,"resources":50},"01M6KF4P0183NWPTH33VG41NAC","run2_greedy_matching",null,"Greedy one-to-one matching of cluster centroids to expert points with maximum distance constraint","cxcscmu\u002FSkillLearnBench","cxcscmu","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F142838272?v=4","01M6KCQDFQWPDSN0MKZY96MSQP","01M6KCQDM7G70TKJ28NTSQC0RZ",92,"MIT","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fb2-self-feedback-claude-haiku-4-5\u002Fdbscan-parameter-tuning\u002Frun2_greedy_matching\u002FSKILL.md",[],[18,19,20,21,22,23],"matching","run2 greedy matching","expert","cluster","with","constraint","2026-11-10 10:12:30",false,"---\nname: run2_greedy_matching\ndescription: Greedy one-to-one matching of cluster centroids to expert points with maximum distance constraint\n---\n\n# Greedy Matching: Cluster Centroids to Expert Points\n\n## Problem Statement\n\n**Input**:\n- Cluster centroids from DBSCAN (variable number per image)\n- Expert annotations (ground truth points)\n\n**Goal**: Find best one-to-one matching between clusters and experts.\n\n**Constraints**:\n- Each cluster matches to at most one expert\n- Each expert matches to at most one cluster\n- Maximum allowed distance: 100 pixels (standard Euclidean)\n- No matches beyond 100 pixels\n\n## Algorithm: Greedy Nearest-Neighbor Matching\n\nThe greedy algorithm matches pairs in order of **increasing distance**, skipping pairs where either endpoint is already matched.\n\n### Step-by-Step\n\n```python\nimport numpy as np\nfrom scipy.spatial.distance import cdist\n\ndef greedy_match(cluster_centroids, expert_points, max_distance=100):\n    \"\"\"\n    Greedily match cluster centroids to expert points.\n\n    Algorithm:\n    1. Compute all pairwise Euclidean distances (standard, not custom)\n    2. Create list of valid pairs (distance ≤ max_distance)\n    3. Sort by distance (ascending)\n    4. Iterate through sorted pairs:\n       - If both endpoints unmatched: create match, mark as matched\n       - Otherwise: skip (one endpoint already matched)\n    5. Return all created matches and their distances\n\n    Parameters:\n    - cluster_centroids: (n_clusters, 2) array of [x, y]\n    - expert_points: (n_experts, 2) array of [x, y]\n    - max_distance: float, maximum Euclidean distance for valid match (default: 100)\n\n    Returns:\n    - matches: list of (centroid_idx, expert_idx) tuples\n    - match_distances: list of distances for each match\n    \"\"\"\n    # Handle empty inputs\n    if len(cluster_centroids) == 0 or len(expert_points) == 0:\n        return [], []\n\n    # Compute pairwise STANDARD Euclidean distances (not custom weighted)\n    distances = cdist(cluster_centroids, expert_points, metric='euclidean')\n\n    # Track which endpoints are already matched\n    unmatched_centroids = set(range(len(cluster_centroids)))\n    unmatched_experts = set(range(len(expert_points)))\n\n    # Create list of valid candidate pairs\n    valid_pairs = []\n    for i in range(len(cluster_centroids)):\n        for j in range(len(expert_points)):\n            if distances[i, j] \u003C= max_distance:\n                valid_pairs.append((distances[i, j], i, j))\n\n    # Sort by distance (ascending)\n    valid_pairs.sort()\n\n    # Greedy matching\n    matches = []\n    match_distances = []\n    for dist, centroid_idx, expert_idx in valid_pairs:\n        # Only match if both endpoints are still unmatched\n        if centroid_idx in unmatched_centroids and expert_idx in unmatched_experts:\n            matches.append((centroid_idx, expert_idx))\n            match_distances.append(dist)\n            unmatched_centroids.remove(centroid_idx)\n            unmatched_experts.remove(expert_idx)\n\n    return matches, match_distances\n```\n\n## Why Greedy Works Well\n\n### 1. Computational Efficiency\n- O(n·m log(n·m)) sorting + O(n·m) iteration\n- Fast for typical image sizes (hundreds of points)\n\n### 2. Reasonable Quality\n- Greedy on sorted distances is \"locally optimal\"\n- Avoids blocking good matches\n- Not globally optimal, but typically within 5-10% of optimal\n\n### 3. Interpretability\n- Easy to verify: check that all matches are valid\n- No complex hyperparameters to tune\n\n### 4. Stability\n- Deterministic output for same input\n- No randomization\n\n## Maximum Distance Constraint: 100 Pixels\n\nThe 100-pixel threshold:\n- Represents typical cloud feature size in Mars images (~1728×880 pixels)\n- Prevents spurious matches far from expert annotations\n- Effective false positive filtering\n\n```python\n# Example: Rejecting distant matches\nif distance > 100:\n    # Skip this pair, do not consider for matching\n    continue\n```\n\n## Computing Cluster Centroids\n\n```python\ndef get_cluster_centroids(points, labels):\n    \"\"\"\n    Compute centroid for each cluster from DBSCAN labels.\n\n    Parameters:\n    - points: (n_points, 2) array of [x, y] coordinates\n    - labels: DBSCAN labels (integer, -1 for noise points)\n\n    Returns:\n    - centroids: (n_clusters, 2) array of cluster centroids (excluding noise)\n    \"\"\"\n    unique_labels = set(labels)\n\n    # Remove noise label (-1)\n    if -1 in unique_labels:\n        unique_labels.remove(-1)\n\n    centroids = []\n    for label in sorted(unique_labels):\n        # Get all points with this label\n        cluster_points = points[labels == label]\n\n        # Compute mean coordinate\n        centroid = cluster_points.mean(axis=0)\n        centroids.append(centroid)\n\n    return np.array(centroids) if centroids else np.empty((0, 2))\n```\n\n## Integration with DBSCAN\n\n```python\nfrom sklearn.cluster import DBSCAN\n\ndef cluster_and_match(image_points, expert_points, distance_matrix, epsilon, min_samples):\n    \"\"\"\n    Complete workflow: DBSCAN → centroids → matching.\n    \"\"\"\n    # Run DBSCAN with custom distance matrix\n    clusterer = DBSCAN(eps=epsilon, min_samples=min_samples, metric='precomputed')\n    labels = clusterer.fit_predict(distance_matrix)\n\n    # Compute centroids\n    centroids = get_cluster_centroids(image_points, labels)\n\n    # Match centroids to experts (using standard Euclidean)\n    matches, match_distances = greedy_match(centroids, expert_points, max_distance=100)\n\n    return matches, match_distances\n```\n\n## Edge Cases\n\n### 1. No Clusters\n```python\nif len(centroids) == 0:\n    matches = []\n    match_distances = []\n    # → Results in: F1 = 0.0, delta = NaN\n```\n\n### 2. No Experts\n```python\nif len(expert_points) == 0:\n    matches = []\n    # → Results in: F1 = 0.0 (recall = 0), delta = NaN\n```\n\n### 3. No Valid Pairs (all distances > 100)\n```python\nvalid_pairs = []  # Empty after filtering by max_distance\nmatches = []\n# → Results in: F1 = 0.0, delta = NaN\n```\n\n### 4. Single Cluster and Single Expert\n```python\nif len(centroids) == 1 and len(expert_points) == 1:\n    distance = euclidean_distance(centroids[0], expert_points[0])\n    if distance \u003C= 100:\n        matches = [(0, 0)]\n        match_distances = [distance]\n    else:\n        matches = []\n        match_distances = []\n```\n\n## Verification\n\n```python\ndef verify_matching(matches, n_clusters, n_experts):\n    \"\"\"\n    Sanity checks for matching result.\n    \"\"\"\n    # Check 1: No duplicate centroids\n    centroid_indices = [m[0] for m in matches]\n    assert len(centroid_indices) == len(set(centroid_indices)), \\\n        \"Duplicate centroid in matches\"\n\n    # Check 2: No duplicate experts\n    expert_indices = [m[1] for m in matches]\n    assert len(expert_indices) == len(set(expert_indices)), \\\n        \"Duplicate expert in matches\"\n\n    # Check 3: All indices in valid range\n    assert all(0 \u003C= i \u003C n_clusters for i in centroid_indices), \\\n        \"Centroid index out of range\"\n    assert all(0 \u003C= j \u003C n_experts for j in expert_indices), \\\n        \"Expert index out of range\"\n\n    # Check 4: Matches ≤ min(clusters, experts)\n    assert len(matches) \u003C= min(n_clusters, n_experts), \\\n        \"Too many matches\"\n\n    print(f\"✓ Matching verified: {len(matches)} matches\")\n```\n\n## Note: Standard vs. Custom Distance\n\n**Critical**: Always use **standard Euclidean distance** for matching, NOT the custom weighted distance:\n\n```python\n# ✓ Correct: Standard Euclidean\ndistances = cdist(centroids, experts, metric='euclidean')\n\n# ✗ Wrong: Using custom weighted distance would bias matching\n# based on hyperparameter choice, not actual spatial accuracy\n```\n\nThe custom distance is only for **clustering** (DBSCAN), not for **evaluation** or **matching**.\n","# Greedy Matching: Cluster Centroids to Expert Points\n\n## Problem Statement\n\n**Input**:\n- Cluster centroids from DBSCAN (variable number per image)\n- Expert annotations (ground truth points)\n\n**Goal**: Find best one-to-one matching between clusters and experts.\n\n**Constraints**:\n- Each cluster matches to at most one expert\n- Each expert matches to at most one cluster\n- Maximum allowed distance: 100 pixels (standard Euclidean)\n- No matches beyond 100 pixels\n\n## Algorithm: Greedy Nearest-Neighbor Matching\n\nThe greedy algorithm matches pairs in order of **increasing distance**, skipping pairs where either endpoint is already matched.\n\n### Step-by-Step\n\n```python\nimport numpy as np\nfrom scipy.spatial.distance import cdist\n\ndef greedy_match(cluster_centroids, expert_points, max_distance=100):\n    \"\"\"\n    Greedily match cluster centroids to expert points.\n\n    Algorithm:\n    1. Compute all pairwise Euclidean distances (standard, not custom)\n    2. Create list of valid pairs (distance ≤ max_distance)\n    3. Sort by distance (ascending)\n    4. Iterate through sorted pairs:\n       - If both endpoints unmatched: create match, mark as matched\n       - Otherwise: skip (one endpoint already matched)\n    5. Return all created matches and their distances\n\n    Parameters:\n    - cluster_centroids: (n_clusters, 2) array of [x, y]\n    - expert_points: (n_experts, 2) array of [x, y]\n    - max_distance: float, maximum Euclidean distance for valid match (default: 100)\n\n    Returns:\n    - matches: list of (centroid_idx, expert_idx) tuples\n    - match_distances: list of distances for each match\n    \"\"\"\n    # Handle empty inputs\n    if len(cluster_centroids) == 0 or len(expert_points) == 0:\n        return [], []\n\n    # Compute pairwise STANDARD Euclidean distances (not custom weighted)\n    distances = cdist(cluster_centroids, expert_points, metric='euclidean')\n\n    # Track which endpoints are already matched\n    unmatched_centroids = set(range(len(cluster_centroids)))\n    unmatched_experts = set(range(len(expert_points)))\n\n    # Create list of valid candidate pairs\n    valid_pairs = []\n    for i in range(len(cluster_centroids)):\n        for j in range(len(expert_points)):\n            if distances[i, j] \u003C= max_distance:\n                valid_pairs.append((distances[i, j], i, j))\n\n    # Sort by distance (ascending)\n    valid_pairs.sort()\n\n    # Greedy matching\n    matches = []\n    match_distances = []\n    for dist, centroid_idx, expert_idx in valid_pairs:\n        # Only match if both endpoints are still unmatched\n        if centroid_idx in unmatched_centroids and expert_idx in unmatched_experts:\n            matches.append((centroid_idx, expert_idx))\n            match_distances.append(dist)\n            unmatched_centroids.remove(centroid_idx)\n            unmatched_experts.remove(expert_idx)\n\n    return matches, match_distances\n```\n\n## Why Greedy Works Well\n\n### 1. Computational Efficiency\n- O(n·m log(n·m)) sorting + O(n·m) iteration\n- Fast for typical image sizes (hundreds of points)\n\n### 2. Reasonable Quality\n- Greedy on sorted distances is \"locally optimal\"\n- Avoids blocking good matches\n- Not globally optimal, but typically within 5-10% of optimal\n\n### 3. Interpretability\n- Easy to verify: check that all matches are valid\n- No complex hyperparameters to tune\n\n### 4. Stability\n- Deterministic output for same input\n- No randomization\n\n## Maximum Distance Constraint: 100 Pixels\n\nThe 100-pixel threshold:\n- Represents typical cloud feature size in Mars images (~1728×880 pixels)\n- Prevents spurious matches far from expert annotations\n- Effective false positive filtering\n\n```python\n# Example: Rejecting distant matches\nif distance > 100:\n    # Skip this pair, do not consider for matching\n    continue\n```\n\n## Computing Cluster Centroids\n\n```python\ndef get_cluster_centroids(points, labels):\n    \"\"\"\n    Compute centroid for each cluster from DBSCAN labels.\n\n    Parameters:\n    - points: (n_points, 2) array of [x, y] coordinates\n    - labels: DBSCAN labels (integer, -1 for noise points)\n\n    Returns:\n    - centroids: (n_clusters, 2) array of cluster centroids (excluding noise)\n    \"\"\"\n    unique_labels = set(labels)\n\n    # Remove noise label (-1)\n    if -1 in unique_labels:\n        unique_labels.remove(-1)\n\n    centroids = []\n    for label in sorted(unique_labels):\n        # Get all points with this label\n        cluster_points = points[labels == label]\n\n        # Compute mean coordinate\n        centroid = cluster_points.mean(axis=0)\n        centroids.append(centroid)\n\n    return np.array(centroids) if centroids else np.empty((0, 2))\n```\n\n## Integration with DBSCAN\n\n```python\nfrom sklearn.cluster import DBSCAN\n\ndef cluster_and_match(image_points, expert_points, distance_matrix, epsilon, min_samples):\n    \"\"\"\n    Complete workflow: DBSCAN → centroids → matching.\n    \"\"\"\n    # Run DBSCAN with custom distance matrix\n    clusterer = DBSCAN(eps=epsilon, min_samples=min_samples, metric='precomputed')\n    labels = clusterer.fit_predict(distance_matrix)\n\n    # Compute centroids\n    centroids = get_cluster_centroids(image_points, labels)\n\n    # Match centroids to experts (using standard Euclidean)\n    matches, match_distances = greedy_match(centroids, expert_points, max_distance=100)\n\n    return matches, match_distances\n```\n\n## Edge Cases\n\n### 1. No Clusters\n```python\nif len(centroids) == 0:\n    matches = []\n    match_distances = []\n    # → Results in: F1 = 0.0, delta = NaN\n```\n\n### 2. No Experts\n```python\nif len(expert_points) == 0:\n    matches = []\n    # → Results in: F1 = 0.0 (recall = 0), delta = NaN\n```\n\n### 3. No Valid Pairs (all distances > 100)\n```python\nvalid_pairs = []  # Empty after filtering by max_distance\nmatches = []\n# → Results in: F1 = 0.0, delta = NaN\n```\n\n### 4. Single Cluster and Single Expert\n```python\nif len(centroids) == 1 and len(expert_points) == 1:\n    distance = euclidean_distance(centroids[0], expert_points[0])\n    if distance \u003C= 100:\n        matches = [(0, 0)]\n        match_distances = [distance]\n    else:\n        matches = []\n        match_distances = []\n```\n\n## Verification\n\n```python\ndef verify_matching(matches, n_clusters, n_experts):\n    \"\"\"\n    Sanity checks for matching result.\n    \"\"\"\n    # Check 1: No duplicate centroids\n    centroid_indices = [m[0] for m in matches]\n    assert len(centroid_indices) == len(set(centroid_indices)), \\\n        \"Duplicate centroid in matches\"\n\n    # Check 2: No duplicate experts\n    expert_indices = [m[1] for m in matches]\n    assert len(expert_indices) == len(set(expert_indices)), \\\n        \"Duplicate expert in matches\"\n\n    # Check 3: All indices in valid range\n    assert all(0 \u003C= i \u003C n_clusters for i in centroid_indices), \\\n        \"Centroid index out of range\"\n    assert all(0 \u003C= j \u003C n_experts for j in expert_indices), \\\n        \"Expert index out of range\"\n\n    # Check 4: Matches ≤ min(clusters, experts)\n    assert len(matches) \u003C= min(n_clusters, n_experts), \\\n        \"Too many matches\"\n\n    print(f\"✓ Matching verified: {len(matches)} matches\")\n```\n\n## Note: Standard vs. Custom Distance\n\n**Critical**: Always use **standard Euclidean distance** for matching, NOT the custom weighted distance:\n\n```python\n# ✓ Correct: Standard Euclidean\ndistances = cdist(centroids, experts, metric='euclidean')\n\n# ✗ Wrong: Using custom weighted distance would bias matching\n# based on hyperparameter choice, not actual spatial accuracy\n```\n\nThe custom distance is only for **clustering** (DBSCAN), not for **evaluation** or **matching**.\n",{"name":5,"description":7},"main","726e1f79b96b0cb3d729d0e55a1c847e0b5353ae","skills\u002Fb2-self-feedback-claude-haiku-4-5\u002Fdbscan-parameter-tuning\u002Frun2_greedy_matching",7,"https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench","https:\u002F\u002Fcxcscmu.github.io\u002FSkillLearnBench","https:\u002F\u002Fgithub.com\u002Fcxcscmu","2026-10-02 22:55:36",{"source":8,"skillName":5,"commands":38,"prompt":48,"zipAvailable":49},[39,42,45],{"tool":40,"command":41},"npx","npx skills add cxcscmu\u002FSkillLearnBench --skill run2_greedy_matching",{"tool":43,"command":44},"bunx","bunx skills add cxcscmu\u002FSkillLearnBench --skill run2_greedy_matching",{"tool":46,"command":47},"pnpm","pnpm dlx skills add cxcscmu\u002FSkillLearnBench --skill run2_greedy_matching","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fb2-self-feedback-claude-haiku-4-5\u002Fdbscan-parameter-tuning\u002Frun2_greedy_matching\u002FSKILL.md",true,[],[52,70,95,113,132,144],{"skillNo":53,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":56,"categories":57,"keywords":63,"publishedAt":24},"01M6KM5KH175P5ABP5JMX2SBDQ","object_counter","Count occurrences of an object in the image using computer vision algorithm.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Fvideo-object-counting\u002Fobject_counter\u002FSKILL.md",[58],{"categoryNo":59,"categoryName":60,"taxonomyType":61,"taxonomyTypeDesc":62},"01JBSEEDCAT000000000000016","图像与多媒体","SCENARIO","使用场景",[64,65,66,67,68,69],"object counter","object","vision","computer","Computer Vision","image",{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":79,"publishedAt":24},"01M6KM51TMVXG79MMPCS6Y8G86","travel-planning-workflow","Invoke this skill when performing travel planning. It defines a structured workflow for generating itineraries. Following this workflow is essential to ensure the final plan satisfies user requirements.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftravel-planning\u002Ftravel-planning-workflow\u002FSKILL.md",[76],{"categoryNo":77,"categoryName":78,"taxonomyType":61,"taxonomyTypeDesc":62},"01JBSEEDCAT000000000000023","Skill与智能体开发",[80,81,82,83,84,85,86,87,88,89,90,91,92,93,94],"workflow","planning","planning workflow","travel","travel planning","travel planning workflow","structured","performing","plan","for","user","it","requirements","essential","itineraries",{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":101,"publishedAt":24},"01M6KM4DY820XHS9YTSK5QP5HD","bundled-dataset-search-tool","invoke this skill when you need to perform database search for travel planning. This skill provides some useful pre-packaged tools to look up accommodations, attractions, cities, driving distance, flights, and restaurants from the bundled dataset.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftravel-planning\u002Fbundled-dataset-search-tool\u002FSKILL.md",[],[102,103,104,105,106,107,108,83,109,110,84,111,89,112,81],"search","tool","dataset","bundled dataset search tool","restaurants","Tools","up","look","flights","you","database",{"skillNo":114,"name":115,"nameZh":6,"description":116,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":117,"categories":118,"keywords":119,"publishedAt":24},"01M6KM465BB9PQ0B548HQSVAWZ","glm-output","Output-processing guidance for GLM tasks. Especially useful after glm-basics and glm-calibration when you need verifier-matching metrics from output.nc and a final \u002Froot\u002Fmetrics.json.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftemperature-simulation\u002Fglm-output\u002FSKILL.md",[],[120,121,122,89,123,124,125,126,127,18,128,129,111,130,131],"glm output","output","glm","tasks","metrics","json","basics","guidance","verifier","processing","root","calibration",{"skillNo":133,"name":134,"nameZh":6,"description":135,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":136,"categories":137,"keywords":139,"publishedAt":24},"01M6KM40KY3QWDW5W97S39R2BC","glm-calibration","Calibration guidance for GLM tasks. Often most effective after glm-basics has clarified the setup; glm-output is the companion skill for exact final metric computation.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftemperature-simulation\u002Fglm-calibration\u002FSKILL.md",[138],{"categoryNo":77,"categoryName":78,"taxonomyType":61,"taxonomyTypeDesc":62},[140,131,122,121,127,126,123,141,142,89,143],"glm calibration","setup","companion","metric",{"skillNo":145,"name":146,"nameZh":6,"description":147,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":148,"categories":149,"keywords":150,"publishedAt":24},"01M6KM3VHHVSGMGHJQB3PPT6YG","glm-basics","A good starting point for GLM calibration tasks. Use to inspect glm3.nml, confirm how GLM runs, and identify the relevant files before moving on to calibration and output evaluation.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftemperature-simulation\u002Fglm-basics\u002FSKILL.md",[],[151,122,126,152,140,131,89,121,153,154,155,156,157,158,123],"glm basics","inspect","relevant","files","good","use","how","Evaluation"]