快速构建数据集-假数据（生成&划分）

爱补鱼的猫猫2025-09-09 18:02

快速构建数据集-假数据

  • 1、torch.randn（✅）
  • [2、HuggingFace Datasets（✅）](#2、HuggingFace Datasets（✅）)
    • [🔹1. 从字典生成](#🔹1. 从字典生成)
    • [🔹2. 从 `pandas.DataFrame` 生成](#🔹2. 从 pandas.DataFrame 生成)
    • [🔹3. 批量生成"业务型"假数据（配合 Faker）](#🔹3. 批量生成“业务型”假数据（配合 Faker）)
    • [🔹4. 随机文本/时间序列假数据](#🔹4. 随机文本/时间序列假数据)
    • [🔹5. 直接生成 `DatasetDict`](#🔹5. 直接生成 DatasetDict)
  • [3、HF Datasets 切分数据集](#3、HF Datasets 切分数据集)
    • [🔹1. 随机切分（最常用）](#🔹1. 随机切分（最常用）)
    • [🔹2. 固定比例切分（多份）](#🔹2. 固定比例切分（多份）)
    • [🔹3. 按索引选择（精确控制）](#🔹3. 按索引选择（精确控制）)
    • [🔹4. 按分片切分（均匀划分）](#🔹4. 按分片切分（均匀划分）)
    • [🔹5. 自定义条件切分](#🔹5. 自定义条件切分)
    • [1️⃣ 使用 `train_test_split` 按比例划分](#1️⃣ 使用 train_test_split 按比例划分)
    • [2️⃣ 手动按索引切分 `select`](#2️⃣ 手动按索引切分 select)
    • [3️⃣ 随机采样子集](#3️⃣ 随机采样子集)
    • [4️⃣ 多重划分（train/val/test）](#4️⃣ 多重划分（train/val/test）)
    • [5️⃣ 使用数据集自带 split](#5️⃣ 使用数据集自带 split)
    • [6️⃣ 高级：使用 `train_test_split` 并指定 stratify（按类别平衡）](#6️⃣ 高级：使用 train_test_split 并指定 stratify（按类别平衡）)
      • [✅ 总结](#✅ 总结)
  • 4、示例（窗口）
  • 5、汇总（生成）
    • [🔹1. 用 **Numpy / Pandas** 随机生成](#🔹1. 用 Numpy / Pandas 随机生成)
    • [🔹2. 用 **Scikit-learn** 自带造数函数](#🔹2. 用 Scikit-learn 自带造数函数)
    • [🔹3. 用 **Faker** 生成"真实感"假数据](#🔹3. 用 Faker 生成“真实感”假数据)
    • [🔹4. 用 **Torch / TensorFlow** 生成张量假数据](#🔹4. 用 Torch / TensorFlow 生成张量假数据)
    • [🔹5. 时间序列/股票类假数据](#🔹5. 时间序列/股票类假数据)
  • 6、汇总（划分）
    • [**1. 使用 Python 原生方法（列表/数组切分）**](#1. 使用 Python 原生方法（列表/数组切分）)
    • [**2. 使用 NumPy 切分**](#2. 使用 NumPy 切分)
    • [**3. 使用 scikit-learn `train_test_split`**](#3. 使用 scikit-learn train_test_split)
    • [**4. 使用 pandas 切分**](#4. 使用 pandas 切分)
    • [**5. 时间序列专用切分**](#5. 时间序列专用切分)
    • [**6. HuggingFace Datasets 快速切分**](#6. HuggingFace Datasets 快速切分)
      • [🔹 总结](#🔹 总结)

推荐：
生成，torch.randn快速生成
切分, HuggingFace Datasets

1、torch.randn（✅）

python 复制代码 
# --- 1. 数据生成和辅助模块 (无变化) ---

def generate_ohlcv_data(num_samples, seq_len, num_features, multi_step):
    """生成伪造的 OHLCV 数据"""
    ohlcv = np.random.randn(num_samples, seq_len, num_features).astype(np.float32)
    y = np.random.randn(num_samples, multi_step, num_features).astype(np.float32)
    return torch.from_numpy(ohlcv), torch.from_numpy(y)
python 复制代码 
import torch
import torch.nn as nn
from mamba_ssm import Mamba
from st_moe_pytorch import MoE, Expert
import numpy as np

# --- 1. 模拟数据生成 ---
def create_dummy_ohlcv_data(num_samples, seq_len, predict_steps):
    """
    生成伪造的 OHLCV 股票数据。
    
    Args:
        num_samples (int): 样本数量。
        seq_len (int): 每个样本的序列长度。
        predict_steps (int): 预测的未来步数。
    
    Returns:
        tuple: (输入数据, 标签数据)
    """
    # 5个特征: 开盘价, 最高价, 最低价, 收盘价, 交易量
    feature_dim = 5
    
    # 输入: (样本数, 序列长度, 特征维度)
    inputs = torch.randn(num_samples, seq_len, feature_dim)
    
    # 标签: (样本数, 预测步数, 预测维度)
    # 我们预测未来 predict_steps 的收盘价
    labels = torch.randn(num_samples, predict_steps, 1)
    
    print(f"生成的假数据输入形状: {inputs.shape}")
    print(f"生成的假数据标签形状: {labels.shape}")
    
    return inputs, labels

2、HuggingFace Datasets（✅）

HuggingFace Datasets，快速生成假数据集的方法

好问题 👍

如果你已经在用 🤗 HuggingFace Datasets ，生成"假数据集"其实非常方便，可以直接从 字典 / DataFrame / 列表 构建。下面我整理几种常见方法：

🔹1. 从字典生成

最简单，直接写个 dict 就行：

python 复制代码 
from datasets import Dataset

data = {
    "text": ["hello world", "foo bar", "lorem ipsum"],
    "label": [0, 1, 0]
}
dataset = Dataset.from_dict(data)

print(dataset)
print(dataset[0])

🔹2. 从 pandas.DataFrame 生成

结合前面提到的 numpy/pandas 假数据：

python 复制代码 
import pandas as pd
import numpy as np
from datasets import Dataset

df = pd.DataFrame({
    "feature1": np.random.randn(100),
    "feature2": np.random.randint(0, 10, 100),
    "label": np.random.choice([0, 1], size=100)
})

dataset = Dataset.from_pandas(df)
print(dataset[0])

🔹3. 批量生成"业务型"假数据（配合 Faker）

python 复制代码 
from datasets import Dataset
from faker import Faker

fake = Faker("en_US")

data = {
    "name": [fake.name() for _ in range(20)],
    "email": [fake.email() for _ in range(20)],
    "date": [fake.date() for _ in range(20)],
    "amount": [fake.random_int(100, 10000) for _ in range(20)]
}

dataset = Dataset.from_dict(data)
print(dataset[0])

🔹4. 随机文本/时间序列假数据

比如快速生成 NLP 数据：

python 复制代码 
from datasets import Dataset
import numpy as np

data = {
    "sentence": [f"sample text {i}" for i in range(50)],
    "label": np.random.randint(0, 2, 50).tolist()
}

dataset = Dataset.from_dict(data)
print(dataset[:5])

比如金融时间序列：

python 复制代码 
import pandas as pd
import numpy as np
from datasets import Dataset

n = 100
df = pd.DataFrame({
    "date": pd.date_range("2025-01-01", periods=n),
    "price": 100 + np.random.randn(n).cumsum(),
    "volume": np.random.randint(100, 1000, n)
})

dataset = Dataset.from_pandas(df)
print(dataset[:3])

🔹5. 直接生成 DatasetDict

方便划分 train/test：

python 复制代码 
from datasets import Dataset, DatasetDict

data = {
    "text": [f"sample {i}" for i in range(100)],
    "label": [i % 2 for i in range(100)]
}

dataset = Dataset.from_dict(data)
dataset = dataset.train_test_split(test_size=0.2)

dataset_dict = DatasetDict({
    "train": dataset["train"],
    "test": dataset["test"]
})

print(dataset_dict)

✅ 总结：

  • Dataset.from_dict → 最快，直接传 Python dict
  • Dataset.from_pandas → 用 pandas/numpy 快速造数据
  • 配合 Faker → 生成"看起来真实"的假数据
  • train_test_split → 一步得到训练集/测试集

要不要我帮你写一个 通用函数 make_fake_hf_dataset(mode="classification"/"nlp"/"finance")，一行就能造 HuggingFace 假数据集？

3、HF Datasets 切分数据集

👌 在 🤗 HuggingFace Datasets 里，切分数据集非常灵活，主要用 .train_test_split() ，也可以用 .select()、.shard() 等。下面给你总结常见方法：

🔹1. 随机切分（最常用）

python 复制代码 
from datasets import Dataset

data = {"text": [f"sample {i}" for i in range(100)], "label": [i % 2 for i in range(100)]}
dataset = Dataset.from_dict(data)

# 80% train, 20% test
split = dataset.train_test_split(test_size=0.2, seed=42)

print(split["train"])
print(split["test"])

🔹2. 固定比例切分（多份）

可以用 train_test_split 递归拆分，得到 train/valid/test：

python 复制代码 
# 先切 train/test
split = dataset.train_test_split(test_size=0.2, seed=42)

# 再从 train 中切出 valid
split2 = split["train"].train_test_split(test_size=0.1, seed=42)

# 合并成 DatasetDict
from datasets import DatasetDict
dataset_dict = DatasetDict({
    "train": split2["train"],
    "valid": split2["test"],
    "test": split["test"]
})

print(dataset_dict)

🔹3. 按索引选择（精确控制）

python 复制代码 
train_dataset = dataset.select(range(0, 80))   # 前 80 个样本
test_dataset  = dataset.select(range(80, 100)) # 后 20 个样本

🔹4. 按分片切分（均匀划分）

python 复制代码 
# 把数据均匀分成 5 份，取第 0 份
part0 = dataset.shard(num_shards=5, index=0)

# 取第 1 份
part1 = dataset.shard(num_shards=5, index=1)

🔹5. 自定义条件切分

比如按 label 分：

python 复制代码 
def is_positive(example):
    return example["label"] == 1

positive = dataset.filter(is_positive)
negative = dataset.filter(lambda x: x["label"] == 0)

✅ 总结

  • 随机划分 → .train_test_split()
  • 固定索引/前后切分 → .select()
  • 均匀分片 → .shard()
  • 条件过滤 → .filter()
  • 组合多份 → DatasetDict

要不要我帮你写一个 通用函数 split_dataset(dataset, train=0.8, valid=0.1, test=0.1) ，自动返回 DatasetDict(train/valid/test)？

在 HuggingFace Datasets 里，切分数据集的方法主要有几种，根据你是想 按比例 、按索引 、还是 使用自带 split 来划分。下面详细说明并举例：

1️⃣ 使用 train_test_split 按比例划分

python 复制代码 
from datasets import load_dataset

# 加载数据集（通常 split='train'）
dataset = load_dataset("imdb", split="train")

# 划分 80% 训练，20% 测试
split_dataset = dataset.train_test_split(test_size=0.2, seed=42)

train_dataset = split_dataset["train"]
test_dataset  = split_dataset["test"]

print(len(train_dataset), len(test_dataset))
  • test_size 可以是整数（样本数）或浮点数（比例）
  • seed 用于固定随机打乱结果

2️⃣ 手动按索引切分 select

python 复制代码 
train_end = 20000
val_end   = 25000

train_dataset = dataset.select(range(0, train_end))
val_dataset   = dataset.select(range(train_end, val_end))
test_dataset  = dataset.select(range(val_end, len(dataset)))
  • 适合固定顺序划分
  • dataset.select(indices) 会返回一个新的 Dataset 子集

3️⃣ 随机采样子集

python 复制代码 
# 打乱数据
shuffled = dataset.shuffle(seed=42)

# 取前 5000 条作为子集
subset = shuffled.select(range(5000))
  • 常用于快速调试或小规模实验

4️⃣ 多重划分（train/val/test）

python 复制代码 
# 先划分训练+测试
train_test = dataset.train_test_split(test_size=0.2, seed=42)

# 再划分测试集为验证集+测试集
valid_test = train_test["test"].train_test_split(test_size=0.5, seed=42)

train_dataset = train_test["train"]
valid_dataset = valid_test["train"]
test_dataset  = valid_test["test"]
  • 常用于需要三份数据集的情况

5️⃣ 使用数据集自带 split

python 复制代码 
dataset = load_dataset("imdb")

train_dataset = dataset["train"]
test_dataset  = dataset["test"]
  • 有些数据集本身就提供了 split，无需再划分

6️⃣ 高级：使用 train_test_split 并指定 stratify（按类别平衡）

python 复制代码 
split_dataset = dataset.train_test_split(test_size=0.2, stratify_by_column="label", seed=42)
  • 可以保证训练集和测试集的标签分布一致

✅ 总结

方法 适用场景
train_test_split 快速按比例随机划分
select 按固定索引自定义划分
shuffle().select() 随机采样子集
数据集自带 split 直接使用官方划分
多次 train_test_split 生成 train/val/test 三份数据
stratify_by_column 保持标签分布一致

如果你需要，我可以帮你写一个 通用函数，只用一个方法就能支持：

  • train/val/test 划分
  • 按比例或固定数量
  • 是否随机打乱
  • 是否保持类别分布

这样直接调用就能得到切好的 HF Dataset。

你希望我写吗？

4、示例（窗口）

时间序列切分，验证和测试集加上前面窗口长度数据

1.示例1：切片

明白了，你想做时间序列切分 ，并且为了训练模型或滚动预测，需要在 验证集和测试集前面补上 window_size 的历史数据，保证模型可以拿到足够的历史信息。下面给你一个标准示例：

python 复制代码 
import pandas as pd

# 假数据
data = pd.DataFrame({
    'date': pd.date_range('2020-01-01', periods=100),
    'value': range(100)
})

window_size = 10  # 历史窗口长度
train_ratio = 0.7
val_ratio = 0.2  # 测试集自动是剩下的 0.1

n = len(data)
train_end = int(n * train_ratio)
val_end = train_end + int(n * val_ratio)

# 切分
train_data = data.iloc[:train_end]

# 验证集前加上 window_size 历史数据
val_data = data.iloc[max(train_end - window_size, 0):val_end]

# 测试集前加上 window_size 历史数据
test_data = data.iloc[max(val_end - window_size, 0):]

print("Train:", train_data.shape)
print("Validation:", val_data.shape)
print("Test:", test_data.shape)
python 复制代码 
import pandas as pd
import numpy as np

# 假数据
n = 100
data = pd.DataFrame({
    "date": pd.date_range("2025-01-01", periods=n),
    "value": np.random.randn(n).cumsum()
})

window_size = 10
train_ratio, valid_ratio, test_ratio = 0.7, 0.2, 0.1

train_end = int(len(data) * train_ratio)
valid_end = train_end + int(len(data) * valid_ratio)

# 切分训练集
train_data = data.iloc[:train_end]

# 验证集，需要加上前面 window_size 个数据
valid_data = data.iloc[train_end - window_size : valid_end]

# 测试集，也需要加上前面 window_size 个数据
test_data = data.iloc[valid_end - window_size :]

print("Train:", train_data.shape)
print("Valid:", valid_data.shape)
print("Test:", test_data.shape)

✅ 特点

  1. 保留时间顺序，不打乱。
  2. 验证集和测试集前加 window_size 历史数据，保证模型有完整的序列输入。
  3. max(..., 0) 防止索引越界。

如果你想，我可以帮你写一个可复用函数 ，直接传入 data, train_ratio, val_ratio, window_size，返回 train/val/test，并且自动处理窗口前置，非常适合滚动预测。

你希望我写这个函数吗？

2.示例2：HuggingFace Datasets

明白了，你想在 HuggingFace Datasets 中做 时间序列切分 ，同时保证 验证集和测试集前加上 window_size 的历史数据。下面是一个完整示例：

python 复制代码 
from datasets import Dataset
import pandas as pd

# 假数据
df = pd.DataFrame({
    'date': pd.date_range('2020-01-01', periods=100),
    'value': range(100)
})

# 转成 HF Dataset
dataset = Dataset.from_pandas(df)

# 参数
window_size = 10
train_ratio = 0.7
val_ratio = 0.2

n = len(dataset)
train_end = int(n * train_ratio)
val_end = train_end + int(n * val_ratio)

# 切分索引
train_dataset = dataset.select(range(train_end))

# 验证集：前加 window_size 历史
val_start = max(train_end - window_size, 0)
val_dataset = dataset.select(range(val_start, val_end))

# 测试集：前加 window_size 历史
test_start = max(val_end - window_size, 0)
test_dataset = dataset.select(range(test_start, n))

print("Train:", len(train_dataset))
print("Validation:", len(val_dataset))
print("Test:", len(test_dataset))

✅ 特点

  1. 保留时间顺序，适合时间序列。
  2. 验证集和测试集前补历史窗口，方便滑动窗口模型输入。
  3. 输出仍然是 HF Dataset 对象 ，可以直接用于 map、set_format 等处理。

如果你需要，我可以帮你写一个通用函数，直接传入：

  • HF Dataset
  • train_ratio、val_ratio
  • window_size

然后返回 train/val/test 并自动处理窗口前置，非常适合批量时间序列切分。

你希望我写吗？

明白了，你想用 HuggingFace Datasets 做 时间序列切分 ，并且 验证集和测试集前面要加上窗口长度的数据，保证滑窗模型输入完整。下面给你一个通用方法。

1️⃣ 思路

假设：

  • dataset 是 HF Dataset
  • window_size 是滑窗长度
  • 切分比例：train_ratio、valid_ratio、test_ratio

做法：

  1. 按比例计算训练集、验证集、测试集的结束索引。
  2. 验证集前加上训练集最后 window_size 行。
  3. 测试集前加上验证集最后 window_size 行。

2️⃣ 代码示例

python 复制代码 
from datasets import Dataset, DatasetDict
import numpy as np
import pandas as pd

# 假数据
n = 100
df = pd.DataFrame({
    "date": pd.date_range("2025-01-01", periods=n),
    "value": np.random.randn(n).cumsum()
})

dataset = Dataset.from_pandas(df)

# 参数
window_size = 10
train_ratio, valid_ratio, test_ratio = 0.7, 0.2, 0.1

# 索引
train_end = int(len(dataset) * train_ratio)
valid_end = train_end + int(len(dataset) * valid_ratio)

# 切分
train_ds = dataset.select(range(0, train_end))
valid_ds = dataset.select(range(train_end - window_size, valid_end))
test_ds  = dataset.select(range(valid_end - window_size, len(dataset)))

# 合并成 DatasetDict
dataset_dict = DatasetDict({
    "train": train_ds,
    "valid": valid_ds,
    "test": test_ds
})

print(dataset_dict)

3️⃣ 滑窗生成 X, y（可选）

如果你要直接生成滑窗输入：

python 复制代码 
def create_windows(dataset, window_size, column="value"):
    values = np.array(dataset[column])
    X, y = [], []
    for i in range(len(values) - window_size):
        X.append(values[i:i+window_size])
        y.append(values[i+window_size])
    return np.array(X), np.array(y)

X_train, y_train = create_windows(dataset_dict["train"], window_size)
X_valid, y_valid = create_windows(dataset_dict["valid"], window_size)
X_test, y_test   = create_windows(dataset_dict["test"], window_size)

print(X_train.shape, X_valid.shape, X_test.shape)

✅ 特点：

  • 验证集和测试集包含前置 window_size 行，保证滑窗完整
  • 适合股票、传感器、气象等时间序列预测任务
  • 保持 HF Dataset 格式，可直接用于 Transformers 或自定义模型

如果你需要，我可以帮你写一个 通用函数 split_timeseries_hf(dataset, window_size, ratios) ，一行返回 train/valid/test HF DatasetDict，并自动处理前置窗口，非常方便。

你希望我帮你写吗？

3.示例3: 没窗口

python 复制代码 
from datasets import Dataset, DatasetDict
import numpy as np
import pandas as pd

# -------------------------
SEED = 42
NUM_DAYS = 900
CONTEXT_LEN = 5
HORIZON = 2
BATCH_SIZE = 32
EPOCHS = 6
LR = 3e-3
D_MODEL = 64
DATE_INPUT_DIM = 3
LOSS_TYPE = "wmse"
REPORT_N = 3
# -------------------------

def make_fake_stock(num_days=900, start_date="2018-01-01"):
    dates = pd.date_range(start=start_date, periods=num_days, freq="D")
    x = np.arange(num_days)
    base = 100.0 + 0.02*x + 5.0*np.sin(2*np.pi*x/30)
    open_ = base + np.random.normal(0,1,num_days)
    close = base + np.random.normal(0,1,num_days)
    high = np.maximum(open_,close) + np.abs(np.random.normal(0,1,num_days))
    low = np.minimum(open_,close) - np.abs(np.random.normal(0,1,num_days))
    volume = np.random.randint(1000,20000,num_days)

    df = pd.DataFrame({
        "date": dates,
        "open": open_,
        "high": high,
        "low": low,
        "close": close,
        "volume": volume
    })
    df["year"] = df["date"].dt.year
    df["month"] = df["date"].dt.month
    df["day"] = df["date"].dt.day
    return df

def prepare_hf_dataset(df, context_len=30, horizon=5):
    records = []
    N = len(df)
    for i in range(N - context_len - horizon + 1):
        ohlcv = df.loc[i:i+context_len-1, ["open","high","low","close","volume"]].values.astype(np.float32)
        date_feats = df.loc[i:i+context_len-1, ["year","month","day"]].values.astype(np.float32)
        labels = df.loc[i+context_len:i+context_len+horizon-1, "close"].values.astype(np.float32)
        records.append({
            "ohlcv": ohlcv,
            "date_feats": date_feats,
            "labels": labels
        })
    
    # 🔑 直接转成 Hugging Face Dataset
    return Dataset.from_list(records)


df=make_fake_stock(num_days=900, start_date="2018-01-01")
print(df.head())

# 1) 构造完整 Dataset
dataset = prepare_hf_dataset(df, CONTEXT_LEN, HORIZON)
print(dataset)

# 2) 切分
N = len(dataset)
train_end = int(N * 0.7)
val_end = int(N * 0.85)

dataset_dict = DatasetDict({
    "train": dataset.select(range(0, train_end)),
    "valid": dataset.select(range(train_end, val_end)),
    "test": dataset.select(range(val_end, N))
})

print(dataset_dict)

print(dataset_dict["train"][0])  # 查看第一个样本

4.示例4:日期划分窗口

python 复制代码 
import pandas as pd
import numpy as np

"""
最终数据格式如下：
date	    tic	  close volume
2020-01-01	AAPL	300	1000
2020-01-01	MSFT	150	2000

2020-01-02	AAPL	305	1100
2020-01-02	MSFT	NaN	NaN

2020-01-03	AAPL	NaN	NaN
2020-01-03	MSFT	152	2100

你的数据是 多股票、多天且时间不连续 的情况，并且希望在 切分交易集时加上训练集最后的窗口长度，保证滑窗完整。下面给你一个 完整可运行示例，包括：

构造不连续时间的假数据（带 NaN）

切分训练集和交易集

对交易集前面加上训练集最后 window_size 天的数据
"""


# =========================
# 1️⃣ 构造不连续时间的假数据
# =========================
dates = ["2020-01-01", "2020-01-03", "2020-01-06", "2020-01-08", "2020-01-10"]
tics = ["AAPL", "MSFT"]

data_list = []
for date in dates:
    for tic in tics:
        close = np.random.randint(100, 500)
        volume = np.random.randint(1000, 5000)
        # 人为加入 NaN
        if np.random.rand() < 0.3:
            close, volume = np.nan, np.nan
        data_list.append([pd.to_datetime(date), tic, close, volume])

processed_full = pd.DataFrame(data_list, columns=["date", "tic", "close", "volume"])
print("示例数据:")
print(processed_full)

# =========================
# 2️⃣ 切分函数（带窗口）
# =========================
def data_split_with_window(df, start, end, window_size=0, target_date_col="date"):
    """
    按日期切分数据集，并可在验证/交易集前加上前面 window_size 日期
    :param df: pandas DataFrame, 必须包含 target_date_col 和 'tic'
    :param start: 起始日期（字符串或 Timestamp）
    :param end: 结束日期（字符串或 Timestamp）
    :param window_size: int, 交易集或验证集前加上训练集最后的 window_size 日期
    :param target_date_col: 时间列名称
    :return: pandas DataFrame
    """
    # 主区间切分
    data = df[(df[target_date_col] >= start) & (df[target_date_col] < end)]
    
    # 如果需要窗口前置，取 start 前的 window_size 日期
    if window_size > 0:
        prev_dates = df[df[target_date_col] < start][target_date_col].drop_duplicates().sort_values().tail(window_size)
        prev_data = df[df[target_date_col].isin(prev_dates)]
        data = pd.concat([prev_data, data], ignore_index=True)
    
    # 按 date 和 tic 排序
    data = data.sort_values([target_date_col, "tic"], ignore_index=True)
    
    # 重新索引
    data.index = data[target_date_col].factorize()[0]
    
    return data

# =========================
# 3️⃣ 定义日期区间和窗口长度
# =========================
TRAIN_START_DATE = '2020-01-01'
TRAIN_END_DATE = '2020-01-08'
TRADE_START_DATE = '2020-01-08'
TRADE_END_DATE = '2020-01-11'
WINDOW_SIZE = 2  # 假设滑窗长度为 2 天

# =========================
# 4️⃣ 切分训练集和交易集
# =========================
train = data_split_with_window(processed_full, TRAIN_START_DATE, TRAIN_END_DATE, window_size=0)
trade = data_split_with_window(processed_full, TRADE_START_DATE, TRADE_END_DATE, window_size=WINDOW_SIZE)

print("\nTrain length:", len(train))
print(train)

print("\nTrade length (with window):", len(trade))
print(trade)

5、汇总（生成）

明白 ✅ 你想要的是 快速生成假数据集 （fake dataset）的方法，用来做 测试 / 调试 / 原型开发。这类数据不需要真实含义，只要结构和格式对。下面给你几类常用的办法：

🔹1. 用 Numpy / Pandas 随机生成

适合表格类任务（分类、回归、时间序列等）：

python 复制代码 
import numpy as np
import pandas as pd

# 随机生成 1000 行数据，含 3 个特征和一个标签
n = 1000
df = pd.DataFrame({
    "feature1": np.random.randn(n),            # 正态分布
    "feature2": np.random.randint(0, 100, n),  # 整数
    "feature3": np.random.rand(n),             # 0-1之间
    "label": np.random.choice([0, 1], n)       # 分类标签
})

print(df.head())

🔹2. 用 Scikit-learn 自带造数函数

特别适合分类、回归、聚类实验。

python 复制代码 
from sklearn.datasets import make_classification, make_regression, make_blobs

# 分类数据
X, y = make_classification(n_samples=1000, n_features=10, n_classes=2, random_state=42)

# 回归数据
X_reg, y_reg = make_regression(n_samples=1000, n_features=5, noise=0.1)

# 聚类数据
X_blobs, y_blobs = make_blobs(n_samples=1000, centers=3, n_features=2)

🔹3. 用 Faker 生成"真实感"假数据

适合生成带人名、地址、日期、公司等业务场景的数据。

python 复制代码 
from faker import Faker
import pandas as pd

fake = Faker("en_US")  # 可改 "zh_CN" 生成中文数据
data = []
for _ in range(10):
    data.append({
        "name": fake.name(),
        "email": fake.email(),
        "address": fake.address(),
        "date": fake.date(),
        "amount": fake.random_int(100, 10000)
    })

df = pd.DataFrame(data)
print(df.head())

🔹4. 用 Torch / TensorFlow 生成张量假数据

适合深度学习测试：

python 复制代码 
import torch

X = torch.randn(1000, 20)          # 1000 个样本，每个20维特征
y = torch.randint(0, 2, (1000,))   # 二分类标签

🔹5. 时间序列/股票类假数据

用 cumsum 模拟股价走势：

python 复制代码 
import numpy as np
import pandas as pd

n = 200
dates = pd.date_range("2023-01-01", periods=n)
prices = 100 + np.random.randn(n).cumsum()  # 模拟股价
volumes = np.random.randint(100, 1000, n)

df = pd.DataFrame({"date": dates, "price": prices, "volume": volumes})
print(df.head())

✅ 总结：

  • 科研/调试 → numpy/pandas
  • 机器学习 → sklearn.datasets
  • 业务数据场景 → Faker
  • 深度学习 → torch.randn
  • 金融/时序 → cumsum

要不要我帮你写一个 通用函数 generate_fake_dataset（参数选择模式：分类/回归/业务/时间序列，直接返回 DataFrame）？

6、汇总（划分）

你想要快速切分数据集，可以根据数据量大小、数据类型（结构化/时间序列/文本/图像）选择不同方法。我整理了几种常用且高效的方法：

1. 使用 Python 原生方法（列表/数组切分）

适合小型数据集或自定义格式的数据。

python 复制代码 
import random

data = list(range(1000))  # 假数据
random.shuffle(data)

train_ratio = 0.8
train_size = int(len(data) * train_ratio)

train_data = data[:train_size]
test_data = data[train_size:]
  • ✅ 简单、快速
  • ⚠️ 不适合复杂切分需求（分层、时间序列）

2. 使用 NumPy 切分

适合数值型大数组：

python 复制代码 
import numpy as np

data = np.arange(1000)
np.random.shuffle(data)

train_ratio = 0.7
train_size = int(len(data) * train_ratio)

train_data = data[:train_size]
test_data = data[train_size:]
  • ✅ 对大数组高效
  • ⚠️ 需要手动保证标签和特征对应

3. 使用 scikit-learn train_test_split

适合监督学习任务，有标签数据，可实现分层切分：

python 复制代码 
from sklearn.model_selection import train_test_split

X = np.random.rand(1000, 10)  # 特征
y = np.random.randint(0, 2, 1000)  # 标签

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
  • ✅ 支持 train/val/test、分层采样
  • ✅ 支持随机种子控制可复现
  • ⚠️ 对时间序列不适合（会打乱顺序）

4. 使用 pandas 切分

适合 DataFrame 结构数据：

python 复制代码 
import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.DataFrame({'x': range(1000), 'y': range(1000)})

train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)
  • ✅ 可直接对 DataFrame 操作
  • ✅ 保留列名和索引
  • ⚠️ 默认打乱顺序，不适合时间序列

5. 时间序列专用切分

如果数据有时间顺序，不要随机打乱：

python 复制代码 
data = pd.DataFrame({'date': pd.date_range('2020-01-01', periods=1000),
                     'value': range(1000)})

train_size = int(len(data) * 0.8)
train_data = data.iloc[:train_size]
test_data = data.iloc[train_size:]
  • ✅ 保证时间顺序
  • ✅ 可扩展到 sliding window 或 rolling split

6. HuggingFace Datasets 快速切分

如果使用 HF Datasets（文本/表格/CSV 数据集）：

python 复制代码 
from datasets import Dataset

dataset = Dataset.from_dict({'text': ['a', 'b', 'c', 'd', 'e'], 'label': [0,1,0,1,0]})
split = dataset.train_test_split(test_size=0.2, seed=42)

train_dataset = split['train']
test_dataset = split['test']
  • ✅ 快速切分并保持 Dataset 对象
  • ✅ 支持随机种子
  • ✅ 可直接切分大规模文本/表格数据

🔹 总结

方法 优势 注意点
原生 Python/NumPy 简单、高效 需手动处理标签
scikit-learn 支持分层、train/val/test 打乱顺序，不适合时间序列
pandas DataFrame 友好 打乱顺序，不适合时间序列
时间序列切分 保留顺序 无随机性
HuggingFace Datasets 高效、可扩展 需要安装 datasets

如果你愿意，我可以帮你写一个统一函数 ，只要传入 DataFrame 或 Dataset，就能根据比例快速切分成 train/val/test，还能选择随机或时间序列切分。

你希望我帮你写吗？

相关推荐
飞翔的佩奇3 天前
【完整源码+数据集+部署教程】骰子点数识别图像实例分割系统源码和数据集：改进yolo11-DCNV2
python·yolo·计算机视觉·数据集·yolo11·骰子点数识别图像实例分割
程序猿小D10 天前
【完整源码+数据集+部署教程】硬币分类与识别系统源码和数据集：改进yolo11-SWC
人工智能·yolo·计算机视觉·数据挖掘·数据集·yolo11·硬币分类与识别系统
程序猿小D12 天前
【完整源码+数据集+部署教程】脑部CT图像分割系统源码和数据集：改进yolo11-CSwinTransformer
python·yolo·计算机视觉·数据集·yolo11·脑部ct图像分割
猫头虎12 天前
什么是AI+？什么是人工智能+？
人工智能·ai·prompt·aigc·数据集·ai编程·mcp
飞翔的佩奇18 天前
【完整源码+数据集+部署教程】遥感森林砍伐检测系统源码和数据集：改进yolo11-SWC
python·yolo·计算机视觉·数据集·yolo11·遥感森林砍伐检测
飞翔的佩奇20 天前
【完整源码+数据集+部署教程】表盘指针检测系统源码和数据集：改进yolo11-CA-HSFPN
python·yolo·计算机视觉·数据集·yolo11·表盘指针检测
飞翔的佩奇20 天前
【完整源码+数据集+部署教程】二维码与查找模式检测系统源码和数据集：改进yolo11-CSwinTransformer
python·yolo·计算机视觉·数据集·yolo11·二维码与查找模式检测
飞翔的佩奇22 天前
【完整源码+数据集+部署教程】食品分类与实例分割系统源码和数据集：改进yolo11-AggregatedAttention
python·yolo·计算机视觉·数据集·yolo11·食品分类与实例分割
程序猿小D24 天前
【完整源码+数据集+部署教程】孔洞检测系统源码和数据集：改进yolo11-RetBlock
yolo·计算机视觉·毕业设计·数据集·yolo11·孔洞检测
热门推荐
01UV安装并设置国内源022025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！032025年数学建模国赛C题超详细解题思路04A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程05不再让Windows更新！&Edge游戏助手卸载及关闭自动更新06KGG转MP3工具|非KGM文件|解密音频07UV 工具安装与国内镜像源配置指南08突破百度网盘的下载限速，两种方法教会你【超详细】09Linux下V2Ray安装配置指南10教你如何认证 Gemini 教育优惠的二次验证，薅个 1年的 Gemini Pro 会员