[PYTHON] Technologie de super-résolution-SRCNN-I a essayé de l'implémenter (Tensorflow 2.0) Phase de prédiction

Aperçu

Dans la continuité de la Dernière fois, c'est la phase de prédiction du SRCNN. En fait, j'ai essayé d'expliquer le code, mais je ne l'ai pas beaucoup expliqué. .. .. Donc, cette fois, je vais omettre l'explication du code. Il se termine après avoir montré le résultat de la super résolution. .. ..

Postscript

Après avoir reçu des conseils dans les commentaires et modifié partiellement le code [Attention (résolu)](https://qiita.com/hima_zin331/items/ebb6046a2a8d860254e1#%E6%B3%A8%E6%84%8F%E8 % A7% A3% E6% B1% BA% E6% B8% 88% E3% 81% BF) a été résolu. L'image du résultat de l'exécution a également été remplacée. De même, les programmes du référentiel Github ont été retravaillés.

environnement

-Software- Windows 10 Home Anaconda3 64-bit(Python3.7) Spyder -Library- Tensorflow 2.1.0 opencv-python 4.1.2.30 -Hardware- CPU: Intel core i9 9900K GPU: NVIDIA GeForce RTX2080ti RAM: 16GB 3200MHz

programme

Je le posterai sur Github. https://github.com/himazin331/Super-resolution-CNN Le référentiel contient une phase d'apprentissage, une phase de prédiction et un jeu de données (General-100).

Code source

Je ne mettrai que le code source. ** Veuillez noter que le code est sale ... **

srcnn_pre.py

import argparse as arg
import os
import sys

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #Masquer le message TF

import tensorflow as tf
import tensorflow.keras.layers as kl

import cv2
from PIL import Image
import matplotlib.pyplot as plt

import numpy as np

# SRCNN
class SRCNN(tf.keras.Model):

    def __init__(self, h, w):
        super(SRCNN, self).__init__()

        self.conv1 = kl.Conv2D(64, 3, padding='same', activation='relu', input_shape=(None, h, w, 3))
        self.conv2 = kl.Conv2D(32, 3, padding='same', activation='relu')
        self.conv3 = kl.Conv2D(3, 3, padding='same', activation='relu')

    def call(self, x):
        
        h1 = self.conv1(x)
        h2 = self.conv2(h1)
        h3 = self.conv3(h2)

        return h3
    
def main():
    
    #Créer des options de ligne de commande
    parser = arg.ArgumentParser(description='Super-resolution CNN prediction')
    parser.add_argument('--param', '-p', type=str, default=None,
                        help='Spécification des paramètres appris(Erreur si non spécifié)')    
    parser.add_argument('--data_img', '-d', type=str, default=None,
                        help='Spécifier un fichier image(Erreur si non spécifié)')
    parser.add_argument('--out', '-o', type=str, default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "result"),
                        help='Spécifiez la destination d'enregistrement(Valeur par défaut=./result)')                        
    parser.add_argument('--he', '-he', type=int, default=256,
                        help='Redimensionner la spécification de hauteur(Valeur par défaut=256)')      
    parser.add_argument('--wi', '-wi', type=int, default=256,
                        help='Spécifier le redimensionnement(Valeur par défaut=256)')
    parser.add_argument('--mag', '-m', type=int, default=2,
                        help='Spécifier le taux de réduction(Valeur par défaut=2)')                           
    args = parser.parse_args()

    #Lorsque le fichier de paramètres n'est pas spécifié->exception
    if args.param == None:
        print("\nException: Trained Parameter-File not specified.\n")
        sys.exit()
    #Lorsqu'un fichier de paramètres inexistant est spécifié->exception
    if os.path.exists(args.param) != True:
        print("\nException: Trained Parameter-File {} is not found.\n".format(args.param))
        sys.exit()
    #Lorsqu'aucun fichier image n'est spécifié->exception
    if args.data_img == None:
        print("\nException: Image not specified.\n")
        sys.exit()
    #Lorsqu'un fichier image inexistant est spécifié->exception
    if os.path.exists(args.data_img) != True:
        print("\nException: Image {} is not found.\n".format(args.data_img))
        sys.exit()
    #Lorsque 0 est entré dans la hauteur de la largeur ou le grossissement de réduction->exception
    if args.he == 0 or args.wi == 0 or args.mag == 0:
        print("\nException: Invalid value has been entered.\n")
        sys.exit()

    #Réglage de la sortie des informations
    print("=== Setting information ===")
    print("# Trained Prameter-File: {}".format(os.path.abspath(args.param)))
    print("# Image: {}".format(args.data_img))
    print("# Output folder: {}".format(args.out))
    print("")
    print("# Height: {}".format(args.he))
    print("# Width: {}".format(args.wi))
    print("# Magnification: {}".format(args.mag))
    print("===========================")

    #Créer un dossier de sortie(Ne pas créer si le dossier existe)
    os.makedirs(args.out, exist_ok=True)

    #Construction de modèles
    model = SRCNN(args.he, args.wi)
    model.build((None, args.he, args.wi, 3))
    model.load_weights(args.param)

    #Traitement d'image d'entrée(Image haute résolution)
    img = cv2.imread(args.data_img)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    hr_img = cv2.resize(img, (args.he, args.wi))

    #Création d'images en basse résolution
    lr_img = cv2.resize(hr_img, (int(args.he/args.mag), int(args.wi/args.mag)))
    lr_img = cv2.resize(lr_img, (args.he, args.wi))
    lr_img_s = lr_img

    #Normalisation
    lr_img = tf.convert_to_tensor(lr_img, np.float32)
    lr_img /= 255.0
    lr_img = lr_img[np.newaxis, :, :, :]

    #Super résolution
    re = model.predict(lr_img)

    #Traitement de l'information
    re = np.reshape(re, (args.he, args.wi, 3))
    re *= 255
    re = np.clip(re, 0.0, 255.0) #coupure(0~Arrondir à 255)

    #Stockage d'images basse résolution
    lr_img = Image.fromarray(np.uint8(lr_img_s))
    lr_img.show()
    lr_img.save(os.path.join(args.out, "Low-resolution Image(SRCNN).bmp"))

    #Stockage d'images en super résolution
    sr_img = Image.fromarray(np.uint8(re))
    sr_img.show()
    sr_img.save(os.path.join(args.out, "Super-resolution Image(SRCNN).bmp"))

    #Stockage d'images haute résolution
    hr_img = Image.fromarray(np.uint8(hr_img))
    hr_img.show()
    hr_img.save(os.path.join(args.out, "High-resolution Image(SRCNN).bmp"))

if __name__ == "__main__":
    main()

Attention (résolu)

Dans le code

    re *= 240 #Si elle est de 255, la sortie sera anormale.

Il existe un tel processus. re est le résultat de model.predict (), c'est-à-dire une image en super-résolution. D'un autre côté, je pense que la bonne réponse est de multiplier la valeur du pixel de 0 à 1 par 255 et de la changer en 0 à 255, mais si vous multipliez par 255, les informations de couleur seront corrompues (?) Comme le montre l'image ci-dessous. Je vais. Je ne sais pas pourquoi cela se produit, mais si quelqu'un le sait, faites-le moi savoir dans les commentaires. Puisqu'elle est multipliée par 240 au lieu de 255, la couleur est un peu plus foncée que l'original.

Résultat d'exécution

Ceci est le résultat de 3000 numéros d'époque. J'ai utilisé le General-100 pour les données d'entraînement.

** Résultat du grossissement 2 **

La résolution est si élevée qu'elle est presque impossible à distinguer d'une image haute résolution.

** Résultat du grossissement 4 **

Si la résolution est si faible, des informations détaillées seront perdues.

en conclusion

J'ai essayé d'augmenter la résolution des images basse résolution en utilisant SRCNN, une technologie de super-résolution. Comme je l'ai mentionné au début de la dernière fois, j'ai également implémenté SRGAN en plus du SRCNN. Je vais le résumer un jour.