[PYTHON] Super-Resolution-Technologie-SRCNN-I hat versucht, diese (Tensorflow 2.0) Vorhersagephase zu implementieren

Überblick

Fortsetzung von Letztes Mal ist dies die Vorhersagephase von SRCNN. Eigentlich habe ich versucht, den Code zu erklären, aber ich habe ihn nicht so oft erklärt. .. .. Diesmal werde ich also die Erklärung des Codes weglassen. Es endet, nachdem das Ergebnis der Superauflösung angezeigt wurde. .. ..

Nachtrag

Nachdem Sie in den Kommentaren Ratschläge erhalten und den Code teilweise geändert haben [Achtung (gelöst)](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) wurde behoben. Das Bild des Ausführungsergebnisses wurde ebenfalls ersetzt. Ebenso wurden die Programme im Github-Repository überarbeitet.

Umgebung

-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

Programm

Ich werde es auf Github posten. https://github.com/himazin331/Super-resolution-CNN Das Repository enthält eine Lernphase, eine Vorhersagephase und einen Datensatz (General-100).

Quellcode

Ich werde nur den Quellcode setzen. ** Bitte beachten Sie, dass der Code verschmutzt ist ... **

srcnn_pre.py


import argparse as arg
import os
import sys

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' #TF-Nachricht ausblenden

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():
    
    #Erstellen Sie Befehlszeilenoptionen
    parser = arg.ArgumentParser(description='Super-resolution CNN prediction')
    parser.add_argument('--param', '-p', type=str, default=None,
                        help='Gelernte Parameter angeben(Fehler, wenn nicht angegeben)')    
    parser.add_argument('--data_img', '-d', type=str, default=None,
                        help='Angeben einer Bilddatei(Fehler, wenn nicht angegeben)')
    parser.add_argument('--out', '-o', type=str, default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "result"),
                        help='Geben Sie das Speicherziel an(Standardwert=./result)')                        
    parser.add_argument('--he', '-he', type=int, default=256,
                        help='Ändern Sie die Größenangabe(Standardwert=256)')      
    parser.add_argument('--wi', '-wi', type=int, default=256,
                        help='Geben Sie die Größenänderung an(Standardwert=256)')
    parser.add_argument('--mag', '-m', type=int, default=2,
                        help='Angabe des Untersetzungsverhältnisses(Standardwert=2)')                           
    args = parser.parse_args()

    #Wenn keine Parameterdatei angegeben ist->Ausnahme
    if args.param == None:
        print("\nException: Trained Parameter-File not specified.\n")
        sys.exit()
    #Wenn eine nicht vorhandene Parameterdatei angegeben wird->Ausnahme
    if os.path.exists(args.param) != True:
        print("\nException: Trained Parameter-File {} is not found.\n".format(args.param))
        sys.exit()
    #Wenn keine Bilddatei angegeben ist->Ausnahme
    if args.data_img == None:
        print("\nException: Image not specified.\n")
        sys.exit()
    #Wenn eine nicht vorhandene Bilddatei angegeben wird->Ausnahme
    if os.path.exists(args.data_img) != True:
        print("\nException: Image {} is not found.\n".format(args.data_img))
        sys.exit()
    #Wenn 0 entweder in der Breitenhöhe oder in der Verkleinerungsvergrößerung eingegeben wird->Ausnahme
    if args.he == 0 or args.wi == 0 or args.mag == 0:
        print("\nException: Invalid value has been entered.\n")
        sys.exit()

    #Informationsausgabe einstellen
    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("===========================")

    #Ausgabeordner erstellen(Nicht erstellen, wenn der Ordner vorhanden ist)
    os.makedirs(args.out, exist_ok=True)

    #Modellbau
    model = SRCNN(args.he, args.wi)
    model.build((None, args.he, args.wi, 3))
    model.load_weights(args.param)

    #Eingabebildverarbeitung(Hochauflösendes Bild)
    img = cv2.imread(args.data_img)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    hr_img = cv2.resize(img, (args.he, args.wi))

    #Bilderzeugung mit niedriger Auflösung
    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

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

    #Super Auflösung
    re = model.predict(lr_img)

    #Datenverarbeitung
    re = np.reshape(re, (args.he, args.wi, 3))
    re *= 255
    re = np.clip(re, 0.0, 255.0) #Ausschnitt(0~Runde auf 255)

    #Bildspeicher mit niedriger Auflösung
    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"))

    #Bildspeicher mit hoher Auflösung
    sr_img = Image.fromarray(np.uint8(re))
    sr_img.show()
    sr_img.save(os.path.join(args.out, "Super-resolution Image(SRCNN).bmp"))

    #Hochauflösender Bildspeicher
    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()

Achtung (gelöst)

Im Code

    re *= 240 #Wenn es 255 ist, ist die Ausgabe abnormal.

Es gibt einen solchen Prozess. re ist das Ergebnis von model.predict (), dh einem hochauflösenden Bild. Andererseits denke ich, dass die richtige Antwort darin besteht, den Pixelwert von 0 auf 1 mit 255 zu multiplizieren und auf 0 bis 255 zu ändern. Wenn Sie jedoch mit 255 multiplizieren, werden die Farbinformationen verfälscht (?) Wie in der folgenden Abbildung gezeigt. Ich werde. Ich weiß nicht, warum das passiert, aber wenn jemand es weiß, lass es mich bitte in den Kommentaren wissen. Da es mit 240 statt 255 multipliziert wird, ist die Farbe etwas dunkler als das Original.

image.png

Ausführungsergebnis

Dies ist das Ergebnis von 3000 Epochennummern. Ich habe General-100 für Trainingsdaten verwendet.

** Ergebnis der Vergrößerung 2 ** image.png

Die Auflösung ist so hoch, dass sie von einem hochauflösenden Bild kaum zu unterscheiden ist.

** Ergebnis der Vergrößerung 4 ** image.png

Wenn die Auflösung so niedrig ist, gehen detaillierte Informationen verloren.

abschließend

Ich habe versucht, die Auflösung von Bildern mit niedriger Auflösung mithilfe von SRCNN, einer hochauflösenden Technologie, zu erhöhen. Wie ich zu Beginn des letzten Males erwähnt habe, habe ich neben SRCNN auch SRGAN implementiert. Ich werde es eines Tages zusammenfassen.

Recommended Posts

Super-Resolution-Technologie-SRCNN-I hat versucht, diese (Tensorflow 2.0) Vorhersagephase zu implementieren
Super-Resolution-Technologie-SRCNN-I hat versucht, sie zu implementieren (Tensorflow 2.0) Lernphase
Sprachvorhersagemodell von TensorFlow