करस पर DCGAN का उपयोग कर कला का निर्माण

शुभ दिन। छह महीने पहले, मैंने मशीन लर्निंग का अध्ययन करना शुरू किया, कुछ पाठ्यक्रमों के माध्यम से चला गया और इसके साथ कुछ अनुभव प्राप्त किया। फिर, तंत्रिका नेटवर्क क्या शांत हैं और बहुत कुछ कर सकते हैं, इस बारे में सभी प्रकार की खबरें देखकर मैंने उनका अध्ययन करने की कोशिश करने का फैसला किया। मैंने गहरी शिक्षा के बारे में निकेलेंको की किताब को पढ़ना शुरू किया और पढ़ने के दौरान मेरे पास कई विचार थे (जो दुनिया के लिए नए नहीं हैं, लेकिन मेरे लिए बहुत रुचि के थे), जिनमें से एक तंत्रिका नेटवर्क बनाना है जो मेरे लिए कला उत्पन्न करेगा जो शांत नहीं लगेगा। केवल मेरे लिए, "ड्राइंग बच्चे के पिता", लेकिन अन्य लोगों के लिए भी। इस लेख में मैं उस पथ का वर्णन करने की कोशिश करूंगा जो मुझे संतुष्ट करने वाले पहले परिणामों को प्राप्त करने के लिए चला था।

डेटा संग्रह

जब मैंने प्रतिस्पर्धी नेटवर्क पर अध्याय पढ़ा, तो मुझे महसूस हुआ कि अब मैं कुछ लिख सकता हूं।
पहले कार्यों में से एक डेटासेट को इकट्ठा करने के लिए एक वेब पेज पार्सर लिखना था। इसके लिए, विकीआर्ट वेबसाइट एकदम सही थी , इसमें बड़ी संख्या में पेंटिंग हैं और सभी को शैली द्वारा एकत्र किया गया है। यह मेरा पहला पार्सर था, इसलिए मैंने इसे 4-5 दिनों के लिए लिखा था, जिसमें से पहले 3 ने पूरी तरह से गलत रास्ते पर कदम बढ़ाया। सही तरीका यह था कि पेज के सोर्स कोड में नेटवर्क टैब पर जाएं और ट्रैक करें कि "अधिक" बटन पर क्लिक करने पर चित्र कैसे दिखाई देते हैं। दरअसल, मेरे जैसे ही शुरुआती लोगों के लिए, कोड दिखाना अच्छा रहेगा।

from scipy.misc import imresize, imsave from matplotlib.image import imread import requests import json from bs4 import BeautifulSoup from itertools import count import os import glob 

पहले बृहस्पति सेल में, मैंने आवश्यक पुस्तकालयों का आयात किया।

• ग्लोब - एक निर्देशिका में फ़ाइलों की सूची प्राप्त करने के लिए एक आसान बात
• अनुरोध, सुंदरसुपर - पार्सिंग के लिए मूंछें
• json - एक शब्दकोश पाने के लिए एक पुस्तकालय जो किसी साइट पर "अधिक" बटन पर क्लिक करने पर वापस लौटता है
• छवियों को पढ़ने और उन्हें तैयार करने के लिए आकार बदलें, सहेजें, अपठित करें।

 def get_page(style, pagenum): page = requests.get(url1 + style + url2 + str(pagenum) + url3) return page def make_soup(page): soup = BeautifulSoup(page.text, 'html5lib') return soup def make_dir(name, s): path = os.getcwd() + '/' + s + '/' + name os.mkdir(path) 

मैं सुविधाजनक संचालन के लिए कार्यों का वर्णन करता हूं।

पहले - पाठ के रूप में एक पृष्ठ मिलता है, दूसरा इस पाठ को काम के लिए अधिक सुविधाजनक बनाता है। खैर, तीसरी शैली द्वारा आवश्यक फ़ोल्डर बनाना है।

 styles = ['kubizm'] url1 = 'https://www.wikiart.org/ru/paintings-by-style/' url2 = '?select=featured&json=2&layout=new&page=' url3 = '&resultType=masonry' 

