सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

BigGAN के साथ छवियाँ बनाना

TensorFlow.org पर देखें गिटहब पर देखें नोटबुक डाउनलोड करें TF हब मॉडल देखें

इस नोटबुक BigGAN छवि पर उपलब्ध जनरेटर के लिए एक डेमो है TF हब

देखें arXiv पर BigGAN कागज इन मॉडलों के बारे में अधिक जानकारी के लिए [1]।

किसी रनटाइम से कनेक्ट होने के बाद, इन निर्देशों का पालन करके प्रारंभ करें:

  1. (वैकल्पिक) अद्यतन चयनित module_path नीचे पहले कोड सेल में एक अलग छवि संकल्प के लिए एक BigGAN जनरेटर लोड करने के लिए।
  2. रनटाइम> क्रम में प्रत्येक कोशिका को चलाने के लिए सभी भागो पर क्लिक करें।
    • बाद में, जब आप स्लाइडर्स और ड्रॉपडाउन मेनू का उपयोग करके सेटिंग्स को संशोधित करते हैं तो इंटरैक्टिव विज़ुअलाइज़ेशन स्वचालित रूप से अपडेट हो जाना चाहिए।
    • यदि नहीं, तो करने के लिए मैन्युअल रूप से आउटपुट फिर से प्रस्तुत करना सेल द्वारा चलाएं बटन को दबाना।

[1] एंड्रयू ब्रॉक, जेफ डोनह्यू, और करेन सिमोनियन। हाई फिडेलिटी प्राकृतिक छवि संश्लेषण के लिए बड़े पैमाने पर GAN प्रशिक्षणarXiv: १,८०९.११,०९६, 2018।

सबसे पहले, मॉड्यूल पथ सेट करें। डिफ़ॉल्ट रूप से, हम से 256x256 छवियों के लिए BigGAN गहरा जनरेटर लोड https://hub.tensorflow.google.cn/deepmind/biggan-deep-256/1 । 128x128 या 512x512 छवियों उत्पन्न करने के लिए या बाहर सक्रिय मूल BigGAN जनरेटर, टिप्पणी का उपयोग करने के module_path सेटिंग और दूसरों की टिप्पणी हटाएं एक।

# BigGAN-deep models
# module_path = 'https://hub.tensorflow.google.cn/deepmind/biggan-deep-128/1'  # 128x128 BigGAN-deep
module_path = 'https://hub.tensorflow.google.cn/deepmind/biggan-deep-256/1'  # 256x256 BigGAN-deep
# module_path = 'https://hub.tensorflow.google.cn/deepmind/biggan-deep-512/1'  # 512x512 BigGAN-deep

# BigGAN (original) models
# module_path = 'https://hub.tensorflow.google.cn/deepmind/biggan-128/2'  # 128x128 BigGAN
# module_path = 'https://hub.tensorflow.google.cn/deepmind/biggan-256/2'  # 256x256 BigGAN
# module_path = 'https://hub.tensorflow.google.cn/deepmind/biggan-512/2'  # 512x512 BigGAN

सेट अप

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

import os
import io
import IPython.display
import numpy as np
import PIL.Image
from scipy.stats import truncnorm
import tensorflow_hub as hub
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/compat/v2_compat.py:111: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.
Instructions for updating:
non-resource variables are not supported in the long term

TF हब से BigGAN जनरेटर मॉड्यूल लोड करें

tf.reset_default_graph()
print('Loading BigGAN module from:', module_path)
module = hub.Module(module_path)
inputs = {k: tf.placeholder(v.dtype, v.get_shape().as_list(), k)
          for k, v in module.get_input_info_dict().items()}
output = module(inputs)

print()
print('Inputs:\n', '\n'.join(
    '  {}: {}'.format(*kv) for kv in inputs.items()))
print()
print('Output:', output)
Loading BigGAN module from: https://hub.tensorflow.google.cn/deepmind/biggan-deep-256/1
INFO:tensorflow:Saver not created because there are no variables in the graph to restore
INFO:tensorflow:Saver not created because there are no variables in the graph to restore
Inputs:
   y: Tensor("y:0", shape=(?, 1000), dtype=float32)
  z: Tensor("z:0", shape=(?, 128), dtype=float32)
  truncation: Tensor("truncation:0", shape=(), dtype=float32)

Output: Tensor("module_apply_default/G_trunc_output:0", shape=(?, 256, 256, 3), dtype=float32)

BigGAN छवियों के नमूने और प्रदर्शित करने के लिए कुछ कार्यों को परिभाषित करें

