Python normalization示例

在Python中，数据规范化（Normalization）是一种常见的预处理步骤，用于将不同范围的数据转换到统一的标准，以便于分析或模型训练。通常，我们会将其缩放到0-1之间或均值为0，标准差为1（Z-score标准化）。这里是一个简单的示例：

import numpy as np

# 假设我们有一个数据集
data = [50, 100, 150, 200, 250]

# 计算最大值和最小值
min_val = min(data)
max_val = max(data)

# Z-score标准化
normalized_data = [(x - min_val) / (max_val - min_val) for x in data]

print("Original data:", data)
print("Normalized data:", normalized_data)

# 或者使用NumPy的zscore函数
normalized_data_np = np.array(data).reshape(- np.mean(normalized_data_np)) / np.std(normalized_data_np)
print("Normalized data with NumPy zscore:", normalized_data_np_zscore)

相关问题

batch normalization代码示例

好的，以下是一个简单的 batch normalization 的代码示例：

import numpy as np

class BatchNorm:
    def __init__(self, gamma, beta, eps=1e-5):
        self.gamma = gamma
        self.beta = beta
        self.eps = eps
        self.mean = None
        self.var = None
        self.batch_size = None
        self.xc = None
        self.std = None

    def forward(self, x):
        self.batch_size = x.shape[0]
        self.mean = np.mean(x, axis=0)
        self.xc = x - self.mean
        self.var = np.var(x, axis=0)
        self.std = np.sqrt(self.var + self.eps)
        x_norm = self.xc / self.std
        out = self.gamma * x_norm + self.beta
        return out

    def backward(self, dout):
        dx_norm = dout * self.gamma
        dxc = dx_norm / self.std
        dstd = -np.sum(dx_norm * self.xc / (self.std * self.std), axis=0)
        dvar = 0.5 * dstd / self.std
        dsq = np.ones_like(dout) / self.batch_size * dvar
        dxc += 2 * self.xc * dsq
        dmu = -np.sum(dxc, axis=0)
        dx = dxc + np.ones_like(dout) / self.batch_size * dmu
        dgamma = np.sum(dout * (self.xc / self.std), axis=0)
        dbeta = np.sum(dout, axis=0)
        return dx, dgamma, dbeta

其中，gamma 和 beta 是可学习的参数，eps 是一个小常数，用于避免除以零的情况。

写一段Batch normalization 的python代码

示例：
import numpy as npdef batchnorm(X, gamma, beta, epsilon=1e-5):
# 计算均值
mu = np.mean(X, axis=0)
# 计算方差
var = np.var(X, axis=0)
# 计算X的标准差
std = np.sqrt(var + epsilon)
# 计算X的标准分布
z = (X - mu) / std
# 计算batch normalization
out = gamma * z + beta
return out