No último texto sobre programação, demos os primeiros passos na utilização do módulo multiprocessing, que permite a execução paralela de código em Python. Neste post iremos estudar mais a fundo as funcionalidades deste módulo usando como exemplo um pequeno programa de detecção de bordas em imagens.
Imagens digitais são normalmente representadas utilizando matrizes, onde a posição $(i, j)$ contém a "cor" presente no pixel correspondente da imagem. Neste texto trataremos somente de imagens em níveis de cinza. Portanto, nossas imagens serão matrizes de inteiros entre $0$ (preto) e $255$ (branco). O gradiente morfológico é uma operação muito simples que realça as bordas de uma imagem, seja ela binária ou em níveis de cinza. Para cada ponto da imagem de saída, analisamos os valores presentes em uma vizinhança de tamanho $3\times 3$ ao seu redor. O valor de saída é a diferença entre o pixel de maior valor e o de menor valor.
O código abaixo calcula o gradiente morfológico sequencialmente e mostra a imagem resultado.
%matplotlib inline
import numpy as np
import scipy as sp
import scipy.ndimage
import time
import matplotlib.pyplot as plt
def morpho_gradient(img, out, p):
pi, pj = p
minv = 255
maxv = 0
for i in range(-1, 2):
for j in range(-1, 2):
if img[pi+i, pj+j] < minv:
minv = img[pi+i, pj+j]
if img[pi+i, pj+j] > maxv:
maxv = img[pi+i, pj+j]
out[pi, pj] = maxv - minv
def versao_serial(img):
out = np.zeros(img.shape, img.dtype)
for i in range(1, img.shape[0]-1):
for j in range(1, img.shape[1]-1):
morpho_gradient(img, out, (i, j))
return out
img = sp.misc.lena()
start = time.clock()
out = versao_serial(img)
print('Versao serial:', time.clock() - start)
plt.figure(figsize=(10, 10))
plt.subplot(121)
plt.gray()
plt.imshow(img)
plt.subplot(122)
plt.gray()
plt.imshow(out)
Seguindo a nossa receita anterior, podemos paralelizar os dois for da versao_serial. Para facilitar a passagem de argumentos para nossa função iremos usar os módulos functools e itertools.
Como vimos anteriormente, a função chamada pelo Pool.map só recebe um argumento. Podemos usar a função partial do módulo functools para criar uma versão de morpho_gradient cujos parâmetros img e out são fixos. A função chama-se partial pois ela aplica parcialmente a função.
Para criar a lista de pontos a serem processados usamos o módulo itertools, que permite criar diversos tipos de iteradores. No nosso caso, queremos o produto cartesiano entre os pontos horizontais e verticais da imagem. A função itertools.product realiza exatamente este trabalho. Este módulo contém diversas funções úteis e vale a pena uma olhada na documentação para conhecê-lo melhor.
A nossa primeira tentativa de paralelização está abaixo.
import multiprocessing as mp
import functools
import itertools
def versao_paralela(img):
out = np.zeros(img.shape, img.dtype)
p = mp.Pool()
pi = range(1, img.shape[0]-1)
pj = range(1, img.shape[1]-1)
point_list = itertools.product(pi, pj)
par = functools.partial(morpho_gradient, img, out)
p.map(par, point_list)
p.close()
p.join()
return out
start = time.clock()
out2 = versao_paralela(img)
print('Versao paralela:', time.clock() - start)
plt.figure(figsize=(10, 10))
plt.subplot(121)
plt.gray()
plt.imshow(img)
plt.subplot(122)
plt.gray()
plt.imshow(out)
Surpreendentemente (ou não), esta versão não é muito mais rápida que a serial e dependendo do ambiente de execução pode ser até mais lenta. A razão disto é que, da mesma maneira do exemplo anterior, fazemos uma cópia de img e out para cada processo do Pool. No exemplo anterior, cada elemento da lista era diferente e esta cópia realmente é necessária, mas neste caso todos os processos leem img e cada processo escreve em uma posição $(i,j)$ diferente de out.
Objetos "normais" de Python, como listas, dicionários e até arrays do Numpy, não são "compartilháveis" automaticamente. Todo objeto contém informações específicas do processo em que foram criadas e que podem se tornar inválidas se manipuladas paralelamente por outros processos. É preciso, portanto, utilizar versões destes objetos que suportem a utilização por mais de um processo.
O módulo multiprocessing.sharedctypes contém, basicamente, dois tipos de objetos com nomes bastante descritivos: Array e Value. Quando criamos um objeto destes tipos alocamos sua memória em uma área especial que pode ser acessada por mais de um processo ao mesmo tempo. Porém, é necessário especificar o tipo dos objetos armazenados e, para o Array, o número de elementos desejados. Também é necessário deletá-los manualmente. Ou seja, é praticamente uma chamada às funções malloc()/free() usadas em C.
A utilização de memória compartilhada deixa o código um pouco mais longo, mas as mudanças são mais mecânicas que complexas. Primeiramente, precisamos copiar nossas imagens para a memória compartilhada (variáveis img_shared e out_shared) e criar uma nova função morpho_grad_map que cria arrays do numpy utilizando a memória compartilhada que alocamos para então chamar morpho_gradient. Note que usamos variáveis globais chamadas img e out em morpho_grad_map. Essas variáveis globais são criadas na função init_pool, que é chamada ao inicializar cada processo do Pool e que recebe as nossas variáveis compartilhadas img_shared e out_shared. As variáveis globais só existem nos processo do Pool e não irão vazar para processo principal que estamos executando. Desta maneira, todos os processos contém uma referência à nossa área de memória compartilhada e evitamos copiar dados entre os processos.
Novamente, o código da versão paralela2 está abaixo.
import multiprocessing.sharedctypes
from ctypes import c_int32
def morpho_grad_map(p):
img_np = np.frombuffer(img, dtype=np.int32).reshape(shape)
out_np = np.frombuffer(out, dtype=np.int32).reshape(shape)
morpho_gradient(img_np, out_np, p)
def init_pool(img_shared, out_shared, shape_):
global img, out, shape
img = img_shared
out = out_shared
shape = shape_
def versao_paralela2(img):
out_shared = mp.sharedctypes.RawArray(c_int32, np.zeros(img.shape, np.int32).flat)
img_shared = mp.sharedctypes.RawArray(c_int32, img.flat)
p = mp.Pool(initializer=init_pool, initargs=(img_shared, out_shared, img.shape))
pi = range(1, img.shape[0]-1)
pj = range(1, img.shape[1]-1)
point_list = itertools.product(pi, pj)
p.map(morpho_grad_map, point_list)
p.close()
p.join()
out_np = np.zeros(img.shape, np.int32)
out_np.flat[:] = out_shared # usar um view aqui para copiar os dados
del img_shared
del out_shared
return out_np
start = time.clock()
out2 = versao_paralela2(img)
print('Versao paralela 2:', time.clock() - start)
plt.figure(figsize=(10, 10))
plt.subplot(121)
plt.gray()
plt.imshow(img)
plt.subplot(122)
plt.gray()
plt.imshow(out)
Os ganhos de desempenho desta versão são significativos e mostram a capacidade do módulo multiprocessing em acelerar nosso código. Os benefícios da computação paralela, porém, não são exatamente proporcionais ao número de processadores usados e muitas vezes um código paralelo que funciona bem em um sistema pode não ser tão eficiente em outros. Por exemplo, ao rodar este post em um computador com 4 processadores a diferença entre as duas versões paralelas foi bem menor, pois o tempo gasto para criar 4 cópias é menor que o tempo necessário para criar 24.
É importante notar, porém, que usar memória compartilhada é um trabalho mais delicado. No nosso caso cada processo usou uma matriz somente leitura e escreveu em uma posição diferente da matriz de saída. Esta condição não é sempre verdadeira. Nos próximos textos veremos como utilizar travas para compartilhar objetos em situações em que pode haver conflito entre os processos.
