7.7. Normalização#

ml.Model.predict() aceita uma lista de entradas porque algumas redes têm mais de um tensor de entrada, mas a lista não tem forma de transportar argumentos por entrada em linha – não existe nenhum slot kwarg para «recortar esta entrada a (x, y, w, h) mas deixar as outras entradas em paz». ml.preprocessing.Normalization é o wrapper que preenche essa lacuna. Uma instância de Normalization contém os parâmetros para uma entrada; o script passa a entrada envolvida na lista do predict sempre que necessita de algo diferente dos valores predefinidos.

A razão mais comum para o utilizar é recortar uma região específica do fotograma capturado para a rede em vez da imagem inteira.

7.7.1. Parâmetros#

Normalization(scale=(0.0, 1.0),
              mean=(0.0, 0.0, 0.0),
              stdev=(1.0, 1.0, 1.0),
              roi=None)

roi – retângulo (x, y, w, h) no fotograma de origem a recortar antes do redimensionamento. Por omissão, corresponde ao fotograma inteiro. A maioria das utilizações de Normalization define apenas este parâmetro.
scale – o intervalo (min, max) que os tensores de entrada em ponto flutuante esperam após a normalização. O intervalo de pixel 0..255 é mapeado linearmente para este intervalo. Valores comuns são (0.0, 1.0) para redes treinadas com ReLU e (-1.0, 1.0) para redes normalizadas simetricamente.
mean – média (R, G, B) por canal subtraída à imagem após o escalonamento. Corresponde às estatísticas de canal utilizadas no treino da rede – (0.485, 0.456, 0.406) para redes derivadas do ImageNet é o exemplo canónico. As redes em escala de cinzentos reduzem a média para um valor de luminância usando o padrão 0.299*R + 0.587*G + 0.114*B.
stdev – desvio padrão (R, G, B) por canal pelo qual a imagem é dividida após a subtração da média, correspondendo igualmente às estatísticas de treino da rede. Reduzido para luminância da mesma forma para redes em escala de cinzentos.

7.7.2. Quando os parâmetros são relevantes#

scale, mean e stdev são ignorados quando o input_dtype da rede é int8 ou uint8. Para redes com entrada inteira, os bytes da imagem recortada são escritos diretamente no tensor e o input_scale e o input_zero_point da rede tratam da conversão de inteiro para real. Os três parâmetros só são relevantes quando a rede espera entrada em ponto flutuante.

roi é lido em todos os casos – controla qual a parte do fotograma de origem que chega à rede, independentemente do dtype de entrada.

7.7.3. ROI e redimensionamento#

O ROI é escalado bilinearmente das suas dimensões de origem para as dimensões de entrada da rede. A imagem é centrada no destino e o escalonamento preenche o destino – não preserva a proporção da imagem. Um ROI não quadrado alimentado a uma entrada de rede quadrada fica esticado horizontal ou verticalmente.

Se o esticamento é relevante depende da rede. Os modelos de deteção facial e de pontos de referência como a família MediaPipe (BlazeFace, FaceLandmarks, HandLandmarks, MoveNet) foram treinados com recortes quadrados e degradam rapidamente quando a proporção da entrada está incorreta; para estes, a aplicação precisa de lhes fornecer um ROI quadrado – seja capturando numa resolução quadrada através de window() ou recortando com o parâmetro roi=. Os detetores de objetos da família YOLO são tipicamente treinados com aumentação que inclui esticamentos aleatórios e aceitam ROIs não quadrados sem grande perda de precisão; passar o fotograma capturado inteiro diretamente costuma funcionar bem.

Quando as dimensões de entrada da rede correspondem exatamente ao ROI, o escalonamento colapsa para uma cópia, que é o caso mais económico.

7.7.4. Substituir o valor predefinido#

predict() envolve automaticamente cada entrada image.Image com Normalization() – os parâmetros predefinidos acima. A maioria dos modelos que acompanham a câmara foram treinados contra intervalos de pixel que os valores predefinidos já cobrem, pelo que o caso comum é passar a imagem diretamente:

result = model.predict([img])

Para utilizar um ROI personalizado – a substituição mais comum – construa uma Normalization com o ROI definido e associe a imagem a ela:

from ml.preprocessing import Normalization

norm = Normalization(roi=(80, 60, 160, 120))
result = model.predict([norm(img)])

Para corresponder às estatísticas de canal em tempo de treino de uma rede, defina os parâmetros em ponto flutuante:

norm = Normalization(scale=(0.0, 1.0),
                     mean=(0.485, 0.456, 0.406),
                     stdev=(0.229, 0.224, 0.225))

result = model.predict([norm(img)])

Chamar a instância Normalization sobre a imagem devolve uma nova instância associada a partir da qual o motor preenche o tensor. A instância associada é o que o predict aceita em vez da imagem bruta e, como é um objeto por entrada, uma rede com múltiplas entradas pode misturar imagens com ROIs diferentes na mesma lista do predict.

Para redes que esperam entradas que a aplicação já produziu em forma de tensor – um buffer de um periférico, um ndarray calculado por outra pipeline, dados numéricos não-imagem – ignore Normalization inteiramente e passe o ndarray ou um callable que o produza. predict() passa esses diretamente para o motor sem os envolver.