时间序列常用数据处理

1.组合技巧Compose

1.2 实例应用及其解释

# 用于组合多个数据处理方法
class Compose(object):
    def __init__(self, transforms):
        self.transforms = transforms

    def __call__(self, seq):
        for t in self.transforms:
            seq = t(seq)
        return seq

这段Python代码定义了一个名为`Compose`的类。此类的主要目的是组合多个变换函数并按顺序应用它们。这在数据预处理中很常见,尤其是在图像和序列数据处理中。让我们逐行解释代码:

1. **`class Compose(object):`**  
定义了一个名为`Compose`的新类,该类继承自Python的基类`object`。

2. **`def __init__(self, transforms):`**  
这是类的初始化方法。当创建`Compose`对象时,它会被调用。
    - `transforms`是传递给此方法的参数,它预期是一个列表,其中包含要按顺序应用的一系列变换函数。

3. **`self.transforms = transforms`**  
将传递的变换函数列表存储在类实例的`transforms`属性中。

4. **`def __call__(self, seq):`**  
这是类的特殊方法`__call__`。当你像函数一样调用一个对象时,这个方法会被执行。因此,它使得对象的实例具有可调用的性质。
    - `seq`是传递给此方法的参数,它是将要应用一系列变换的数据(例如,可以是一个图像、音频片段或文本序列)。

5. **`for t in self.transforms:`**  
这是一个循环,用于遍历`transforms`列表中的每个变换函数。

6. **`seq = t(seq)`**  
在循环内部,当前的变换函数`t`被应用于`seq`,并且结果重新赋值给`seq`。这意味着每个变换都是按顺序依次应用的,每次都更新`seq`的内容。

7. **`return seq`**  
经过所有变换后,返回处理后的`seq`。

总体来说,`Compose`类的作用是,它接收一个变换函数列表,然后当你调用一个`Compose`对象并传递给它一个数据序列时,它会按照列表中的顺序依次应用这些变换,并返回处理后的数据。这种方式在深度学习库(如PyTorch的`torchvision.transforms`)中非常常见,用于定义数据增强和预处理的流程。

1.2应用逻辑

上述代码定义了一个`Compose`类,这个类的主要逻辑是:接受一个变换函数列表,并按顺序依次应用这些函数到某个输入数据上。

**实现逻辑**:

1. 初始化时,接受一个变换函数列表`transforms`并存储它。
2. 当类的实例被像函数一样调用时(使用`__call__`方法),它将按列表中的顺序依次应用这些变换函数到输入数据`seq`上。

**使用场景**:

这种设计模式在数据预处理中非常常见,特别是在机器学习和深度学习的领域:

1. **图像处理**:例如,在图像增强中,你可能希望先进行裁剪,然后旋转,接着调整亮度。通过将这些单独的变换组合成一个`Compose`对象,可以简化处理流程。
  
2. **文本处理**:对于文本数据,你可能希望进行分词、移除停用词、然后进行词干提取。这些变换可以通过一个`Compose`对象依次应用。

3. **数据增强**:在深度学习训练中,为了增强模型的泛化能力,经常使用数据增强技术,如图像旋转、翻转等。`Compose`可以按照指定的顺序应用这些增强。

4. **数据正则化与标准化**:在预处理流水线中,可能需要将数据进行缩放、中心化或标准化。通过`Compose`,可以将这些步骤组合成一个连续的流程。

例如,PyTorch的`torchvision`库中就有一个与上述代码类似的`transforms.Compose`类,用于构建图像预处理和数据增强的流程。

总之,`Compose`类提供了一种简洁、模块化的方法,用于组合和顺序应用多个处理步骤,使得数据预处理和增强流程更为有序和高效。

1.3 简单地上手示例

示例

想象一下,你经常需要对数字列表进行一系列操作:先求平方,然后增加一个固定值,接着求每个数字的倒数。以下是如何使用一个Compose类似的方法来简化这个过程:

1.3.1 定义每个操作

def square(nums):
    return [num**2 for num in nums]

def add_value(nums, value=5):
    return [num + value for num in nums]

def reciprocal(nums):
    return [1/num for num in nums]

1.3.2 创建Compose工具: 

class Compose:
    def __init__(self, functions):
        self.functions = functions

    def __call__(self, data):
        for func in self.functions:
            data = func(data)
        return data

1.3.3 使用Compose工具

transform = Compose([square, lambda x: add_value(x, value=10), reciprocal])
result = transform([1, 2, 3, 4])
print(result)  # 输出: [0.05263157894736842, 0.027777777777777776, 0.0196078431372549, 0.015625]

