Upload 5 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+best_weights.hdf5 filter=lfs diff=lfs merge=lfs -text
+RPS_Model.hdf5 filter=lfs diff=lfs merge=lfs -text

RPS_Model.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14728323d0ac51a38b137351c5bd10f5135a23229ba6a913fbdac332f0a09e92
+size 165984992

RPS_Part2_VGG16.py

@@ -0,0 +1,61 @@
+import sys
+import os
+import numpy as np
+import tensorflow as tf
+from keras_preprocessing import image
+from matplotlib import pyplot as plt
+
+# Part 2
+# a) The tested image is to be supplied via the arguments list
+# b) visualisation of the supplied image with the prediction score and predicted label
+
+# Loading the pre-trained model/best saved weight and perform Prediction
+# model = tf.keras.models.load_model('../Rock_Paper_Scissors_VGG16/RPS_Model.hdf5')
+model = tf.keras.models.load_model('../Rock_Paper_Scissors_VGG16/best_weights.hdf5')
+img_width, img_height = 224, 224
+
+
+# Predict function
+def predict_image(image_input, model):
+    if image_input is None or image_input == '':
+        print("Invalid type")
+        return None
+    # putting the images in an array
+    img_array = image.img_to_array(image_input)
+    processed_img = tf.reshape(img_array, shape=[1, img_width, img_height, 3])
+
+    # It uses the model to predict the class probabilities for the processed image.
+    predict_proba = np.max(model.predict(processed_img)[0])
+    # It identifies the predicted class index and its corresponding label.
+    predict_class = np.argmax(model.predict(processed_img))
+
+    # Map predicted class index to label
+    class_labels = ['Paper', 'Rock', 'Scissors']
+    predict_label = class_labels[predict_class]
+
+    # It plots the input image with its predicted class label and displays the image without axis ticks.
+    plt.figure(figsize=(4, 4))
+    plt.imshow(img)
+    plt.axis('off')
+    plt.title(f'Predicted Class: {predict_label}')
+    plt.show()
+
+    # Print prediction result and probability
+    print("\nImage prediction result:", predict_label)
+    print("Probability:", round(predict_proba * 100, 2), "%")
+    print('\n')
+
+
+# asking the user for their desired folder location
+if __name__ == "__main__":
+    image_path = ''
+    if len(sys.argv) != 2:
+        image_path = input("Enter the path to the image file: ")
+        if input() == '':
+            image_path = '../rps/test'
+    # it collects 21 random images from the folder
+    for filename in os.listdir(image_path)[0:20]:
+        filepath = os.path.join(image_path, filename)
+        # it sends the images and loaded model to prediction function
+        img = image.load_img(filepath, target_size=(img_width, img_height))
+        predict_image(img, model)

RPS_Part3_VGG16.py

@@ -0,0 +1,87 @@
+import os
+import random
+import matplotlib.pyplot as plt
+import numpy as np
+import tensorflow as tf
+from keras_preprocessing import image
+
+# Part 3
+# a) Read two images of hand signs provided as script arguments
+# b) Predict the labels of the two images
+# c) Output which image won the rock, paper, scissor game
+
+# Loading the pre-trained model/best saved weight and perform Prediction
+# vgg16_model = tf.keras.models.load_model('../Rock_Paper_Scissors_VGG16/RPS_Model.hdf5')
+vgg16_model = tf.keras.models.load_model('../Rock_Paper_Scissors_VGG16/best_weights.hdf5')
+img_width, img_height = 224, 224
+# Define labels and Image addresses
+class_labels = ['paper', 'rock', 'scissors']
+folder_path = '../rps/test'
+
+
+# Get a random Image from Folder
+def selectRandomPicture(folder_path):
+    files = os.listdir(folder_path)
+    image_files = [file for file in files if file.lower().endswith(('.png', '.jpg', '.jpeg'))]
+    random_photo = random.choice(image_files)
+    return os.path.join(folder_path, random_photo)
+
+
+# Function to load and preprocess images
+def load_and_preprocess_image(image_path):
+    img = image.load_img(image_path, target_size=(img_width, img_height))
+    img_array = image.img_to_array(img)
+    img_array /= 255.0  # Normalize pixel values
+
+    return img_array
+
+
+# A simple condition/rules to decide who’s the winner
+def whos_winner(first_image, second_image):
+    winner = ''
+    if first_image == second_image:
+        winner = "Tie!!"
+
+    elif (first_image == 'rock' and second_image == 'scissors' or
+          first_image == 'scissors' and second_image == 'rock'):
+        winner = "Rock wins"
+
+    elif (first_image == 'rock' and second_image == 'paper' or
+          first_image == 'paper' and second_image == 'rock'):
+        winner = "Paper wins"
+
+    elif (first_image == 'paper' and second_image == 'scissors' or
+          first_image == 'scissors' and second_image == 'paper'):
+        winner = "Scissors wins"
+
+    return winner
+
+
+# Read and preprocess the images and put 2 images in separate variables
+image1 = load_and_preprocess_image(selectRandomPicture(folder_path))
+image2 = load_and_preprocess_image(selectRandomPicture(folder_path))
+
+# Predict the labels of the images
+images = np.array([image1, image2])
+predictions = vgg16_model.predict(images)
+predicted_classes = np.argmax(predictions, axis=1)
+
+firs_img = class_labels[predicted_classes[0]]
+sec_img = class_labels[predicted_classes[1]]
+
+# Plot the images
+plt.figure(figsize=(8, 5))
+plt.subplot(1, 2, 1)
+plt.imshow(image1)
+plt.title(class_labels[predicted_classes[0]])
+plt.axis('off')
+# Plot/Display the last result
+plt.subplot(1, 2, 2)
+plt.imshow(image2)
+plt.title(class_labels[predicted_classes[1]])
+plt.axis('off')
+plt.tight_layout()
+plt.suptitle(f'{whos_winner(firs_img, sec_img)}!')
+plt.show()
+
+print(f'The winner is:{whos_winner(firs_img, sec_img)}')

