shancx 1.8.92__py3-none-any.whl → 1.9.33.218__py3-none-any.whl

shancx/Calmetrics/__init__.py

@@ -0,0 +1,97 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+import os 
+# constants
+__author__ = 'shancx'
+ 
+__author_email__ = 'shanhe12@163.com'
+# @Time : 2025/08/19 下午11:31
+# @Author : shanchangxi
+# @File : Calmetrics.py 
+from sklearn.metrics import mean_squared_error, r2_score
+from scipy.stats import pearsonr
+import numpy as np
+def calculate_metrics(y_true, y_pred):
+    # Calculate metrics
+    correlation, _ = pearsonr(y_true, y_pred)
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+    mask = y_true != 0
+    y_true = y_true[mask]
+    y_pred = y_pred[mask]
+    mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
+    r2 = r2_score(y_true, y_pred)
+    rmse = f"{rmse:0.4f}"
+    correlation = f"{correlation:0.4f}"
+    mape = f"{mape:0.4f}"
+    r2 = f"{r2:0.4f}"
+    return rmse,correlation,mape,r2
+import numpy as np
+class Metrics:
+    def __init__(self, true_values, forecast_values):
+        """
+        初始化Metrics类，传入真值和预测值
+        :param true_values: 实际观测值，二值化数据
+        :param forecast_values: 预测结果，二值化数据
+        """
+        self.true_values = true_values
+        self.forecast_values = forecast_values
+
+    def cal_confusion_matrix(self):
+        """
+        计算混淆矩阵的四个要素: TP, TN, FP, FN
+        :return: 返回TP, TN, FP, FN
+        """
+        TP = np.sum((self.true_values == 1) & (self.forecast_values == 1))  # True Positive
+        TN = np.sum((self.true_values == 0) & (self.forecast_values == 0))  # True Negative
+        FP = np.sum((self.true_values == 0) & (self.forecast_values == 1))  # False Positive
+        FN = np.sum((self.true_values == 1) & (self.forecast_values == 0))  # False Negative
+        
+        return TP, TN, FP, FN
+
+    def cal_ts(self):
+        """
+        计算TS评分
+        :return: TS评分
+        """
+        TP, TN, FP, FN = self.cal_confusion_matrix()
+        ts_score = TP / (TP + FP + FN) if (TP + FP + FN) > 0 else np.nan
+        return ts_score
+
+    def cal_acc(self):
+        """
+        计算准确率
+        :return: 准确率
+        """
+        TP, TN, FP, FN = self.cal_confusion_matrix()
+        accuracy = (TP + TN) / (TP + TN + FP + FN) if (TP + TN + FP + FN) > 0 else np.nan
+        return accuracy
+
+    def cal_pod(self):  
+        """  
+        计算命中率(Probability of Detection, POD)
+        :return: 命中率(POD)
+        """  
+        TP, TN, FP, FN = self.cal_confusion_matrix()  
+        pod = TP / (TP + FN) if (TP + FN) > 0 else np.nan  
+        return pod
+
+
+    def cal_fnr(self):
+            """
+            计算漏报率（False Negative Rate, FNR）
+            :return: 漏报率（FNR）
+            """
+            TP, TN, FP, FN = self.cal_confusion_matrix()
+            fnr = FN / (TP + FN) if (TP + FN) > 0 else np.nan
+            return fnr
+
+    def cal_far(self):
+        """
+        计算空报率（False Alarm Rate, FAR）
+        :return: 空报率（FAR）
+        """
+        TP, TN, FP, FN = self.cal_confusion_matrix()
+        far = FP / (TP + FP) if (TP + FP) > 0 else np.nan
+        return far
+
+        

shancx/Calmetrics/calmetrics.py

@@ -0,0 +1,14 @@
+import numpy as np
+from . import Metrics
+def cal_metrics(obs_v,pre_v):
+    metrics = Metrics(obs_v.ravel(), pre_v.ravel())
+    ts_score = np.around(metrics.cal_ts(),4)
+    accuracy = np.around(metrics.cal_acc(),4)
+    pod = np.around(metrics.cal_pod(),4)
+    fnr = np.around(metrics.cal_fnr(),4)
+    far = np.around(metrics.cal_far(),4)
+    return ts_score,accuracy,pod,fnr,far
+
+"""
+ts_score, accuracy, pod, fnr, far = cal_metrics(obs_v,pre_v)  两个是维度一致的二维数组
+"""