时间序列常用数据处理_第1张图片

 

2.对序列进行转置操作Reshape

# 用于对序列进行转置操作
class Reshape(object):
    def __call__(self, seq):
        return seq.transpose()

这个`Reshape`类是一个简单的工具,设计用来对输入数据(在这里是`seq`)进行转置操作。

让我们详细解释这个类:

1. **`class Reshape(object):`**  
定义了一个新类名为`Reshape`,继承自Python的基类`object`。

2. **`def __call__(self, seq):`**  
这是类的特殊方法`__call__`。这个方法允许我们像函数那样调用类的实例。在这种情况下,当我们创建一个`Reshape`对象,并像函数一样使用它时,这个方法将被执行。
    - `seq`是传递给此方法的参数,它可能是一个矩阵或数组,我们希望对它进行转置操作。

3. **`return seq.transpose()`**  
这里,我们使用了`transpose`方法对`seq`进行转置。该方法通常用于NumPy数组或其他支持这种操作的数据结构来转置矩阵。

**使用场景**:

1. **矩阵处理**:在机器学习和数据处理中,经常需要重新整形和转置数据。这个`Reshape`类提供了一种简单的方法来转置数据。

2. **图像处理**:图像通常被表示为三维数组,其中三个维度分别是高度、宽度和颜色通道。有时,基于计算需求,你可能需要调换这些维度的顺序。使用转置操作可以实现这一点。

3. **神经网络和深度学习**:在构建和训练神经网络模型时,经常需要对输入数据进行转置,以确保它们与模型的权重矩阵正确对齐。

2.1 举例实现

示例

假设你经常需要对一系列数字进行以下操作:

  • 对每个数字加5
  • 将结果列表反转

传统的做法可能是:

numbers = [1, 2, 3, 4]
numbers = [num + 5 for num in numbers]
numbers.reverse()
print(numbers)  # 输出:[9, 8, 7, 6]

现在,为了模块化和简化这些操作,你可以创建两个独立的类:

class AddFive:
    def __call__(self, nums):
        return [num + 5 for num in nums]

class Reverse:
    def __call__(self, nums):
        return nums[::-1]

然后,你可以使用先前介绍的Compose类将这两个操作组合起来:

class Compose:
    def __init__(self, transforms):
        self.transforms = transforms

    def __call__(self, data):
        for t in self.transforms:
            data = t(data)
        return data

transform = Compose([AddFive(), Reverse()]) # 可见此步是需要按照数据处理的顺序进行的
numbers = [1, 2, 3, 4]
print(transform(numbers))  # 输出:[9, 8, 7, 6]

3.给序列添加高斯噪声 

# 用于给序列添加服从高斯分布的噪声
class AddGaussian(object):
    def __init__(self, sigma=0.01):
        self.sigma = sigma

    def __call__(self, seq):
        return seq + np.random.normal(loc=0, scale=self.sigma, size=seq.shape)

3.1 以一定概率给序列添加高斯噪声

# 用于以一定概率给序列添加高斯噪声
class RandomAddGaussian(object):
    def __init__(self, sigma=0.01):
        self.sigma = sigma

    def __call__(self, seq):
        if np.random.randint(2):
            return seq
        else:
            return seq + np.random.normal(loc=0, scale=self.sigma, size=seq.shape)

4.对序列进行缩放操作

# 用于对序列进行缩放操作
class Scale(object):
    def __init__(self, sigma=0.01): # 定义缩放因子的标准差。默认值为0.01
        self.sigma = sigma
    
    """
    类的特殊方法__call__,它允许我们像函数那样调用类的实例。这意味着你可以创建一个Scale对象,并直接对序列进行缩放,而不需要调用特定的方法。
    seq:这是传入此方法的序列,我们打算对它进行缩放。
    """
    def __call__(self, seq):
        scale_factor = np.random.normal(loc=1, scale=self.sigma, size=(seq.shape[0], 1))
        scale_matrix = np.matmul(scale_factor, np.ones((1, seq.shape[1])))
        return seq*scale_matrix
  1. scale_factor = np.random.normal(loc=1, scale=self.sigma, size=(seq.shape[0], 1))
    这行代码生成一个随机缩放因子。缩放因子来自正态分布,其均值为1(即loc=1),标准差为sigma。这些缩放因子的形状与输入序列的行数相同。

  2. scale_matrix = np.matmul(scale_factor, np.ones((1, seq.shape[1])))
    这行代码创建一个缩放矩阵。为此,它将缩放因子与一个全为1的矩阵进行矩阵乘法。这确保了每行的所有元素都乘以相同的缩放因子。

  3. return seq*scale_matrix
    这是最后一步,它返回缩放后的序列。这是通过将原始序列与缩放矩阵进行元素级乘法来实现的。