Rock_Paper_Scissors_VGG16.py

@@ -0,0 +1,186 @@
+import os
+import numpy as np
+from keras import applications, Sequential
+from keras.callbacks import ReduceLROnPlateau, EarlyStopping, ModelCheckpoint
+from keras.layers import Dense, Dropout, Flatten, BatchNormalization
+from keras.optimizers import Adam, SGD
+from keras.preprocessing.image import ImageDataGenerator
+from keras.regularizers import l2
+from matplotlib import pyplot as plt
+from sklearn.metrics import classification_report, confusion_matrix
+
+# Part 1
+# a) visualized samples from the dataset, i.e.: rock, paper, scissors hand signs
+# with the appropriate labels
+# b) summary of the model architecture in a form of a plot or text
+# c) model accuracy evaluation plot after the training concludes
+# d) model loss evaluation plot after the training concludes
+
+
+# Image directory's and defining the dimensions & Batch size as well as epochs
+base_dir = '../rps'
+train_dir = os.path.join(base_dir, 'train')
+valid_dir = os.path.join(base_dir, 'validation')
+BATCH_SIZE = 32
+EPOCHS = 7
+img_width, img_height = 224, 224
+# Define L2 regularization coefficient to prevent overfitting
+l2_reg = 0.00001
+
+# Optimization + Learning rate variables
+opt = Adam(learning_rate=1e-4)
+opt1 = Adam(learning_rate=2e-4)
+opt2 = Adam(learning_rate=0.0001)
+opt3 = SGD(learning_rate=1e-4, momentum=0.99)
+
+# Preparing the Train/Validation and Augmentation Data
+train_datagen = ImageDataGenerator(
+    rescale=1.0 / 255,
+    rotation_range=90,
+    zoom_range=0.1,
+    width_shift_range=0.2,
+    height_shift_range=0.2,
+    shear_range=0.2,
+    # horizontal_flip=True,
+    vertical_flip=True,
+    brightness_range=(0.2, 1),
+    fill_mode='nearest',
+    validation_split=0.2)
+
+train_generator = train_datagen.flow_from_directory(
+    train_dir,
+    shuffle=True,
+    target_size=(img_width, img_height),
+    batch_size=BATCH_SIZE,
+    class_mode='categorical',
+    subset='training')
+
+# a) Visualize samples from the dataset
+class_names = ['paper', 'rock', 'scissors']
+images, labels = train_generator.next()
+plt.figure(figsize=(10, 10))
+for i in range(9):
+    plt.subplot(3, 3, i + 1)
+    label_index = np.argmax(labels[i])
+    plt.title('Label: ' + class_names[label_index])
+    plt.imshow(images[i])
+    plt.tight_layout()
+    plt.axis('off')
+plt.show()
+
+validation_datagen = ImageDataGenerator(rescale=1.0 / 255)
+validation_generator = validation_datagen.flow_from_directory(
+    valid_dir,
+    target_size=(img_width, img_height),
+    batch_size=BATCH_SIZE,
+    class_mode='categorical')
+
+# -------Callbacks-------------#
+# It'll save the best trained weight
+checkpoint = ModelCheckpoint(
+    filepath='best_weights.hdf5',
+    monitor='val_loss',
+    verbose=1,
+    save_best_only=True,
+    mode='min',
+    save_weights_only=False
+)
+# Early stop = in case of high Validation Loss
+early_stop = EarlyStopping(
+    monitor='val_loss',
+    min_delta=0.001,
+    patience=5,
+    verbose=1,
+    mode='auto'
+)
+# Defining a learning rate reduction callback when its necessary it'll reduce
+#  the learning rate when its necessary
+lr_reduction = ReduceLROnPlateau(
+    monitor='val_loss',
+    factor=0.2,
+    patience=2,
+    verbose=1,
+    mode='auto',
+    cooldown=1,
+    min_lr=0.000001
+)
+callbacks = [checkpoint, early_stop, lr_reduction]
+
+# Load the pre-trained VGG16 model without the top layer
+base_model = applications.VGG16(weights='imagenet', include_top=False, pooling='max',
+                                input_shape=(img_width, img_height, 3))
+
+# Freeze the pre-trained layers from 0-14,
+# so they are not updated during training
+for layer in base_model.layers[:10]:
+    layer.trainable = False
+# b) summary of base model
+base_model.summary()
+
+# Adding custom layers on top of VGG16
+model = Sequential()
+model.add(base_model)
+model.add(Flatten())
+model.add(Dense(512, activation='relu', kernel_regularizer=l2(l2_reg)))
+model.add(BatchNormalization())
+model.add(Dropout(0.3))
+model.add(Dense(3, activation='softmax', kernel_regularizer=l2(l2_reg)))
+# b) summary of model
+model.summary()
+
+# Compile the model
+model.compile(optimizer=opt,
+              loss='categorical_crossentropy',
+              metrics=['accuracy'])
+
+# Finally we train the model with our desired adjustments
+history = model.fit(
+    train_generator,
+    epochs=EPOCHS,
+    callbacks=callbacks,
+    validation_data=validation_generator)
+
+
+# Plotting the Models 'accuracy' & 'loss'
+def eval_plot(history):
+    plt.figure(figsize=(14, 5))
+
+    # Accuracy plot
+    plt.subplot(1, 2, 1)
+    acc = history.history['accuracy']
+    val_acc = history.history['val_accuracy']
+    epochs = range(len(acc))
+    acc_plot, = plt.plot(epochs, acc, 'r')
+    val_acc_plot, = plt.plot(epochs, val_acc, 'b')
+    plt.title('Training and Validation Accuracy')
+    plt.legend([acc_plot, val_acc_plot], ['Training Accuracy', 'Validation Accuracy'])
+
+    # Loss plot
+    plt.subplot(1, 2, 2)
+    loss = history.history['loss']
+    val_loss = history.history['val_loss']
+    epochs = range(len(loss))
+    loss_plot, = plt.plot(epochs, loss, 'r')
+    val_loss_plot, = plt.plot(epochs, val_loss, 'b')
+    plt.title('Training and Validation Loss')
+    plt.legend([loss_plot, val_loss_plot], ['Training Loss', 'Validation Loss'])
+    plt.tight_layout()
+    plt.show()
+
+
+# Evaluate the Process to find out how well the model has been trained
+def evaluate(model):
+    num_of_test_samples = len(validation_generator.filenames)
+
+    y_pred = model.predict(validation_generator, num_of_test_samples // BATCH_SIZE + 1)
+    y_pred = np.argmax(y_pred, axis=1)
+    print('\nConfusion Matrix\n')
+    print(confusion_matrix(validation_generator.classes, y_pred))
+    print('\n\nClassification Report\n')
+    target_names = ['Paper', 'Rock', 'Scissors']
+    print(classification_report(validation_generator.classes, y_pred, target_names=target_names))
+
+
+eval_plot(history)
+evaluate(model)
+model.save('../Rock_Paper_Scissors_VGG16/RPS_Model.hdf5')

best_weights.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf61b1d4dad01b6cc0ed83fc6b4aa8167540e9fadcdafda8a765eb56bda7ca85
+size 165984992