shancx/Calmetrics/calmetricsmatrixLib.py

@@ -0,0 +1,147 @@
+# coding=utf-8
+
+from sklearn.metrics import confusion_matrix
+import numpy as np
+import copy
+def prep_clf(obs, pre, thresholdR=None, thresholdF=None):
+    if thresholdR is not None and thresholdF is not None:
+        obs = np.where(obs >= thresholdR, 1, 0)
+        pre = np.where(pre >= thresholdF, 1, 0)
+    # True positive (TP)
+    hits = np.sum((obs == 1) & (pre == 1))
+    # False negative (FN)
+    misses = np.sum((obs == 1) & (pre == 0))
+    # False positive (FP)
+    falsealarms = np.sum((obs == 0) & (pre == 1))
+    # True negative (TN)
+    correctnegatives = np.sum((obs == 0) & (pre == 0))
+    return hits, misses, falsealarms, correctnegatives
+def precision(obs, pre, thresholdR=None, thresholdF=None):
+    TP, FN, FP, TN = prep_clf(obs=obs, pre = pre, thresholdR=thresholdR, thresholdF=thresholdF)
+    return TP / (TP + FP+10e-5)
+def recall(obs, pre, thresholdR=None, thresholdF=None):
+    TP, FN, FP, TN = prep_clf(obs=obs, pre = pre, thresholdR=thresholdR, thresholdF=thresholdF)
+    return TP / (TP + FN+10e-5)
+def ACC(obs, pre, thresholdR=None, thresholdF=None):
+    TP, FN, FP, TN = prep_clf(obs=obs, pre = pre, thresholdR=thresholdR, thresholdF=thresholdF)
+    return (TP + TN) / (TP + TN + FP + FN)
+def F1(obs, pre, thresholdR=None, thresholdF=None):   
+    precision_socre = precision(obs, pre, thresholdR=thresholdR, thresholdF=thresholdF)
+    recall_score = recall(obs, pre, thresholdR=thresholdR, thresholdF=thresholdF)
+    return 2 * ((precision_socre * recall_score) / (precision_socre + recall_score+10e-5))
+def TS(obs, pre, thresholdR=None, thresholdF=None):
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre, thresholdR=thresholdR, thresholdF=thresholdF)
+    return hits/(hits + falsealarms + misses+10e-5)
+def ETS(obs, pre, thresholdR=None, thresholdF=None): 
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre,
+                                                           thresholdR=thresholdR, thresholdF=thresholdF)
+    num = (hits + falsealarms) * (hits + misses)
+    den = hits + misses + falsealarms + correctnegatives
+    Dr = num / den
+    ETS = (hits - Dr) / (hits + misses + falsealarms - Dr)
+    return ETS
+def FAR(obs, pre, thresholdR=None, thresholdF=None):   
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre,
+                                                           thresholdR=thresholdR, thresholdF=thresholdF)
+    return falsealarms / (hits + falsealarms+10e-5)
+def PO(obs, pre, thresholdR=None, thresholdF=None):  
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre,
+                                                           thresholdR=thresholdR, thresholdF=thresholdF)
+    return misses / (hits + misses+10e-5)
+def POD(obs, pre, thresholdR=None, thresholdF=None):
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre,
+                                                           thresholdR=thresholdR, thresholdF=thresholdF)
+    return hits / (hits + misses)
+def BIAS(obs, pre, thresholdR = 0.1, thresholdF=None):
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre,
+                                                           thresholdR=thresholdR, thresholdF=thresholdF)
+    return (hits + falsealarms) / (hits + misses)
+def HSS(obs, pre, thresholdR=None, thresholdF=None):   
+    hits, misses, falsealarms, correctnegatives = prep_clf(obs=obs, pre = pre,
+                                                           thresholdR=thresholdR, thresholdF=thresholdF)
+    HSS_num = 2 * (hits * correctnegatives - misses * falsealarms)
+    HSS_den = (misses**2 + falsealarms**2 + 2*hits*correctnegatives +
+               (misses + falsealarms)*(hits + correctnegatives))
+    return HSS_num / HSS_den
+def BSS(obs, pre, threshold=None): 
+    if threshold is not None:  
+        obs = np.where(obs >= threshold, 1, 0)
+        pre = np.where(pre >= threshold, 1, 0)
+    obs = obs.flatten()
+    pre = pre.flatten()
+    return np.sqrt(np.mean((obs - pre) ** 2))
+def MAE(obs, pre):
+    obs = obs.flatten()
+    pre = pre.flatten()
+    return np.mean(np.abs(pre - obs))
+def RMSE(obs, pre):
+    obs = obs.flatten()
+    pre = pre.flatten()
+    return np.sqrt(np.mean((obs - pre) ** 2))
+def sun_rain_Matrix(o, f, threshold=None):
+    if threshold is not None:  
+        o = np.where(o >= 0.1, 1, 0)
+        f = np.where(f >= threshold, 1, 0)
+    c_matrix = confusion_matrix(o, f, labels=[0, 1])
+    return c_matrix
+def CY_classify(pre0):
+    # < 0.031 < 0.0606    无雨／雪
+    # 0.031~0.25 0.0606~0.8989   小雨／雪
+    # 0.25~0.35  0.8989~2.8700   中雨／雪
+    # 0.35~0.48  2.8700~12.8638  大雨／雪
+    # >= 0.48 >= 12.8638  暴雨／雪
+    pre = copy.deepcopy(pre0)
+    pre[pre0 < 0.031] = 0
+    pre[(pre0 >= 0.031)&(pre0 < 0.25)] = 1
+    pre[(pre0 >= 0.25)&(pre0 < 0.35)] = 2
+    pre[(pre0 >= 0.35)&(pre0 < 0.48)] = 3
+    pre[(pre0 >= 0.48)&(pre0 < 9990)] = 4
+    pre[pre0 > 9990] = -1
+    pre[np.isnan(pre0)] = -1
+    return pre
+def pre1h_Matrix(obs, fore,mode):
+    try:
+        if len(obs) == 0:
+            return np.zeros([5,5])
+        else:
+            o = classify1h(obs)
+            if mode=="WTX":
+                f = classify1h(fore)
+                c_matrix = confusion_matrix(o, f, labels=[0, 1,2,3,4])
+                return c_matrix
+            else:
+                f = CY_classify(fore)
+                c_matrix = confusion_matrix(o, f, labels=[0, 1, 2, 3, 4])
+                return c_matrix
+    except Exception as e:
+        print(e)    
+def classify1h(pre0):
+    pre = copy.deepcopy(pre0)
+    pre[pre0 < 0.1] = 0
+    pre[np.logical_and(pre0 >= 0.1, pre0 <= 2.5)] = 1
+    pre[np.logical_and(pre0 > 2.5, pre0 <= 8)] = 2
+    pre[np.logical_and(pre0 > 8, pre0 <= 16)] = 3
+    pre[np.logical_and(pre0 > 16, pre0 <= 9990)] = 4
+    pre[pre0 > 9990] = -1
+    pre[np.isnan(pre0)] = -1
+    return pre
+
+def calsmhsTS(mat):
+    tsList = []
+    for i in range(1, 5):
+        ts = mat[i, i] / (np.sum(mat[:i, i]) + np.sum(mat[i, :i + 1]))
+        tsList.append(np.round(ts, 3))
+    print(f"小雨:{tsList[0]},中雨:{tsList[1]},大雨:{tsList[2]},暴雨:{tsList[3]}")
+    return {"小雨":tsList[0],"中雨":tsList[1],"大雨":tsList[2],"暴雨":tsList[3]}
+
+"""
+cm1_C = sun_rain_Matrix(df["PRE1_r"].values, df["PRE1_c"].values)
+F1h =TS( df[f"PRE{i}_r"],df[f"PRE{i}_c"],thresholdF=thresholdF)
+F1hm =TS(df[f"PRE{i}_r"],df[f"PRE{i}_w"])
+TSV[i]=[np.round(F1h,3),np.round(F1hm,3)]
+"""
+
+"""
+cm1_C_pre1h = pre1h_Matrix(df["PRE1_r"].values, df["PRE1_c"].values,"CY")  
+calsmhsTS(cm1_C_pre1h)
+"""

