如何针对无限迭代计算运行平均值？

针对无限或极大次数迭代的运行平均值计算，不需要存储所有历史数据，可以通过递推公式实现内存固定的高效计算，核心思路是仅跟踪当前平均值和已处理样本的数量。

核心递推公式 #

运行平均值的递推计算基于以下公式：

new_average = previous_average + (new_value - previous_average) / (count + 1)

其中：

• previous_average 是上一次计算得到的平均值
• new_value 是当前新增的样本值
• count 是新增当前样本前已处理的样本总数（新增后总数为 count + 1）

这个公式的等价形式也可以写成：

new_average = (previous_average * count + new_value) / (count + 1)

两种形式效果一致，前者在数值稳定性上表现更优。

基础实现代码 #

直接修改你提供的代码，加入计数跟踪，实现运行平均值计算：

import random

# 初始化：初始平均值为0，已处理样本数为0
current_avg = 0.0
sample_count = 0

# 注意：range不支持float，需转换为整数
epochs = int(1e10)
for epoch in range(epochs):
    new_value = random.randint(1, 100)
    sample_count += 1
    # 更新运行平均值
    current_avg = current_avg + (new_value - current_avg) / sample_count
    
    # 可选：每隔一定次数打印结果，避免输出过多
    if epoch % 1000000 == 0:
        print(f"当前运行平均值: {current_avg:.2f}")

如果要封装成独立函数：

def update_running_avg(prev_avg, new_val, current_count):
    """
    更新运行平均值
    :param prev_avg: 上一次的平均值
    :param new_val: 新增的样本值
    :param current_count: 新增样本前的已处理数量
    :return: 新的运行平均值
    """
    return prev_avg + (new_val - prev_avg) / (current_count + 1)

多参数场景的解决方案 #

如果需要同时为多个参数计算运行平均值，可以用类来封装每个参数的跟踪状态，避免变量混乱：

import random

class RunningAverageTracker:
    def __init__(self):
        # 存储每个参数的(当前平均值, 已处理样本数)
        self._trackers = {}
    
    def update(self, param_name, new_value):
        """更新指定参数的运行平均值"""
        if param_name not in self._trackers:
            # 首次跟踪该参数，初始化状态
            self._trackers[param_name] = (0.0, 0)
        
        prev_avg, count = self._trackers[param_name]
        count += 1
        new_avg = prev_avg + (new_value - prev_avg) / count
        self._trackers[param_name] = (new_avg, count)
        return new_avg
    
    def get_average(self, param_name):
        """获取指定参数的当前平均值"""
        return self._trackers.get(param_name, (0.0, 0))[0]

# 使用示例
tracker = RunningAverageTracker()
epochs = int(1e10)
for epoch in range(epochs):
    # 模拟两个不同参数的样本值
    val_param1 = random.randint(1, 100)
    val_param2 = random.randint(50, 150)
    
    # 更新并获取平均值
    avg_param1 = tracker.update("param1", val_param1)
    avg_param2 = tracker.update("param2", val_param2)
    
    if epoch % 1000000 == 0:
        print(f"param1 平均值: {avg_param1:.2f}, param2 平均值: {avg_param2:.2f}")

关键优势 #

• 内存占用固定：无论迭代多少次，仅需存储当前平均值和样本计数（多参数场景下仅和参数数量相关），不会出现内存溢出问题
• 计算效率高：每次更新仅需常数时间O(1)的计算，不影响迭代性能
• 扩展性强：通过类封装可以轻松扩展到任意数量的参数跟踪

内容的提问来源于stack exchange，提问作者Penguin