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

爱补鱼的猫猫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，还能选择随机或时间序列切分。

你希望我帮你写吗？

相关推荐
城南皮卡丘5 天前
苹果果实成熟度检测数据集 4195张+YOLO格式
深度学习·yolo·目标检测·计算机视觉·数据集
微尘hjx5 天前
【数据集 11】面向城市道路的坑洞检测数据集（含8760张，已按比例划分训练、验证、测试集，支持YOLO全系列训练）
人工智能·yolo·目标检测·数据集·道路坑洞·路坑数据集·路坑
数聚天成DeepSData8 天前
两份名录里的同名机构，主键该怎么合并
人工智能·深度学习·机器学习·数据集·deepsdata
Felaim11 天前
【SLAM】SLAM数据集相机规格说明
数据集·vslam·slam·相机标定
数聚天成DeepSData12 天前
第三方地图工具导出的 Landsat 影像，使用条件和 USGS 官方下载的一样吗
人工智能·深度学习·机器学习·数据集·deepsdata
数聚天成DeepSData13 天前
验收一批标注数据时，一致性到底在比谁和谁
人工智能·深度学习·机器学习·数据集·deepsdata
数聚天成DeepSData14 天前
两批标注数据合并前要核对什么
人工智能·深度学习·机器学习·数据集·deepsdata
数聚天成DeepSData14 天前
外部标注需求里该写清哪几项，样例包才验收得动
人工智能·深度学习·机器学习·数据集·deepsdata
数聚天成DeepSData14 天前
Landsat 影像去哪里下载：选景、批量与脚本检索怎么选
人工智能·深度学习·机器学习·数据集·deepsdata
数聚天成DeepSData22 天前
夜间灯光可以代表经济活动吗？先处理年际一致性
人工智能·深度学习·机器学习·数据集·deepsdata
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03历年考研数学一、数学二、数学三真题试卷及答案PDF04几个好用的ip纯净度检测网站05GitHub 镜像站点06苹果iPA游戏软件资源下载网站07蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接08昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战09微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新10Dify：一站式AI应用开发平台全解析与Windows部署指南