这个Scale类提供了一种随机缩放输入序列的方法。缩放的程度由参数sigma决定,它控制随机生成的缩放因子的变异程度。这种随机缩放通常在数据增强中使用,特别是在机器学习和深度学习领域,用于增加模型的泛化能力。 

  4.1 以一定概率对序列进行缩放操作

# 以一定概率对序列进行缩放操作
class RandomScale(object):
    def __init__(self, sigma=0.01):
        self.sigma = sigma

    def __call__(self, seq):
        if np.random.randint(2):
            return seq
        else:
            scale_factor = np.random.normal(loc=1, scale=self.sigma, size=(seq.shape[0], 1))
            scale_matrix = np.matmul(scale_factor, np.ones((1, seq.shape[1])))
            return seq*scale_matrix

`RandomScale`类与之前的`Scale`类主要有一个显著的区别:在`RandomScale`中,有一个随机决策过程决定是否对序列`seq`进行缩放。

以下是该类的特定部分的解释:

1. **`if np.random.randint(2):`**  
   这里使用`np.random.randint(2)`随机生成0或1。如果生成的数字是1(有50%的概率),则直接返回原始序列而不进行缩放。

2. **`else:`**  
   如果生成的数字是0,该方法将继续并对序列进行与`Scale`类相同的缩放操作。

这种随机决策意味着不是每次都对输入序列进行缩放。大约有一半的机会序列会保持不变,而另一半的机会会进行随机缩放。

此设计有以下可能的原因或应用场景:

1. **提供更多的多样性**:有时不对数据进行任何变化也是有益的,这增加了数据集的多样性,可以更好地模拟真实世界的不确定性。

2. **减少计算成本**:在某些情况下,每次都进行缩放可能会增加不必要的计算成本。通过随机地只对一部分数据进行缩放,可以在保持模型性能的同时减少这些额外的计算。

3. **数据增强的平衡**:在某些情况下,过多的数据增强可能会导致模型学到错误的模式。通过只随机应用缩放,可以为模型提供更平衡的、增强与未增强的数据组合。

总的来说,`RandomScale`类提供了一个在随机情况下对输入序列进行缩放的方法,而`Scale`类则始终对输入序列进行缩放。根据应用场景和需求,你可以选择最适合的方法。

 

4.2 在什么情况下需要做此缩放

在机器学习和深度学习中,对数据进行缩放或其他类型的增强是为了满足多种目的。使用`Scale`类进行随机缩放可能是基于以下几个原因:

1. **数据增强**:特别是在深度学习领域,数据增强是一种常用的技术,用于通过对原始数据进行微小的变化来人为地增加训练数据。这可以帮助模型更好地泛化到未见过的数据,防止过拟合。

2. **模拟真实情境**:在某些情况下,原始数据可能会受到各种因素的影响而发生微小的变化。随机缩放可以模拟这种真实的数据变化,帮助模型在实际应用中表现得更好。

3. **特征工程**:缩放可以作为特征工程的一部分,以创建新的或修改现有的特征,从而提高模型的性能。

4. **破坏不相关的模式**:在某些情况下,数据中可能存在不希望模型学习的模式。随机缩放可以破坏这些模式,使模型更加专注于真正重要的特征。

5. **增加模型的鲁棒性**:通过训练模型处理缩放后的数据,可以增加其对输入变化的鲁棒性。

6. **处理不稳定数据**:在某些应用中,例如金融或医学图像处理,数据可能会有大的变化或不稳定性。随机缩放可以帮助模型适应这些变化,提高预测的稳定性。

总的来说,随机缩放和其他数据增强技术在处理有限的数据、增加模型泛化能力或模拟特定的实际情境时都非常有用。

 5.以一定概率对序列进行随机拉伸操作

随机地“拉伸”或“压缩”一个输入的序列:

