NumPy中的随机洗牌和随机状态：深入理解和实践

NumPy中的随机洗牌和随机状态：深入理解和实践

参考：numpy shuffle random state

NumPy是Python中用于科学计算的核心库之一，它提供了强大的多维数组对象和用于处理这些数组的工具。在处理数据时，随机性常常扮演着重要角色，无论是在数据预处理、模型训练还是模拟实验中。本文将深入探讨NumPy中的随机洗牌（shuffle）功能和随机状态（random state）的概念，帮助读者全面理解这些功能的使用方法和重要性。

1. NumPy中的随机洗牌（Shuffle）

随机洗牌是一种将数组元素随机重新排列的操作。在NumPy中，我们可以使用numpy.random.shuffle()函数来实现这一功能。这个函数会直接修改输入数组，而不是返回一个新的数组。

1.1 基本用法

让我们从一个简单的例子开始：

import numpy as np

# 创建一个包含网站名称的数组
websites = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])

# 打乱数组
np.random.shuffle(websites)

print(websites)

Output:

在这个例子中，我们创建了一个包含四个网站名称的数组，其中包括”numpyarray.com”。然后我们使用np.random.shuffle()函数来随机打乱这个数组。每次运行这段代码，你都可能得到不同的排列顺序。

1.2 多维数组的洗牌

numpy.random.shuffle()函数也可以用于多维数组，但它只会沿着第一个轴（axis=0）进行洗牌。这意味着对于二维数组，它会打乱行的顺序，但每行内部的元素顺序保持不变。

import numpy as np

# 创建一个2D数组
data = np.array([
    ['numpyarray.com', 1, 2],
    ['numpy.org', 3, 4],
    ['scipy.org', 5, 6],
    ['pandas.pydata.org', 7, 8]
])

# 打乱数组
np.random.shuffle(data)

print(data)

Output:

在这个例子中，我们创建了一个2D数组，每行包含一个网站名称和两个数字。使用np.random.shuffle()后，行的顺序会被随机打乱，但每行内部的元素顺序保持不变。

1.3 自定义洗牌

有时候，我们可能需要更灵活的洗牌方式。例如，我们可能想要沿着不同的轴进行洗牌，或者只洗牌部分元素。在这种情况下，我们可以结合使用numpy.random.permutation()和数组索引来实现自定义的洗牌。

import numpy as np

# 创建一个2D数组
data = np.array([
    ['numpyarray.com', 1, 2, 3],
    ['numpy.org', 4, 5, 6],
    ['scipy.org', 7, 8, 9],
    ['pandas.pydata.org', 10, 11, 12]
])

# 只打乱数字列
columns_to_shuffle = [1, 2, 3]
data[:, columns_to_shuffle] = data[:, np.random.permutation(columns_to_shuffle)]

print(data)

Output:

在这个例子中，我们创建了一个2D数组，第一列是网站名称，后面三列是数字。我们只想打乱数字列，保持网站名称列不变。我们使用np.random.permutation()生成列索引的随机排列，然后用这个排列来重新排列选定的列。

2. 随机状态（Random State）

随机状态是生成伪随机数的起点。在NumPy中，我们可以通过设置随机种子（seed）来控制随机状态，从而使随机操作可重复。这在科学计算和机器学习中特别重要，因为它允许我们重现实验结果。

2.1 设置全局随机种子

最简单的方法是使用numpy.random.seed()函数来设置全局随机种子：

import numpy as np

# 设置全局随机种子
np.random.seed(42)

# 创建一个数组并打乱
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
np.random.shuffle(data)

print(data)

# 重置随机种子
np.random.seed(42)

# 再次创建相同的数组并打乱
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
np.random.shuffle(data)

print(data)

Output:

在这个例子中，我们两次设置相同的随机种子（42），然后执行相同的随机操作。你会发现两次打乱的结果是完全相同的。这就是随机种子的作用：它确保了随机操作的可重复性。

2.2 使用RandomState对象

虽然设置全局随机种子很方便，但它可能会影响程序中的其他随机操作。为了更好地控制随机性，我们可以使用numpy.random.RandomState对象：

import numpy as np

# 创建RandomState对象
rng = np.random.RandomState(42)

# 使用RandomState对象进行随机操作
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
rng.shuffle(data)

print(data)

# 创建新的RandomState对象
rng2 = np.random.RandomState(42)

# 使用新的RandomState对象进行相同的随机操作
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
rng2.shuffle(data)

