{"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_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import tensorflow as tf\nprint(\"Num GPUs Available: \", len(tf.config.experimental.list_physical_devices('GPU')))","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:09:38.836876Z","iopub.execute_input":"2022-11-18T22:09:38.837213Z","iopub.status.idle":"2022-11-18T22:09:43.792503Z","shell.execute_reply.started":"2022-11-18T22:09:38.837185Z","shell.execute_reply":"2022-11-18T22:09:43.791658Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tf.debugging.set_log_device_placement(True)\n\n# Create some tensors\na = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\nb = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])\nc = tf.matmul(a, b)\n\nprint(c)","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:25:04.68278Z","iopub.execute_input":"2022-11-18T22:25:04.683117Z","iopub.status.idle":"2022-11-18T22:25:07.319185Z","shell.execute_reply.started":"2022-11-18T22:25:04.683088Z","shell.execute_reply":"2022-11-18T22:25:07.318326Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Initialising Hyper Parameters\n\n#Uncomment one of the two below lines. For some reason, on some computers the first one works, while on others the second.\nfrom tensorflow.keras.optimizers import Adam\n#from keras.optimizers import adam\nimport tensorflow as tf\n\nimport numpy as np\nimport keras\n\nnp.random.seed(10)  #for consistency of random numbers and our images\n\nnoise_dim = 100  # input dimension of random vector - the vector that goes into the generator\n\nbatch_size = 16   #How many images do we want to include in each batch\nsteps_per_epoch = 3750  #How many steps do we want to take per iteration of our training set (number of batches)\nepochs = 10      #How many iterations of our training set do we want to do.\n\n#change the below values to the dimensions of your image. The channels number refers to the number of colors\nimg_rows, img_cols, channels = 128, 128, 1\n\n#These are the recommended values for the optimizer\noptimizer = Adam(0.0002, 0.5)\n","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:25:15.123298Z","iopub.execute_input":"2022-11-18T22:25:15.123663Z","iopub.status.idle":"2022-11-18T22:25:15.244597Z","shell.execute_reply.started":"2022-11-18T22:25:15.123604Z","shell.execute_reply":"2022-11-18T22:25:15.243734Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def siim-isic-2019-organized as /kaggle/input/siim-isic-2019-organized as\npip install sim-isic-2019-organized","metadata":{"execution":{"iopub.status.busy":"2022-12-20T15:02:58.122816Z","iopub.execute_input":"2022-12-20T15:02:58.12312Z","iopub.status.idle":"2022-12-20T15:02:58.131376Z","shell.execute_reply.started":"2022-12-20T15:02:58.123083Z","shell.execute_reply":"2022-12-20T15:02:58.129994Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from siim-isic-2019-organized import paths\nimport cv2","metadata":{"execution":{"iopub.status.busy":"2022-12-20T15:02:58.132955Z","iopub.status.idle":"2022-12-20T15:02:58.134085Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"ImagePaths = list(paths.list_images(ssim-isic-2019-organized))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os, warnings\nimport matplotlib.pyplot as plt\nfrom matplotlib import gridspec\nimport pandas as pd\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.keras.preprocessing import siim-isic-2019-organized","metadata":{"execution":{"iopub.status.busy":"2022-12-20T15:02:58.236708Z","iopub.execute_input":"2022-12-20T15:02:58.237064Z","iopub.status.idle":"2022-12-20T15:02:58.243941Z","shell.execute_reply.started":"2022-12-20T15:02:58.23703Z","shell.execute_reply":"2022-12-20T15:02:58.242602Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Reproducability\ndef set_seed(seed=31415):\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    os.environ['TF_DETERMINISTIC_OPS'] = '1'\nset_seed()","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:28:15.496921Z","iopub.execute_input":"2022-11-18T22:28:15.497253Z","iopub.status.idle":"2022-11-18T22:28:15.50258Z","shell.execute_reply.started":"2022-11-18T22:28:15.497221Z","shell.execute_reply":"2022-11-18T22:28:15.501523Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Set Matplotlib defaults\nplt.rc('figure', autolayout=True)\nplt.rc('axes', labelweight='bold', labelsize='large',\n       titleweight='bold', titlesize=18, titlepad=10)\nplt.rc('image', cmap='magma')\nwarnings.filterwarnings(\"ignore\") # to clean up output cells","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:28:21.253109Z","iopub.execute_input":"2022-11-18T22:28:21.253427Z","iopub.status.idle":"2022-11-18T22:28:21.258498Z","shell.execute_reply.started":"2022-11-18T22:28:21.253398Z","shell.execute_reply":"2022-11-18T22:28:21.257399Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Load training and validation sets\nmalignant_str_images = os.listdir('../input/siim-isic-2019-organized/dataset organized/malignant')","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:05:26.186118Z","iopub.execute_input":"2022-11-18T22:05:26.186456Z","iopub.status.idle":"2022-11-18T22:05:26.214827Z","shell.execute_reply.started":"2022-11-18T22:05:26.186426Z","shell.execute_reply":"2022-11-18T22:05:26.213462Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Data Pipeline\ndef convert_to_float(image, label):\n    image = tf.image.convert_image_dtype(image, dtype=tf.float32)\n    return image, label","metadata":{"execution":{"iopub.status.busy":"2022-11-18T22:28:26.140987Z","iopub.execute_input":"2022-11-18T22:28:26.141306Z","iopub.status.idle":"2022-11-18T22:28:26.146397Z","shell.execute_reply.started":"2022-11-18T22:28:26.141275Z","shell.execute_reply":"2022-11-18T22:28:26.145348Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Splitting dataset into train, test and validation\nDATASET_SIZE = 518\n\ntrain_size = int(0.75 * DATASET_SIZE)\nval_size = int(0.125 * DATASET_SIZE)\ntest_size = int(0.125 * DATASET_SIZE)\n","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.22079Z","iopub.status.idle":"2022-11-06T21:44:12.221621Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"full_dataset = total_DS\ntraining_Data = full_dataset.take(train_size)\ntest_Data = full_dataset.skip(train_size)\nvalidation_Data = test_Data.skip(val_size)\ntest_Data = test_Data.take(test_size)","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.222796Z","iopub.status.idle":"2022-11-06T21:44:12.223589Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"AUTOTUNE = tf.data.experimental.AUTOTUNE\ntrainingData = (\n    training_Data\n    .map(convert_to_float)\n    .cache()\n    .prefetch(buffer_size=AUTOTUNE)\n)","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.224736Z","iopub.status.idle":"2022-11-06T21:44:12.225473Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"validationData = (\n    validation_Data\n    .map(convert_to_float)\n    .cache()\n    .prefetch(buffer_size=AUTOTUNE)\n)\n","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.226616Z","iopub.status.idle":"2022-11-06T21:44:12.227345Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"testData = (\n    test_Data\n    .map(convert_to_float)\n    .cache()\n    .prefetch(buffer_size=AUTOTUNE)\n)","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.329483Z","iopub.execute_input":"2022-11-06T21:44:12.329753Z","iopub.status.idle":"2022-11-06T21:44:12.350989Z","shell.execute_reply.started":"2022-11-06T21:44:12.329727Z","shell.execute_reply":"2022-11-06T21:44:12.349894Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Starting to create FCGAN (fully connected GAN)\n\n#creating generator portion of the GAN\n\n\n\nfrom keras.models import Sequential\nfrom keras.layers import Dense\nfrom keras.layers.advanced_activations import LeakyReLU\n\ndef create_generator():\n    generator = Sequential()\n\n    generator.add(Dense(256, input_dim=noise_dim))\n    generator.add(LeakyReLU(0.2))\n    \n    generator.add(Dense(512))\n    generator.add(LeakyReLU(0.2))\n    \n    generator.add(Dense(1024))\n    generator.add(LeakyReLU(0.2))\n    \n    generator.add(Dense(img_rows*img_cols*channels, activation='tanh'))  #The output layer has the same number of neurons as pixels in the image, because each neuron produces the color value for each pixel\n    \n    generator.compile(loss='binary_crossentropy', optimizer=optimizer) # A standard cross entropy loss would work, because the feedback it is getting is whether it fooled the discriminator or not.\n    \n    return generator\n    ","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.352197Z","iopub.status.idle":"2022-11-06T21:44:12.352972Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#creating the discriminator for the GAN\n\ndef create_discriminator():\n    discriminator = Sequential()\n    \n    discriminator.add(Dense(1024, input_dim=img_rows*img_cols*channels))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Dense(512))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Dense(256))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Dense(1, activation='sigmoid'))  #sigmoid activation as output is 0/1 fake/real\n    \n    discriminator.compile(loss='binary_crossentropy', optimizer = optimizer)  #Binary Cross entropy loss as the discriminator has to try and classify all images (real or fake) in the right category\n    \n    return discriminator","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.354172Z","iopub.status.idle":"2022-11-06T21:44:12.35494Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#combining the generator and discriminator to make a single large gan (loss and derivatives have to flow from discriminator to generator)\n\nfrom keras.layers import Input\nfrom keras.models import Model\n\ndiscriminator = create_discriminator()   #Creating the discriminator using the function\ngenerator = create_generator()           #Creating the generator using the function\n\ndiscriminator.trainable = False          #We will set this to false, so that when we train the entire GAN together, only the generator part will be trained. We will train the discriminator separately. See below code block for more details.\n\ngan_input = Input(shape=(noise_dim,))    #We set the input of the whole model as the noise vector that the generator takes in as input. This is because the generator first has to develop an image for training to start.\nfake_image = generator(gan_input)        #Image generated by GAN for this noise vector is stored in fake_image\n\ngan_output = discriminator(fake_image)   #The output of the GAN is the discriminator\n\ngan = Model(gan_input, gan_output)       #Finally putting the generator and discriminator together\ngan.compile(loss='binary_crossentropy', optimizer=optimizer)  # Using binary cross entropy loss (same as discriminator loss)\n","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.356079Z","iopub.status.idle":"2022-11-06T21:44:12.356832Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Code for plotting results\nimport matplotlib.pyplot as plt\n\ndef show_images(noise, size_fig):\n    generated_images = generator.predict(noise)   #Create the images from the GAN.\n    plt.figure(figsize=size_fig)\n    \n    for i, image in enumerate(generated_images):\n        plt.subplot(size_fig[0], size_fig[1], i+1)\n        if channels == 1:\n            plt.imshow(image.reshape((img_rows, img_cols)), cmap='gray')    #If the image is grayscale, as in our case, then we will reshape the output in the following way.\n                                                                            #Also, we set the coloring to grayscale so that it doesn't look like it came out of an infrared camera :)\n        else:\n            plt.imshow(image.reshape((img_rows, img_cols, channels)))\n        plt.axis('off')\n    \n    plt.tight_layout()   #Tight layout so that all of the generated images form a nice grid\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.357941Z","iopub.status.idle":"2022-11-06T21:44:12.358669Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for epoch in range(epochs):         #iterate the dataset for the number of epochs\n    for batch in range(steps_per_epoch):    #for the number of batches we wanted to create\n        noise = np.random.normal(0, 1, size=(batch_size, noise_dim))   #We generate a new noise vector to feed the generator before every training iteration\n        fake_x = generator.predict(noise)        #The image the generator develops for the noise vector we created above\n\n        real_x = x_train[np.random.randint(0, x_train.shape[0], size=batch_size)]  #We won't use all real images from our dataset at once, we will only select a random sample of images\n        \n        x = np.concatenate((real_x, fake_x))    #making the x dataset for the discriminator. This includes a mix of real and fake examples for the discriminator to correctly classify\n\n        disc_y = np.zeros(2*batch_size)\n        disc_y[:batch_size] = 0.9\n\n        d_loss = discriminator.train_on_batch(x, disc_y)   #We are training the discriminator separately. Remember, we set trainable = false when adding it to the GAN, so that when we train the GAN, we only train the generator. Hence this extra step\n\n        y_gen = np.ones(batch_size)\n        g_loss = gan.train_on_batch(noise, y_gen)       #Now we train the entire GAN. But since the discriminator can't be trained, only the generator is trained in this step.\n\n    print(f'Epoch: {epoch + 1} \\t Discriminator Loss: {d_loss} \\t\\t Generator Loss: {g_loss}')\n    noise = np.random.normal(0, 1, size=(25, noise_dim))\n    show_images(noise, (5, 5))","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.359887Z","iopub.status.idle":"2022-11-06T21:44:12.360618Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"noise = np.random.normal(0, 1, size=(100, noise_dim))\nshow_images(noise)","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.361845Z","iopub.status.idle":"2022-11-06T21:44:12.362592Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Choose from one of the below datasets\nfrom keras.datasets import fashion_mnist\n#from keras.datasets import mnist\n\nimport os\n\n(x_train, y_train), (x_tet, y_test) = fashion_mnist.load_data()   #Load the data\n\nx_train = (x_train.astype(np.float32) - 127.5) / 127.5       #Normalize the images again so that the pixel value is from -1 to 1\n\nx_train = x_train.reshape(-1, img_rows, img_cols, channels)  #Reshaping the data into a more NN friendly format","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.363741Z","iopub.status.idle":"2022-11-06T21:44:12.364484Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from keras.initializers import RandomNormal\nfrom keras.layers import Dense, Conv2D, Conv2DTranspose, Reshape\nfrom keras.layers.advanced_activations import LeakyReLU\nfrom keras.models import Sequential\n\n\ndef create_generator_cgan():\n    generator = Sequential()\n    \n    d = 7\n    generator.add(Dense(d*d*256, kernel_initializer=RandomNormal(0, 0.02), input_dim=noise_dim))\n    generator.add(LeakyReLU(0.2))     #We are going to use the same leaky relu activation function as the FCGAN.\n    \n    generator.add(Reshape((d, d, 256)))\n    \n    generator.add(Conv2DTranspose(128, (4, 4), strides=2, padding='same', kernel_initializer=RandomNormal(0, 0.02)))\n    generator.add(LeakyReLU(0.2))\n\n    generator.add(Conv2DTranspose(128, (4, 4), strides=2, padding='same', kernel_initializer=RandomNormal(0, 0.02)))\n    generator.add(LeakyReLU(0.2))\n    \n\n    \n    generator.add(Conv2D(channels, (3, 3), padding='same', activation='tanh', kernel_initializer=RandomNormal(0, 0.02)))  #Remember that the final activation has to be tanh, since pixel values go from -1 to 1\n    \n    generator.compile(loss='binary_crossentropy', optimizer=optimizer)    #The loss doesn't change when you use convolutional layers\n    return generator","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.365609Z","iopub.status.idle":"2022-11-06T21:44:12.366354Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from keras.initializers import RandomNormal\nfrom keras.layers import Dense, Conv2D, Flatten, Reshape, Dropout\nfrom keras.layers.advanced_activations import LeakyReLU\nfrom keras.models import Sequential\n\ndef create_discriminator_cgan():\n    discriminator = Sequential()\n    \n    discriminator.add(Conv2D(64, (3, 3), padding='same', kernel_initializer=RandomNormal(0, 0.02), input_shape=(img_cols, img_rows, channels)))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Conv2D(128, (3, 3), strides=2, padding='same', kernel_initializer=RandomNormal(0, 0.02)))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Conv2D(128, (3, 3), strides=2, padding='same', kernel_initializer=RandomNormal(0, 0.02)))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Conv2D(256, (3, 3), strides=2, padding='same', kernel_initializer=RandomNormal(0, 0.02)))\n    discriminator.add(LeakyReLU(0.2))\n    \n    discriminator.add(Flatten())\n    discriminator.add(Dropout(0.4))\n    discriminator.add(Dense(1, activation='sigmoid', input_shape=(img_cols, img_rows, channels)))\n    \n    discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)  #Again, the loss doesn't change when creating a DCGAN.\n    return discriminator","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.36749Z","iopub.status.idle":"2022-11-06T21:44:12.368246Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from keras.layers import Input\nfrom keras.models import Model\n\ndiscriminator = create_discriminator_cgan()\ngenerator = create_generator_cgan()\n\ndiscriminator.trainable = False\n\ngan_input = Input(shape=(noise_dim,))\nfake_image = generator(gan_input)\n\ngan_output = discriminator(fake_image)\n\ngan = Model(gan_input, gan_output)\ngan.compile(loss='binary_crossentropy', optimizer=optimizer)","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.369408Z","iopub.status.idle":"2022-11-06T21:44:12.370178Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"x_train = x_train[np.where(y_train == 0)[0]]","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.371276Z","iopub.status.idle":"2022-11-06T21:44:12.372007Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"image = x_train[29]\nplt.imshow(image.reshape((img_rows, img_cols)), cmap='gray')","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.37314Z","iopub.status.idle":"2022-11-06T21:44:12.373885Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Whatisrandom.randint\nfor epoch in range(epochs):\n    for batch in range(steps_per_epoch):\n        noise = np.random.normal(0, 1, size=(batch_size, noise_dim))\n        fake_x = generator.predict(noise)\n\n        real_x = x_train[np.random.randint(0, x_train.shape[0], size=batch_size)]\n        #print(real_x.shape)\n        #print(fake_x.shape)\n        x = np.concatenate((real_x, fake_x))\n\n        disc_y = np.zeros(2*batch_size)\n        disc_y[:batch_size] = 0.9\n\n        d_loss = discriminator.train_on_batch(x, disc_y)\n\n        y_gen = np.ones(batch_size)\n        g_loss = gan.train_on_batch(noise, y_gen)\n\n    print(f'Epoch: {epoch + 1} \\t Discriminator Loss: {d_loss} \\t\\t Generator Loss: {g_loss}')\n    noise = np.random.normal(0, 1, size=(25, noise_dim))\n    show_images(noise, (5, 5))","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.374981Z","iopub.status.idle":"2022-11-06T21:44:12.375679Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"noise = np.random.normal(0, 1, size=(100, noise_dim))\nshow_images(noise, (10, 10))","metadata":{"execution":{"iopub.status.busy":"2022-11-06T21:44:12.377282Z","iopub.status.idle":"2022-11-06T21:44:12.378017Z"},"trusted":true},"execution_count":null,"outputs":[]}]}