Cacher is the code snippet organizer for pro developers

# Setting Up Pre-commit Hooks with UV

Pre-commit hooks automatically check your code before each commit, catching issues early and enforcing consistent code quality.

## Installation

Add pre-commit as a development dependency:

```bash
uv add --dev pre-commit
```

## Configuration

Create `.pre-commit-config.yaml` in your project root:

```yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.5.0
    hooks:
      - id: trailing-whitespace
      

# 查看远程仓库
git remote -v

# 断联
git remote remove origin

import cartopy.crs as ccrs
import cartopy.feature as cfeature
from cartopy.io.shapereader import Reader

sys.path.insert(0, "/data8/xuyf/Project/shouxian")
from configs import MAP_DIR
sheng = Reader(os.path.join(MAP_DIR, 'sheng.shp'))

BDY_DIR = "/data8/xuyf/Data/Static/boundary/GS(2024)0650-SHP"
sheng = Reader(os.path.join(BDY_DIR, 'sheng.shp'))

fig = plt.figure(figsize=(12, 8), dpi=300)
ax = fig.subplots(1, 1, subplot_kw={'projection': ccrs.PlateCarree()})

ax.add_feature(cfeatu

function Mount-RegistryHive {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true, Position = 0, ValueFromPipeline = $true, ValueFromPipelineByPropertyName = $true)]
        $KeyName
        ,
        [Parameter(Mandatory = $true, Position = 1, ValueFromPipeline = $true, ValueFromPipelineByPropertyName = $true)]
        $FileName
    )

    begin {
            Add-Type -Name LoadHive -NameSpace RegistryHelper -MemberDefinition @"

[DllImport("advapi32.dll", SetLast

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {boolean}
 */
var hasIncreasingSubarrays = function(nums, k) {
    // Helper function to check if a subarray is strictly increasing
    function isStrictlyIncreasing(start, end) {
        for (let i = start; i < end; i++) {
            if (nums[i] >= nums[i + 1]) {
                return false; // Not strictly increasing
            }
        }
        return true;
    }

    // Total length needed for two adjacent subarrays of length

<div class="pp-stats-countup" data-id="pp-{{Matrix.MatrixId}}">
   <div class="section-copy">{{Module.FieldValues.SectionCopy}}</div>
   <ul class="stats-countup-list" data-layout="{{Module.FieldValues.Layout | default: 'quarter'}}">
      {% for item in List.Items %}
         {% assign el = item.FieldValues %}
         <li
            class="single-stat"
            data-start-value="{{el.StartingValue}}"
            data-value="{{el.Value}}"
         >
            <h3>
             

```python
# model.py
# SFAN + CMEFS unified model for semantic music culture modeling
# Based on Feng Liu (2025)​:contentReference[oaicite:11]{index=11}​:contentReference[oaicite:12]{index=12}

import torch
import torch.nn as nn
import torch.nn.functional as F


class MultiHeadAttention(nn.Module):
    """Multi-head self-attention for multimodal fusion."""
    def __init__(self, dim, heads=4):
        super().__init__()
        self.qkv = nn.Linear(dim, dim * 3)
      

