大NumPy数组拼接内存占用过高的解决方案咨询

你遇到的核心问题其实不是拼接本身，而是预处理阶段把稀疏矩阵转成了密集数组——CountVectorizer输出的csr_matrix是稀疏格式，只存储非零值，内存占用极低，但你用toarray()转成密集数组后，高维文本向量里的大量0值会瞬间吃掉所有内存。我们从根源优化，再给你几个可行的方案：

方案一：用稀疏矩阵直接拼接（最推荐，内存占用最少） #

文本数据的向量天生是稀疏的，完全没必要转成密集数组。我们可以用scipy.sparse.hstack直接拼接稀疏矩阵，全程不用加载密集数组到内存：

修改你的预处理代码： #

from scipy.sparse import hstack, coo_matrix

vectorizer = CountVectorizer()
# 保留稀疏矩阵格式，不要转toarray()
x = vectorizer.fit_transform(train['discourse_text'])

def str_to_numeric_sparse(df, column):
    # 生成one-hot的稀疏矩阵，比密集数组省内存
    unique_vals = df[column].unique()
    dict_types = {val:i for i, val in enumerate(unique_vals)}
    # 用coo_matrix创建稀疏one-hot矩阵
    row_indices = df.index
    col_indices = [dict_types[val] for val in df[column]]
    data = [1]*len(row_indices)
    return coo_matrix((data, (row_indices, col_indices)), shape=(len(df), len(unique_vals)))

# 生成稀疏的one-hot矩阵
discourse_type = str_to_numeric_sparse(train, 'discourse_type')
# 标签维度低，转密集数组不影响内存
y = str_to_numeric_sparse(train, 'discourse_effectiveness').toarray()

# 直接拼接稀疏矩阵，内存占用几乎可以忽略
X = hstack([discourse_type, x])

这样拼接出来的X还是稀疏矩阵，后续如果用scikit-learn的模型（比如LogisticRegression、SVM等），大部分都支持直接输入稀疏矩阵，不用转密集数组。

方案二：优化密集数组的数据类型（如果必须用NumPy数组） #

如果你因为某些原因必须用密集数组，那可以通过降低数据类型来减少内存占用：

• 文本向量的计数是非负整数，用uint8（0-255）就足够，比默认的int64节省7/8内存；
• One-hot编码只有0和1，同样可以用uint8或者bool类型。

修改你的代码：

import numpy as np

vectorizer = CountVectorizer()
# 转密集数组时指定小数据类型，同时去掉多余的维度扩展
x = vectorizer.fit_transform(train['discourse_text']).toarray().astype(np.uint8)

def str_to_numeric(df, column):
    unique_vals = df[column].unique()
    # 直接指定uint8类型，减少内存
    y = np.zeros((len(df), len(unique_vals)), dtype=np.uint8)
    dict_types = {val:i for i, val in enumerate(unique_vals)}
    for i in df.index:
        y[i][dict_types[df[column][i]]] = 1
    return y

discourse_type = str_to_numeric(train, 'discourse_type')
y = str_to_numeric(train, 'discourse_effectiveness')

# 现在再拼接，内存会大幅降低
X = np.concatenate([discourse_type, x], axis=1)

注意你之前加的[:,np.newaxis,:]完全是多余的，把2D数组变成3D，平白增加了内存占用，直接用2D数组拼接就好。

方案三：分块处理（适合模型训练场景） #

如果你的最终目的是训练模型，那完全没必要一次性拼接整个数组。可以分批次加载数据，每次只处理一小部分：

batch_size = 1000
# 假设model是你的训练模型，且支持partial_fit
for i in range(0, len(train), batch_size):
    # 取当前批次的数据
    batch_data = train.iloc[i:i+batch_size]
    # 处理当前批次的向量
    batch_x = vectorizer.transform(batch_data['discourse_text']).toarray().astype(np.uint8)
    batch_discourse = str_to_numeric(batch_data, 'discourse_type')
    # 拼接当前批次
    batch_X = np.concatenate([batch_discourse, batch_x], axis=1)
    batch_y = str_to_numeric(batch_data, 'discourse_effectiveness')
    # 用当前批次训练模型
    model.partial_fit(batch_X, batch_y)

这种方式内存占用始终是单个批次的大小，完全不会耗尽内存。

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