input_z = inputs['z']
input_y = inputs['y']
input_trunc = inputs['truncation']

dim_z = input_z.shape.as_list()[1]
vocab_size = input_y.shape.as_list()[1]

def truncated_z_sample(batch_size, truncation=1., seed=None):
  state = None if seed is None else np.random.RandomState(seed)
  values = truncnorm.rvs(-2, 2, size=(batch_size, dim_z), random_state=state)
  return truncation * values

def one_hot(index, vocab_size=vocab_size):
  index = np.asarray(index)
  if len(index.shape) == 0:
    index = np.asarray([index])
  assert len(index.shape) == 1
  num = index.shape[0]
  output = np.zeros((num, vocab_size), dtype=np.float32)
  output[np.arange(num), index] = 1
  return output

def one_hot_if_needed(label, vocab_size=vocab_size):
  label = np.asarray(label)
  if len(label.shape) <= 1:
    label = one_hot(label, vocab_size)
  assert len(label.shape) == 2
  return label

def sample(sess, noise, label, truncation=1., batch_size=8,
           vocab_size=vocab_size):
  noise = np.asarray(noise)
  label = np.asarray(label)
  num = noise.shape[0]
  if len(label.shape) == 0:
    label = np.asarray([label] * num)
  if label.shape[0] != num:
    raise ValueError('Got # noise samples ({}) != # label samples ({})'
                     .format(noise.shape[0], label.shape[0]))
  label = one_hot_if_needed(label, vocab_size)
  ims = []
  for batch_start in range(0, num, batch_size):
    s = slice(batch_start, min(num, batch_start + batch_size))
    feed_dict = {input_z: noise[s], input_y: label[s], input_trunc: truncation}
    ims.append(sess.run(output, feed_dict=feed_dict))
  ims = np.concatenate(ims, axis=0)
  assert ims.shape[0] == num
  ims = np.clip(((ims + 1) / 2.0) * 256, 0, 255)
  ims = np.uint8(ims)
  return ims

def interpolate(A, B, num_interps):
  if A.shape != B.shape:
    raise ValueError('A and B must have the same shape to interpolate.')
  alphas = np.linspace(0, 1, num_interps)
  return np.array([(1-a)*A + a*B for a in alphas])

def imgrid(imarray, cols=5, pad=1):
  if imarray.dtype != np.uint8:
    raise ValueError('imgrid input imarray must be uint8')
  pad = int(pad)
  assert pad >= 0
  cols = int(cols)
  assert cols >= 1
  N, H, W, C = imarray.shape
  rows = N // cols + int(N % cols != 0)
  batch_pad = rows * cols - N
  assert batch_pad >= 0
  post_pad = [batch_pad, pad, pad, 0]
  pad_arg = [[0, p] for p in post_pad]
  imarray = np.pad(imarray, pad_arg, 'constant', constant_values=255)
  H += pad
  W += pad
  grid = (imarray
          .reshape(rows, cols, H, W, C)
          .transpose(0, 2, 1, 3, 4)
          .reshape(rows*H, cols*W, C))
  if pad:
    grid = grid[:-pad, :-pad]
  return grid

def imshow(a, format='png', jpeg_fallback=True):
  a = np.asarray(a, dtype=np.uint8)
  data = io.BytesIO()
  PIL.Image.fromarray(a).save(data, format)
  im_data = data.getvalue()
  try:
    disp = IPython.display.display(IPython.display.Image(im_data))
  except IOError:
    if jpeg_fallback and format != 'jpeg':
      print(('Warning: image was too large to display in format "{}"; '
             'trying jpeg instead.').format(format))
      return imshow(a, format='jpeg')
    else:
      raise
  return disp

एक TensorFlow सत्र बनाएं और चर प्रारंभ करें

initializer = tf.global_variables_initializer()
sess = tf.Session()
sess.run(initializer)

किसी विशेष श्रेणी के BigGAN नमूनों का अन्वेषण करें

बदलती प्रयास करें truncation मूल्य।

(कोड देखने के लिए सेल पर डबल-क्लिक करें।)

श्रेणी-सशर्त नमूनाकरण

पीएनजी

BigGAN नमूनों के बीच इंटरपोलेट करें

अलग सेट करने का प्रयास category में एक ही साथ रों noise_seed रों, या एक ही category विभिन्न साथ एस noise_seed रों। या जंगली जाओ और दोनों को अपनी पसंद के अनुसार सेट करें!

(कोड देखने के लिए सेल पर डबल-क्लिक करें।)

प्रक्षेप

पीएनजी