Huawei acaba de lançar P30 "telescópio" O telefone pode ser dezenas de metros para os nomes na foto ao ar livre no Eifel, de fato admirável, mas seu preço é proibitivo. Portanto, não comprar celular Huawei, SLR de alto nível para disparar menos de detalhes de imagem de alta definição ainda?
A câmera não é suficiente algoritmo compacto, tem um super capacidade de tirar fotos do telefone não pode fazer sem a bênção do algoritmo. Este artigo descreve os imagem de super-resolução projetos pode ajudá-lo preenchido bordo lente da câmera curto.
conferência P30 Huawei mostrado na torre Eiffel HD fotos de longa distância.
Hoje, um usuário do Reddit postou seus projetos de super-resolução de imagem com base Keras, depois de deixar para ampliar a imagem ainda está claro. Primeiro, olhe para os resultados.
Depois fotografias significativamente ampliadas de borboletas (traças?) Ainda sem distorção, a parte de trás das vilosidades claramente visível.
Autores disse que o projeto visa melhorar a qualidade das imagens de baixa resolução, tornando-se um novo visual. Usando esta ferramenta pode ser super dimensionamento da imagem, mas também facilmente na RDN e GAN para experimentar diante.
O projecto Keras residual compreende uma rede densa de implementações diferentes, eles podem ser utilizados imagem de super-resolução único eficiente (ISR) para. O autor também fornece uma variedade de documentação para ajudar a treinar o modelo, incluindo como usar essas redes contra a perda de componentes de formação.
Os exemplos de projectos
O factor de amplificação (factor de aumento de escala) usado no Exemplo 2, isto é, o triplo do número de pixels. Podemos ver no exemplo de uma imagem gerada em peso sample_weights, eles são armazenados em lfs git. Para baixar esses pesos, você precisa copiar o repo, e depois executar git pull LFS.
Da esquerda para a imagem de baixa resolução original, a saída do gráfico intermédio da rede, da direita é o modelo da linha de base utilizando o GIMP escala bicúbica obtido resultado amplificado.
A seguir, são diferentes métodos de ação em contraste com o efeito do ruído de imagem, estes métodos são: uso bicubic escalar o modelo de linha de base, usando a rede RDN função treinando nível de pixel perda de conteúdo, eo uso de VGG 19 conteúdo comprimido conjunto de dados e as funções de perda de reciclagem. rede RDN. A repo contém grande peso destes modelos.
Bicubic up-scaling (modelo de base) de uma amostra de saída.
O nível de pixel de saída usando o conteúdo das amostras da função perda treinados rede RDN.
O exemplo de saída usa conteúdo e formação componentes VGG contra a perda de rede RDN.
Que projetos de super-resolução
Show na frente do efeito de super-resolução é feita de diferentes modelos de acordo com a implementação do projeto. Super-resolução reconstruída detalhe de imagem de eliminação desejado de acordo com a informação da imagem existente, que é normalmente, por meio de uma rede neural convolucional dizimados informação de imagem, e, em seguida, estender estes resolução convolução informação desejada para a imagem obtida pela transposição.
Neste projeto, um monte de novas funcionalidades e módulos, como o uso de VGG e GAN alcançar verdadeira ampliada da imagem. A implementação do projecto é RDN com a rede RRDN, além de fornecer pré-formação e pesos tutoriais Colab. Quer seja para treinamento ou inferir, com base nessas informações, podemos começar rapidamente.
Além disso, o projeto agora pode ser publicado para PyPI, que a instalação é também só comando pip tipo.
Em suma, o projeto atingir super-resolução três redes, eo uso de Keras versão VGG-19 como um módulo de extração de características. Correlação é mostrada abaixo a três redes de super-resolução:
-
Residual densa rede de Imagem Super-Resolution (Zhang et al 2018, arXiv:. 1.802,08797)
-
ESRGAN: Avançado Super-Resolution Generative Adversarial Networks (Wang et al 2018, arXiv:. 1.809,00219)
-
Photo-Realistic única imagem Super-Resolution Usando um Adversarial de rede Generative (SRGANS, Ledig et al 2017, arXiv:. 1.609,04802)
Se queremos gerar esse tipo de visão de alta definição do exposto, o projeto também oferece uma gama de recursos:
-
Documentação: https: //idealo.github.io/image-super-resolution/
-
Código: https: //github.com/idealo/image-super-resolution/
-
Colab Código inferir: https: //colab.research.google.com/github/idealo/image-super-resolution/blob/master/notebooks/ISR_Prediction_Tutorial.ipynb
-
Colab formação cupom: https: //colab.research.google.com/github/idealo/image-super-resolution/blob/master/notebooks/ISR_Traininig_Tutorial.ipynb
Como usar o projeto de super-resolução
Você pode escolher entre duas formas de instalar pacote de super-resolução da imagem (ISR).
instalação PyPI do ISR (recomendado):
pip install ISR
Montar a fonte ISR GitHub:
git clone https://github.com/idealo/image-super-resolution
cd image-super-resolution
python setup.py install
previsão
Se precisamos estender a imagem de baixa resolução, por meio de um ISR simples de duas etapas pode executar super-resolução. Primeiro, carregar a imagem e fazer algumas pré-transformação:
import numpy as npfrom PIL import Image
img = Image.open('data/input/test_images/sample_image.jpg')
lr_img = np.array(img)/255.
lr_img = np.expand_dims(lr_img, axis=0)
Carregar modelo de previsão e execução:
from ISR.models import RDN
rdn = RDN(arch_params={'C':6, 'D':20, 'G':64, 'G0':64, 'x':2})
rdn.model.load_weights('weights/rdn-C6-D20-G64-G064-x2_enhanced-e219.hdf5')
sr_img = rdn.model.predict(lr_img)[0]
sr_img = sr_img.clip(0, 1) * 255
sr_img = np.uint8(sr_img)
Image.fromarray(sr_img)
treinamento
Se você precisa usar seu conjunto de dados reciclagem modelo de super-resolução, então só precisamos modificá-lo para ler os parâmetros. Primeiro, crie o modelo da seguinte forma:
from ISR.models import RRDN
from ISR.models import Discriminator
from ISR.models import Cut_VGG19
lr_train_patch_size = 40
layers_to_extract = [5, 9]
scale = 2
hr_train_patch_size = lr_train_patch_size * scale
rrdn = RRDN(arch_params={'C':4, 'D':3, 'G':64, 'G0':64, 'T':10, 'x':scale}, patch_size=lr_train_patch_size)
f_ext = Cut_VGG19(patch_size=hr_train_patch_size, layers_to_extract=layers_to_extract)
discr = Discriminator(patch_size=hr_train_patch_size, kernel_size=3)
Trainer criar uma variedade de objetos, configuração e treinamento entregue ao objeto:
from ISR.train import Trainer
loss_weights = {
'generator': 0.0,
'feat_extr': 0.0833,
'discriminator': 0.01,
}
trainer = Trainer(
generator=rrdn,
discriminator=discr,
feature_extractor=f_ext,
lr_train_dir='low_res/training/images',
hr_train_dir='high_res/training/images',
lr_valid_dir='low_res/validation/images',
hr_valid_dir='high_res/validation/images',
loss_weights=loss_weights,
dataname='image_dataset',
logs_dir='./logs',
weights_dir='./weights',
weights_generator=None,
weights_discriminator=None,
n_validation=40,
lr_decay_frequency=30,
lr_decay_factor=0.5,
T=0.01,
)
formação inicial:
trainer.train(
epochs=80,
steps_per_epoch=500,
batch_size=16,
)
arquitetura de rede e hiperparâmetro
Na verdade, se nós precisamos de re-treinamento, você também precisa saber quais parâmetros específicos têm dito. Esta seção descreve a arquitetura e os parâmetros correspondentes da rede de super-super-resolução.
arquitetura de rede RDN
Os principais parâmetros RDN arquitetura de rede da seguinte forma:
-
D: bloqueio residual denso (RDB) Número
-
C: Número de camada interna convolucional empilhados RDB
-
L: número de característica dentro de cada convolução FIG camada RDB
A Fig. Fonte: https: //arxiv.org/abs/1802.08797
arquitetura de rede RRDN
Os principais parâmetros RRDN arquitetura são as seguintes:
-
T: o número de resíduos no bloco denso residual (o RRDB)
-
Cada número RRDB de bloco denso residual interna (RDB) é: D
-
C: Número de camada interna convolucional empilhados RDB
-
L: número de característica dentro de cada convolução FIG camada RDB
A Fig. Fonte: https: //arxiv.org/abs/1809.00219