shancx/Calmetrics/rmseR2score.py

@@ -0,0 +1,35 @@
+from sklearn.metrics import mean_squared_error, r2_score
+from scipy.stats import pearsonr
+import numpy as np
+def calculate_metrics(y_true, y_pred):
+    # Calculate metrics
+    correlation, _ = pearsonr(y_true, y_pred)
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+    mask = y_true != 0
+    y_true = y_true[mask]
+    y_pred = y_pred[mask]
+    mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
+    r2 = r2_score(y_true, y_pred)
+    rmse = f"{rmse:0.4f}"
+    correlation = f"{correlation:0.4f}"
+    mape = f"{mape:0.4f}"
+    r2 = f"{r2:0.4f}"
+    return rmse,correlation,mape,r2
+"""
+calculate_metrics(data.flatten(),datanpy.flatten())
+"""    
+"""
+dt_res[f'{flag}'] = dt_res[f'{flag}'].astype(float)
+dt_res[f'{flag}_p'] = dt_res[f'{flag}_p'].astype(float)
+dt_ = dt_res[(dt_res[f'{flag}'] != 0) & (dt_res[f'{flag}_p'] != 0)]
+dt_ = dt_res[(dt_res[f'{flag}'] < 900000.0) & (dt_res[f'{flag}_p'] < 900000.0)]      
+dt_.replace([np.inf, -np.inf], np.nan, inplace=True)
+dt_.dropna(inplace=True)
+correlation, rmse, mape, r2 = calculate_metrics(dt_[f"{flag}"], dt_[f"{flag}_p"])
+
+
+y_true = arry1.flatten()
+y_pred = arry2.flatten()
+correlation, rmse, mape, r2  =  calculate_metrics(y_true, y_pred)
+"""
+    