print(data)

Output:

在这个例子中，我们创建了两个RandomState对象，它们使用相同的种子。这两个对象会产生相同的随机序列，但它们不会影响全局的随机状态。

2.3 使用default_rng()

从NumPy 1.17开始，推荐使用numpy.random.default_rng()来创建随机数生成器。这个新的API提供了更好的统计属性和性能：

import numpy as np

# 创建默认的随机数生成器
rng = np.random.default_rng(42)

# 使用生成器进行随机操作
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
rng.shuffle(data)

print(data)

# 创建新的随机数生成器
rng2 = np.random.default_rng(42)

# 使用新的生成器进行相同的随机操作
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
rng2.shuffle(data)

print(data)

Output:

这个例子与前面使用RandomState的例子类似，但使用了新的default_rng()API。这个API提供了更现代和更可靠的随机数生成方法。

3. 随机洗牌的应用场景

随机洗牌在数据科学和机器学习中有许多重要的应用。以下是一些常见的场景：

3.1 数据集分割

在机器学习中，我们经常需要将数据集分割为训练集和测试集。随机洗牌可以确保这种分割是无偏的：

import numpy as np

# 创建一个示例数据集
X = np.array([
    ['numpyarray.com', 1, 2],
    ['numpy.org', 3, 4],
    ['scipy.org', 5, 6],
    ['pandas.pydata.org', 7, 8],
    ['matplotlib.org', 9, 10]
])

# 设置随机种子
np.random.seed(42)

# 随机打乱数据集
np.random.shuffle(X)

# 分割数据集
split_index = int(0.8 * len(X))
train_data = X[:split_index]
test_data = X[split_index:]

print("训练集:")
print(train_data)
print("\n测试集:")
print(test_data)

Output:

在这个例子中，我们创建了一个包含网站名称和数字的数据集。我们首先打乱整个数据集，然后将其分割为训练集（80%）和测试集（20%）。这种方法确保了数据在两个集合中的分布是随机的，有助于防止采样偏差。

3.2 交叉验证

交叉验证是一种评估机器学习模型性能的技术，它涉及多次随机分割数据集。以下是一个简化的K折交叉验证示例：

import numpy as np

# 创建一个示例数据集
X = np.array([
    ['numpyarray.com', 1],
    ['numpy.org', 2],
    ['scipy.org', 3],
    ['pandas.pydata.org', 4],
    ['matplotlib.org', 5],
    ['scikit-learn.org', 6],
    ['pytorch.org', 7],
    ['tensorflow.org', 8],
    ['keras.io', 9],
    ['jupyter.org', 10]
])

# 设置随机种子
np.random.seed(42)

# 随机打乱数据集
np.random.shuffle(X)

# 定义折数
k = 5

# 执行K折交叉验证
for i in range(k):
    start = i * len(X) // k
    end = (i + 1) * len(X) // k
    test_fold = X[start:end]
    train_fold = np.concatenate([X[:start], X[end:]])

    print(f"Fold {i+1}:")
    print("Test data:", test_fold)
    print("Train data:", train_fold)
    print()

Output:

在这个例子中，我们首先随机打乱数据集，然后将其分成5个相等的部分。在每次迭代中，我们使用一个部分作为测试集，其余部分作为训练集。这种方法可以帮助我们更好地评估模型的泛化能力。

3.3 随机采样

在处理大型数据集时，我们可能需要随机抽取一个子集进行分析或可视化。随机洗牌可以帮助我们实现这一点：

import numpy as np

# 创建一个大型数据集
large_dataset = np.array([f'data_{i}' for i in range(1000)])
large_dataset[0] = 'numpyarray.com'  # 确保包含特定字符串

# 设置随机种子
np.random.seed(42)

# 随机打乱数据集
np.random.shuffle(large_dataset)

# 随机抽取100个样本
sample_size = 100
random_sample = large_dataset[:sample_size]

print(f"Random sample of {sample_size} elements:")
print(random_sample)

Output:

在这个例子中，我们创建了一个包含1000个元素的大型数据集，其中包括”numpyarray.com”。我们首先打乱整个数据集，然后从中抽取前100个元素作为随机样本。这种方法可以确保我们得到的是一个无偏的随机样本。

4. 随机状态的重要性

理解和正确使用随机状态对于科学计算和机器学习来说至关重要。以下是一些关键原因：

4.1 结果可重复性

在科学研究中，结果的可重复性是非常重要的。通过设置固定的随机种子，我们可以确保每次运行代码时得到相同的结果：

