[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6ERT3EC6ZJDED12XRVKEKCF":3,"skill-same:01M6ERT3EC6ZJDED12XRVKEKCF":95},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":23,"publishedAt":35,"linkOnly":36,"markdownContent":37,"markdownBody":38,"frontMatter":39,"refName":40,"commitSha":41,"skillDirectory":42,"forksCount":43,"repositoryHtmlUrl":44,"repositoryHomepageUrl":45,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":47,"updatedAt":48,"install":49,"resources":62},"01M6ERT3EC6ZJDED12XRVKEKCF","umap-learn",null,"UMAP dimensionality reduction. Fast nonlinear manifold learning for 2D\u002F3D visualization, clustering preprocessing (HDBSCAN), supervised\u002Fparametric UMAP, for high-dimensional data.","ComeOnOliver\u002Fskillshub","ComeOnOliver","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43215937?v=4","01M6E5JNFECJAAVFE0W7SMWWD2","Haoran Shu","01M6E5JNNDQS7AJZDYFQ8TPZCK",67,"MIT","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Faiskillstore\u002Fmarketplace\u002Fdavila7\u002Fumap-learn\u002FSKILL.md",[18],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000013","分析与可视化","SCENARIO","使用场景",[24,25,26,27,28,29,30,31,32,33,34],"learn","umap learn","umap","visualization","fast","data","clustering","3D","learning","preprocessing","dimensionality reduction","2026-11-10 10:12:30",false,"---\nname: umap-learn\ndescription: \"UMAP dimensionality reduction. Fast nonlinear manifold learning for 2D\u002F3D visualization, clustering preprocessing (HDBSCAN), supervised\u002Fparametric UMAP, for high-dimensional data.\"\n---\n\n# UMAP-Learn\n\n## Overview\n\nUMAP (Uniform Manifold Approximation and Projection) is a dimensionality reduction technique for visualization and general non-linear dimensionality reduction. Apply this skill for fast, scalable embeddings that preserve local and global structure, supervised learning, and clustering preprocessing.\n\n## Quick Start\n\n### Installation\n\n```bash\nuv pip install umap-learn\n```\n\n### Basic Usage\n\nUMAP follows scikit-learn conventions and can be used as a drop-in replacement for t-SNE or PCA.\n\n```python\nimport umap\nfrom sklearn.preprocessing import StandardScaler\n\n# Prepare data (standardization is essential)\nscaled_data = StandardScaler().fit_transform(data)\n\n# Method 1: Single step (fit and transform)\nembedding = umap.UMAP().fit_transform(scaled_data)\n\n# Method 2: Separate steps (for reusing trained model)\nreducer = umap.UMAP(random_state=42)\nreducer.fit(scaled_data)\nembedding = reducer.embedding_  # Access the trained embedding\n```\n\n**Critical preprocessing requirement:** Always standardize features to comparable scales before applying UMAP to ensure equal weighting across dimensions.\n\n### Typical Workflow\n\n```python\nimport umap\nimport matplotlib.pyplot as plt\nfrom sklearn.preprocessing import StandardScaler\n\n# 1. Preprocess data\nscaler = StandardScaler()\nscaled_data = scaler.fit_transform(raw_data)\n\n# 2. Create and fit UMAP\nreducer = umap.UMAP(\n    n_neighbors=15,\n    min_dist=0.1,\n    n_components=2,\n    metric='euclidean',\n    random_state=42\n)\nembedding = reducer.fit_transform(scaled_data)\n\n# 3. Visualize\nplt.scatter(embedding[:, 0], embedding[:, 1], c=labels, cmap='Spectral', s=5)\nplt.colorbar()\nplt.title('UMAP Embedding')\nplt.show()\n```\n\n## Parameter Tuning Guide\n\nUMAP has four primary parameters that control the embedding behavior. Understanding these is crucial for effective usage.\n\n### n_neighbors (default: 15)\n\n**Purpose:** Balances local versus global structure in the embedding.\n\n**How it works:** Controls the size of the local neighborhood UMAP examines when learning manifold structure.\n\n**Effects by value:**\n- **Low values (2-5):** Emphasizes fine local detail but may fragment data into disconnected components\n- **Medium values (15-20):** Balanced view of both local structure and global relationships (recommended starting point)\n- **High values (50-200):** Prioritizes broad topological structure at the expense of fine-grained details\n\n**Recommendation:** Start with 15 and adjust based on results. Increase for more global structure, decrease for more local detail.\n\n### min_dist (default: 0.1)\n\n**Purpose:** Controls how tightly points cluster in the low-dimensional space.\n\n**How it works:** Sets the minimum distance apart that points are allowed to be in the output representation.\n\n**Effects by value:**\n- **Low values (0.0-0.1):** Creates clumped embeddings useful for clustering; reveals fine topological details\n- **High values (0.5-0.99):** Prevents tight packing; emphasizes broad topological preservation over local structure\n\n**Recommendation:** Use 0.0 for clustering applications, 0.1-0.3 for visualization, 0.5+ for loose structure.\n\n### n_components (default: 2)\n\n**Purpose:** Determines the dimensionality of the embedded output space.\n\n**Key feature:** Unlike t-SNE, UMAP scales well in the embedding dimension, enabling use beyond visualization.\n\n**Common uses:**\n- **2-3 dimensions:** Visualization\n- **5-10 dimensions:** Clustering preprocessing (better preserves density than 2D)\n- **10-50 dimensions:** Feature engineering for downstream ML models\n\n**Recommendation:** Use 2 for visualization, 5-10 for clustering, higher for ML pipelines.\n\n### metric (default: 'euclidean')\n\n**Purpose:** Specifies how distance is calculated between input data points.\n\n**Supported metrics:**\n- **Minkowski variants:** euclidean, manhattan, chebyshev\n- **Spatial metrics:** canberra, braycurtis, haversine\n- **Correlation metrics:** cosine, correlation (good for text\u002Fdocument embeddings)\n- **Binary data metrics:** hamming, jaccard, dice, russellrao, kulsinski, rogerstanimoto, sokalmichener, sokalsneath, yule\n- **Custom metrics:** User-defined distance functions via Numba\n\n**Recommendation:** Use euclidean for numeric data, cosine for text\u002Fdocument vectors, hamming for binary data.\n\n### Parameter Tuning Example\n\n```python\n# For visualization with emphasis on local structure\numap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, metric='euclidean')\n\n# For clustering preprocessing\numap.UMAP(n_neighbors=30, min_dist=0.0, n_components=10, metric='euclidean')\n\n# For document embeddings\numap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, metric='cosine')\n\n# For preserving global structure\numap.UMAP(n_neighbors=100, min_dist=0.5, n_components=2, metric='euclidean')\n```\n\n## Supervised and Semi-Supervised Dimension Reduction\n\nUMAP supports incorporating label information to guide the embedding process, enabling class separation while preserving internal structure.\n\n### Supervised UMAP\n\nPass target labels via the `y` parameter when fitting:\n\n```python\n# Supervised dimension reduction\nembedding = umap.UMAP().fit_transform(data, y=labels)\n```\n\n**Key benefits:**\n- Achieves cleanly separated classes\n- Preserves internal structure within each class\n- Maintains global relationships between classes\n\n**When to use:** When you have labeled data and want to separate known classes while keeping meaningful point embeddings.\n\n### Semi-Supervised UMAP\n\nFor partial labels, mark unlabeled points with `-1` following scikit-learn convention:\n\n```python\n# Create semi-supervised labels\nsemi_labels = labels.copy()\nsemi_labels[unlabeled_indices] = -1\n\n# Fit with partial labels\nembedding = umap.UMAP().fit_transform(data, y=semi_labels)\n```\n\n**When to use:** When labeling is expensive or you have more data than labels available.\n\n### Metric Learning with UMAP\n\nTrain a supervised embedding on labeled data, then apply to new unlabeled data:\n\n```python\n# Train on labeled data\nmapper = umap.UMAP().fit(train_data, train_labels)\n\n# Transform unlabeled test data\ntest_embedding = mapper.transform(test_data)\n\n# Use as feature engineering for downstream classifier\nfrom sklearn.svm import SVC\nclf = SVC().fit(mapper.embedding_, train_labels)\npredictions = clf.predict(test_embedding)\n```\n\n**When to use:** For supervised feature engineering in machine learning pipelines.\n\n## UMAP for Clustering\n\nUMAP serves as effective preprocessing for density-based clustering algorithms like HDBSCAN, overcoming the curse of dimensionality.\n\n### Best Practices for Clustering\n\n**Key principle:** Configure UMAP differently for clustering than for visualization.\n\n**Recommended parameters:**\n- **n_neighbors:** Increase to ~30 (default 15 is too local and can create artificial fine-grained clusters)\n- **min_dist:** Set to 0.0 (pack points densely within clusters for clearer boundaries)\n- **n_components:** Use 5-10 dimensions (maintains performance while improving density preservation vs. 2D)\n\n### Clustering Workflow\n\n```python\nimport umap\nimport hdbscan\nfrom sklearn.preprocessing import StandardScaler\n\n# 1. Preprocess data\nscaled_data = StandardScaler().fit_transform(data)\n\n# 2. UMAP with clustering-optimized parameters\nreducer = umap.UMAP(\n    n_neighbors=30,\n    min_dist=0.0,\n    n_components=10,  # Higher than 2 for better density preservation\n    metric='euclidean',\n    random_state=42\n)\nembedding = reducer.fit_transform(scaled_data)\n\n# 3. Apply HDBSCAN clustering\nclusterer = hdbscan.HDBSCAN(\n    min_cluster_size=15,\n    min_samples=5,\n    metric='euclidean'\n)\nlabels = clusterer.fit_predict(embedding)\n\n# 4. Evaluate\nfrom sklearn.metrics import adjusted_rand_score\nscore = adjusted_rand_score(true_labels, labels)\nprint(f\"Adjusted Rand Score: {score:.3f}\")\nprint(f\"Number of clusters: {len(set(labels)) - (1 if -1 in labels else 0)}\")\nprint(f\"Noise points: {sum(labels == -1)}\")\n```\n\n### Visualization After Clustering\n\n```python\n# Create 2D embedding for visualization (separate from clustering)\nvis_reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, random_state=42)\nvis_embedding = vis_reducer.fit_transform(scaled_data)\n\n# Plot with cluster labels\nimport matplotlib.pyplot as plt\nplt.scatter(vis_embedding[:, 0], vis_embedding[:, 1], c=labels, cmap='Spectral', s=5)\nplt.colorbar()\nplt.title('UMAP Visualization with HDBSCAN Clusters')\nplt.show()\n```\n\n**Important caveat:** UMAP does not completely preserve density and can create artificial cluster divisions. Always validate and explore resulting clusters.\n\n## Transforming New Data\n\nUMAP enables preprocessing of new data through its `transform()` method, allowing trained models to project unseen data into the learned embedding space.\n\n### Basic Transform Usage\n\n```python\n# Train on training data\ntrans = umap.UMAP(n_neighbors=15, random_state=42).fit(X_train)\n\n# Transform test data\ntest_embedding = trans.transform(X_test)\n```\n\n### Integration with Machine Learning Pipelines\n\n```python\nfrom sklearn.svm import SVC\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\nimport umap\n\n# Split data\nX_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2)\n\n# Preprocess\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\n# Train UMAP\nreducer = umap.UMAP(n_components=10, random_state=42)\nX_train_embedded = reducer.fit_transform(X_train_scaled)\nX_test_embedded = reducer.transform(X_test_scaled)\n\n# Train classifier on embeddings\nclf = SVC()\nclf.fit(X_train_embedded, y_train)\naccuracy = clf.score(X_test_embedded, y_test)\nprint(f\"Test accuracy: {accuracy:.3f}\")\n```\n\n### Important Considerations\n\n**Data consistency:** The transform method assumes the overall distribution in the higher-dimensional space is consistent between training and test data. When this assumption fails, consider using Parametric UMAP instead.\n\n**Performance:** Transform operations are efficient (typically \u003C1 second), though initial calls may be slower due to Numba JIT compilation.\n\n**Scikit-learn compatibility:** UMAP follows standard sklearn conventions and works seamlessly in pipelines:\n\n```python\nfrom sklearn.pipeline import Pipeline\n\npipeline = Pipeline([\n    ('scaler', StandardScaler()),\n    ('umap', umap.UMAP(n_components=10)),\n    ('classifier', SVC())\n])\n\npipeline.fit(X_train, y_train)\npredictions = pipeline.predict(X_test)\n```\n\n## Advanced Features\n\n### Parametric UMAP\n\nParametric UMAP replaces direct embedding optimization with a learned neural network mapping function.\n\n**Key differences from standard UMAP:**\n- Uses TensorFlow\u002FKeras to train encoder networks\n- Enables efficient transformation of new data\n- Supports reconstruction via decoder networks (inverse transform)\n- Allows custom architectures (CNNs for images, RNNs for sequences)\n\n**Installation:**\n```bash\nuv pip install umap-learn[parametric_umap]\n# Requires TensorFlow 2.x\n```\n\n**Basic usage:**\n```python\nfrom umap.parametric_umap import ParametricUMAP\n\n# Default architecture (3-layer 100-neuron fully-connected network)\nembedder = ParametricUMAP()\nembedding = embedder.fit_transform(data)\n\n# Transform new data efficiently\nnew_embedding = embedder.transform(new_data)\n```\n\n**Custom architecture:**\n```python\nimport tensorflow as tf\n\n# Define custom encoder\nencoder = tf.keras.Sequential([\n    tf.keras.layers.InputLayer(input_shape=(input_dim,)),\n    tf.keras.layers.Dense(128, activation='relu'),\n    tf.keras.layers.Dense(64, activation='relu'),\n    tf.keras.layers.Dense(2)  # Output dimension\n])\n\nembedder = ParametricUMAP(encoder=encoder, dims=(input_dim,))\nembedding = embedder.fit_transform(data)\n```\n\n**When to use Parametric UMAP:**\n- Need efficient transformation of new data after training\n- Require reconstruction capabilities (inverse transforms)\n- Want to combine UMAP with autoencoders\n- Working with complex data types (images, sequences) benefiting from specialized architectures\n\n**When to use standard UMAP:**\n- Need simplicity and quick prototyping\n- Dataset is small and computational efficiency isn't critical\n- Don't require learned transformations for future data\n\n### Inverse Transforms\n\nInverse transforms enable reconstruction of high-dimensional data from low-dimensional embeddings.\n\n**Basic usage:**\n```python\nreducer = umap.UMAP()\nembedding = reducer.fit_transform(data)\n\n# Reconstruct high-dimensional data from embedding coordinates\nreconstructed = reducer.inverse_transform(embedding)\n```\n\n**Important limitations:**\n- Computationally expensive operation\n- Works poorly outside the convex hull of the embedding\n- Accuracy decreases in regions with gaps between clusters\n\n**Use cases:**\n- Understanding structure of embedded data\n- Visualizing smooth transitions between clusters\n- Exploring interpolations between data points\n- Generating synthetic samples in embedding space\n\n**Example: Exploring embedding space:**\n```python\nimport numpy as np\n\n# Create grid of points in embedding space\nx = np.linspace(embedding[:, 0].min(), embedding[:, 0].max(), 10)\ny = np.linspace(embedding[:, 1].min(), embedding[:, 1].max(), 10)\nxx, yy = np.meshgrid(x, y)\ngrid_points = np.c_[xx.ravel(), yy.ravel()]\n\n# Reconstruct samples from grid\nreconstructed_samples = reducer.inverse_transform(grid_points)\n```\n\n### AlignedUMAP\n\nFor analyzing temporal or related datasets (e.g., time-series experiments, batch data):\n\n```python\nfrom umap import AlignedUMAP\n\n# List of related datasets\ndatasets = [day1_data, day2_data, day3_data]\n\n# Create aligned embeddings\nmapper = AlignedUMAP().fit(datasets)\naligned_embeddings = mapper.embeddings_  # List of embeddings\n```\n\n**When to use:** Comparing embeddings across related datasets while maintaining consistent coordinate systems.\n\n## Reproducibility\n\nTo ensure reproducible results, always set the `random_state` parameter:\n\n```python\nreducer = umap.UMAP(random_state=42)\n```\n\nUMAP uses stochastic optimization, so results will vary slightly between runs without a fixed random state.\n\n## Common Issues and Solutions\n\n**Issue:** Disconnected components or fragmented clusters\n- **Solution:** Increase `n_neighbors` to emphasize more global structure\n\n**Issue:** Clusters too spread out or not well separated\n- **Solution:** Decrease `min_dist` to allow tighter packing\n\n**Issue:** Poor clustering results\n- **Solution:** Use clustering-specific parameters (n_neighbors=30, min_dist=0.0, n_components=5-10)\n\n**Issue:** Transform results differ significantly from training\n- **Solution:** Ensure test data distribution matches training, or use Parametric UMAP\n\n**Issue:** Slow performance on large datasets\n- **Solution:** Set `low_memory=True` (default), or consider dimensionality reduction with PCA first\n\n**Issue:** All points collapsed to single cluster\n- **Solution:** Check data preprocessing (ensure proper scaling), increase `min_dist`\n\n## Resources\n\n### references\u002F\n\nContains detailed API documentation:\n- `api_reference.md`: Complete UMAP class parameters and methods\n\nLoad these references when detailed parameter information or advanced method usage is needed.\n","# UMAP-Learn\n\n## Overview\n\nUMAP (Uniform Manifold Approximation and Projection) is a dimensionality reduction technique for visualization and general non-linear dimensionality reduction. Apply this skill for fast, scalable embeddings that preserve local and global structure, supervised learning, and clustering preprocessing.\n\n## Quick Start\n\n### Installation\n\n```bash\nuv pip install umap-learn\n```\n\n### Basic Usage\n\nUMAP follows scikit-learn conventions and can be used as a drop-in replacement for t-SNE or PCA.\n\n```python\nimport umap\nfrom sklearn.preprocessing import StandardScaler\n\n# Prepare data (standardization is essential)\nscaled_data = StandardScaler().fit_transform(data)\n\n# Method 1: Single step (fit and transform)\nembedding = umap.UMAP().fit_transform(scaled_data)\n\n# Method 2: Separate steps (for reusing trained model)\nreducer = umap.UMAP(random_state=42)\nreducer.fit(scaled_data)\nembedding = reducer.embedding_  # Access the trained embedding\n```\n\n**Critical preprocessing requirement:** Always standardize features to comparable scales before applying UMAP to ensure equal weighting across dimensions.\n\n### Typical Workflow\n\n```python\nimport umap\nimport matplotlib.pyplot as plt\nfrom sklearn.preprocessing import StandardScaler\n\n# 1. Preprocess data\nscaler = StandardScaler()\nscaled_data = scaler.fit_transform(raw_data)\n\n# 2. Create and fit UMAP\nreducer = umap.UMAP(\n    n_neighbors=15,\n    min_dist=0.1,\n    n_components=2,\n    metric='euclidean',\n    random_state=42\n)\nembedding = reducer.fit_transform(scaled_data)\n\n# 3. Visualize\nplt.scatter(embedding[:, 0], embedding[:, 1], c=labels, cmap='Spectral', s=5)\nplt.colorbar()\nplt.title('UMAP Embedding')\nplt.show()\n```\n\n## Parameter Tuning Guide\n\nUMAP has four primary parameters that control the embedding behavior. Understanding these is crucial for effective usage.\n\n### n_neighbors (default: 15)\n\n**Purpose:** Balances local versus global structure in the embedding.\n\n**How it works:** Controls the size of the local neighborhood UMAP examines when learning manifold structure.\n\n**Effects by value:**\n- **Low values (2-5):** Emphasizes fine local detail but may fragment data into disconnected components\n- **Medium values (15-20):** Balanced view of both local structure and global relationships (recommended starting point)\n- **High values (50-200):** Prioritizes broad topological structure at the expense of fine-grained details\n\n**Recommendation:** Start with 15 and adjust based on results. Increase for more global structure, decrease for more local detail.\n\n### min_dist (default: 0.1)\n\n**Purpose:** Controls how tightly points cluster in the low-dimensional space.\n\n**How it works:** Sets the minimum distance apart that points are allowed to be in the output representation.\n\n**Effects by value:**\n- **Low values (0.0-0.1):** Creates clumped embeddings useful for clustering; reveals fine topological details\n- **High values (0.5-0.99):** Prevents tight packing; emphasizes broad topological preservation over local structure\n\n**Recommendation:** Use 0.0 for clustering applications, 0.1-0.3 for visualization, 0.5+ for loose structure.\n\n### n_components (default: 2)\n\n**Purpose:** Determines the dimensionality of the embedded output space.\n\n**Key feature:** Unlike t-SNE, UMAP scales well in the embedding dimension, enabling use beyond visualization.\n\n**Common uses:**\n- **2-3 dimensions:** Visualization\n- **5-10 dimensions:** Clustering preprocessing (better preserves density than 2D)\n- **10-50 dimensions:** Feature engineering for downstream ML models\n\n**Recommendation:** Use 2 for visualization, 5-10 for clustering, higher for ML pipelines.\n\n### metric (default: 'euclidean')\n\n**Purpose:** Specifies how distance is calculated between input data points.\n\n**Supported metrics:**\n- **Minkowski variants:** euclidean, manhattan, chebyshev\n- **Spatial metrics:** canberra, braycurtis, haversine\n- **Correlation metrics:** cosine, correlation (good for text\u002Fdocument embeddings)\n- **Binary data metrics:** hamming, jaccard, dice, russellrao, kulsinski, rogerstanimoto, sokalmichener, sokalsneath, yule\n- **Custom metrics:** User-defined distance functions via Numba\n\n**Recommendation:** Use euclidean for numeric data, cosine for text\u002Fdocument vectors, hamming for binary data.\n\n### Parameter Tuning Example\n\n```python\n# For visualization with emphasis on local structure\numap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, metric='euclidean')\n\n# For clustering preprocessing\numap.UMAP(n_neighbors=30, min_dist=0.0, n_components=10, metric='euclidean')\n\n# For document embeddings\numap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, metric='cosine')\n\n# For preserving global structure\numap.UMAP(n_neighbors=100, min_dist=0.5, n_components=2, metric='euclidean')\n```\n\n## Supervised and Semi-Supervised Dimension Reduction\n\nUMAP supports incorporating label information to guide the embedding process, enabling class separation while preserving internal structure.\n\n### Supervised UMAP\n\nPass target labels via the `y` parameter when fitting:\n\n```python\n# Supervised dimension reduction\nembedding = umap.UMAP().fit_transform(data, y=labels)\n```\n\n**Key benefits:**\n- Achieves cleanly separated classes\n- Preserves internal structure within each class\n- Maintains global relationships between classes\n\n**When to use:** When you have labeled data and want to separate known classes while keeping meaningful point embeddings.\n\n### Semi-Supervised UMAP\n\nFor partial labels, mark unlabeled points with `-1` following scikit-learn convention:\n\n```python\n# Create semi-supervised labels\nsemi_labels = labels.copy()\nsemi_labels[unlabeled_indices] = -1\n\n# Fit with partial labels\nembedding = umap.UMAP().fit_transform(data, y=semi_labels)\n```\n\n**When to use:** When labeling is expensive or you have more data than labels available.\n\n### Metric Learning with UMAP\n\nTrain a supervised embedding on labeled data, then apply to new unlabeled data:\n\n```python\n# Train on labeled data\nmapper = umap.UMAP().fit(train_data, train_labels)\n\n# Transform unlabeled test data\ntest_embedding = mapper.transform(test_data)\n\n# Use as feature engineering for downstream classifier\nfrom sklearn.svm import SVC\nclf = SVC().fit(mapper.embedding_, train_labels)\npredictions = clf.predict(test_embedding)\n```\n\n**When to use:** For supervised feature engineering in machine learning pipelines.\n\n## UMAP for Clustering\n\nUMAP serves as effective preprocessing for density-based clustering algorithms like HDBSCAN, overcoming the curse of dimensionality.\n\n### Best Practices for Clustering\n\n**Key principle:** Configure UMAP differently for clustering than for visualization.\n\n**Recommended parameters:**\n- **n_neighbors:** Increase to ~30 (default 15 is too local and can create artificial fine-grained clusters)\n- **min_dist:** Set to 0.0 (pack points densely within clusters for clearer boundaries)\n- **n_components:** Use 5-10 dimensions (maintains performance while improving density preservation vs. 2D)\n\n### Clustering Workflow\n\n```python\nimport umap\nimport hdbscan\nfrom sklearn.preprocessing import StandardScaler\n\n# 1. Preprocess data\nscaled_data = StandardScaler().fit_transform(data)\n\n# 2. UMAP with clustering-optimized parameters\nreducer = umap.UMAP(\n    n_neighbors=30,\n    min_dist=0.0,\n    n_components=10,  # Higher than 2 for better density preservation\n    metric='euclidean',\n    random_state=42\n)\nembedding = reducer.fit_transform(scaled_data)\n\n# 3. Apply HDBSCAN clustering\nclusterer = hdbscan.HDBSCAN(\n    min_cluster_size=15,\n    min_samples=5,\n    metric='euclidean'\n)\nlabels = clusterer.fit_predict(embedding)\n\n# 4. Evaluate\nfrom sklearn.metrics import adjusted_rand_score\nscore = adjusted_rand_score(true_labels, labels)\nprint(f\"Adjusted Rand Score: {score:.3f}\")\nprint(f\"Number of clusters: {len(set(labels)) - (1 if -1 in labels else 0)}\")\nprint(f\"Noise points: {sum(labels == -1)}\")\n```\n\n### Visualization After Clustering\n\n```python\n# Create 2D embedding for visualization (separate from clustering)\nvis_reducer = umap.UMAP(n_neighbors=15, min_dist=0.1, n_components=2, random_state=42)\nvis_embedding = vis_reducer.fit_transform(scaled_data)\n\n# Plot with cluster labels\nimport matplotlib.pyplot as plt\nplt.scatter(vis_embedding[:, 0], vis_embedding[:, 1], c=labels, cmap='Spectral', s=5)\nplt.colorbar()\nplt.title('UMAP Visualization with HDBSCAN Clusters')\nplt.show()\n```\n\n**Important caveat:** UMAP does not completely preserve density and can create artificial cluster divisions. Always validate and explore resulting clusters.\n\n## Transforming New Data\n\nUMAP enables preprocessing of new data through its `transform()` method, allowing trained models to project unseen data into the learned embedding space.\n\n### Basic Transform Usage\n\n```python\n# Train on training data\ntrans = umap.UMAP(n_neighbors=15, random_state=42).fit(X_train)\n\n# Transform test data\ntest_embedding = trans.transform(X_test)\n```\n\n### Integration with Machine Learning Pipelines\n\n```python\nfrom sklearn.svm import SVC\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\nimport umap\n\n# Split data\nX_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2)\n\n# Preprocess\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\n# Train UMAP\nreducer = umap.UMAP(n_components=10, random_state=42)\nX_train_embedded = reducer.fit_transform(X_train_scaled)\nX_test_embedded = reducer.transform(X_test_scaled)\n\n# Train classifier on embeddings\nclf = SVC()\nclf.fit(X_train_embedded, y_train)\naccuracy = clf.score(X_test_embedded, y_test)\nprint(f\"Test accuracy: {accuracy:.3f}\")\n```\n\n### Important Considerations\n\n**Data consistency:** The transform method assumes the overall distribution in the higher-dimensional space is consistent between training and test data. When this assumption fails, consider using Parametric UMAP instead.\n\n**Performance:** Transform operations are efficient (typically \u003C1 second), though initial calls may be slower due to Numba JIT compilation.\n\n**Scikit-learn compatibility:** UMAP follows standard sklearn conventions and works seamlessly in pipelines:\n\n```python\nfrom sklearn.pipeline import Pipeline\n\npipeline = Pipeline([\n    ('scaler', StandardScaler()),\n    ('umap', umap.UMAP(n_components=10)),\n    ('classifier', SVC())\n])\n\npipeline.fit(X_train, y_train)\npredictions = pipeline.predict(X_test)\n```\n\n## Advanced Features\n\n### Parametric UMAP\n\nParametric UMAP replaces direct embedding optimization with a learned neural network mapping function.\n\n**Key differences from standard UMAP:**\n- Uses TensorFlow\u002FKeras to train encoder networks\n- Enables efficient transformation of new data\n- Supports reconstruction via decoder networks (inverse transform)\n- Allows custom architectures (CNNs for images, RNNs for sequences)\n\n**Installation:**\n```bash\nuv pip install umap-learn[parametric_umap]\n# Requires TensorFlow 2.x\n```\n\n**Basic usage:**\n```python\nfrom umap.parametric_umap import ParametricUMAP\n\n# Default architecture (3-layer 100-neuron fully-connected network)\nembedder = ParametricUMAP()\nembedding = embedder.fit_transform(data)\n\n# Transform new data efficiently\nnew_embedding = embedder.transform(new_data)\n```\n\n**Custom architecture:**\n```python\nimport tensorflow as tf\n\n# Define custom encoder\nencoder = tf.keras.Sequential([\n    tf.keras.layers.InputLayer(input_shape=(input_dim,)),\n    tf.keras.layers.Dense(128, activation='relu'),\n    tf.keras.layers.Dense(64, activation='relu'),\n    tf.keras.layers.Dense(2)  # Output dimension\n])\n\nembedder = ParametricUMAP(encoder=encoder, dims=(input_dim,))\nembedding = embedder.fit_transform(data)\n```\n\n**When to use Parametric UMAP:**\n- Need efficient transformation of new data after training\n- Require reconstruction capabilities (inverse transforms)\n- Want to combine UMAP with autoencoders\n- Working with complex data types (images, sequences) benefiting from specialized architectures\n\n**When to use standard UMAP:**\n- Need simplicity and quick prototyping\n- Dataset is small and computational efficiency isn't critical\n- Don't require learned transformations for future data\n\n### Inverse Transforms\n\nInverse transforms enable reconstruction of high-dimensional data from low-dimensional embeddings.\n\n**Basic usage:**\n```python\nreducer = umap.UMAP()\nembedding = reducer.fit_transform(data)\n\n# Reconstruct high-dimensional data from embedding coordinates\nreconstructed = reducer.inverse_transform(embedding)\n```\n\n**Important limitations:**\n- Computationally expensive operation\n- Works poorly outside the convex hull of the embedding\n- Accuracy decreases in regions with gaps between clusters\n\n**Use cases:**\n- Understanding structure of embedded data\n- Visualizing smooth transitions between clusters\n- Exploring interpolations between data points\n- Generating synthetic samples in embedding space\n\n**Example: Exploring embedding space:**\n```python\nimport numpy as np\n\n# Create grid of points in embedding space\nx = np.linspace(embedding[:, 0].min(), embedding[:, 0].max(), 10)\ny = np.linspace(embedding[:, 1].min(), embedding[:, 1].max(), 10)\nxx, yy = np.meshgrid(x, y)\ngrid_points = np.c_[xx.ravel(), yy.ravel()]\n\n# Reconstruct samples from grid\nreconstructed_samples = reducer.inverse_transform(grid_points)\n```\n\n### AlignedUMAP\n\nFor analyzing temporal or related datasets (e.g., time-series experiments, batch data):\n\n```python\nfrom umap import AlignedUMAP\n\n# List of related datasets\ndatasets = [day1_data, day2_data, day3_data]\n\n# Create aligned embeddings\nmapper = AlignedUMAP().fit(datasets)\naligned_embeddings = mapper.embeddings_  # List of embeddings\n```\n\n**When to use:** Comparing embeddings across related datasets while maintaining consistent coordinate systems.\n\n## Reproducibility\n\nTo ensure reproducible results, always set the `random_state` parameter:\n\n```python\nreducer = umap.UMAP(random_state=42)\n```\n\nUMAP uses stochastic optimization, so results will vary slightly between runs without a fixed random state.\n\n## Common Issues and Solutions\n\n**Issue:** Disconnected components or fragmented clusters\n- **Solution:** Increase `n_neighbors` to emphasize more global structure\n\n**Issue:** Clusters too spread out or not well separated\n- **Solution:** Decrease `min_dist` to allow tighter packing\n\n**Issue:** Poor clustering results\n- **Solution:** Use clustering-specific parameters (n_neighbors=30, min_dist=0.0, n_components=5-10)\n\n**Issue:** Transform results differ significantly from training\n- **Solution:** Ensure test data distribution matches training, or use Parametric UMAP\n\n**Issue:** Slow performance on large datasets\n- **Solution:** Set `low_memory=True` (default), or consider dimensionality reduction with PCA first\n\n**Issue:** All points collapsed to single cluster\n- **Solution:** Check data preprocessing (ensure proper scaling), increase `min_dist`\n\n## Resources\n\n### references\u002F\n\nContains detailed API documentation:\n- `api_reference.md`: Complete UMAP class parameters and methods\n\nLoad these references when detailed parameter information or advanced method usage is needed.\n",{"name":5,"description":7},"main","def8531e65114c0fca8fb8551c1871ee0eed705c","skills\u002Faiskillstore\u002Fmarketplace\u002Fdavila7\u002Fumap-learn",24,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub","https:\u002F\u002Fskillshub.wtf","https:\u002F\u002Fgithub.com\u002FComeOnOliver","AI & Blockchain Engineer\r\n","2026-06-24 22:07:19",{"source":8,"skillName":5,"commands":50,"prompt":60,"zipAvailable":61},[51,54,57],{"tool":52,"command":53},"npx","npx skills add ComeOnOliver\u002Fskillshub --skill umap-learn",{"tool":55,"command":56},"bunx","bunx skills add ComeOnOliver\u002Fskillshub --skill umap-learn",{"tool":58,"command":59},"pnpm","pnpm dlx skills add ComeOnOliver\u002Fskillshub --skill umap-learn","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Faiskillstore\u002Fmarketplace\u002Fdavila7\u002Fumap-learn\u002FSKILL.md",true,[63,69,75,79,83,87,91],{"path":64,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":67,"sourceHtmlUrl":68},"customize.toml","OTHER","其他",1658,"https:\u002F\u002Fgithub.com\u002Fdeveloperworks\u002Frust-supervisor\u002Fblob\u002Fmain\u002F.agent\u002Fskills\u002Fgds-generate-project-context\u002Fcustomize.toml",{"path":70,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":73,"sourceHtmlUrl":74},"project-context-template.md","REFERENCE","参考文档",467,"https:\u002F\u002Fgithub.com\u002Fdeveloperworks\u002Frust-supervisor\u002Fblob\u002Fmain\u002F.agent\u002Fskills\u002Fgds-generate-project-context\u002Fproject-context-template.md",{"path":76,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":77,"sourceHtmlUrl":78},"references\u002Fapi_reference.md",18966,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Faiskillstore\u002Fmarketplace\u002Fdavila7\u002Fumap-learn\u002Freferences\u002Fapi_reference.md",{"path":80,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":81,"sourceHtmlUrl":82},"skill-report.json",22532,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Faiskillstore\u002Fmarketplace\u002Fdavila7\u002Fumap-learn\u002Fskill-report.json",{"path":84,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":85,"sourceHtmlUrl":86},"steps\u002Fstep-01-discover.md",6453,"https:\u002F\u002Fgithub.com\u002Fdeveloperworks\u002Frust-supervisor\u002Fblob\u002Fmain\u002F.agent\u002Fskills\u002Fgds-generate-project-context\u002Fsteps\u002Fstep-01-discover.md",{"path":88,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":89,"sourceHtmlUrl":90},"steps\u002Fstep-02-generate.md",9620,"https:\u002F\u002Fgithub.com\u002Fdeveloperworks\u002Frust-supervisor\u002Fblob\u002Fmain\u002F.agent\u002Fskills\u002Fgds-generate-project-context\u002Fsteps\u002Fstep-02-generate.md",{"path":92,"resourceType":71,"resourceTypeDesc":72,"sizeBytes":93,"sourceHtmlUrl":94},"steps\u002Fstep-03-complete.md",8256,"https:\u002F\u002Fgithub.com\u002Fdeveloperworks\u002Frust-supervisor\u002Fblob\u002Fmain\u002F.agent\u002Fskills\u002Fgds-generate-project-context\u002Fsteps\u002Fstep-03-complete.md",[96,108,118,127,133,140],{"skillNo":97,"name":98,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":104,"publishedAt":35},"01M6FKJN13GMG4KY57J3QD8GY5","model-hierarchy-skill","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzscole\u002Fmodel-hierarchy-skill\u002Fmodel-hierarchy-skill\u002FSKILL.md",[101],{"categoryNo":102,"categoryName":103,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000023","Skill与智能体开发",[105,106,107],"model","model hierarchy","model hierarchy skill",{"skillNo":109,"name":110,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":111,"categories":112,"keywords":114,"publishedAt":35},"01M6FKJJJ6GCAMR4PPPRD12M5X","zoom-mcp","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-mcp\u002FSKILL.md",[113],{"categoryNo":102,"categoryName":103,"taxonomyType":21,"taxonomyTypeDesc":22},[115,116,117],"MCP","zoom","zoom mcp",{"skillNo":119,"name":120,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":121,"categories":122,"keywords":123,"publishedAt":35},"01M6FKJE3KYT3KPEZMEEHYKA6K","zoom-apps-sdk","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-apps-sdk\u002FSKILL.md",[],[124,125,126,116],"sdk","zoom apps sdk","apps",{"skillNo":128,"name":129,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":130,"categories":131,"keywords":132,"publishedAt":35},"01M6FKJ9EDH9Q5VWDF8HAJRSP0","windows","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwindows\u002FSKILL.md",[],[129],{"skillNo":134,"name":135,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":136,"categories":137,"keywords":139,"publishedAt":35},"01M6FKJ666BEEFC3AE9GJ72Q93","whiteboard","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwhiteboard\u002FSKILL.md",[138],{"categoryNo":102,"categoryName":103,"taxonomyType":21,"taxonomyTypeDesc":22},[135],{"skillNo":141,"name":142,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":143,"categories":144,"keywords":145,"publishedAt":35},"01M6FKJ21WFCDGTJQ2Q91T9DVW","websockets","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwebsockets\u002FSKILL.md",[],[142]]