shancx/Clip/__init__.py

@@ -0,0 +1,50 @@
+
+
+import numpy as np
+class Bounds:
+    def __init__(self, north, south, west, east):
+        self.n = north  # 北边界
+        self.s = south  # 南边界
+        self.w = west   # 西边界
+        self.e = east   # 东边界
+
+    def __str__(self):
+        return f"n:{self.n}, s:{self.s}, w:{self.w}, e:{self.e}"
+
+def calc_idx(start_val, bound_val, step, data_len):
+    idx = int(np.round(abs(start_val - bound_val) / step + 0.5, 3))
+    return max(0, min(idx, data_len - 1))
+
+def clip(data, bound_start, bound_end, step, pad=False):
+    idx_start = calc_idx(data[0], bound_start, step, len(data))
+    idx_end = calc_idx(data[0], bound_end, step, len(data))
+    if idx_start > idx_end:
+        idx_start, idx_end = idx_end, idx_start
+    if pad:
+        if data[idx_start] < bound_start and idx_start > 0:
+            idx_start -= 1
+        if data[idx_end] > bound_end and idx_end < (len(data) - 1):
+            idx_end += 1
+    return data[idx_start:idx_end + 1]
+
+def clip_lat(bounds, step, pad=False):
+    # 使用 np.linspace 生成纬度数组
+    lat = np.linspace(90, -90, int(180 / step) + 1)  # 从 90 到 -90，步长为 step
+    return clip(lat, bounds.n, bounds.s, step, pad)
+
+def clip_lon(bounds, step, pad=False):
+    # 使用 np.linspace 生成经度数组
+    lon = np.linspace(-180, 180, int(360 / step) + 1)  # 从 -180 到 180，步长为 step
+    return clip(lon, bounds.w, bounds.e, step, pad)
+ 
+"""
+if __name__ == "__main__":
+    from shancx.Clip import Bounds,clip_lat,clip_lon
+    bounds = Bounds(65, -65, 40, 170)
+    lat_clipped = clip_lat(bounds, 0.04)
+    print(f"Clipped Latitude Data Length: {len(lat_clipped)}")
+    lon_clipped = clip_lon(bounds, 0.04)
+    print(f"Clipped Longitude Data Length: {len(lon_clipped)}")
+"""
+
+ 

shancx/Cmd.py

