tutorial 01 running on pyCharm 2020.2 & 3.7

import tensorflow as tf

 

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D

from tensorflow.keras.preprocessing.image import ImageDataGenerator

 

import os

import numpy as np

import matplotlib.pyplot as plt

import pydicom

import glob

 

os.environ['CUDA_VISIBLE_DEVICES'] = "0"

 

tf.debugging.set_log_device_placement(True)

 

try:

  # 유효하지 않은 GPU 장치를 명시

  with tf.device('/device:GPU:2'):

    a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])

    b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])

    c = tf.matmul(a, b)

except RuntimeError as e:

  print(e)

 

#from pydicom.data import get_testdata_files

 

#_URL = 'https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip'

 

#path_to_zip = tf.keras.utils.get_file('cats_and_dogs.zip', origin=_URL, extract=True)

 

#PATH = os.path.join(os.path.dirname(path_to_zip), 'cats_and_dogs_filtered')

 

train_dir = os.path.join(os.path.curdir, './train')

validation_dir = os.path.join(os.path.curdir, './validation')

 

train_cats_dir = os.path.join(train_dir, 'cats')  # directory with our training cat pictures

train_dogs_dir = os.path.join(train_dir, 'dogs')  # directory with our training dog pictures

validation_cats_dir = os.path.join(validation_dir, 'cats')  # directory with our validation cat pictures

validation_dogs_dir = os.path.join(validation_dir, 'dogs')  # directory with our validation dog pictures

 

num_cats_tr = len(os.listdir(train_cats_dir))

num_dogs_tr = len(os.listdir(train_dogs_dir))

 

num_cats_val = len(os.listdir(validation_cats_dir))

num_dogs_val = len(os.listdir(validation_dogs_dir))

 

total_train = num_cats_tr + num_dogs_tr

total_val = num_cats_val + num_dogs_val

 

print('total training cat images:', num_cats_tr)

print('total training dog images:', num_dogs_tr)

 

print('total validation cat images:', num_cats_val)

print('total validation dog images:', num_dogs_val)

print("--")

print("Total training images:", total_train)

print("Total validation images:", total_val)

 

batch_size = 128

epochs = 15

IMG_HEIGHT = 150

IMG_WIDTH = 150

 

train_image_generator = ImageDataGenerator(rescale=1./255) # Generator for our training data

validation_image_generator = ImageDataGenerator(rescale=1./255) # Generator for our validation data

 

train_data_gen = train_image_generator.flow_from_directory(batch_size=batch_size,

                                                           directory=train_dir,

                                                           shuffle=True,

                                                           target_size=(IMG_HEIGHT, IMG_WIDTH),

                                                           class_mode='binary')

def transform_to_hu(medical_image, image):

    intercept = medical_image.RescaleIntercept

    slope = medical_image.RescaleSlope

    hu_image = image * slope + intercept

 

    return hu_image

 

def window_image(image, window_center, window_width):

    img_min = window_center - window_width // 2

    img_max = window_center + window_width // 2

    window_image = image.copy()

    window_image[window_image < img_min] = img_min

    window_image[window_image > img_max] = img_max

 

    return window_image

 

def load_image(file_path):

    medical_image = pydicom.read_file(file_path)

    image = medical_image.pixel_array

 

    hu_image = transform_to_hu(medical_image, image)

    brain_image = window_image(hu_image, 40, 80)

    return brain_image

 

#files = sorted(glob.glob('qb02/*.dcm'))

files2 = load_image('./train/qb02/1-01.dcm')

#images = np.array([load_image(path) for path in files])

 

#plt.imshow([load_image(path) for path in files])

plt.imshow(files2)

#train_data_gen = train_image_generator.flow(images, images, batch_size=9)

 

val_data_gen = validation_image_generator.flow_from_directory(batch_size=batch_size,

                                                              directory=validation_dir,

                                                              target_size=(IMG_HEIGHT, IMG_WIDTH),

                                                              class_mode='binary')

 

sample_training_images, _ = next(train_data_gen)

 

# This function will plot images in the form of a grid with 1 row and 5 columns where images are placed in each column.

def plotImages(images_arr):

    fig, axes = plt.subplots(1, 5, figsize=(20,20))

    axes = axes.flatten()

    for img, ax in zip( images_arr, axes):

        ax.imshow(img)

        ax.axis('off')

    plt.tight_layout()

    plt.show()

 

plotImages(sample_training_images[:5])

 

model = Sequential([

    Conv2D(16, 3, padding='same', activation='relu', input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),

    MaxPooling2D(),

    Conv2D(32, 3, padding='same', activation='relu'),

    MaxPooling2D(),

    Conv2D(64, 3, padding='same', activation='relu'),

    MaxPooling2D(),

    Flatten(),

    Dense(512, activation='relu'),

    Dense(1)

])

 

