{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\nfrom random import random\nimport os\nfrom numpy import zeros\nfrom numpy import ones\nfrom numpy.random import randn\nfrom numpy.random import randint\nimport tensorflow as tf\nimport cv2\n#import keras\nfrom kaggle_datasets import KaggleDatasets\n#for dirname, _, filenames in os.walk('/kaggle/input'):\n #   for filename in filenames:\n  #      print(os.path.join(dirname, filename))\n\n# You can write up to 5GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from tensorflow.keras.preprocessing.image import *\nfrom matplotlib import pyplot\nfrom tensorflow.keras.layers import Dense, Flatten, Conv2D, Conv2DTranspose, Reshape, LeakyReLU, Dropout, Input, BatchNormalization\nfrom tensorflow.keras.layers import Concatenate, Activation\nfrom tensorflow.keras.models import Sequential, Model, load_model\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.initializers import RandomNormal\nimport re\n\n%matplotlib inline","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"try:\n    # TPU detection. No parameters necessary if TPU_NAME environment variable is\n    # set: this is always the case on Kaggle.\n    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n    print('Running on TPU ', tpu.master())\nexcept ValueError:\n    tpu = None\n\nif tpu:\n    tf.config.experimental_connect_to_cluster(tpu)\n    tf.tpu.experimental.initialize_tpu_system(tpu)\n    strategy = tf.distribute.experimental.TPUStrategy(tpu)\nelse:\n    # Default distribution strategy in Tensorflow. Works on CPU and single GPU.\n    strategy = tf.distribute.get_strategy()\n\nprint(\"REPLICAS: \", strategy.num_replicas_in_sync)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tf.test.is_gpu_available()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"input_path = '/kaggle/input/mela-domain-data/'\noutput_path = '/kaggle/working/'\n#train_data = pd.read_csv(input_path+'/train.csv', usecols = ['image_name', 'target'])\n#test_data = pd.read_csv(input_path+'/test.csv')\n\n#NUM_TEST_IMAGES = test_data.shape[0]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"IMAGE_SIZE=[256, 256]\ndef decode_image(image_data):\n    image = tf.image.decode_jpeg(image_data, channels=3)\n    image = tf.cast(image, tf.float32) \n    image = (image - 127.5) /127.5   # convert image to floats in [-1, 1] range\n    image = tf.reshape(image, [*IMAGE_SIZE, 3]) # explicit size needed for TPU\n    return image\n\n\ndef load_dataset(filenames, labeled=True, ordered=False):\n    ignore_order = tf.data.Options()\n    if not ordered:\n        ignore_order.experimental_deterministic = False # disable order, increase speed\n\n    dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTO) # automatically interleaves reads from multiple files\n    dataset = dataset.with_options(ignore_order) # uses data as soon as it streams in, rather than in its original order\n    dataset = dataset.map(read_labeled_tfrecord if labeled else read_unlabeled_tfrecord, num_parallel_calls=AUTO)\n    # returns a dataset of (image, label) pairs if labeled=True or (image, id) pairs if labeled=False\n    return dataset\n\n\ndef read_labeled_tfrecord(example):\n    LABELED_TFREC_FORMAT = {\n        \"image\": tf.io.FixedLenFeature([], tf.string), # tf.string means bytestring\n        \"target\": tf.io.FixedLenFeature([], tf.int64)  # shape [] means single element\n    }\n    example = tf.io.parse_single_example(example, LABELED_TFREC_FORMAT)\n    image = decode_image(example['image'])\n    #label = tf.cast(example['class'], tf.int32)\n    #label = tf.cast(example['target'], tf.int32)\n    return image #, label # returns a dataset of (image, label) pairs\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#GCS_PATH = KaggleDatasets().get_gcs_path('siim-isic-melanoma-classification')\nGCS_PATH = KaggleDatasets().get_gcs_path('mela-domain-data')\nAUTO = tf.data.experimental.AUTOTUNE\n\nBATCH_SIZE = 1\nEPOCHS = 20\n\ntrainB = tf.io.gfile.glob(GCS_PATH+'/train00-584.tfrec')\ntrainA = tf.io.gfile.glob(GCS_PATH+'/train*-[0-9][0-9][0-9][0-9].tfrec')\n\ntrainA_dataset = load_dataset(trainA, labeled=True).repeat()#.shuffle(2048).batch(1)\ntrainB_dataset = load_dataset(trainB, labeled=True).shuffle(584)#.batch(1)\n    \n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def count_data_items(filenames):\n    # the number of data items is written in the name of the .tfrec files, i.e. flowers00-230.tfrec = 230 data items\n    n = [int(re.compile(r\"-([0-9]*)\\.\").search(filename).group(1)) for filename in filenames]\n    return np.sum(n)","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"markdown","source":"def build_discriminator(image_shape,name):\n    with strategy.scope():\n        init = RandomNormal(stddev=0.02)\n        \n        in_image = Input(shape=image_shape)\n        d = Conv2D(64, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(in_image)\n        d = LeakyReLU(alpha=0.2)(d)\n        \n        d = Conv2D(128, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n        d = BatchNormalization()(d)\n        d = LeakyReLU(alpha=0.2)(d)\n                   \n        d = Conv2D(256, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n        d = BatchNormalization()(d)\n        d = LeakyReLU(alpha=0.2)(d)\n        \n        d = Conv2D(512, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n        d = BatchNormalization()(d)\n        d = LeakyReLU(alpha=0.2)(d)\n        \n        d = Conv2D(512, (4,4), padding='same', kernel_initializer=init)(d)\n        d = BatchNormalization()(d)\n        d = LeakyReLU(alpha=0.2)(d)\n       \n        output = Conv2D(1, (4,4), padding='same', kernel_initializer=init)(d)\n        \n        model = Model(in_image, output, name=name)\n        model.compile(loss='mse', optimizer=Adam(lr=0.0002, beta_1=0.5), loss_weights=[0.5])\n        \n        return model","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def build_discriminator(image_shape,name):\n    init = RandomNormal(stddev=0.02)\n    \n    in_image = Input(shape=image_shape)\n    d = Conv2D(64, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(in_image)\n    d = LeakyReLU(alpha=0.2)(d)\n    \n    d = Conv2D(128, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n    d = BatchNormalization()(d)\n    d = LeakyReLU(alpha=0.2)(d)\n               \n    d = Conv2D(256, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n    d = BatchNormalization()(d)\n    d = LeakyReLU(alpha=0.2)(d)\n    \n    d = Conv2D(512, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n    d = BatchNormalization()(d)\n    d = LeakyReLU(alpha=0.2)(d)\n    \n    d = Conv2D(512, (4,4), padding='same', kernel_initializer=init)(d)\n    d = BatchNormalization()(d)\n    d = LeakyReLU(alpha=0.2)(d)\n    \n    output = Conv2D(1, (4,4), padding='same', kernel_initializer=init)(d)\n    \n    model = Model(in_image, output, name=name)\n    model.compile(loss='mse', optimizer=Adam(lr=0.0002, beta_1=0.5), loss_weights=[0.5])\n    \n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Define Residual Block\n\ndef resnet_block(n_filters, input_layer):\n    init = RandomNormal(stddev=0.02)\n    \n    r = Conv2D(n_filters, (3,3), padding='same', kernel_initializer=init)(input_layer)\n    r = BatchNormalization()(r)\n    r = Activation('relu')(r)\n    \n    r = Conv2D(n_filters, (3,3), padding='same', kernel_initializer=init)(r)\n    r = BatchNormalization()(r)\n    \n    r = Concatenate()([r, input_layer])\n    \n    return r","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"def build_generator(name, image_shape, n_resnet=9):\n    with strategy.scope():\n        init = RandomNormal(stddev=0.02)\n        \n        in_image = Input(shape=image_shape)\n        \n        g = Conv2D(64, (7,7), padding='same', kernel_initializer=init)(in_image)\n        g = BatchNormalization()(g)\n        g = Activation('relu')(g)\n        \n        g = Conv2D(128, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n        g = BatchNormalization()(g)\n        g = Activation('relu')(g)\n        \n        g = Conv2D(256, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n        g = BatchNormalization()(g)\n        g = Activation('relu')(g)\n        \n        for _ in range(n_resnet):\n            g = resnet_block(256, g)\n        \n        g = Conv2DTranspose(128, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n        g = BatchNormalization()(g)\n        g = Activation('relu')(g)\n        \n        g = Conv2DTranspose(64, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n        g = BatchNormalization()(g)\n        g = Activation('relu')(g) \n        \n        g = Conv2D(3, (7,7), padding='same', kernel_initializer=init)(g)\n        g = BatchNormalization()(g)\n        out_image = Activation('tanh')(g)\n        \n       \n        model = Model(in_image, out_image, name=name)\n        return model","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def build_generator(name, image_shape, n_resnet=9):\n    init = RandomNormal(stddev=0.02)\n    \n    in_image = Input(shape=image_shape)\n    \n    g = Conv2D(64, (7,7), padding='same', kernel_initializer=init)(in_image)\n    g = BatchNormalization()(g)\n    g = Activation('relu')(g)\n    \n    g = Conv2D(128, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n    g = BatchNormalization()(g)\n    g = Activation('relu')(g)\n    \n    g = Conv2D(256, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n    g = BatchNormalization()(g)\n    g = Activation('relu')(g)\n    \n    for _ in range(n_resnet):\n        g = resnet_block(256, g)\n    \n    g = Conv2DTranspose(128, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n    g = BatchNormalization()(g)\n    g = Activation('relu')(g)\n    \n    g = Conv2DTranspose(64, (3,3), strides=(2,2), padding='same', kernel_initializer=init)(g)\n    g = BatchNormalization()(g)\n    g = Activation('relu')(g) \n    \n    g = Conv2D(3, (7,7), padding='same', kernel_initializer=init)(g)\n    g = BatchNormalization()(g)\n    out_image = Activation('tanh')(g)\n    \n    \n    model = Model(in_image, out_image, name=name)\n    return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def composite_model(g_model_1, d_model, g_model_2, image_shape,name):\n    with strategy.scope():\n        g_model_1.trainable = True\n        d_model.trainable = False\n        g_model_2.trainable = False\n        \n        input_gen = Input(shape=image_shape)\n        gen1_out = g_model_1(input_gen)\n        output_d = d_model(gen1_out)\n        \n        input_id = Input(shape=image_shape)\n        output_id = g_model_1(input_id)\n        \n        output_f = g_model_2(gen1_out)\n        \n        gen2_out = g_model_2(input_id)\n        output_b = g_model_1(gen2_out)\n        \n        model = Model([input_gen, input_id], [output_d, output_id, output_f, output_b],name=name)\n        \n        opt = Adam(lr=0.0002, beta_1=0.5)\n        \n        model.compile(loss=['mse', 'mae', 'mae', 'mae'], loss_weights=[1, 5, 10, 10], optimizer=opt)\n        \n        return model","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# select real samples\ndef generate_real_samples(X, n_samples, patch_shape):\n    y = tf.ones([n_samples, patch_shape, patch_shape, 1])\n    return X, y","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def generate_fake_samples(g_model, dataset, patch_shape):\n    x = g_model.predict(dataset)\n    y = tf.zeros([len(x), patch_shape, patch_shape, 1])\n    return x, y","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def save_models(step, g_model_AtoB, g_model_BtoA, d_model_A, d_model_B):\n    filename1 = 'g_model_AtoB_%06d.h5' % (step+1)\n    g_model_AtoB.save(filename1)\n    filename2 = 'g_model_BtoA_%06d.h5' % (step+1)\n    g_model_BtoA.save(filename2)\n    filename3 = 'd_model_A_%06d.h5' % (step+1)\n    d_model_A.save(filename3)\n    filename4 = 'd_model_B_%06d.h5' % (step+1)\n    d_model_B.save(filename4)\n    print('>Saved: %s , %s , %s and %s' % (filename1, filename2, filename3, filename4))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def summarize_performance(step, g_model, trainX, name, n_samples=1):\n    X_in, _ = generate_real_samples(trainX, n_samples, 0)\n    X_out, _ = generate_fake_samples(g_model, X_in, 0)\n    X_in = (X_in + 1) / 2.0\n    X_out = (X_out + 1) / 2.0\n    for i in range(n_samples):\n        pyplot.subplot(2, n_samples, 1 + i)\n        pyplot.axis('off')\n        pyplot.imshow(X_in[i])\n    for i in range(n_samples):\n        pyplot.subplot(2, n_samples, 1 + n_samples + i)\n        pyplot.axis('off')\n        pyplot.imshow(X_out[i])\n    filename1 = '%s_generated_plot_%06d.png' % (name, (step+1))\n    pyplot.savefig(filename1)\n    pyplot.close()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def update_image_pool(pool, images, max_size=50):\n    selected = list()\n    for image in images:\n        if len(pool) < max_size:\n            pool.append(image)\n            selected.append(image)\n        elif random() < 0.5:\n            selected.append(image)\n        else:\n            ix = np.random.randint(0, len(pool))\n            selected.append(pool[ix])\n            pool[ix] = image\n    return np.asarray(selected)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"with strategy.scope():\n    def train(d_model_A, d_model_B, g_model_AtoB, g_model_BtoA, c_model_AtoB, c_model_BtoA, train_ben, train_mal):\n            n_batch = 1\n            n_patch = d_model_A.output_shape[1]\n            poolA, poolB = list(), list()\n            bat_per_epo = 584\n            train_a = []\n            batch_B = train_mal.batch(1)\n            \n        \n            for i in range(EPOCHS):\n                train_a_dataset = train_ben.skip(i*4000).take(4000)\n                for x in train_a_dataset:\n                    train_a.append(x.numpy())\n                    \n                a = tf.random.uniform(shape=[bat_per_epo,], maxval=4000, dtype=tf.int32)\n                train_a = np.array(train_a)\n                batch_A = tf.gather(train_a, a)\n                train_a = []  \n                batch_A = tf.data.Dataset.from_tensor_slices((batch_A)).batch(1)\n                \n        \n                for trainA,trainB in tf.data.Dataset.zip((batch_A, batch_B)):\n                    X_realA, y_realA = generate_real_samples(trainA, n_batch, n_patch)\n                    X_realB, y_realB = generate_real_samples(trainB, n_batch, n_patch)\n                    X_fakeA, y_fakeA = generate_fake_samples(g_model_BtoA, X_realB, n_patch)\n                    X_fakeB, y_fakeB = generate_fake_samples(g_model_AtoB, X_realA, n_patch)\n                    X_fakeA = update_image_pool(poolA, X_fakeA)\n                    X_fakeB = update_image_pool(poolB, X_fakeB)\n                    g_loss2, _, _, _, _ = c_model_BtoA.train_on_batch([X_realB, X_realA], [y_realA,X_realA, X_realB, X_realA])\n                    dA_loss1 = d_model_A.train_on_batch(X_realA, y_realA)\n                    dA_loss2 = d_model_A.train_on_batch(X_fakeA, y_fakeA)\n                    g_loss1, _, _, _, _ = c_model_AtoB.train_on_batch([X_realA, X_realB], [y_realB,X_realB, X_realA, X_realB])\n                    dB_loss1 = d_model_B.train_on_batch(X_realB, y_realB)\n                    dB_loss2 = d_model_B.train_on_batch(X_fakeB, y_fakeB)\n                    print('>%d, dA[%.3f,%.3f] dB[%.3f,%.3f] g[%.3f,%.3f]' % (i+1, dA_loss1,dA_loss2, dB_loss1,dB_loss2, g_loss1,g_loss2))\n                    \n                if (i+1) % 10 == 0:\n                        summarize_performance(i, g_model_AtoB, trainA, 'AtoB')\n                        summarize_performance(i, g_model_BtoA, trainB, 'BtoA')\n                if (i+1) % 25 == 0: \n                        save_models(i, g_model_AtoB, g_model_BtoA, d_model_A, d_model_B)\n        ","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def train(d_model_A, d_model_B, g_model_AtoB, g_model_BtoA, c_model_AtoB, c_model_BtoA, train_ben, train_mal):\n    n_batch = 1\n    n_patch = d_model_A.output_shape[1]\n    poolA, poolB = list(), list()\n    bat_per_epo = 584\n    train_a = []\n    batch_B = train_mal.batch(1)\n    \n    \n    for i in range(EPOCHS):\n        train_a_dataset = train_ben.skip(i*4000).take(4000)\n        for x in train_a_dataset:\n            train_a.append(x.numpy())\n            \n        a = tf.random.uniform(shape=[bat_per_epo,], maxval=4000, dtype=tf.int32)\n        train_a = np.array(train_a)\n        batch_A = tf.gather(train_a, a)\n        train_a = []  \n        batch_A = tf.data.Dataset.from_tensor_slices((batch_A)).batch(1)\n            \n            \n        for trainA,trainB in tf.data.Dataset.zip((batch_A, batch_B)):\n            X_realA, y_realA = generate_real_samples(trainA, n_batch, n_patch)\n            X_realB, y_realB = generate_real_samples(trainB, n_batch, n_patch)\n            X_fakeA, y_fakeA = generate_fake_samples(g_model_BtoA, X_realB, n_patch)\n            X_fakeB, y_fakeB = generate_fake_samples(g_model_AtoB, X_realA, n_patch)\n            X_fakeA = update_image_pool(poolA, X_fakeA)\n            X_fakeB = update_image_pool(poolB, X_fakeB)\n            g_loss2, _, _, _, _ = c_model_BtoA.train_on_batch([X_realB, X_realA], [y_realA,X_realA, X_realB, X_realA])\n            dA_loss1 = d_model_A.train_on_batch(X_realA, y_realA)\n            dA_loss2 = d_model_A.train_on_batch(X_fakeA, y_fakeA)\n            g_loss1, _, _, _, _ = c_model_AtoB.train_on_batch([X_realA, X_realB], [y_realB,X_realB, X_realA, X_realB])\n            dB_loss1 = d_model_B.train_on_batch(X_realB, y_realB)\n            dB_loss2 = d_model_B.train_on_batch(X_fakeB, y_fakeB)\n            print('>%d, dA[%.3f,%.3f] dB[%.3f,%.3f] g[%.3f,%.3f]' % (i+1, dA_loss1,dA_loss2, dB_loss1,dB_loss2, g_loss1,g_loss2))\n            \n        if (i+1) % 10 == 0:\n            summarize_performance(i, g_model_AtoB, trainA, 'AtoB')\n            summarize_performance(i, g_model_BtoA, trainB, 'BtoA')\n        if (i+1) % 20 == 0: \n            save_models(i, g_model_AtoB, g_model_BtoA, d_model_A, d_model_B)\n                        ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"image_shape = (256, 256, 3)\nMODEL_PATH = '/kaggle/input/gan-model'\n#KaggleDatasets().get_gcs_path('gan-model')\n\n\n#g_model_AtoB = build_generator('g_model_AtoB',image_shape)\n#g_model_BtoA = build_generator('g_model_BtoA',image_shape)\ng_model_AtoB = load_model(MODEL_PATH+'/g_model_AtoB_000040.h5')\ng_model_BtoA = load_model(MODEL_PATH+'/g_model_BtoA_000040.h5')\n#d_model_A = build_discriminator(image_shape, 'd_model_A')\n#d_model_B = build_discriminator(image_shape, 'd_model_B')\nd_model_A = load_model(MODEL_PATH+'/d_model_A_000040.h5')\nd_model_B = load_model(MODEL_PATH+'/d_model_B_000040.h5')\nc_model_AtoB = composite_model(g_model_AtoB, d_model_B, g_model_BtoA, image_shape, 'c_model_AtoB')\nc_model_BtoA = composite_model(g_model_BtoA, d_model_A, g_model_AtoB, image_shape, 'c_model_BtoA')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train(d_model_A, d_model_B, g_model_AtoB, g_model_BtoA, c_model_AtoB, c_model_BtoA, trainA_dataset, trainB_dataset)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"from google.cloud import storage\nstorage_client = storage.Client(project='imposing-sentry-281615')","execution_count":null},{"metadata":{"trusted":true},"cell_type":"markdown","source":"bucket_name = 'mela-domain-data'         \ndef download_to_kaggle(bucket_name,destination_directory,file_name):\n    \"\"\"Takes the data from your GCS Bucket and puts it into the working directory of your Kaggle notebook\"\"\"\n    os.makedirs(destination_directory, exist_ok = True)\n    full_file_path = os.path.join(destination_directory, file_name)\n    blobs = storage_client.list_blobs(bucket_name)\n    for blob in blobs:\n        blob.download_to_filename(full_file_path)\n        \ndestination_directory = '/kaggle/working'       \n\nfor dirname, _, filenames in os.walk('/kaggle/input/mela-domain-data'):\n    for filename in filenames:\n        file_name = filename\n        print(file_name)\n        download_to_kaggle(bucket_name,destination_directory,file_name)","execution_count":null},{"metadata":{"trusted":true},"cell_type":"markdown","source":"Prediction","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"def _bytes_feature(value):\n    if isinstance(value, type(tf.constant(0))):\n        value = value.numpy() # BytesList won't unpack a string from an EagerTensor.\n    return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))\n\ndef _float_feature(value):\n  \"\"\"Returns a float_list from a float / double.\"\"\"\n  return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))\n\ndef _int64_feature(value):\n  \"\"\"Returns an int64_list from a bool / enum / int / uint.\"\"\"\n  return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def serialize_example(feature0, feature1):\n    feature = {\n      'image': _bytes_feature(feature0),\n      'target': _int64_feature(feature1)\n    }\n    example_proto = tf.train.Example(features=tf.train.Features(feature=feature))\n    return example_proto.SerializeToString()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"with tf.device('/gpu:0'):\n    def create_tfrecords(dataset, count,j):\n        CT = count\n        with tf.io.TFRecordWriter('generated_mela%.2i-%i.tfrec'%(j,CT)) as writer:\n            for k in dataset:\n                img = tf.image.convert_image_dtype(k, tf.uint8)\n                img = tf.image.resize(img, [256, 256], method=\"nearest\")              \n                img = tf.image.encode_jpeg(img, quality=94, optimize_size=True)\n                        #img = cv2.imread(PATH+IMGS['image_name'].iloc[SIZE*j+k]+'.jpg')\n                        #img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) # Fix incorrect colors\n                        #img = cv2.resize(img, (256, 256))\n                        #img = cv2.imencode('.jpg', img, (cv2.IMWRITE_JPEG_QUALITY, 94))[1].tostring()\n                example = serialize_example(img, 1)\n                writer.write(example)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#gen_dataset = np.array(gen_dataset)\n#dataset = tf.data.Dataset.from_tensor_slices((gen_dataset)).unbatch()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#create_tfrecords(dataset, 2000)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#g_model_AtoB = load_model('/kaggle/input/gan-model/g_model_AtoB_000050.h5')\n\ndef generate_img(dataset):\n    for i in range(10):\n        gen_dataset = []\n        train = dataset.skip(2071*i).batch(1)\n        for j,x in enumerate(train):\n            img,_ = generate_fake_samples(g_model_AtoB, x, 16)\n            img = (img + 1) / 2.0\n            gen_dataset.append(img)\n            #filename1 = '%s_generated_plot_%06d.png' % (name, (step+1))\n            if((j+1) %2071 == 0):\n                break\n            else:\n                pass\n            \n        gen_dataset = np.array(gen_dataset)\n        test = tf.data.Dataset.from_tensor_slices((gen_dataset)).unbatch()\n        create_tfrecords(test, 2071,i)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"generate_img(trainA_dataset)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}