import numpy as np

def run_experiment(seed):
    rng = np.random.default_rng(seed)
    data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
    rng.shuffle(data)
    return data

# 使用相同的种子运行两次实验
result1 = run_experiment(42)
result2 = run_experiment(42)

print("Result 1:", result1)
print("Result 2:", result2)
print("Results are identical:", np.array_equal(result1, result2))

Output:

在这个例子中，我们定义了一个简单的”实验”函数，它对数组进行随机洗牌。通过使用相同的随机种子，我们可以确保两次运行得到完全相同的结果。这对于调试和验证结果非常有用。

4.2 公平比较

当比较不同的算法或模型时，使用相同的随机状态可以确保比较的公平性：

import numpy as np

def algorithm_a(data, seed):
    rng = np.random.default_rng(seed)
    shuffled = data.copy()
    rng.shuffle(shuffled)
    return shuffled[:len(shuffled)//2]

def algorithm_b(data, seed):
    rng = np.random.default_rng(seed)
    return rng.choice(data, size=len(data)//2, replace=False)

# 创建数据集
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org',
                 'matplotlib.org', 'scikit-learn.org', 'pytorch.org', 'tensorflow.org'])

# 使用相同的种子比较两种算法
seed = 42
result_a = algorithm_a(data, seed)
result_b = algorithm_b(data, seed)

print("Algorithm A result:", result_a)
print("Algorithm B result:", result_b)

Output:

在这个例子中，我们定义了两个不同的算法来选择数据的子集。通过使用相同的随机种子，我们可以确保两种算法在相同的随机条件下进行比较，从而得出更可靠的结论。

4.3 调试和错误复现

当遇到与随机性相关的问题时，能够重现问题场景是非常重要的。使用固定的随机状态可以帮助我们更容易地调试和复现错误：

import numpy as np

def buggy_function(data, seed):
    rng = np.random.default_rng(seed)
    shuffled = data.copy()
    rng.shuffle(shuffled)
    # 假设这里有一个 bug，只返回前两个元素
    return shuffled[:2]

# 创建数据集
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])

# 使用固定的种子运行函数
seed = 42
result = buggy_function(data, seed)

print("Buggy function result:", result)

# 现在我们可以使用相同的种子来复现这个问题

Output:

在这个例子中，我们有一个包含 bug 的函数，它总是只返回洗牌后的前两个元素。通过使用固定的随机种子，我们可以确保每次运行都能复现这个问题，这对于调试和修复 bug 非常有帮助。

5. 高级洗牌技巧

除了基本的洗牌操作，NumPy 还提供了一些高级技巧，可以用于更复杂的场景。

5.1 部分洗牌

有时我们可能只想洗牌数组的一部分。我们可以使用 NumPy 的高级索引功能来实现这一点：

import numpy as np

# 创建一个数组
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org',
                 'matplotlib.org', 'scikit-learn.org', 'pytorch.org', 'tensorflow.org'])

# 只洗牌后半部分
half = len(data) // 2
indices = np.arange(len(data))
indices[half:] = np.random.permutation(indices[half:])

shuffled_data = data[indices]

print("Partially shuffled data:", shuffled_data)

Output:

在这个例子中，我们只对数组的后半部分进行了洗牌。这种技术在某些特殊场景下可能会很有用，比如当你想保持数据的某些部分有序时。

5.2 带权重的洗牌

有时我们可能想要根据某些权重来洗牌数组。虽然 NumPy 没有直接提供这样的功能，但我们可以使用 numpy.random.choice() 来实现类似的效果：

import numpy as np

# 创建一个数组和对应的权重
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
weights = np.array([0.4, 0.3, 0.2, 0.1])

# 使用带权重的随机选择来模拟洗牌
rng = np.random.default_rng(42)
shuffled_indices = rng.choice(len(data), size=len(data), replace=False, p=weights)
shuffled_data = data[shuffled_indices]

print("Weighted shuffled data:", shuffled_data)

Output:

在这个例子中，我们为每个元素分配了一个权重。权重越高的元素，在洗牌后出现在前面的概率就越大。这种方法可以用于在保持某种偏好的同时引入随机性。

5.3 多维数组的自定义洗牌

前面我们提到，numpy.random.shuffle() 只会沿着第一个轴进行洗牌。但有时我们可能需要沿着其他轴进行洗牌。我们可以使用 numpy.apply_along_axis() 来实现这一点：

