هوش مصنوعی | متن کامل رایگان | تک تصویر با وضوح فوق العاده با استفاده از یادگیری عمیق باقی مانده

پیوست اول

کد TensorFlow که مدل را ایجاد، آموزش و آزمایش می کند در اینجا فهرست شده است:

###################################

#### واردات کتابخانه ها #####

###################################

numpy را به عنوان np وارد کنید

وارد کردن tensorflow به عنوان tf

واردات سخت

وارد کردن cv2

از keras.models import Sequential

از tensorflow.keras.utils img_to_array را وارد می کند

از skimage.metrics structural_similarity را به عنوان ssim وارد می کند

واردات ریاضی

ما را وارد کنید

از واردات tqdm tqdm

واردات مجدد

matplotlib.pyplot را به صورت plt وارد کنید

از درایو واردات google.colab

drive.mount('/content/gdrive')

###############################

##### مدیریت فایل ها #####

###############################

def sorted_alphanumeric(data):

تبدیل = متن لامبدا: int(text) if text.isdigit() else text.lower()

alphanum_key = کلید لامبدا: [convert(c) for c in re.split(’([۰-۹]+)'،

کلید)]

برگرداندن مرتب شده (داده، کلید = کلید_الفانی)

# تعیین اندازه تصویر

سایز = ۲۵۶

height_img = []

#os.makedirs('gdrive/MyDrive/TMU/Neural_Networks/Project/kaggle/

داده خام/high_res'، exist_ok=True)

path = 'gdrive/MyDrive/TMU/Neural_Networks/Project/kaggle/

داده های خام/با وضوح بالا

files = os.listdir (مسیر)

فایل ها = sorted_alphanumeric (فایل ها)

برای i در فایل های tqdm:

if i == '855.jpg':

زنگ تفریح

در غیر این صورت:

img = cv2.imread(مسیر + '/'+i,1)

# open cv تصاویر را با فرمت BGR می خواند بنابراین باید آن را به آن تبدیل کنیم

RGB

img = cv2.cvtColor(img، cv2.COLOR_BGR2RGB)

#تغییر اندازه تصویر

img = cv2.resize(img، (SIZE، SIZE))

img = img.atype('float32') / 255.0

high_img.append(img_to_array(img))

low_img = []

path = 'gdrive/MyDrive/TMU/Neural_Networks/Project/kaggle/Raw Data/low_res'

files = os.listdir (مسیر)

فایل ها = sorted_alphanumeric (فایل ها)

برای i در فایل های tqdm:

if i == '855.jpg':

زنگ تفریح

در غیر این صورت:

img = cv2.imread(مسیر + '/'+i,1)

#تغییر اندازه تصویر

img = cv2.resize(img، (SIZE، SIZE))

img = img.atype('float32') / 255.0

low_img.append(img_to_array(img))

#################################

##### تجسم داده ها #####

#################################

برای i در محدوده (۴):

a = np.random.randint(0,855)

plt.figure(figsize=(10,10))

plt.subplot(1،۲،۱)

plt.title('تصویر با وضوح بالا'، رنگ = 'سبز'، فونت = ۲۰)

plt.imshow(high_img[a])

plt.axis ('خاموش')

plt.subplot(1،۲،۲)

plt.title('تصویر با وضوح پایین'، رنگ = 'سیاه'، اندازه قلم = ۲۰)

plt.imshow(low_img[a])

plt.axis ('خاموش')

###############################

##### تغییر شکل داده ها #####

###############################

train_high_image = high_img[:700]

train_low_image = low_img[:700]

train_high_image = np.reshape(train_high_image,

len(train_high_image),SIZE,SIZE,3))

train_low_image = np.reshape(train_low_image,(len(train_low_image),

SIZE, SIZE, 3))

validation_high_image = high_img[700:830]

validation_low_image = low_img[700:830]

validation_high_image = np.reshape(validation_high_image,

(لنز(تصویر_بالا_تأیید)،SIZE،SIZE،۳))

validation_low_image = np.reshape(validation_low_image,

(len(validation_low_image),SIZE,SIZE,3))

test_high_image = high_img[830:]

test_low_image = low_img[830:]

test_high_image= np.reshape(test_high_image,(len(test_high_image),

SIZE, SIZE, 3))

test_low_image = np.reshape(test_low_image,(len(test_low_image),

SIZE, SIZE, 3))

print("شکل تصاویر آموزشی:",train_high_image.shape)

print("شکل تصاویر آزمایشی:",test_high_image.shape)

print("شکل تصاویر اعتبارسنجی:",validation_high_image.shape)

##############################

##### تعریف مدل #####

##############################

از لایه های وارداتی keras

def down (فیلترها، kernel_size، application_batch_normalization = True):