# 以一定概率对序列进行随机拉伸操作
class RandomStretch(object):
    def __init__(self, sigma=0.3):
        self.sigma = sigma

    def __call__(self, seq):
        if np.random.randint(2):
            return seq  # 返回原始的、未修改的序列。
        else:           # 如果进入这部分代码,序列将会被拉伸或压缩。
            
            # 创建一个形状与原始序列相同的零数组,用于存储修改后的序列。
            seq_aug = np.zeros(seq.shape)
            len = seq.shape[1]
            
            """
            计算拉伸或压缩后的序列长度,其中,(random.random()-0.5)*self.sigma会生成一个在-self.sigma/2到self.sigma/2范围内的随机值,这决定了拉             伸或压缩的幅度。
            """
            length = int(len * (1 + (random.random()-0.5)*self.sigma))
            
            # 这个循环会对序列的每一行(假设序列是二维的)进行拉伸或压缩。
            for i in range(seq.shape[0]):
                
                # 使用resample方法对当前行的数据进行重采样,使其达到前面计算的length长度。
                y = resample(seq[i, :], length)
                
                """
                接下来的if-else语句块
                这部分考虑了新的序列长度与原始长度的关系,并相应地填充或截断数据以适应seq_aug的形状。
                如果新长度小于原始长度,程序会选择将重采样后的数据放在seq_aug的开头或结尾。
                如果新长度大于原始长度,程序会选择从重采样后的数据的开头或结尾截取适量的数据以适应seq_aug                 的长度。
                """
                if length < len:
                    if random.random() < 0.5:
                        seq_aug[i, :length] = y
                    else:
                        seq_aug[i, len-length:] = y
                else:
                    if random.random() < 0.5:
                        seq_aug[i, :] = y[:len]
                    else:
                        seq_aug[i, :] = y[length-len:]
            return seq_aug # 最后,返回拉伸或压缩后的序列。

总结:RandomStretch类是用于对输入序列进行随机拉伸或压缩的。这种拉伸或压缩的数据增强方法可能在处理时序数据,如音频、股票价格或其他连续数据时特别有用,因为它可以模拟序列的时间变化,从而增加模型的泛化能力。 

6.以一定概率对序列进行随机裁剪操作 

RandomCrop类的目的是以一定的概率对输入的序列进行随机裁剪操作。裁剪并不是像图像裁剪那样移除某个部分,而是将选定的序列部分设置为0。

# 以一定概率对序列进行随机裁剪操作
class RandomCrop(object):
    def __init__(self, crop_len=20): #参数crop_len,代表需要被设置为0的序列的长度。默认长度为20。
        self.crop_len = crop_len

    def __call__(self, seq):
        if np.random.randint(2): # 有50%的机会直接返回原始的、未修改的序列。
            return seq
        else: # 否则序列的某一部分将会被设置为0。
            
            """
            计算可以裁剪的最大起始索引。例如,如果序列长度为100,crop_len为20,那么最大的起始索引为80,             以确保裁剪的部分不会超出序列长度。
            """
            max_index = seq.shape[1] - self.crop_len
            
            # 随机选择一个起始索引,范围从0到max_index。
            random_index = np.random.randint(max_index)
            
            """
            将选定的部分设置为0。这里,:表示操作应用于所有行(如果seq是二维的),而            	  random_index:random_index+self.crop_len选择从random_index开始的self.crop_len长度的序列。
            """
            seq[:, random_index:random_index+self.crop_len] = 0
            return seq # 返回裁剪后的序列

总体来说,RandomCrop类将随机选择输入序列的一个部分,并将其设置为0。这种数据增强方法可以模拟序列中的数据丢失或干扰,从而增强模型的鲁棒性和泛化能力。 

 

 7.对序列进行归一化操作

这个Normalize类用于对输入的序列进行规范化或标准化处理。这是处理数据集时常见的一个预处理步骤,以确保所有数据在同一尺度上,从而有助于模型的训练和收敛。 

# 对序列进行归一化操作
class Normalize(object):
    # 默认为"0-1"范围规范化。
    def __init__(self, type = "0-1"): # "0-1","-1-1","mean-std"
        self.type = type
        
    def __call__(self, seq):
        if  self.type == "0-1":
            seq = (seq-seq.min())/(seq.max()-seq.min())
 
        # 如果选择的规范化类型为"-1-1",则使用这种方法。这会将序列中的最小值映射到-1,最大值映射到1,所有其他值将在-1到1之间。
        elif  self.type == "-1-1":
            seq = 2*(seq-seq.min())/(seq.max()-seq.min()) + -1
        elif self.type == "mean-std" :
            seq = (seq-seq.mean())/seq.std()
        else:
            raise NameError('This normalization is not included!')
        return seq

 

 

 

 

 

 

  

 

 

 

 

 

 

 

 

你可能感兴趣的:(python数据分析与数据处理,python,开发语言)