```python
# model.py
# GEMFEN + AKIS for Intelligent Rural Evaluation System
# Based on Zhu et al. (2025)​:contentReference[oaicite:11]{index=11}

import torch
import torch.nn as nn
import torch.nn.functional as F


class GraphConvLayer(nn.Module):
    """Basic GNN layer (Eq. 1 & 4)."""
    def __init__(self, in_dim, out_dim):
        super().__init__()
        self.linear = nn.Linear(in_dim, out_dim)

    def forward(self, x, adj):
        h = torch.matmul(adj, x)
      

```python
# model.py
# Implementation of EVCAN + AVPAM for Art Style Recognition
# Based on equations and architecture in Shi & He (2025) :contentReference[oaicite:9]{index=9}

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class MultiScaleConv(nn.Module):
    """Multi-scale feature extraction (Eq. 7–10)."""
    def __init__(self, in_ch, out_ch, scales=(3,5,7)):
        super().__init__()
        self.branches = nn.ModuleList([
            nn.Conv2

```python
# model.py
# TSLM + AKIS (minimal PyTorch implementation)
# References to equations and sections follow the uploaded paper. :contentReference[oaicite:10]{index=10}

from typing import Optional, Tuple
import math
import torch
import torch.nn as nn
import torch.nn.functional as F


class SinusoidalPositionalEncoding(nn.Module):
    """
    Classic sinusoidal positional encodings (paper Eq. (9)-(10)). :contentReference[oaicite:11]{index=11}
    """
    def __init__(self, d

```python
# model.py
# MPFN-AMFS: Multimodal Pose Fusion Network + Adaptive Multimodal Fusion Strategy
# Author: Chen Niyun (Macao Polytechnic University, 2024) :contentReference[oaicite:8]{index=8}

import torch
import torch.nn as nn
import torch.nn.functional as F


# ======== Encoders ========

class CNNEncoder(nn.Module):
    """Visual feature extractor (2D Conv + BN + ReLU)​:contentReference[oaicite:9]{index=9}"""
    def __init__(self, in_ch=3, out_dim=128):
        su

```python
# model.py
# DCMFN-AMFS: Deep Convolutional Multi-Scale Fusion Network with Adaptive Multi-Scale Fusion Strategy
# Based on Zhang et al. (2024), Comprehensive Evaluation of Green Building Indoor Environment :contentReference[oaicite:9]{index=9}

import torch
import torch.nn as nn
import torch.nn.functional as F


class ConvBlock(nn.Module):
    """Convolution + BN + ReLU"""
    def __init__(self, in_ch, out_ch, k=3, s=1, p=1):
        super().__init__()
        self.conv 

```python
# model.py
# RSAN-ARSAS: Residual Self-Attention Network with Adaptive Residual Strategy
# Based on: Zhou & Li, "Data-Driven Fault Diagnosis..." Jiangsu Normal University, 2024 :contentReference[oaicite:12]{index=12}

import torch
import torch.nn as nn
import torch.nn.functional as F


class ResidualBlock(nn.Module):
    """Standard residual block with GELU activation"""
    def __init__(self, dim):
        super().__init__()
        self.fc1 = nn.Linear(dim, dim)
      

```python
# model.py
# SARP-ASAUE: Sparse Attention & Uncertainty Estimation for Risk Prediction
# Based on Bin Zhan (Zhejiang A&F University) 2024 :contentReference[oaicite:10]{index=10}

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional, Tuple


class SparseAttention(nn.Module):
    """Sparse multi-head attention selecting top-k keys per query."""

    def __init__(self, dim: int, num_heads: int = 4, topk: int = 16):
        super()._

```python
# model.py
# CMARL-COS: Collaborative Multi-Agent RL with Constraint-Aware Optimization
# Author: Legend Co., Ltd. (Sharon's workspace)
# Inspired by: Yu Caixia, "Multi-Agent Collaboration and Reinforcement Learning-Driven Framework..."  :contentReference[oaicite:5]{index=5}

from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
import torch
import torch.nn as nn
import torch.nn.functional as F


def mlp(sizes: List[int], activation=nn.ReLU, out_

```python
# model.py
# Hybrid Attention-Fusion Network (HAFN)
# Based on Wang & Wu (2024)

import torch
import torch.nn as nn
import torch.nn.functional as F


# ----- Attention Modules -----
class CrossAttention(nn.Module):
    def __init__(self, in_e, in_g, hidden):
        super().__init__()
        self.W_e = nn.Linear(in_e, hidden)
        self.W_g = nn.Linear(in_g, hidden)

    def forward(self, He, Hg):
        # Compute attention maps
        Ae = F.softmax(torch.matmu