управление памятью Python при обработке больших изображений

голоса
2

Я сопровождающим пакета , который реализует несколько алгоритмов демозаики для Python и пользователь сообщил , чрезмерное использование памяти при обработке изображений 7K. Я наткнулся на вопросы , как , что , когда делают многопроцессорной обработки , хотя решение было использовать менее параллельные процессы в моем случае.

Вот, например, наиболее определение обижая, есть много промежуточных шаги, которые сохраняются, так что код не затемненные и некоторые из них повторно позже тоже.

def demosaicing_CFA_Bayer_Menon2007(CFA, pattern='RGGB', refining_step=True):
    CFA = np.asarray(CFA)
    R_m, G_m, B_m = masks_CFA_Bayer(CFA.shape, pattern)

    h_0 = np.array([0, 0.5, 0, 0.5, 0])
    h_1 = np.array([-0.25, 0, 0.5, 0, -0.25])

    R = CFA * R_m
    G = CFA * G_m
    B = CFA * B_m

    G_H = np.where(G_m == 0, _cnv_h(CFA, h_0) + _cnv_h(CFA, h_1), G)
    G_V = np.where(G_m == 0, _cnv_v(CFA, h_0) + _cnv_v(CFA, h_1), G)

    C_H = np.where(R_m == 1, R - G_H, 0)
    C_H = np.where(B_m == 1, B - G_H, C_H)

    C_V = np.where(R_m == 1, R - G_V, 0)
    C_V = np.where(B_m == 1, B - G_V, C_V)

    D_H = np.abs(C_H - np.pad(C_H, ((0, 0), (0, 2)),
                            mode=str('reflect'))[:, 2:])
    D_V = np.abs(C_V - np.pad(C_V, ((0, 2), (0, 0)),
                            mode=str('reflect'))[2:, :])

    k = np.array(
        [[0, 0, 1, 0, 1],
        [0, 0, 0, 1, 0],
        [0, 0, 3, 0, 3],
        [0, 0, 0, 1, 0],
        [0, 0, 1, 0, 1]])  # yapf: disable

    d_H = convolve(D_H, k, mode='constant')
    d_V = convolve(D_V, np.transpose(k), mode='constant')

    mask = d_V >= d_H
    G = np.where(mask, G_H, G_V)
    M = np.where(mask, 1, 0)

    # Red rows.
    R_r = np.transpose(np.any(R_m == 1, axis=1)[np.newaxis]) * np.ones(R.shape)
    # Blue rows.
    B_r = np.transpose(np.any(B_m == 1, axis=1)[np.newaxis]) * np.ones(B.shape)

    k_b = np.array([0.5, 0, 0.5])

    R = np.where(
        np.logical_and(G_m == 1, R_r == 1),
        G + _cnv_h(R, k_b) - _cnv_h(G, k_b), R)

    R = np.where(
        np.logical_and(G_m == 1, B_r == 1) == 1,
        G + _cnv_v(R, k_b) - _cnv_v(G, k_b), R)

    B = np.where(
        np.logical_and(G_m == 1, B_r == 1),
        G + _cnv_h(B, k_b) - _cnv_h(G, k_b), B)

    B = np.where(
        np.logical_and(G_m == 1, R_r == 1) == 1,
        G + _cnv_v(B, k_b) - _cnv_v(G, k_b), B)

    R = np.where(
        np.logical_and(B_r == 1, B_m == 1),
        np.where(M == 1, B + _cnv_h(R, k_b) - _cnv_h(B, k_b),
                B + _cnv_v(R, k_b) - _cnv_v(B, k_b)), R)

    B = np.where(
        np.logical_and(R_r == 1, R_m == 1),
        np.where(M == 1, R + _cnv_h(B, k_b) - _cnv_h(R, k_b),
                R + _cnv_v(B, k_b) - _cnv_v(R, k_b)), B)

    RGB = tstack((R, G, B))

    if refining_step:
        RGB = refining_step_Menon2007(RGB, tstack((R_m, G_m, B_m)), M)

    return RGB

Пользователь предложил PR , где переменная промежуточные шаги удаляются , как процесс идет и вывоз мусора принудительно запрашивается. Я никогда не ходил по этому пути , потому что сам я считаю , что unelegant и когда вы начинаете делать , что трудно провести линию о том, где остановиться. В любом случае, я хотел бы, что поведение будет неавтоматическим также как принуждение сбора мусора может ввести другие проблемы с производительностью.

Учитывая вышесказанное, я хочу знать, если есть альтернативы не делать это, и если нет, если есть способ, чтобы написать функцию, которая будет заботиться о делеции и сборке мусора в одном кадре. Единственный удар я вижу, это удаление переменных из их родительской области, которая, вероятно, достижима с помощью интроспекции.

Задан 07/11/2018 в 19:55
источник пользователем
На других языках...                            

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more