@@ -0,0 +1,126 @@
+
+
+import subprocess
+import logging
+from shancx.NN import setlogger
+logger = setlogger(level=logging.INFO)
+def runcommand(cmd, timeout=300):
+    try:
+        result = subprocess.run(
+                                cmd
+                                ,shell=True
+                                ,timeout=timeout
+                                ,check=True
+                                ,capture_output=True
+                                ,text=True
+                                )        
+        for output, label in [(result.stdout, "output"), (result.stderr, "error output")]:
+            if output:
+                logger.info(f"Command {label}:\n{output}")                
+        logger.info("Command succeeded!")
+        return True        
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout after {timeout} seconds!")
+        return False
+    except subprocess.CalledProcessError as e:
+        error_msg = e.stderr.strip() if e.stderr else "Unknown error"
+        logger.error(f"Command failed! Code: {e.returncode}, Error: {error_msg}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        return False
+        
+"""
+allDf.dtypes
+
+vim ~/.bash_history
+git checkout main  -- /home/scx/mqpf_pmsc/backup/of_ref_pre.py
+du -sh * | sort -h
+rsync -avid scx@10.1.98.7:/home/scx/test/project   ./
+rsync -avid scx@10.1.98.7:/home/scx/ESRGAN-PyTorch-main /home/scx/test/   整个文件夹以及文件夹下
+find . -type f -name "project1.log*" -exec rm -f {} \;
+find . -type f -name "project*.log*" -exec rm -f {} \;
+sudo nvidia-smi -i 2 -pm 0
+ssh scx@10.1.98.7     cmd 链接
+   
+grep users /etc/group
+sudo groupdel scx
+sudo useradd -u 1015 -g 1015 scx
+id scx
+
+
+more /etc/passwd  
+
+sudo usermod -g users scx
+sudo groupdel users1
+sudo groupadd -g 1015 scx
+sudo usermod -g 1015 scx
+id scx
+grep scx /etc/group
+sudo chown -R scx:scx /mnt/wtx_weather_forecast/scx/mqpf_0722_wtyN/
+ssh-keygen -t rsa -b 4096 -C "shanhe12@163.com"  
+cat id_rsa111.pub   >>  /home/scx/.ssh/authorized_keys   centos 链接ssh秘钥链接问题用升级为ubuntu22.04
+df  -h
+data_r_com = np.max([data_r_700, data_r_850], axis=0)
+traceback.format_exc()
+np.unique(pre, return_counts=True)
+data = instantiate_from_config(config.data) 类动态传参
+id scx
+sudo usermod -u 1015 scx
+sudo groupmod -g 1015 scx
+systemctl | grep scx
+sudo loginctl terminate-user scx
+sudo pkill -9 -u scx
+.gitignore
+pip.conf
+w
+python main.py -h
+export  CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+print("CUDA_VISIBLE_DEVICES:", os.environ.get("CUDA_VISIBLE_DEVICES"))
+cuda:0  export CUDA_VISIBLE_DEVICES=7,1,2,3,4,5,6,0  
+tmux kill-session -t 1
+passwd
+pgrep -u scx | wc -l
+sudo chmod -R u+w /mnt/wtx_weather_forecast/scx/sever7/exam/.git/objects   ls -l  
+rsync -avid scx@10.1.98.5: 
+echo 'alias pgrep="pgrep -u $(whoami) | wc -l"' >> ~/.bashrc   source ~/.bashrc
+netstat -antp
+netstat -antp | grep 140.90.101.79:443 | wc -l
+ps aux|grep scx
+ssh-keygen -t rsa -b 4096
+export PATH="/home/scx1/miniconda3/bin:$PATH"
+for i in reversed(range(n_steps)):
+Every letter and function needs to be understood, and the best way is easy to learn
+nano /home/scx1/miniconda3/envs/mqpf/bin/pip   
+/home/scx1/miniconda3/lib/python3.12/site-packages/matplotlib/mpl-data/fonts/ttf/  copy  simhei.ttf  rm -rf .cache .cache/matplot/*
+chmod -R u+w ./sever7/mqpf_pmsc/.git/objects/  cannot create regular file './sever7/mqpf_pmsc/.git/objects/: Permission denied
+vim 10w 2b ?scx
+pip install git+
+git config --global user.email "shanhe12@163.com"
+git config --global user.name "shancx"
+df.loc['Average'] = averages
+df.at['Average', 'time1'] = 'Average'
+conda init bash && source ~/.bashrc    init bash
+export CUDA_HOME=$CONDA_PREFIX
+export PATH=$CUDA_HOME/bin:$PATH   .bash or  conda init bash && source ~/.bashrc   
+unset LD_LIBRARY_PATH
+export LD_LIBRARY_PATH=""
+hostname -I
+locate libcublasLt.so.11  Could not load library libcublasLt.so.11. Error: libcublasLt.so.11: cannot open shared object file: No such file or directory  libcublasLt 是 cuBLAS 库的一个扩展  cudatoolkit 安装
+nano /home/scx1/miniconda3/envs/mqpf/bin/nvitop
+DS_BUILD_FUSED_LAMB=1 pip install deepspeed
+DS_BUILD_OPS=1 pip install deepspeed
+xception has occurred: SystemExit (note: full exception trace is shown but execution is paused at: _run_module_as_main)
+CST.strftime("%Y%m%d%H%M")
+TypeError: 'module' object is not callable   
+MAILTO="shanhe12@163.com"
+os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3,4,5,6,7"
+python setup.py sdist bdist_wheel
+twine upload dist/*
+pip install setuptools twine
+wmic bios get serialnumber
+wmic diskdrive get serialnumber
+"""
+"""
+sudo chmod a+w /mnt/wtx_weather_forecast/scx/MSG/MSG_Data/2025/20250612/    多人文件夹权限
+"""

shancx/Config_.py

@@ -0,0 +1,26 @@
+import pygrib
+import numpy as np
+import pandas as pd
+import yaml
+def _load_config(config_path: str) :
+    """加载YAML配置文件"""
+    print(f"load config file Get configuration parameters: {config_path}")
+    with open(config_path, 'r') as f:
+        config = yaml.safe_load(f)
+    return config
+
+import configparser
+import traceback
+def parse_config(path,section,option):
+    cp = configparser.ConfigParser()
+    try:
+        cp.read(path)
+        res = cp.get(section,option)
+    except Exception as e:
+        print(traceback.format_exc())
+        exit()
+    return res
+"""
+Path = "./application.conf"
+radar_path = parse_config(Path, "JY", "radar_path")  #JY是选择部分,radar_path配置路径
+"""

shancx/Df/DataFrame.py

@@ -3,7 +3,16 @@ def getmask(df,col = 'PRE1_r'):
     df[col] = df[col].mask(df[col] >= 9999, np.nan)     
     df = df.dropna()
     return df
-
 def Type(df_,col = 'stationID'):
     df_['stationID'] = df_['stationID'].astype("str")
-    return df_
+    return df_
+def Startswith(df,column_name,value):
+    df = df[df[f'{column_name}'].astype(str).str.startswith(f"{value}")].reset_index()
+    return df
+def Startswith1(df,column_name,value):
+    df = df[~df[f'{column_name}'].astype(str).str.startswith(f"{value}")].reset_index()
+    return df
+def Drop_duplicates(realDF,col):
+    realDF = realDF.drop_duplicates(subset=f"{col}").reset_index()
+    return realDF
+ 

shancx/Df/__init__.py

@@ -14,4 +14,21 @@ def getmask(df,col = 'PRE1_r'):
 def Type(df_,col = 'stationID'):
     df_['stationID'] = df_['stationID'].astype("str")
     return df_
+def Dtype(df_):
+    dftypes = df_.dtypes
+    print(dftypes)
+    return dftypes
 
+# 如果env_rang的定义是 (北界, 南界, 西界, 东界)
+def getrange(df,env_rang=None):
+    north, south, west, east = env_rang
+    filtered_data = df[
+        (df["Lat"] < north) & 
+        (df["Lat"] > south) & 
+        (df["Lon"] > west) & 
+        (df["Lon"] < east)
+    ]
+    return filtered_data
+
+#pd.concat(filter(None, results))
+#valid_results = [df for df in results if isinstance(df, pd.DataFrame) and not df.empty]

shancx/Diffm/Psamples.py

@@ -0,0 +1,18 @@
+import torch
+def p_sample_loop(model,shape,n_steps,betas,one_minus_alphas_bar_sqrt):
+    cur_x = torch.randn(shape)
+    x_seq = [cur_x]
+    for i in reversed(range(n_steps)):
+        cur_x = p_sample(model,cur_x,i,betas,one_minus_alphas_bar_sqrt)
+        x_seq.append(cur_x)
+    return x_seq
+
+def p_sample(model,x,t,betas,one_minus_alphas_bar_sqrt):
+    t = torch.tensor([t])    
+    coeff = betas[t] / one_minus_alphas_bar_sqrt[t]    
+    eps_theta = model(x,t)    
+    mean = (1/(1-betas[t]).sqrt())*(x-(coeff*eps_theta))    
+    z = torch.randn_like(x)
+    sigma_t = betas[t].sqrt()    
+    sample = mean + sigma_t * z    
+    return (sample)