[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M73K1ZP2JWQ7HJEEK0JR2M6H":3,"skill-same:01M73K1ZP2JWQ7HJEEK0JR2M6H":48},{"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":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M73K1ZP2JWQ7HJEEK0JR2M6H","torch-geometric-graph-neural-networks",null,"PyTorch Geometric (PyG) for graph neural networks: node\u002Fgraph classification, link prediction with GCN, GAT, GraphSAGE, GIN. Message passing, mini-batches, heterogeneous graphs, neighbor sampling, explainability. Supports molecules (QM9, MoleculeNet), social\u002Fknowledge graphs, 3D point clouds. For non-graph DL use PyTorch; for classical graph algorithms use NetworkX.","bg-szy\u002FTOP-SKILLS","bg-szy","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F106576190?v=4","01M73A4E8KPV67SFXRY8XZGNBX","ShuZhiyong","01M73A4E96MQ294MHM74TZBVQD",6,"MIT","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fawesome-skills\u002Ftorch-geometric-graph-neural-networks\u002FSKILL.md",[],[],"2026-11-11 15:11:14",false,"---\nname: torch-geometric-graph-neural-networks\ndescription: \"PyTorch Geometric (PyG) for graph neural networks: node\u002Fgraph classification, link prediction with GCN, GAT, GraphSAGE, GIN. Message passing, mini-batches, heterogeneous graphs, neighbor sampling, explainability. Supports molecules (QM9, MoleculeNet), social\u002Fknowledge graphs, 3D point clouds. For non-graph DL use PyTorch; for classical graph algorithms use NetworkX.\"\nlicense: MIT\n---\n\n# PyTorch Geometric (PyG) — Graph Neural Networks\n\n## Overview\n\nPyTorch Geometric is a library built on PyTorch for developing and training Graph Neural Networks (GNNs). It provides 40+ convolutional layers, mini-batch processing via block-diagonal adjacency matrices, neighbor sampling for large-scale graphs, and heterogeneous graph support for multi-type node\u002Fedge networks.\n\n## When to Use\n\n- Node classification on citation, social, or biological networks\n- Graph-level classification (molecular activity, protein function)\n- Link prediction (knowledge graphs, recommendation systems)\n- Molecular property prediction (drug discovery, quantum chemistry)\n- 3D point cloud processing and mesh analysis\n- Large-scale graph learning with neighbor sampling (>100K nodes)\n- Heterogeneous graphs with multiple node\u002Fedge types\n- **For non-graph deep learning** → use PyTorch directly\n- **For traditional graph algorithms (shortest path, centrality)** → use NetworkX\n\n## Prerequisites\n\n```bash\npip install torch torch_geometric\n# Optional sparse operations (recommended):\n# pip install pyg_lib torch_scatter torch_sparse torch_cluster\n```\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom torch_geometric.data import Data\nfrom torch_geometric.nn import GCNConv\n```\n\n## Quick Start\n\n```python\nfrom torch_geometric.datasets import Planetoid\nfrom torch_geometric.nn import GCNConv\nimport torch, torch.nn.functional as F\n\ndataset = Planetoid(root='\u002Ftmp\u002FCora', name='Cora')\ndata = dataset[0]\n\nclass GCN(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = GCNConv(dataset.num_features, 16)\n        self.conv2 = GCNConv(16, dataset.num_classes)\n    def forward(self, data):\n        x = F.relu(self.conv1(data.x, data.edge_index))\n        return self.conv2(x, data.edge_index)\n\nmodel = GCN()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)\nfor epoch in range(200):\n    model.train(); optimizer.zero_grad()\n    F.cross_entropy(model(data)[data.train_mask], data.y[data.train_mask]).backward()\n    optimizer.step()\n\nmodel.eval()\npred = model(data).argmax(dim=1)\nacc = (pred[data.test_mask] == data.y[data.test_mask]).float().mean()\nprint(f'Test Accuracy: {acc:.4f}')  # ~0.81\n```\n\n## Core API\n\n### 1. Data Representation\n\n```python\nimport torch\nfrom torch_geometric.data import Data\n\n# Create a graph: 3 nodes, 4 edges (undirected)\nedge_index = torch.tensor([[0, 1, 1, 2],\n                           [1, 0, 2, 1]], dtype=torch.long)\nx = torch.randn(3, 16)  # Node features [num_nodes, features]\ny = torch.tensor([0, 1, 0])  # Node labels\n\ndata = Data(x=x, edge_index=edge_index, y=y)\nprint(f'Nodes: {data.num_nodes}, Edges: {data.num_edges}')\nprint(f'Features: {data.num_node_features}')\nprint(f'Has self-loops: {data.has_self_loops()}')\nprint(f'Is undirected: {data.is_undirected()}')\n\n# Optional attributes\ndata.edge_attr = torch.randn(4, 8)   # Edge features [num_edges, features]\ndata.pos = torch.randn(3, 3)          # Node positions (3D)\ndata.train_mask = torch.tensor([True, True, False])  # Custom masks\n```\n\n```python\n# Mini-batch processing — graphs concatenated as block-diagonal\nfrom torch_geometric.loader import DataLoader\n\nloader = DataLoader(dataset, batch_size=32, shuffle=True)\nfor batch in loader:\n    print(f'Graphs: {batch.num_graphs}, Nodes: {batch.num_nodes}')\n    # batch.batch maps each node → its source graph index\n    # No padding needed — computationally efficient\n```\n\n### 2. Convolutional Layers\n\n```python\nfrom torch_geometric.nn import GCNConv, GATConv, SAGEConv, GINConv\nimport torch.nn as nn\n\n# GCNConv — spectral graph convolution (baseline)\nconv = GCNConv(in_channels=16, out_channels=32)\n# Supports: edge_weight, SparseTensor, Bipartite, Lazy init\n\n# GATConv — attention-based neighbor weighting\nconv = GATConv(16, 32, heads=8, dropout=0.6)\n# Output: [N, heads * out_channels] (concat) or [N, out_channels] (concat=False)\n\n# SAGEConv — inductive learning via sampling\nconv = SAGEConv(16, 32, aggr='mean')  # 'mean', 'max', 'lstm'\n\n# GINConv — maximally powerful for graph isomorphism\nnn_module = nn.Sequential(nn.Linear(16, 32), nn.ReLU(), nn.Linear(32, 32))\nconv = GINConv(nn_module)\n\n# TransformerConv — graph transformer\nfrom torch_geometric.nn import TransformerConv\nconv = TransformerConv(16, 32, heads=8, beta=True)\n\n# All layers: x_out = conv(x, edge_index)\nx_out = conv(x, edge_index)\nprint(f'Output shape: {x_out.shape}')  # [num_nodes, out_channels]\n```\n\n### 3. Custom Message Passing\n\n```python\nfrom torch_geometric.nn import MessagePassing\nfrom torch_geometric.utils import add_self_loops, degree\n\nclass CustomConv(MessagePassing):\n    def __init__(self, in_channels, out_channels):\n        super().__init__(aggr='add')  # 'add', 'mean', 'max'\n        self.lin = torch.nn.Linear(in_channels, out_channels)\n\n    def forward(self, x, edge_index):\n        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))\n        x = self.lin(x)\n\n        # Degree-based normalization\n        row, col = edge_index\n        deg = degree(col, x.size(0), dtype=x.dtype)\n        norm = deg.pow(-0.5)\n        norm = norm[row] * norm[col]\n\n        return self.propagate(edge_index, x=x, norm=norm)\n\n    def message(self, x_j, norm):\n        # x_j: source node features (automatic via _j suffix)\n        return norm.view(-1, 1) * x_j\n\n# Key methods: forward(), message(), aggregate(), update()\n# _i suffix → target node, _j suffix → source node\n```\n\n### 4. Pooling & Graph-Level Readout\n\n```python\nfrom torch_geometric.nn import (\n    global_mean_pool, global_max_pool, global_add_pool,\n    TopKPooling, SAGPooling\n)\n\n# Global pooling: node features → graph-level representation\nx_graph = global_mean_pool(x, batch)  # [num_graphs, features]\n\n# Hierarchical pooling: coarsen graph\npool = TopKPooling(64, ratio=0.8)  # Keep top 80% nodes\nx, edge_index, _, batch, _, _ = pool(x, edge_index, None, batch)\n\n# Graph classification model\nclass GraphClassifier(torch.nn.Module):\n    def __init__(self, num_features, num_classes):\n        super().__init__()\n        self.conv1 = GCNConv(num_features, 64)\n        self.conv2 = GCNConv(64, 64)\n        self.pool = TopKPooling(64, ratio=0.8)\n        self.lin = torch.nn.Linear(64, num_classes)\n\n    def forward(self, data):\n        x, edge_index, batch = data.x, data.edge_index, data.batch\n        x = F.relu(self.conv1(x, edge_index))\n        x, edge_index, _, batch, _, _ = self.pool(x, edge_index, None, batch)\n        x = F.relu(self.conv2(x, edge_index))\n        x = global_mean_pool(x, batch)\n        return self.lin(x)\n```\n\n### 5. Heterogeneous Graphs\n\n```python\nfrom torch_geometric.data import HeteroData\nfrom torch_geometric.nn import HeteroConv, GCNConv, SAGEConv, to_hetero\n\n# Create heterogeneous graph\ndata = HeteroData()\ndata['paper'].x = torch.randn(100, 128)\ndata['author'].x = torch.randn(200, 64)\ndata['author', 'writes', 'paper'].edge_index = torch.randint(0, 200, (2, 500))\ndata['paper', 'cites', 'paper'].edge_index = torch.randint(0, 100, (2, 300))\nprint(data)  # Shows all node\u002Fedge types\n\n# Method 1: Auto-convert homogeneous model\nmodel = GCN(...)\nmodel = to_hetero(model, data.metadata(), aggr='sum')\nout = model(data.x_dict, data.edge_index_dict)\n```\n\n```python\n# Method 2: Custom per-edge-type convolutions\nclass HeteroGNN(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = HeteroConv({\n            ('paper', 'cites', 'paper'): GCNConv(-1, 64),\n            ('author', 'writes', 'paper'): SAGEConv((-1, -1), 64),\n        }, aggr='sum')\n\n    def forward(self, x_dict, edge_index_dict):\n        x_dict = self.conv1(x_dict, edge_index_dict)\n        return {k: F.relu(v) for k, v in x_dict.items()}\n```\n\n### 6. Transforms & Preprocessing\n\n```python\nfrom torch_geometric.transforms import (\n    NormalizeFeatures, AddSelfLoops, ToUndirected,\n    RandomNodeSplit, RandomLinkSplit, Compose,\n    KNNGraph, RadiusGraph, AddLaplacianEigenvectorPE\n)\n\n# Single transform\ndataset = Planetoid(root='\u002Ftmp\u002FCora', name='Cora', transform=NormalizeFeatures())\n\n# Compose multiple transforms\ntransform = Compose([\n    ToUndirected(),\n    AddSelfLoops(),\n    NormalizeFeatures(),\n])\n\n# Data splitting\nnode_split = RandomNodeSplit(num_val=0.1, num_test=0.2)\nlink_split = RandomLinkSplit(num_val=0.1, num_test=0.2, is_undirected=True)\n\n# Point cloud → graph\npc_transform = Compose([KNNGraph(k=6), NormalizeFeatures()])\n\n# Positional encodings (for Graph Transformers)\npe_transform = AddLaplacianEigenvectorPE(k=10)\n```\n\n## Key Concepts\n\n### Layer Selection Guide\n\n| Task | Layer | Key Feature |\n|------|-------|-------------|\n| Baseline \u002F general | `GCNConv` | Spectral, cached, edge_weight |\n| Variable neighbor importance | `GATConv` \u002F `GATv2Conv` | Multi-head attention |\n| Large-scale inductive | `SAGEConv` | Sampling-friendly, mean\u002Fmax\u002Flstm aggr |\n| Graph classification | `GINConv` | Maximally powerful WL-test |\n| Long-range dependencies | `TransformerConv` | Graph transformer |\n| Spectral filtering | `ChebConv` | Chebyshev polynomials, K hops |\n| Rich edge features | `NNConv` | Edge NN processes edge_attr |\n| Molecular \u002F 3D structures | `SchNet`, `DimeNet` | Continuous filters, angles |\n| Heterogeneous \u002F multi-relation | `RGCNConv`, `HGTConv` | Multiple edge types |\n| Point clouds | `EdgeConv`, `PointNetConv` | Dynamic graphs, local features |\n| Deep GNNs (avoid oversmoothing) | `APPNP` + `PairNorm` | Separated propagation |\n\n### Data Flow Architecture\n\n- **edge_index**: `[2, num_edges]` COO format. Row 0 = source, Row 1 = target\n- **Mini-batch**: Block-diagonal adjacency + `batch` vector mapping nodes → graphs. No padding\n- **Neighbor sampling**: `NeighborLoader` samples K-hop subgraphs per seed node. Output is directed, relabeled\n- **Heterogeneous**: `x_dict` (per-type features), `edge_index_dict` (per-relation edges), `metadata()` for schema\n\n### Aggregation Options\n\n| Aggregation | Class | Use Case |\n|-------------|-------|----------|\n| Sum | `SumAggregation` | Counting-sensitive tasks |\n| Mean | `MeanAggregation` | Degree-invariant |\n| Max | `MaxAggregation` | Salient feature detection |\n| Softmax | `SoftmaxAggregation(learn=True)` | Learnable attention |\n| Multi | `MultiAggregation(['mean','max','std'])` | Combined signals |\n\n## Common Workflows\n\n### 1. Node Classification (Full Graph)\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom torch_geometric.datasets import Planetoid\nfrom torch_geometric.nn import GCNConv\n\ndataset = Planetoid(root='\u002Ftmp\u002FCora', name='Cora')\ndata = dataset[0]\n\nclass GCN(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = GCNConv(dataset.num_features, 16)\n        self.conv2 = GCNConv(16, dataset.num_classes)\n    def forward(self, data):\n        x = F.dropout(F.relu(self.conv1(data.x, data.edge_index)), p=0.5, training=self.training)\n        return self.conv2(x, data.edge_index)\n\nmodel = GCN()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)\n\n# Training\nfor epoch in range(200):\n    model.train(); optimizer.zero_grad()\n    out = model(data)\n    F.cross_entropy(out[data.train_mask], data.y[data.train_mask]).backward()\n    optimizer.step()\n\n# Evaluation\nmodel.eval()\npred = model(data).argmax(dim=1)\nacc = (pred[data.test_mask] == data.y[data.test_mask]).float().mean()\nprint(f'Test Accuracy: {acc:.4f}')\n```\n\n### 2. Graph Classification (Mini-Batch)\n\n```python\nfrom torch_geometric.datasets import TUDataset\nfrom torch_geometric.loader import DataLoader\nfrom torch_geometric.nn import GCNConv, global_mean_pool\n\ndataset = TUDataset(root='\u002Ftmp\u002FENZYMES', name='ENZYMES')\ntrain_dataset = dataset[:int(0.8 * len(dataset))]\ntest_dataset = dataset[int(0.8 * len(dataset)):]\ntrain_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n\nclass GraphNet(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = GCNConv(dataset.num_features, 64)\n        self.conv2 = GCNConv(64, 64)\n        self.lin = torch.nn.Linear(64, dataset.num_classes)\n    def forward(self, data):\n        x = F.relu(self.conv1(data.x, data.edge_index))\n        x = F.relu(self.conv2(x, data.edge_index))\n        x = global_mean_pool(x, data.batch)\n        return self.lin(x)\n\nmodel = GraphNet()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01)\nfor epoch in range(100):\n    model.train()\n    for batch in train_loader:\n        optimizer.zero_grad()\n        F.cross_entropy(model(batch), batch.y).backward()\n        optimizer.step()\n```\n\n### 3. Large-Scale with Neighbor Sampling\n\n```python\nfrom torch_geometric.loader import NeighborLoader\n\n# Sample 25 1-hop and 10 2-hop neighbors per seed node\ntrain_loader = NeighborLoader(\n    data,\n    num_neighbors=[25, 10],\n    batch_size=128,\n    input_nodes=data.train_mask,\n)\n\nmodel.train()\nfor batch in train_loader:\n    optimizer.zero_grad()\n    out = model(batch)\n    # Only compute loss on seed nodes (first batch_size nodes)\n    loss = F.cross_entropy(out[:batch.batch_size], batch.y[:batch.batch_size])\n    loss.backward()\n    optimizer.step()\n# Note: output subgraphs are directed, indices relabeled 0..N-1\n```\n\n## Key Parameters\n\n| Parameter | Module | Default | Range | Effect |\n|-----------|--------|---------|-------|--------|\n| `in_channels` | All Conv layers | — | int | Input feature dimension |\n| `out_channels` | All Conv layers | — | int | Output feature dimension |\n| `heads` | GATConv | 1 | 1-16 | Number of attention heads |\n| `dropout` | GATConv | 0.0 | 0-0.8 | Attention weight dropout |\n| `aggr` | MessagePassing | 'add' | add\u002Fmean\u002Fmax | Neighbor aggregation |\n| `K` | ChebConv | — | 2-5 | Chebyshev polynomial order |\n| `num_neighbors` | NeighborLoader | — | list[int] | Neighbors per hop (e.g., [25,10]) |\n| `batch_size` | DataLoader | — | 16-512 | Graphs or seed nodes per batch |\n| `ratio` | TopKPooling | 0.5 | 0.1-0.9 | Fraction of nodes to keep |\n| `lr` | Adam | — | 1e-4 to 0.01 | Learning rate |\n| `weight_decay` | Adam | 0 | 0 to 5e-3 | L2 regularization |\n\n## Best Practices\n\n1. **Start with GCNConv**: Use 2-layer GCN as baseline before trying complex architectures\n2. **Use lazy initialization**: Pass `-1` as `in_channels` to infer dimensions automatically: `GCNConv(-1, 64)`\n3. **Normalize features**: Apply `NormalizeFeatures()` transform for citation\u002Fsocial networks\n4. **Anti-pattern — too many layers**: GNNs typically need only 2-3 layers. Deeper causes oversmoothing. Use `JumpingKnowledge` or `PairNorm` if you need depth\n5. **GPU transfer**: Move both model AND data to GPU: `model.to(device)`, `data.to(device)`\n6. **Anti-pattern — ignoring batch vector**: In graph classification, always use `global_mean_pool(x, batch)` — forgetting `batch` pools across all graphs\n\n## Common Recipes\n\n### Recipe: Model Explainability (GNNExplainer)\n\n```python\nfrom torch_geometric.explain import Explainer, GNNExplainer\n\nexplainer = Explainer(\n    model=model,\n    algorithm=GNNExplainer(epochs=200),\n    explanation_type='model',\n    node_mask_type='attributes',\n    edge_mask_type='object',\n    model_config=dict(mode='multiclass_classification', task_level='node', return_type='log_probs'),\n)\n\nexplanation = explainer(data.x, data.edge_index, index=10)\nprint(f'Important edges: {explanation.edge_mask.topk(5).indices}')\nprint(f'Important features: {explanation.node_mask[10].topk(5).indices}')\n```\n\n### Recipe: Custom InMemoryDataset\n\n```python\nfrom torch_geometric.data import InMemoryDataset, Data\n\nclass MyDataset(InMemoryDataset):\n    def __init__(self, root, transform=None, pre_transform=None):\n        super().__init__(root, transform, pre_transform)\n        self.load(self.processed_paths[0])\n\n    @property\n    def raw_file_names(self):\n        return ['data.csv']\n\n    @property\n    def processed_file_names(self):\n        return ['data.pt']\n\n    def process(self):\n        data_list = []\n        # Build Data objects from raw files\n        edge_index = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)\n        x = torch.randn(2, 16)\n        data_list.append(Data(x=x, edge_index=edge_index, y=torch.tensor([0])))\n\n        if self.pre_filter is not None:\n            data_list = [d for d in data_list if self.pre_filter(d)]\n        if self.pre_transform is not None:\n            data_list = [self.pre_transform(d) for d in data_list]\n        self.save(data_list, self.processed_paths[0])\n```\n\n### Recipe: Deep GNN with JumpingKnowledge\n\n```python\nfrom torch_geometric.nn import GCNConv, JumpingKnowledge, LayerNorm\n\nclass DeepGNN(torch.nn.Module):\n    def __init__(self, in_ch, hidden, num_layers, out_ch):\n        super().__init__()\n        self.convs = torch.nn.ModuleList()\n        self.norms = torch.nn.ModuleList()\n        self.convs.append(GCNConv(in_ch, hidden))\n        self.norms.append(LayerNorm(hidden))\n        for _ in range(num_layers - 2):\n            self.convs.append(GCNConv(hidden, hidden))\n            self.norms.append(LayerNorm(hidden))\n        self.convs.append(GCNConv(hidden, hidden))\n        self.jk = JumpingKnowledge(mode='cat')\n        self.lin = torch.nn.Linear(hidden * num_layers, out_ch)\n\n    def forward(self, x, edge_index, batch):\n        xs = []\n        for conv, norm in zip(self.convs[:-1], self.norms):\n            x = F.relu(norm(conv(x, edge_index)))\n            xs.append(x)\n        xs.append(self.convs[-1](x, edge_index))\n        return self.lin(global_mean_pool(self.jk(xs), batch))\n```\n\n## Troubleshooting\n\n| Problem | Cause | Solution |\n|---------|-------|---------|\n| `edge_index` shape error | Wrong format (should be [2, E]) | Ensure COO format: `torch.tensor([[src...],[dst...]], dtype=torch.long)` |\n| OOM on large graph | Full-graph forward pass | Use `NeighborLoader` for mini-batch training |\n| Low accuracy | Oversmoothing (too many layers) | Reduce to 2-3 layers, add `JumpingKnowledge` or `PairNorm` |\n| NaN in training | Exploding gradients | Add gradient clipping, reduce learning rate, check feature scale |\n| Wrong graph-level output | Missing `batch` in pooling | Pass `batch` tensor to `global_mean_pool(x, batch)` |\n| Heterogeneous type error | Mismatched node\u002Fedge types | Check `data.metadata()` matches model definition |\n| Slow DataLoader | Large graph, no sampling | Use `NeighborLoader` with reasonable `num_neighbors` (e.g., [25,10]) |\n| `x` dimension mismatch | Multi-head attention output | For GATConv: output is `heads*out_channels` unless `concat=False` |\n| Import error for sparse ops | Missing optional dependencies | Install `torch_scatter`, `torch_sparse` from PyG wheels |\n| Pre-transform not applied | Dataset already processed | Delete `processed\u002F` directory and reload |\n\n## Bundled Resources\n\n- **`references\u002Flayers_transforms_reference.md`** — Complete catalog of 40+ convolutional layers (GCN, GAT, SAGE, GIN, molecular layers, hypergraph), aggregation operators, pooling (global + hierarchical), normalization layers, pre-built models, auto-encoders, knowledge graph embeddings, utility layers. Transform catalog: structure, feature, spatial, augmentation, mesh, specialized. Consolidated from original layers_reference.md (486 lines) + transforms_reference.md (680 lines). Script functionality (benchmark_model.py, create_gnn_template.py, visualize_graph.py) covered by Core API code blocks and Common Recipes\n- **`references\u002Fdatasets_catalog.md`** — Comprehensive dataset catalog organized by domain: citation networks (Planetoid, Coauthor, Amazon), graph classification (TUDataset 120+ benchmarks), molecular (QM9, ZINC, MoleculeNet), social (Reddit, Twitch), knowledge graphs (WordNet, FB15k), heterogeneous (OGB_MAG, MovieLens, DBLP), temporal (JODIE), 3D meshes (ShapeNet, ModelNet), OGB integration. Consolidated from original datasets_reference.md (575 lines)\n\n## Related Skills\n\n- **matplotlib-scientific-plotting** — Visualize graph structures, training curves, attention weights\n\n## References\n\n- PyTorch Geometric Documentation: https:\u002F\u002Fpytorch-geometric.readthedocs.io\u002F\n- PyG GitHub: https:\u002F\u002Fgithub.com\u002Fpyg-team\u002Fpytorch_geometric\n- Fey & Lenssen (2019), \"Fast Graph Representation Learning with PyTorch Geometric\", ICLR Workshop\n","# PyTorch Geometric (PyG) — Graph Neural Networks\n\n## Overview\n\nPyTorch Geometric is a library built on PyTorch for developing and training Graph Neural Networks (GNNs). It provides 40+ convolutional layers, mini-batch processing via block-diagonal adjacency matrices, neighbor sampling for large-scale graphs, and heterogeneous graph support for multi-type node\u002Fedge networks.\n\n## When to Use\n\n- Node classification on citation, social, or biological networks\n- Graph-level classification (molecular activity, protein function)\n- Link prediction (knowledge graphs, recommendation systems)\n- Molecular property prediction (drug discovery, quantum chemistry)\n- 3D point cloud processing and mesh analysis\n- Large-scale graph learning with neighbor sampling (>100K nodes)\n- Heterogeneous graphs with multiple node\u002Fedge types\n- **For non-graph deep learning** → use PyTorch directly\n- **For traditional graph algorithms (shortest path, centrality)** → use NetworkX\n\n## Prerequisites\n\n```bash\npip install torch torch_geometric\n# Optional sparse operations (recommended):\n# pip install pyg_lib torch_scatter torch_sparse torch_cluster\n```\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom torch_geometric.data import Data\nfrom torch_geometric.nn import GCNConv\n```\n\n## Quick Start\n\n```python\nfrom torch_geometric.datasets import Planetoid\nfrom torch_geometric.nn import GCNConv\nimport torch, torch.nn.functional as F\n\ndataset = Planetoid(root='\u002Ftmp\u002FCora', name='Cora')\ndata = dataset[0]\n\nclass GCN(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = GCNConv(dataset.num_features, 16)\n        self.conv2 = GCNConv(16, dataset.num_classes)\n    def forward(self, data):\n        x = F.relu(self.conv1(data.x, data.edge_index))\n        return self.conv2(x, data.edge_index)\n\nmodel = GCN()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)\nfor epoch in range(200):\n    model.train(); optimizer.zero_grad()\n    F.cross_entropy(model(data)[data.train_mask], data.y[data.train_mask]).backward()\n    optimizer.step()\n\nmodel.eval()\npred = model(data).argmax(dim=1)\nacc = (pred[data.test_mask] == data.y[data.test_mask]).float().mean()\nprint(f'Test Accuracy: {acc:.4f}')  # ~0.81\n```\n\n## Core API\n\n### 1. Data Representation\n\n```python\nimport torch\nfrom torch_geometric.data import Data\n\n# Create a graph: 3 nodes, 4 edges (undirected)\nedge_index = torch.tensor([[0, 1, 1, 2],\n                           [1, 0, 2, 1]], dtype=torch.long)\nx = torch.randn(3, 16)  # Node features [num_nodes, features]\ny = torch.tensor([0, 1, 0])  # Node labels\n\ndata = Data(x=x, edge_index=edge_index, y=y)\nprint(f'Nodes: {data.num_nodes}, Edges: {data.num_edges}')\nprint(f'Features: {data.num_node_features}')\nprint(f'Has self-loops: {data.has_self_loops()}')\nprint(f'Is undirected: {data.is_undirected()}')\n\n# Optional attributes\ndata.edge_attr = torch.randn(4, 8)   # Edge features [num_edges, features]\ndata.pos = torch.randn(3, 3)          # Node positions (3D)\ndata.train_mask = torch.tensor([True, True, False])  # Custom masks\n```\n\n```python\n# Mini-batch processing — graphs concatenated as block-diagonal\nfrom torch_geometric.loader import DataLoader\n\nloader = DataLoader(dataset, batch_size=32, shuffle=True)\nfor batch in loader:\n    print(f'Graphs: {batch.num_graphs}, Nodes: {batch.num_nodes}')\n    # batch.batch maps each node → its source graph index\n    # No padding needed — computationally efficient\n```\n\n### 2. Convolutional Layers\n\n```python\nfrom torch_geometric.nn import GCNConv, GATConv, SAGEConv, GINConv\nimport torch.nn as nn\n\n# GCNConv — spectral graph convolution (baseline)\nconv = GCNConv(in_channels=16, out_channels=32)\n# Supports: edge_weight, SparseTensor, Bipartite, Lazy init\n\n# GATConv — attention-based neighbor weighting\nconv = GATConv(16, 32, heads=8, dropout=0.6)\n# Output: [N, heads * out_channels] (concat) or [N, out_channels] (concat=False)\n\n# SAGEConv — inductive learning via sampling\nconv = SAGEConv(16, 32, aggr='mean')  # 'mean', 'max', 'lstm'\n\n# GINConv — maximally powerful for graph isomorphism\nnn_module = nn.Sequential(nn.Linear(16, 32), nn.ReLU(), nn.Linear(32, 32))\nconv = GINConv(nn_module)\n\n# TransformerConv — graph transformer\nfrom torch_geometric.nn import TransformerConv\nconv = TransformerConv(16, 32, heads=8, beta=True)\n\n# All layers: x_out = conv(x, edge_index)\nx_out = conv(x, edge_index)\nprint(f'Output shape: {x_out.shape}')  # [num_nodes, out_channels]\n```\n\n### 3. Custom Message Passing\n\n```python\nfrom torch_geometric.nn import MessagePassing\nfrom torch_geometric.utils import add_self_loops, degree\n\nclass CustomConv(MessagePassing):\n    def __init__(self, in_channels, out_channels):\n        super().__init__(aggr='add')  # 'add', 'mean', 'max'\n        self.lin = torch.nn.Linear(in_channels, out_channels)\n\n    def forward(self, x, edge_index):\n        edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))\n        x = self.lin(x)\n\n        # Degree-based normalization\n        row, col = edge_index\n        deg = degree(col, x.size(0), dtype=x.dtype)\n        norm = deg.pow(-0.5)\n        norm = norm[row] * norm[col]\n\n        return self.propagate(edge_index, x=x, norm=norm)\n\n    def message(self, x_j, norm):\n        # x_j: source node features (automatic via _j suffix)\n        return norm.view(-1, 1) * x_j\n\n# Key methods: forward(), message(), aggregate(), update()\n# _i suffix → target node, _j suffix → source node\n```\n\n### 4. Pooling & Graph-Level Readout\n\n```python\nfrom torch_geometric.nn import (\n    global_mean_pool, global_max_pool, global_add_pool,\n    TopKPooling, SAGPooling\n)\n\n# Global pooling: node features → graph-level representation\nx_graph = global_mean_pool(x, batch)  # [num_graphs, features]\n\n# Hierarchical pooling: coarsen graph\npool = TopKPooling(64, ratio=0.8)  # Keep top 80% nodes\nx, edge_index, _, batch, _, _ = pool(x, edge_index, None, batch)\n\n# Graph classification model\nclass GraphClassifier(torch.nn.Module):\n    def __init__(self, num_features, num_classes):\n        super().__init__()\n        self.conv1 = GCNConv(num_features, 64)\n        self.conv2 = GCNConv(64, 64)\n        self.pool = TopKPooling(64, ratio=0.8)\n        self.lin = torch.nn.Linear(64, num_classes)\n\n    def forward(self, data):\n        x, edge_index, batch = data.x, data.edge_index, data.batch\n        x = F.relu(self.conv1(x, edge_index))\n        x, edge_index, _, batch, _, _ = self.pool(x, edge_index, None, batch)\n        x = F.relu(self.conv2(x, edge_index))\n        x = global_mean_pool(x, batch)\n        return self.lin(x)\n```\n\n### 5. Heterogeneous Graphs\n\n```python\nfrom torch_geometric.data import HeteroData\nfrom torch_geometric.nn import HeteroConv, GCNConv, SAGEConv, to_hetero\n\n# Create heterogeneous graph\ndata = HeteroData()\ndata['paper'].x = torch.randn(100, 128)\ndata['author'].x = torch.randn(200, 64)\ndata['author', 'writes', 'paper'].edge_index = torch.randint(0, 200, (2, 500))\ndata['paper', 'cites', 'paper'].edge_index = torch.randint(0, 100, (2, 300))\nprint(data)  # Shows all node\u002Fedge types\n\n# Method 1: Auto-convert homogeneous model\nmodel = GCN(...)\nmodel = to_hetero(model, data.metadata(), aggr='sum')\nout = model(data.x_dict, data.edge_index_dict)\n```\n\n```python\n# Method 2: Custom per-edge-type convolutions\nclass HeteroGNN(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = HeteroConv({\n            ('paper', 'cites', 'paper'): GCNConv(-1, 64),\n            ('author', 'writes', 'paper'): SAGEConv((-1, -1), 64),\n        }, aggr='sum')\n\n    def forward(self, x_dict, edge_index_dict):\n        x_dict = self.conv1(x_dict, edge_index_dict)\n        return {k: F.relu(v) for k, v in x_dict.items()}\n```\n\n### 6. Transforms & Preprocessing\n\n```python\nfrom torch_geometric.transforms import (\n    NormalizeFeatures, AddSelfLoops, ToUndirected,\n    RandomNodeSplit, RandomLinkSplit, Compose,\n    KNNGraph, RadiusGraph, AddLaplacianEigenvectorPE\n)\n\n# Single transform\ndataset = Planetoid(root='\u002Ftmp\u002FCora', name='Cora', transform=NormalizeFeatures())\n\n# Compose multiple transforms\ntransform = Compose([\n    ToUndirected(),\n    AddSelfLoops(),\n    NormalizeFeatures(),\n])\n\n# Data splitting\nnode_split = RandomNodeSplit(num_val=0.1, num_test=0.2)\nlink_split = RandomLinkSplit(num_val=0.1, num_test=0.2, is_undirected=True)\n\n# Point cloud → graph\npc_transform = Compose([KNNGraph(k=6), NormalizeFeatures()])\n\n# Positional encodings (for Graph Transformers)\npe_transform = AddLaplacianEigenvectorPE(k=10)\n```\n\n## Key Concepts\n\n### Layer Selection Guide\n\n| Task | Layer | Key Feature |\n|------|-------|-------------|\n| Baseline \u002F general | `GCNConv` | Spectral, cached, edge_weight |\n| Variable neighbor importance | `GATConv` \u002F `GATv2Conv` | Multi-head attention |\n| Large-scale inductive | `SAGEConv` | Sampling-friendly, mean\u002Fmax\u002Flstm aggr |\n| Graph classification | `GINConv` | Maximally powerful WL-test |\n| Long-range dependencies | `TransformerConv` | Graph transformer |\n| Spectral filtering | `ChebConv` | Chebyshev polynomials, K hops |\n| Rich edge features | `NNConv` | Edge NN processes edge_attr |\n| Molecular \u002F 3D structures | `SchNet`, `DimeNet` | Continuous filters, angles |\n| Heterogeneous \u002F multi-relation | `RGCNConv`, `HGTConv` | Multiple edge types |\n| Point clouds | `EdgeConv`, `PointNetConv` | Dynamic graphs, local features |\n| Deep GNNs (avoid oversmoothing) | `APPNP` + `PairNorm` | Separated propagation |\n\n### Data Flow Architecture\n\n- **edge_index**: `[2, num_edges]` COO format. Row 0 = source, Row 1 = target\n- **Mini-batch**: Block-diagonal adjacency + `batch` vector mapping nodes → graphs. No padding\n- **Neighbor sampling**: `NeighborLoader` samples K-hop subgraphs per seed node. Output is directed, relabeled\n- **Heterogeneous**: `x_dict` (per-type features), `edge_index_dict` (per-relation edges), `metadata()` for schema\n\n### Aggregation Options\n\n| Aggregation | Class | Use Case |\n|-------------|-------|----------|\n| Sum | `SumAggregation` | Counting-sensitive tasks |\n| Mean | `MeanAggregation` | Degree-invariant |\n| Max | `MaxAggregation` | Salient feature detection |\n| Softmax | `SoftmaxAggregation(learn=True)` | Learnable attention |\n| Multi | `MultiAggregation(['mean','max','std'])` | Combined signals |\n\n## Common Workflows\n\n### 1. Node Classification (Full Graph)\n\n```python\nimport torch\nimport torch.nn.functional as F\nfrom torch_geometric.datasets import Planetoid\nfrom torch_geometric.nn import GCNConv\n\ndataset = Planetoid(root='\u002Ftmp\u002FCora', name='Cora')\ndata = dataset[0]\n\nclass GCN(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = GCNConv(dataset.num_features, 16)\n        self.conv2 = GCNConv(16, dataset.num_classes)\n    def forward(self, data):\n        x = F.dropout(F.relu(self.conv1(data.x, data.edge_index)), p=0.5, training=self.training)\n        return self.conv2(x, data.edge_index)\n\nmodel = GCN()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)\n\n# Training\nfor epoch in range(200):\n    model.train(); optimizer.zero_grad()\n    out = model(data)\n    F.cross_entropy(out[data.train_mask], data.y[data.train_mask]).backward()\n    optimizer.step()\n\n# Evaluation\nmodel.eval()\npred = model(data).argmax(dim=1)\nacc = (pred[data.test_mask] == data.y[data.test_mask]).float().mean()\nprint(f'Test Accuracy: {acc:.4f}')\n```\n\n### 2. Graph Classification (Mini-Batch)\n\n```python\nfrom torch_geometric.datasets import TUDataset\nfrom torch_geometric.loader import DataLoader\nfrom torch_geometric.nn import GCNConv, global_mean_pool\n\ndataset = TUDataset(root='\u002Ftmp\u002FENZYMES', name='ENZYMES')\ntrain_dataset = dataset[:int(0.8 * len(dataset))]\ntest_dataset = dataset[int(0.8 * len(dataset)):]\ntrain_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n\nclass GraphNet(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.conv1 = GCNConv(dataset.num_features, 64)\n        self.conv2 = GCNConv(64, 64)\n        self.lin = torch.nn.Linear(64, dataset.num_classes)\n    def forward(self, data):\n        x = F.relu(self.conv1(data.x, data.edge_index))\n        x = F.relu(self.conv2(x, data.edge_index))\n        x = global_mean_pool(x, data.batch)\n        return self.lin(x)\n\nmodel = GraphNet()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01)\nfor epoch in range(100):\n    model.train()\n    for batch in train_loader:\n        optimizer.zero_grad()\n        F.cross_entropy(model(batch), batch.y).backward()\n        optimizer.step()\n```\n\n### 3. Large-Scale with Neighbor Sampling\n\n```python\nfrom torch_geometric.loader import NeighborLoader\n\n# Sample 25 1-hop and 10 2-hop neighbors per seed node\ntrain_loader = NeighborLoader(\n    data,\n    num_neighbors=[25, 10],\n    batch_size=128,\n    input_nodes=data.train_mask,\n)\n\nmodel.train()\nfor batch in train_loader:\n    optimizer.zero_grad()\n    out = model(batch)\n    # Only compute loss on seed nodes (first batch_size nodes)\n    loss = F.cross_entropy(out[:batch.batch_size], batch.y[:batch.batch_size])\n    loss.backward()\n    optimizer.step()\n# Note: output subgraphs are directed, indices relabeled 0..N-1\n```\n\n## Key Parameters\n\n| Parameter | Module | Default | Range | Effect |\n|-----------|--------|---------|-------|--------|\n| `in_channels` | All Conv layers | — | int | Input feature dimension |\n| `out_channels` | All Conv layers | — | int | Output feature dimension |\n| `heads` | GATConv | 1 | 1-16 | Number of attention heads |\n| `dropout` | GATConv | 0.0 | 0-0.8 | Attention weight dropout |\n| `aggr` | MessagePassing | 'add' | add\u002Fmean\u002Fmax | Neighbor aggregation |\n| `K` | ChebConv | — | 2-5 | Chebyshev polynomial order |\n| `num_neighbors` | NeighborLoader | — | list[int] | Neighbors per hop (e.g., [25,10]) |\n| `batch_size` | DataLoader | — | 16-512 | Graphs or seed nodes per batch |\n| `ratio` | TopKPooling | 0.5 | 0.1-0.9 | Fraction of nodes to keep |\n| `lr` | Adam | — | 1e-4 to 0.01 | Learning rate |\n| `weight_decay` | Adam | 0 | 0 to 5e-3 | L2 regularization |\n\n## Best Practices\n\n1. **Start with GCNConv**: Use 2-layer GCN as baseline before trying complex architectures\n2. **Use lazy initialization**: Pass `-1` as `in_channels` to infer dimensions automatically: `GCNConv(-1, 64)`\n3. **Normalize features**: Apply `NormalizeFeatures()` transform for citation\u002Fsocial networks\n4. **Anti-pattern — too many layers**: GNNs typically need only 2-3 layers. Deeper causes oversmoothing. Use `JumpingKnowledge` or `PairNorm` if you need depth\n5. **GPU transfer**: Move both model AND data to GPU: `model.to(device)`, `data.to(device)`\n6. **Anti-pattern — ignoring batch vector**: In graph classification, always use `global_mean_pool(x, batch)` — forgetting `batch` pools across all graphs\n\n## Common Recipes\n\n### Recipe: Model Explainability (GNNExplainer)\n\n```python\nfrom torch_geometric.explain import Explainer, GNNExplainer\n\nexplainer = Explainer(\n    model=model,\n    algorithm=GNNExplainer(epochs=200),\n    explanation_type='model',\n    node_mask_type='attributes',\n    edge_mask_type='object',\n    model_config=dict(mode='multiclass_classification', task_level='node', return_type='log_probs'),\n)\n\nexplanation = explainer(data.x, data.edge_index, index=10)\nprint(f'Important edges: {explanation.edge_mask.topk(5).indices}')\nprint(f'Important features: {explanation.node_mask[10].topk(5).indices}')\n```\n\n### Recipe: Custom InMemoryDataset\n\n```python\nfrom torch_geometric.data import InMemoryDataset, Data\n\nclass MyDataset(InMemoryDataset):\n    def __init__(self, root, transform=None, pre_transform=None):\n        super().__init__(root, transform, pre_transform)\n        self.load(self.processed_paths[0])\n\n    @property\n    def raw_file_names(self):\n        return ['data.csv']\n\n    @property\n    def processed_file_names(self):\n        return ['data.pt']\n\n    def process(self):\n        data_list = []\n        # Build Data objects from raw files\n        edge_index = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)\n        x = torch.randn(2, 16)\n        data_list.append(Data(x=x, edge_index=edge_index, y=torch.tensor([0])))\n\n        if self.pre_filter is not None:\n            data_list = [d for d in data_list if self.pre_filter(d)]\n        if self.pre_transform is not None:\n            data_list = [self.pre_transform(d) for d in data_list]\n        self.save(data_list, self.processed_paths[0])\n```\n\n### Recipe: Deep GNN with JumpingKnowledge\n\n```python\nfrom torch_geometric.nn import GCNConv, JumpingKnowledge, LayerNorm\n\nclass DeepGNN(torch.nn.Module):\n    def __init__(self, in_ch, hidden, num_layers, out_ch):\n        super().__init__()\n        self.convs = torch.nn.ModuleList()\n        self.norms = torch.nn.ModuleList()\n        self.convs.append(GCNConv(in_ch, hidden))\n        self.norms.append(LayerNorm(hidden))\n        for _ in range(num_layers - 2):\n            self.convs.append(GCNConv(hidden, hidden))\n            self.norms.append(LayerNorm(hidden))\n        self.convs.append(GCNConv(hidden, hidden))\n        self.jk = JumpingKnowledge(mode='cat')\n        self.lin = torch.nn.Linear(hidden * num_layers, out_ch)\n\n    def forward(self, x, edge_index, batch):\n        xs = []\n        for conv, norm in zip(self.convs[:-1], self.norms):\n            x = F.relu(norm(conv(x, edge_index)))\n            xs.append(x)\n        xs.append(self.convs[-1](x, edge_index))\n        return self.lin(global_mean_pool(self.jk(xs), batch))\n```\n\n## Troubleshooting\n\n| Problem | Cause | Solution |\n|---------|-------|---------|\n| `edge_index` shape error | Wrong format (should be [2, E]) | Ensure COO format: `torch.tensor([[src...],[dst...]], dtype=torch.long)` |\n| OOM on large graph | Full-graph forward pass | Use `NeighborLoader` for mini-batch training |\n| Low accuracy | Oversmoothing (too many layers) | Reduce to 2-3 layers, add `JumpingKnowledge` or `PairNorm` |\n| NaN in training | Exploding gradients | Add gradient clipping, reduce learning rate, check feature scale |\n| Wrong graph-level output | Missing `batch` in pooling | Pass `batch` tensor to `global_mean_pool(x, batch)` |\n| Heterogeneous type error | Mismatched node\u002Fedge types | Check `data.metadata()` matches model definition |\n| Slow DataLoader | Large graph, no sampling | Use `NeighborLoader` with reasonable `num_neighbors` (e.g., [25,10]) |\n| `x` dimension mismatch | Multi-head attention output | For GATConv: output is `heads*out_channels` unless `concat=False` |\n| Import error for sparse ops | Missing optional dependencies | Install `torch_scatter`, `torch_sparse` from PyG wheels |\n| Pre-transform not applied | Dataset already processed | Delete `processed\u002F` directory and reload |\n\n## Bundled Resources\n\n- **`references\u002Flayers_transforms_reference.md`** — Complete catalog of 40+ convolutional layers (GCN, GAT, SAGE, GIN, molecular layers, hypergraph), aggregation operators, pooling (global + hierarchical), normalization layers, pre-built models, auto-encoders, knowledge graph embeddings, utility layers. Transform catalog: structure, feature, spatial, augmentation, mesh, specialized. Consolidated from original layers_reference.md (486 lines) + transforms_reference.md (680 lines). Script functionality (benchmark_model.py, create_gnn_template.py, visualize_graph.py) covered by Core API code blocks and Common Recipes\n- **`references\u002Fdatasets_catalog.md`** — Comprehensive dataset catalog organized by domain: citation networks (Planetoid, Coauthor, Amazon), graph classification (TUDataset 120+ benchmarks), molecular (QM9, ZINC, MoleculeNet), social (Reddit, Twitch), knowledge graphs (WordNet, FB15k), heterogeneous (OGB_MAG, MovieLens, DBLP), temporal (JODIE), 3D meshes (ShapeNet, ModelNet), OGB integration. Consolidated from original datasets_reference.md (575 lines)\n\n## Related Skills\n\n- **matplotlib-scientific-plotting** — Visualize graph structures, training curves, attention weights\n\n## References\n\n- PyTorch Geometric Documentation: https:\u002F\u002Fpytorch-geometric.readthedocs.io\u002F\n- PyG GitHub: https:\u002F\u002Fgithub.com\u002Fpyg-team\u002Fpytorch_geometric\n- Fey & Lenssen (2019), \"Fast Graph Representation Learning with PyTorch Geometric\", ICLR Workshop\n",{"name":5,"license":15,"description":7},"master","63f17866001c5ca854bf2fa0b678ce277133de5b","skills\u002Fawesome-skills\u002Ftorch-geometric-graph-neural-networks",0,"https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS","https:\u002F\u002Fbg-szy.github.io\u002FTOP-SKILLS\u002F","https:\u002F\u002Fgithub.com\u002Fbg-szy","https:\u002F\u002Fwww.ecust.edu.cn\u002F","a student of East China University of Science and Technology","2026-11-15 03:38:02",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add bg-szy\u002FTOP-SKILLS --skill torch-geometric-graph-neural-networks",{"tool":40,"command":41},"bunx","bunx skills add bg-szy\u002FTOP-SKILLS --skill torch-geometric-graph-neural-networks",{"tool":43,"command":44},"pnpm","pnpm dlx skills add bg-szy\u002FTOP-SKILLS --skill torch-geometric-graph-neural-networks","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fawesome-skills\u002Ftorch-geometric-graph-neural-networks\u002FSKILL.md",true,[],[49,57,64,71,78,85],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":56},"01M7DXW9N826PKXK174PVW3038","serpmaven","Scrape Google search results (SERP) to JSON with SERP Maven (serpmaven) - a real Chrome browser on a residential proxy with sticky sessions. Run it as a CLI, a Python library, a local HTTP search API (`serve`), an MCP server or a Docker image; set the proxy login, workers, pages and cost tracking. Use when the user wants Google results, rank tracking, a self-hosted SERP API, or live Google search for an AI agent.","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fmarketplace\u002Fserpmaven\u002FSKILL.md",[],[],"2026-11-15 14:19:17",{"skillNo":58,"name":59,"nameZh":6,"description":60,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":61,"categories":62,"keywords":63,"publishedAt":56},"01M7DXVHSTWDV65475QEQ915M7","revnu-landing-page-audit","Find out why a landing page isn't turning visitors into signups, demos or sales. Audits one page against what the ad, post or search that sends people there promised, then checks the first screen, proof, call to action, friction and mobile. Returns at most 7 prioritized fixes, plus what is fine and what could not be checked; rewrites specific lines and fixes the page in the repo when asked. Never promises a conversion lift. Works without a Revnu account. Use when the user says or asks: \"audit my landing page\", \"why isn't this page converting\", \"review my homepage\", \"my ads get clicks but no signups\", \"people bounce from the pricing page\", \"CRO review\", \"improve conversion rate\", \"is my hero section clear\", \"roast my landing page\", \"rewrite my headline\", \"what's wrong with this page\", \"landing page feedback\", \"make the signup page convert better\". Not for SEO or AI-search audits, page speed engineering on its own, or building a new page from scratch.","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fmarketplace\u002Frevnu-landing-page-audit\u002FSKILL.md",[],[],{"skillNo":65,"name":66,"nameZh":6,"description":67,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":68,"categories":69,"keywords":70,"publishedAt":56},"01M7DXV8X2D7B3VTD4HHYYHTGR","revnu-growth-context","Write down once who buys, what they're stuck on, what it costs, what proof you have and what you've already tried, so every growth task starts from facts instead of a questionnaire. Creates or updates .agents\u002Frevnu-growth.md from the repo, the live site and the user, and imports an existing product-marketing.md. Use when the user says \"set up our marketing context\", \"who is our ideal customer\", \"write our ICP\", \"describe the product for marketing\", \"positioning doc\", \"what's our brand voice\", \"remember this about our customers\", \"log what we tried\", \"what have we learned from marketing\", \"we changed pricing, update the context\", \"update our growth notes\", \"summarize the business for the agent\", \"import my product-marketing.md\", \"start a growth doc\", or before a first marketing, SEO, outreach or launch task when no context file exists. Works without a Revnu account.","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fmarketplace\u002Frevnu-growth-context\u002FSKILL.md",[],[],{"skillNo":72,"name":73,"nameZh":6,"description":74,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":75,"categories":76,"keywords":77,"publishedAt":56},"01M7DXV0DGJ1G0A60PAHC6J3C5","revnu-get-listed","Get onto the third-party pages AI answers and search cite when buyers ask for the best tool in your category: \"best X\" roundups, directories, review sites, GitHub awesome lists, community threads and comparison pages. Finds which ones are cited, ranks them by fit and effort, and drafts each submission, PR or pitch by the target's own rules. Use when the user says \"get us listed\", \"which directories should we submit to\", \"how do we get into best-of lists\", \"why does ChatGPT recommend competitors and not us\", \"get mentioned in AI answers\", \"submit to awesome lists\", \"get on G2\", \"where are our competitors listed\", \"pitch listicle authors\", \"find backlink opportunities\", \"launch directories\", \"get into roundups\", \"Product Hunt alternatives\", \"where should we be listed\", \"get cited by Perplexity\". Never submits, pays or posts without a yes. Works without a Revnu account.","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fmarketplace\u002Frevnu-get-listed\u002FSKILL.md",[],[],{"skillNo":79,"name":80,"nameZh":6,"description":81,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":82,"categories":83,"keywords":84,"publishedAt":56},"01M7DXTSPMGT9D6DSS0HP9BSTA","revnu-ai-readiness-audit","Audit whether your website gives ChatGPT, Perplexity, Claude, Gemini and Google's AI Overviews something worth quoting, and fix the pages that don't. Use when the user says or asks \"is my site ready for AI search\", \"audit my site for AI answers\", \"AEO audit\", \"GEO audit\", \"why doesn't ChatGPT quote our pricing\", \"make our pages citable by AI\", \"do I need llms.txt\", \"does schema help with ChatGPT\", \"check our structured data\", \"is our content visible without JavaScript\", \"AI SEO audit\", \"optimize our homepage for AI answers\", \"LLM SEO check\", \"why does AI get our product wrong\", \"fix our site for AI Overviews\". Checks fetchability and indexability, answers in the raw HTML, entity facts, schema (including JS-injected markup), headings, dates and llms.txt, then gives at most 10 prioritised fixes and edits the repo when asked. Works without a Revnu account.","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fmarketplace\u002Frevnu-ai-readiness-audit\u002FSKILL.md",[],[],{"skillNo":86,"name":87,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":89,"categories":90,"keywords":91,"publishedAt":56},"01M7DXSZHCVTRS620GC3S97JZV","proxy-troubleshooting","Diagnose residential proxy failures, with NodeMaven's gateway as the reference - 407 with correct credentials, 406, 410, 500, a connection that hangs, ERR_TUNNEL_CONNECTION_FAILED in a browser, Playwright or Puppeteer ignoring proxy credentials, a sticky session that changes IP, geo-targeting that is silently ignored, passwords with special characters, and unexpected traffic from headless Chrome. Use when a proxy connection fails, returns the wrong location, or costs more traffic than expected.","https:\u002F\u002Fgithub.com\u002Fbg-szy\u002FTOP-SKILLS\u002Fblob\u002Fmaster\u002Fskills\u002Fmarketplace\u002Fproxy-troubleshooting\u002FSKILL.md",[],[]]