import numpy as np

# 创建一个 3D 数组
data = np.array([
    [['numpyarray.com', 1], ['numpy.org', 2]],
    [['scipy.org', 3], ['pandas.pydata.org', 4]],
    [['matplotlib.org', 5], ['scikit-learn.org', 6]]
])

# 定义一个沿指定轴洗牌的函数
def shuffle_axis(arr, axis):
    rng = np.random.default_rng(42)
    return rng.permutation(arr)

# 沿着第二个轴（axis=1）洗牌
shuffled_data = np.apply_along_axis(shuffle_axis, 1, data)

print("Shuffled along axis 1:")
print(shuffled_data)

在这个例子中，我们创建了一个 3D 数组，然后定义了一个函数来沿指定轴洗牌。使用 numpy.apply_along_axis()，我们可以沿着第二个轴（axis=1）对数组进行洗牌。这种方法可以让我们更灵活地控制多维数组的洗牌过程。

6. 随机状态的最佳实践

在使用 NumPy 的随机功能时，遵循一些最佳实践可以帮助我们避免常见的陷阱并提高代码的可维护性。

6.1 使用独立的随机生成器

对于不同的任务或模块，最好使用独立的随机生成器：

import numpy as np

# 为数据预处理创建一个随机生成器
preprocess_rng = np.random.default_rng(seed=42)

# 为模型初始化创建另一个随机生成器
model_rng = np.random.default_rng(seed=123)

# 数据预处理
data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
preprocess_rng.shuffle(data)
print("Preprocessed data:", data)

# 模型初始化（这里用简单的随机数组代替）
model_params = model_rng.random(5)
print("Model parameters:", model_params)

Output:

这种方法可以确保不同部分的随机性是相互独立的，使得代码更容易维护和调试。

6.2 记录随机种子

在进行实验或研究时，记录使用的随机种子是一个好习惯：

import numpy as np
import json

def run_experiment(seed):
    rng = np.random.default_rng(seed)
    data = np.array(['numpyarray.com', 'numpy.org', 'scipy.org', 'pandas.pydata.org'])
    rng.shuffle(data)
    return data

# 运行实验
seed = 42
result = run_experiment(seed)

# 记录实验结果和种子
experiment_record = {
    "seed": seed,
    "result": result.tolist()
}

# 将记录保存到文件
with open("experiment_record.json", "w") as f:
    json.dump(experiment_record, f)

print("Experiment record saved.")

Output:

这个例子展示了如何将实验的随机种子和结果一起记录下来。这对于实验的复现和结果的验证非常重要。

6.3 避免全局随机状态

尽量避免使用全局随机状态，因为它可能会导致难以预料的副作用：

import numpy as np

# 不推荐：使用全局随机状态
np.random.seed(42)
data1 = np.random.rand(5)

# 其他代码可能会改变全局随机状态
np.random.seed(123)

# 这里的结果可能不是你期望的
data2 = np.random.rand(5)

print("Data 1:", data1)
print("Data 2:", data2)

# 推荐：使用局部随机生成器
rng1 = np.random.default_rng(42)
data3 = rng1.random(5)

rng2 = np.random.default_rng(42)
data4 = rng2.random(5)

print("Data 3:", data3)
print("Data 4:", data4)

Output:

在这个例子中，我们展示了使用全局随机状态可能导致的问题，以及如何使用局部随机生成器来避免这些问题。

7. 结论

NumPy 的随机洗牌和随机状态功能为科学计算和数据分析提供了强大的工具。通过正确使用这些功能，我们可以确保实验的可重复性，提高模型评估的可靠性，并在需要随机性的场景中获得更好的控制。

本文深入探讨了 NumPy 中随机洗牌的各种方法，从基本的数组洗牌到更复杂的多维数组和带权重的洗牌。我们还讨论了随机状态的重要性，以及如何通过设置随机种子来确保结果的可重复性。

在实际应用中，正确管理随机状态可以帮助我们更好地进行调试、比较不同算法，并确保实验结果的可靠性。通过遵循本文提到的最佳实践，如使用独立的随机生成器、记录随机种子，以及避免全局随机状态，我们可以编写出更加健壮和可维护的代码。

随着数据科学和机器学习领域的不断发展，对随机性的精确控制变得越来越重要。掌握 NumPy 中的随机洗牌和随机状态技术，将使你能够更好地处理各种需要随机性的场景，从而在你的数据分析和模型开发工作中取得更好的结果。