downsample = tf.keras.models.Sequential()

downsample.add(layers.Conv2D(فیلترها، اندازه_kernel، padding = 'همان'،

گام = ۲))

اگر apply_batch_normalization:

downsample.add(layers.BatchNormalization())

downsample.add(keras.layers.LeakyReLU())

نمونه پایین را برگردانید

def up (فیلترها، kernel_size، dropout = False):

upsample = tf.keras.models.Sequential()

upsample.add(layers.Conv2DTranspose(فیلترها، kernel_size،

padding = 'همان'، گام = ۲))

در صورت ترک تحصیل:

upsample.dropout(0.2)

upsample.add(keras.layers.LeakyReLU())

برگرداندن نمونه

مدل def():

ورودی ها = لایه ها. ورودی(شکل= [SIZE,SIZE,3])

d1 = پایین (۱۲۸، (۳،۳)، نادرست (ورودی)

d2 = پایین (۱۲۸، (۳،۳)، نادرست (d1)

d3 = پایین (۲۵۶، (۳،۳)، نادرست (d2)

d4 = پایین (۵۱۲، (۳،۳)، نادرست (d3)

d5 = پایین (۵۱۲، (۳،۳)، نادرست (d4)

#نمونه برداری

u1 = بالا (۵۱۲، (۳،۳)، نادرست (d5)

u1 = layers.concatenate([u1,d4])

u2 = بالا (۲۵۶، (۳،۳)، نادرست (u1)

u2 = layers.concatenate([u2,d3])

u3 = بالا (۱۲۸، (۳،۳)، نادرست (u2)

u3 = layers.concatenate([u3,d2])

u4 = بالا (۱۲۸، (۳،۳)، نادرست (u3)

u4 = layers.concatenate([u4,d1])

u5 = بالا (۳، (۳،۳)، نادرست) (u4)

u5 = layers.concatenate([u5,inputs])

خروجی = لایه ها.

بازگشت tf.keras.Model(inputs=inputs,outputs=output)

model = model()

model.summary()

###############################

##### تدوین مدل #####

###############################

model.compile(بهینه ساز = tf.keras.optimizers.Adam(نرخ_آموزشی = ۰٫۰۰۱)،

ضرر = 'mean_absolute_error',

متریک = [’acc’])

##############################

##### تناسب مدل ######

##############################

model.fit(train_low_image, train_high_image, epochs = 20, batch_size = 1,

validation_data = (validation_low_image, validation_high_image))

##################################

##### ارزیابی مدل #####

#################################

def psnr(هدف، رفرنس):

target_data = target.atype(float)

ref_data = ref.atype(float)

diff = ref_data - target_data

diff = diff.flatten('C')

rmse = math.sqrt(np.mean(diff**2.))

بازگشت ۲۰ * math.log10 (255. / rmse)

def mse(هدف، اشاره):

err = np.sum((target.atype(float) - ref.atype(float))**2)

err /= float(target.shape[0] * target.shape[1])

بازگشت اشتباه

def compare_images(target, ref):

نمرات = []

scores.append(psnr(هدف، مرجع))

scores.append(mse(هدف، مرجع))

scores.append(ssim(هدف، مرجع، چند کانال=درست))

برگشت نمرات

###################################

##### تجسم پیش بینی ها #####

###################################

def plot_images (بالا، کم، پیش بینی شده):

plt.figure(figsize=(15،۱۵))

plt.subplot(1،۳،۱)

plt.title('تصویر بالا'، رنگ = 'سبز'، اندازه قلم = ۲۰)

plt.imshow (بالا)

plt.subplot(1،۳،۲)

plt.title('تصویر کم'، رنگ = 'سیاه'، اندازه قلم = ۲۰)

plt.imshow (کم)

plt.subplot(1،۳،۳)

plt.title('تصویر پیش بینی شده'، رنگ = 'قرمز'، اندازه قلم = ۲۰)

plt.imshow (پیش بینی شده)

plt.show()

نمرات = []

برای i در محدوده (۱،۱۰):

پیش بینی شده = np.clip(model.predict(test_low_image[i].reshape(

۱,SIZE,SIZE,3)),0.0,1.0).تغییر شکل (SIZE,SIZE,3)

scores.append(مقایسه_تصاویر(پیش بینی شده، test_high_image[i]))

plot_images(test_high_image[i],test_low_image[i](پیش بینی شده)

#########################################

##### ذخیره نتایج و مدل #####

#########################################

پانداها را به صورت PD وارد کنید

df = pd.DataFrame(نمرات)

df.columns = [’PSNR’, ’MSE’, ’SSIM’]

df.to_csv('3_3_11_20_0.001.csv'، index=False)

model.save("final_model.h5")