डिज़ाइन के अनुसार, शैली की सरणी में, कई शैलियों होनी चाहिए थीं, लेकिन ऐसा हुआ कि मैंने उन्हें पूरी तरह से असमान रूप से डाउनलोड किया।

 for style in styles: make_dir(style, 'images') for style in styles: make_dir(style, 'new256_images') 

आवश्यक फ़ोल्डर बनाएँ। दूसरा चक्र फ़ोल्डर बनाता है जिसमें छवि संग्रहीत की जाएगी, एक 256x256 वर्ग में चपटा हो जाएगा।

(पहले तो मैंने सोचा कि किसी भी तरह से चित्रों के आकार को सामान्य नहीं किया जाएगा ताकि कोई विकृतियाँ न हों, लेकिन मुझे एहसास हुआ कि यह या तो असंभव था या मेरे लिए बहुत मुश्किल था)

 for style in styles: path = os.getcwd() + '\\images\\' + style + '\\' images = [] names = [] titles = [] for pagenum in count(start=1): page = get_page(style, pagenum) if page.text[0]!='{': break jsons = json.loads(page.text) paintings = jsons['Paintings'] if paintings is None: break for item in paintings: images_temp = [] images_dict = item['images'] if images_dict is None: images_temp.append(item['image']) names.append(item['artistName']) titles.append(item['title']) else: for inner_item in item['images']: images_temp.append(inner_item['image']) names.append(item['artistName']) titles.append(item['title']) images.append(images_temp) for char in ['/','\\','"', '?', ':','*','|','<','>']: titles = [title.replace(char, ' ') for title in titles] for listimg, name, title in zip(images, names, titles): if len(name) > 30: name = name[:25] if len(title) > 50: title = title[:50] if len(listimg) == 1: response = requests.get(listimg[0]) if response.status_code == 200: with open(path + name + ' ' + title + '.png', 'wb') as f: f.write(response.content) else: print('Error from server') else: for i, img in enumerate(listimg): response = requests.get(img) if response.status_code == 200: with open(path + name + ' ' + title + str(i) + '.png', 'wb') as f: f.write(response.content) else: print('Error from server') 

यहां छवियां डाउनलोड की जाती हैं और वांछित फ़ोल्डर में सहेजी जाती हैं। यहां चित्र आकार नहीं बदलते, मूल सहेजे जाते हैं।

पहले नेस्टेड लूप में दिलचस्प चीजें होती हैं:

मैंने बेवकूफी से लगातार पूछने का फैसला किया कि json (शब्दकोष वह शब्दकोश है जो सर्वर "अधिक" बटन पर क्लिक करने पर वापस लौटता है। शब्दकोश में चित्रों के बारे में पूरी जानकारी होती है), और रुकें जब सर्वर कुछ धीमा हो जाए और विशिष्ट मानों की तरह न लौटे। । इस मामले में, लौटे पाठ का पहला चरित्र एक प्रारंभिक घुंघराले ब्रैकेट होना चाहिए था, जिसके बाद शब्दकोश का शरीर आता है।

यह भी देखा गया है कि सर्वर चित्र एल्बम की तरह कुछ वापस कर सकता है। यह अनिवार्य रूप से चित्रों की एक सरणी है। पहले तो मैंने सोचा कि एकल पेंटिंग लौट रही हैं, कलाकारों का नाम उनके पास है, या शायद इसलिए कि एक बार कलाकार के एक नाम के साथ चित्रों की एक सरणी दी गई है।

  for style in styles: directory = os.getcwd() + '\\images\\' + style + '\\' new_dir = os.getcwd() + '\\new256_images\\' + style + '\\' filepaths = [] for dir_, _, files in os.walk(directory): for fileName in files: #relDir = os.path.relpath(dir_, directory) #relFile = os.path.join(relDir, fileName) relFile = fileName #print(directory) #print(relFile) filepaths.append(relFile) #print(filepaths[-1]) print(filepaths[0]) for i, fp in enumerate(filepaths): img = imread(directory + fp, 0) #/ 255.0 img = imresize(img, (256, 256)) imsave(new_dir + str(i) + ".png", img) 

