import pandas as pd
from datetime import datetime, timedelta
import yfinance as yf
# Define the end date
end = str(pd.Timestamp.today().strftime('%Y-%m-%d'))
# Calculate the start date (20 years before the end date)
no_years = 20
start = (datetime.strptime(end, '%Y-%m-%d') - timedelta(days=no_years*365)).strftime('%Y-%m-%d')
# Generate the date range
date_range = pd.date_range(start, end, freq='D')
print(date_range)
tickers = ['SPY', 'MDY']
prices_d = yf.download(tickers, s
Если задача с типом **decomp**

- нужно создать новую задачу на разработку, где производится описание задачи.
- задачу нужно оценить самому и отдать на оценку QA переведя в статус Requirements Review (RR).
QA уже дальше переведет в ready to develop
### Линковки
- Задачу по декомпозиции линкуем children задача для разработки
- Задачу по разработке линкуем с задачей по декомпозу parent
- Задачу
# 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()._