tf numpy内存优化

numpy concatenate

假如使用 numpy.concatenate 对多个矩阵进行连接时，内存使用量会突然增加并导致溢出报错

原因分析

numpy.concatenate 会先在内存中创建一个新的数组来存放连接后的结果，这意味着在连接过程中，系统需要同时保留所有原始矩阵和最终的连接结果。这会导致内存使用量增加，尤其是当原始数据和结果都很大的时候。
numpy.concatenate 可能会涉及大量的数据拷贝操作，特别是当你处理的是大数组时，这些操作会显著增加内存使用量。
Python 使用引用计数来管理内存，释放内存有时可能不会像期望的那样立即发生。因此，在连接操作之前和之后，可能会有一些内存碎片或未立即释放的内存。

优化内存使用的方法

1. 使用生成器而非列表：
   如果你是将多个矩阵保存在一个列表中，考虑使用生成器表达式来延迟加载数据，而不是预先加载所有矩阵到内存中。这可以减少内存峰值。

   matrices = (generate_matrix(i) for i in range(N))
   concatenated = np.concatenate(list(matrices), axis=0)
   

2. 逐步拼接：
   考虑使用 np.append 或 np.vstack 等函数进行逐步拼接，避免一次性占用大量内存。尽管这样可能会稍微牺牲一些速度，但在内存敏感的场景下，这是一种可行的优化。

   result = np.empty((0, columns))
   for matrix in list_of_matrices:
       result = np.vstack((result, matrix))
   

3. 使用内存映射 (Memory-Mapped Files)：
   如果数据非常大，你可以考虑使用 numpy 的内存映射功能 numpy.memmap。这会将数据存储在磁盘而不是内存中，虽然读取速度会慢一些，但可以处理超大规模的数据集。

   with np.memmap('filename', dtype='float32', mode='w+', shape=(total_rows, columns)) as mmapped_array:
       start = 0
       for matrix in list_of_matrices:
           mmapped_array[start:start+matrix.shape[0], :] = matrix
           start += matrix.shape[0]
   

4. 减少数据类型的占用：
   确保数据类型尽可能小。

   matrices = [matrix.astype(np.int32) for matrix in list_of_matrices]
   concatenated = np.concatenate(matrices, axis=0)
   

5. 使用稀疏矩阵 (Sparse Matrices)：
   如果矩阵中有大量零元素，可以使用 scipy.sparse 模块中的稀疏矩阵来表示和操作，这会显著减少内存占用。

   from scipy.sparse import vstack
   
   sparse_matrices = [scipy.sparse.csr_matrix(matrix) for matrix in list_of_matrices]
   result = vstack(sparse_matrices)
   

其他优化

在使用 TensorFlow 读取大量数据并使用 NumPy 处理大规模数据时，内存管理变得尤为重要。以下是一些有效的内存优化策略，可以帮助你最大限度地利用内存并避免内存溢出问题：

1. 数据加载与预处理的优化

使用 tf.data API 进行高效数据管道处理

TensorFlow 的 tf.data API 提供了一种高效且灵活的数据加载方式。它支持按需加载和批处理数据，从而减少内存使用。你可以利用 tf.data.Dataset 来创建一个数据管道，将数据分批加载到内存中，而不是一次性加载所有数据。

dataset = tf.data.Dataset.from_tensor_slices((file_paths, labels))
dataset = dataset.map(parse_function, num_parallel_calls=tf.data.experimental.AUTOTUNE)
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)

使用生成器（Generator）

如果你使用 NumPy 进行数据处理，可以使用 Python 的生成器逐步读取和处理数据，而不是一次性加载所有数据。这种方法减少了内存占用。

def data_generator(file_paths):
    for file_path in file_paths:
        data = np.load(file_path)
        yield process_data(data)

# Example usage:
for batch in data_generator(file_paths):
    process_batch(batch)

2. 使用内存映射（Memory-Mapped Files）

内存映射允许你在处理非常大的数据集时，仅将部分数据加载到内存中。NumPy 的 memmap 函数可以帮助你实现这一点。

data = np.memmap('large_file.dat', dtype='float32', mode='r', shape=(10000, 10000))

这使得数据在磁盘上处理，而不是全部加载到内存中，尤其适合大规模数据。

3. 数据类型优化

数据类型直接影响内存的使用。确保使用最合适的精度：

• 对于整数数据，使用 int8, int16, int32 等合适的类型。
• 对于浮点数据，如果 float32 的精度足够，就不要使用 float64。

你可以通过以下方式转换数据类型：

data = data.astype(np.float32)

4. 释放不再使用的内存

在处理完大数据块后，尽早释放内存，避免内存占用过多。Python 的垃圾回收机制会自动管理内存，但手动删除引用并调用垃圾回收器可以加速内存释放：

import gc

del large_variable
gc.collect()

5. 分批处理数据

对于无法完全加载到内存的大数据集，可以考虑将数据分割成多个小批次处理。TensorFlow 和 NumPy 都支持分批处理。

batch_size = 32
for i in range(0, len(data), batch_size):
    batch = data[i:i+batch_size]
    process_batch(batch)

6. TensorFlow 的分布式训练

在使用 TensorFlow 进行训练时，利用 TensorFlow 的分布式训练功能，将模型和数据分布到多个 GPU 或 TPU 上，可以有效减少单个设备的内存压力。

strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
    model.fit(dataset, epochs=10)

7. 内存优化的 TensorFlow 操作

使用 TensorFlow 中的一些内存优化操作和函数，可以进一步减少内存占用。例如，在梯度计算中，可以使用 tf.gradients 进行内存优化。

gradients = tf.gradients(loss, vars, colocate_gradients_with_ops=True)

8. 使用稀疏数据结构

如果你的数据集大部分是零，可以考虑使用稀疏矩阵来节省内存。TensorFlow 支持稀疏张量，NumPy 可以使用 scipy.sparse 来处理。

from scipy import sparse

sparse_matrix = sparse.csr_matrix(dense_matrix)