यहाँ छवियों का आकार परिवर्तन और उनके लिए तैयार किए गए फ़ोल्डर में सहेजा गया है।

खैर, डेटासेट इकट्ठे हैं, आप सबसे दिलचस्प के लिए आगे बढ़ सकते हैं!

छोटी शुरुआत

आगे, मूल लेख पढ़ने के बाद , मैंने बनाना शुरू किया! लेकिन जब कुछ अच्छा नहीं निकला तो मेरी निराशा क्या थी। इन प्रयासों में, मैंने चित्रों की समान शैली पर नेटवर्क को प्रशिक्षित किया, लेकिन यहां तक ​​कि यह भी काम नहीं करता था, इसलिए मैंने मल्टीप्लायर से संख्याओं को उत्पन्न करने का तरीका सीखना शुरू किया। मैं यहां विस्तार से नहीं रहूंगा, मैं केवल वास्तुकला और टिपिंग बिंदु के बारे में बात करूंगा, धन्यवाद जिसके कारण संख्याएं उत्पन्न होनी शुरू हुईं।

 def build_generator(): model = Sequential() model.add(Dense(128 * 7 * 7, input_dim = latent_dim)) model.add(BatchNormalization()) model.add(LeakyReLU()) model.add(Reshape((7, 7, 128))) model.add(Conv2DTranspose(64, filter_size, strides=(2,2), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(32, filter_size, strides=(1, 1), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(img_channels, filter_size, strides=(2,2), padding='same')) model.add(Activation("tanh")) model.summary() return model 

• latent_dim - 100 बेतरतीब ढंग से उत्पन्न संख्याओं की एक सरणी।

  
  

   def build_discriminator(): model = Sequential() model.add(Conv2D(64, kernel_size=filter_size, strides = (2,2), input_shape=img_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=filter_size, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=filter_size, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(1)) model.add(Activation('sigmoid')) model.summary() return model 

  
  

  यही है, कुल मिलाकर, मूल परतों के आउटपुट आकार और परतों की संख्या आम तौर पर मूल लेख की तुलना में कम होती है। 28x28 क्योंकि मैं उत्पन्न करता हूं, अंदरूनी नहीं!

  
  

खैर, बहुत चाल जिसके कारण सब कुछ काम किया - प्रशिक्षण के भी पुनरावृत्ति में भेदभावकर्ता ने उत्पन्न चित्रों को देखा, और विषम चलना - वास्तविक लोगों पर।

वह मूल रूप से यह है। इसी तरह के DCGAN ने बहुत तेज़ी से सीखा, उदाहरण के लिए, इस सबटॉपिक की शुरुआत में चित्र 19 वें युग में प्राप्त किया गया था,

ये पहले से ही आश्वस्त हैं, लेकिन कई बार वास्तविक संख्या नहीं होने के बावजूद, वे शिक्षा के 99 वें युग में बदल गए।

प्रारंभिक परिणाम से संतुष्ट, मैंने सीखना बंद कर दिया और सोचने लगा कि मुख्य समस्या को कैसे हल किया जाए।

रचनात्मक प्रतिकूल नेटवर्क

अगला चरण लेबल के साथ GAN के बारे में पढ़ने के लिए था: वर्तमान चित्र के वर्ग को विवेचक और जनरेटर को परोसा जाता है। और लेबल वाले गण के बाद, मुझे कैन के बारे में पता चला - डिकोडिंग मूल रूप से सबटॉपिक के नाम पर है।

कैन में, विवेचक चित्र के वर्ग का अनुमान लगाने की कोशिश करता है यदि चित्र वास्तविक सेट से है। और, तदनुसार, एक असली तस्वीर में प्रशिक्षण के मामले में, त्रुटि के रूप में, भेदभावकर्ता, डिफ़ॉल्ट के अलावा, वर्ग का अनुमान लगाने से एक त्रुटि दी जाती है।

एक उत्पन्न चित्र में प्रशिक्षण देते समय, विवेचक को केवल यह अनुमान लगाने की आवश्यकता होती है कि यह चित्र वास्तविक है या नहीं।

जनरेटर, इसके अलावा, बस भेदभाव करने वाले को धोखा देने के लिए, चित्र की कक्षा का अनुमान लगाते समय, भेदभाव करने वाले को नुकसान की आवश्यकता होती है, अर्थात, जनरेटर इस तथ्य में दिलचस्पी रखेगा कि भेदभाव करने वालों के लिए आउटपुट 1, पूर्ण आत्मविश्वास से जितना संभव हो सके।

कैन की ओर मुड़ते हुए, मैंने फिर से कठिनाइयों का अनुभव किया, इस तथ्य के कारण लोकतांत्रिकता कि कुछ भी काम नहीं करता है और सीखता नहीं है। कई अप्रिय असफलताओं के बाद, मैंने फिर से शुरू करने और सभी परिवर्तनों को बचाने का फैसला किया (हाँ, मैंने ऐसा पहले नहीं किया था), वेट और आर्किटेक्चर (प्रशिक्षण को बाधित करने के लिए)।

सबसे पहले, मैं एक ऐसा नेटवर्क बनाना चाहता था जो बिना किसी लेबल के मेरे लिए (इस आकार के सभी निम्नलिखित चित्र) एक एकल 256x256 चित्र उत्पन्न करे। यहाँ निर्णायक मोड़ यह था कि इसके विपरीत, प्रशिक्षण के प्रत्येक पुनरावृत्ति में, विवेचक को उत्पन्न चित्रों और वास्तविक लोगों पर एक नज़र डालनी चाहिए।

यह नतीजा है कि मैं रुक गया और अगले कदम पर आगे बढ़ा। हां, रंग वास्तविक तस्वीर से अलग हैं, लेकिन मैं नेटवर्क की क्षमता और वस्तुओं को उजागर करने में अधिक रुचि रखता था। वह इस के साथ मुकाबला किया।

तब हम मुख्य कार्य के लिए आगे बढ़ सकते हैं - कला उत्पन्न करना। कोड को तुरंत पेश करें, जिस तरह से उस पर टिप्पणी करना।

सबसे पहले, हमेशा की तरह, आपको सभी पुस्तकालयों को आयात करने की आवश्यकता है।

 import glob from PIL import Image from keras.preprocessing.image import array_to_img, img_to_array, load_img from datetime import date from datetime import datetime import tensorflow as tf import numpy as np import argparse import math import os from matplotlib.image import imread from scipy.misc.pilutil import imresize, imsave import matplotlib.pyplot as plt import cv2 import keras from keras.models import Sequential, Model from keras.layers import Dense, Activation, Reshape, Flatten, Dropout, Input from keras.layers.convolutional import Conv2D, Conv2DTranspose, MaxPooling2D from keras.layers.normalization import BatchNormalization from keras.layers.advanced_activations import LeakyReLU from keras.optimizers import Adam, SGD from keras.datasets import mnist from keras import initializers import numpy as np import random 

जेनरेटर बनाना।

परतों का आउटपुट फिर से लेख से अलग है। स्मृति को बचाने के लिए कहीं (शर्तें: gtx970 के साथ एक घर का कंप्यूटर), और कहीं कॉन्फ़िगरेशन के साथ सफलता के कारण

 def build_generator(): model = Sequential() model.add(Dense(128 * 16 * 8, input_dim = latent_dim)) model.add(BatchNormalization()) model.add(LeakyReLU()) model.add(Reshape((8, 8, 256))) model.add(Conv2DTranspose(512, filter_size_g, strides=(1,1), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(512, filter_size_g, strides=(1,1), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(256, filter_size_g, strides=(1,1), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(128, filter_size_g, strides=(2,2), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(64, filter_size_g, strides=(2,2), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(32, filter_size_g, strides=(2,2), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(16, filter_size_g, strides=(2,2), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(8, filter_size_g, strides=(2,2), padding='same')) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU()) model.add(Conv2DTranspose(img_channels, filter_size_g, strides=(1,1), padding='same')) model.add(Activation("tanh")) model.summary() return model 

विवेचक निर्माण फ़ंक्शन दो मॉडल देता है, जिनमें से एक यह पता लगाने की कोशिश करता है कि क्या चित्र वास्तविक है, और दूसरा चित्र के वर्ग का पता लगाने की कोशिश करता है।

 def build_discriminator(num_classes): model = Sequential() model.add(Conv2D(64, kernel_size=filter_size_d, strides = (2,2), input_shape=img_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=filter_size_d, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(256, kernel_size=filter_size_d, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(512, kernel_size=filter_size_d, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(512, kernel_size=filter_size_d, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(512, kernel_size=filter_size_d, strides = (2,2), padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Flatten()) model.summary() img = Input(shape=img_shape) features = model(img) validity = Dense(1)(features) valid = Activation('sigmoid')(validity) label1 = Dense(1024)(features) lrelu1 = LeakyReLU(alpha=0.2)(label1) label2 = Dense(512)(label1) lrelu2 = LeakyReLU(alpha=0.2)(label2) label3 = Dense(num_classes)(label2) label = Activation('softmax')(label3) return Model(img, valid), Model(img, label) 

प्रतिस्पर्धी मॉडल बनाने का कार्य। एक प्रतिस्पर्धी मॉडल में, विवेचक को प्रशिक्षित नहीं किया जाता है।

 def generator_containing_discriminator(g, d, d_label): noise = Input(shape=(latent_dim,)) img = g(noise) d.trainable = False d_label.trainable = False valid, target_label = d(img), d_label(img) return Model(noise, [valid, target_label]) 

वास्तविक चित्रों और लेबल के साथ बैच डाउनलोड करने का कार्य। डेटा - पतों की एक सरणी जिसे बाद में परिभाषित किया जाएगा। उसी फ़ंक्शन में, चित्र सामान्यीकृत होता है।

 def get_images_classes(batch_size, data): X_train = np.zeros((batch_size, img_rows, img_cols, img_channels)) y_labels = np.zeros(batch_size) choice_arr = np.random.randint(0, len(data), batch_size) for i in range(batch_size): rand_number = np.random.randint(0, len(data[choice_arr[i]])) temp_img = cv2.imread(data[choice_arr[i]][rand_number]) X_train[i] = temp_img y_labels[i] = choice_arr[i] X_train = (X_train - 127.5)/127.5 return X_train, y_labels 

छवि बैच के सुंदर आउटपुट के लिए फ़ंक्शन। दरअसल, इस फ़ंक्शन द्वारा इस आलेख के सभी चित्र एकत्र किए गए थे।

 def combine_images(generated_images): num = generated_images.shape[0] width = int(math.sqrt(num)) height = int(math.ceil(float(num)/width)) shape = generated_images.shape[1:3] image = np.zeros((height*shape[0], width*shape[1], img_channels), dtype=generated_images.dtype) for index, img in enumerate(generated_images): i = int(index/width) j = index % width image[i*shape[0]:(i+1)*shape[0], j*shape[1]:(j+1)*shape[1]] = \ img[:, :, :,] return image 

और यहाँ भी यही डेटा है। यह अधिक या कम सुविधाजनक रूप में छवि पतों का एक सेट लौटाता है, जिसे हम ऊपर, फ़ोल्डरों में व्यवस्थित करते हैं

 def get_data(): styles_folder = os.listdir(path=os.getcwd() + "\\new256_images\\") num_styles = len(styles_folder) data = [] for i in range(num_styles): data.append(glob.glob(os.getcwd() + '\\new256_images\\' + styles_folder[i] + '\\*')) return data, num_styles 

युग पारित करने के लिए, एक यादृच्छिक बड़ी संख्या निर्धारित की गई थी, क्योंकि यह सभी चित्रों की संख्या की गणना करने के लिए बहुत आलसी था। उसी फ़ंक्शन में तराजू लोड करना प्रदान किया जाता है यदि प्रशिक्षण जारी रखना आवश्यक है। प्रत्येक 5 युग, वजन और वास्तुकला संरक्षित हैं।

यह भी लिखने योग्य है कि मैंने इनपुट छवियों पर शोर जोड़ने की कोशिश की, लेकिन आखिरी प्रशिक्षण में मैंने ऐसा नहीं करने का फैसला किया।
स्मूदड क्लास लेबल का उपयोग किया जाता है, वे सीखने में बहुत मदद करते हैं।

 def train_another(epochs = 100, BATCH_SIZE = 4, weights = False, month_day = '', epoch = ''): data, num_styles = get_data() generator = build_generator() discriminator, d_label = build_discriminator(num_styles) discriminator.compile(loss=losses[0], optimizer=d_optim) d_label.compile(loss=losses[1], optimizer=d_optim) generator.compile(loss='binary_crossentropy', optimizer=g_optim) if month_day != '': generator.load_weights(os.getcwd() + '/' + month_day + epoch + ' gen_weights.h5') discriminator.load_weights(os.getcwd() + '/' + month_day + epoch + ' dis_weights.h5') d_label.load_weights(os.getcwd() + '/' + month_day + epoch + ' dis_label_weights.h5') dcgan = generator_containing_discriminator(generator, discriminator, d_label) dcgan.compile(loss=losses[0], optimizer=g_optim) discriminator.trainable = True d_label.trainable = True for epoch in range(epochs): for index in range(int(15000/BATCH_SIZE)): noise = np.random.normal(0, 1, (BATCH_SIZE, latent_dim)) real_images, real_labels = get_images_classes(BATCH_SIZE, data) #real_images += np.random.normal(size = img_shape, scale= 0.1) generated_images = generator.predict(noise) X = real_images real_labels = real_labels - 0.1 + np.random.rand(BATCH_SIZE)*0.2 y_classif = keras.utils.to_categorical(np.zeros(BATCH_SIZE) + real_labels, num_styles) y = 0.8 + np.random.rand(BATCH_SIZE)*0.2 d_loss = [] d_loss.append(discriminator.train_on_batch(X, y)) discriminator.trainable = False d_loss.append(d_label.train_on_batch(X, y_classif)) print("epoch %d batch %d d_loss : %f, label_loss: %f" % (epoch, index, d_loss[0], d_loss[1])) X = generated_images y = np.random.rand(BATCH_SIZE) * 0.2 d_loss = discriminator.train_on_batch(X, y) print("epoch %d batch %d d_loss : %f" % (epoch, index, d_loss)) noise = np.random.normal(0, 1, (BATCH_SIZE, latent_dim)) discriminator.trainable = False d_label.trainable = False y_classif = keras.utils.to_categorical(np.zeros(BATCH_SIZE) + 1/num_styles, num_styles) y = np.random.rand(BATCH_SIZE) * 0.3 g_loss = dcgan.train_on_batch(noise, [y, y_classif]) d_label.trainable = True discriminator.trainable = True print("epoch %d batch %d g_loss : %f, label_loss: %f" % (epoch, index, g_loss[0], g_loss[1])) if index % 50 == 0: image = combine_images(generated_images) image = image*127.5+127.5 cv2.imwrite( os.getcwd() + '\\generated\\epoch%d_%d.png' % (epoch, index), image) image = combine_images(real_images) image = image*127.5+127.5 cv2.imwrite( os.getcwd() + '\\generated\\epoch%d_%d_data.png' % (epoch, index), image) if epoch % 5 == 0: date_today = date.today() month, day = date_today.month, date_today.day #      json d_json = discriminator.to_json() #     json_file = open(os.getcwd() + "/%d.%d dis_model.json" % (day, month), "w") json_file.write(d_json) json_file.close() #      json d_l_json = d_label.to_json() #     json_file = open(os.getcwd() + "/%d.%d dis_label_model.json" % (day, month), "w") json_file.write(d_l_json) json_file.close() #      json gen_json = generator.to_json() #     json_file = open(os.getcwd() + "/%d.%d gen_model.json" % (day, month), "w") json_file.write(gen_json) json_file.close() discriminator.save_weights(os.getcwd() + '/%d.%d %d_epoch dis_weights.h5' % (day, month, epoch)) d_label.save_weights(os.getcwd() + '/%d.%d %d_epoch dis_label_weights.h5' % (day, month, epoch)) generator.save_weights(os.getcwd() + '/%d.%d %d_epoch gen_weights.h5' % (day, month, epoch)) 

शुरुआती चर और प्रशिक्षण चलाएं। मेरे कंप्यूटर की कम "शक्ति" के कारण, अधिकतम 16 छवियों पर प्रशिक्षण संभव है।

 img_rows = 256 img_cols = 256 img_channels = 3 img_shape = (img_rows, img_cols, img_channels) latent_dim = 100 filter_size_g = (5,5) filter_size_d = (5,5) d_strides = (2,2) color_mode = 'rgb' losses = ['binary_crossentropy', 'categorical_crossentropy'] g_optim = Adam(0.0002, beta_2 = 0.5) d_optim = Adam(0.0002, beta_2 = 0.5) train_another(1000, 16) 

सामान्य तौर पर, लंबे समय से मैं अपने इस विचार के बारे में हब्र पर एक पोस्ट लिखना चाहता हूं, अब इसके लिए सबसे अच्छा समय नहीं है, क्योंकि यह न्यूरॉन तीन दिनों से अध्ययन कर रहा है और अब 113 वें युग में है, लेकिन आज मुझे दिलचस्प तस्वीरें मिलीं, इसलिए मैंने फैसला किया कि यह समय था पहले से ही एक पोस्ट लिखूंगा!

ये वो तस्वीरें हैं जो आज सामने आई हैं। शायद उनका नामकरण करके, मैं पाठक को इन चित्रों के बारे में मेरी व्यक्तिगत धारणा से अवगत करा सकता हूँ। यह काफी ध्यान देने योग्य है कि नेटवर्क को पर्याप्त रूप से प्रशिक्षित नहीं किया गया है (या यह इस तरह के तरीकों से बिल्कुल प्रशिक्षित नहीं हो सकता है), विशेष रूप से यह देखते हुए कि चित्रों को स्क्राइब करके लिया गया था, लेकिन आज मुझे एक परिणाम मिला जो मुझे पसंद आया।

भविष्य की योजनाओं में इस कॉन्फ़िगरेशन को फिर से लागू करना शामिल है जब तक कि यह स्पष्ट नहीं हो जाता कि यह क्या सक्षम है। यह एक नेटवर्क बनाने की भी योजना है जो इन चित्रों को समझदार आकारों में बड़ा करेगा। यह पहले से ही आविष्कार किया गया है और कार्यान्वयन हैं।

मुझे रचनात्मक आलोचना, अच्छी सलाह और सवालों के लिए बेहद खुशी होगी।