model.compile(optimizer='adam',

              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

              metrics=['accuracy'])

 

model.summary()

 

history = model.fit_generator(

    train_data_gen,

    steps_per_epoch=total_train // batch_size,

    epochs=epochs,

    validation_data=val_data_gen,

    validation_steps=total_val // batch_size

)

 

acc = history.history['accuracy']

val_acc = history.history['val_accuracy']

 

loss=history.history['loss']

val_loss=history.history['val_loss']

 

epochs_range = range(epochs)

 

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

plt.subplot(1, 2, 1)

plt.plot(epochs_range, acc, label='Training Accuracy')

plt.plot(epochs_range, val_acc, label='Validation Accuracy')

plt.legend(loc='lower right')

plt.title('Training and Validation Accuracy')

 

plt.subplot(1, 2, 2)

plt.plot(epochs_range, loss, label='Training Loss')

plt.plot(epochs_range, val_loss, label='Validation Loss')

plt.legend(loc='upper right')

plt.title('Training and Validation Loss')

plt.show()

 

image_gen = ImageDataGenerator(rescale=1./255, horizontal_flip=True)

#image_gen.flow_from_dataframe()

#dcm = pydicom.dcmread(train_dir)

train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,

                                               directory=train_dir,

                                               shuffle=True,

                                               target_size=(IMG_HEIGHT, IMG_WIDTH))

 

augmented_images = [train_data_gen[0][0][0] for i in range(5)]

 

# Re-use the same custom plotting function defined and used

# above to visualize the training images

plotImages(augmented_images)

 

image_gen = ImageDataGenerator(rescale=1./255, rotation_range=45)

 

train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,

                                               directory=train_dir,

                                               shuffle=True,

                                               target_size=(IMG_HEIGHT, IMG_WIDTH))

 

augmented_images = [train_data_gen[0][0][0] for i in range(5)]

 

plotImages(augmented_images)

 

# zoom_range from 0 - 1 where 1 = 100%.

image_gen = ImageDataGenerator(rescale=1./255, zoom_range=0.5) #

 

train_data_gen = image_gen.flow_from_directory(batch_size=batch_size,

                                               directory=train_dir,

                                               shuffle=True,

                                               target_size=(IMG_HEIGHT, IMG_WIDTH))

 

augmented_images = [train_data_gen[0][0][0] for i in range(5)]

 

plotImages(augmented_images)

 

image_gen_train = ImageDataGenerator(

                    rescale=1./255,

                    rotation_range=45,

                    width_shift_range=.15,

                    height_shift_range=.15,

                    horizontal_flip=True,

                    zoom_range=0.5

                    )

 

train_data_gen = image_gen_train.flow_from_directory(batch_size=batch_size,

                                                     directory=train_dir,

                                                     shuffle=True,

                                                     target_size=(IMG_HEIGHT, IMG_WIDTH),

                                                     class_mode='binary')

 

augmented_images = [train_data_gen[0][0][0] for i in range(5)]

plotImages(augmented_images)

 

image_gen_val = ImageDataGenerator(rescale=1./255)

 

val_data_gen = image_gen_val.flow_from_directory(batch_size=batch_size,

                                                 directory=validation_dir,

                                                 target_size=(IMG_HEIGHT, IMG_WIDTH),

                                                 class_mode='binary')

 

model_new = Sequential([

    Conv2D(16, 3, padding='same', activation='relu',

           input_shape=(IMG_HEIGHT, IMG_WIDTH ,3)),

    MaxPooling2D(),

    Dropout(0.2),

    Conv2D(32, 3, padding='same', activation='relu'),

    MaxPooling2D(),

    Conv2D(64, 3, padding='same', activation='relu'),

    MaxPooling2D(),

    Dropout(0.2),

    Flatten(),

    Dense(512, activation='relu'),

    Dense(1)

])

 

model_new.compile(optimizer='adam',

                  loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),

                  metrics=['accuracy'])

 

model_new.summary()

 

history = model_new.fit_generator(

    train_data_gen,

    steps_per_epoch=total_train // batch_size,

    epochs=epochs,

    validation_data=val_data_gen,

    validation_steps=total_val // batch_size

)

 

acc = history.history['accuracy']

val_acc = history.history['val_accuracy']

 

loss = history.history['loss']

val_loss = history.history['val_loss']

 

epochs_range = range(epochs)

 

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

plt.subplot(1, 2, 1)

plt.plot(epochs_range, acc, label='Training Accuracy')

plt.plot(epochs_range, val_acc, label='Validation Accuracy')

plt.legend(loc='lower right')

plt.title('Training and Validation Accuracy')

 

plt.subplot(1, 2, 2)

plt.plot(epochs_range, loss, label='Training Loss')

plt.plot(epochs_range, val_loss, label='Validation Loss')

plt.legend(loc='upper right')

plt.title('Training and Validation Loss')

plt.show()