Skip to content
Snippets Groups Projects
Commit 668e8ce6 authored by Michiel_VE's avatar Michiel_VE
Browse files

update what image is send

parent aaf61b9f
No related branches found
No related tags found
1 merge request!1made so code can be trained on GPU
Hide whitespace changes
Inline Side-by-side
Func/ClassifierModule.py
+ 8
− 7
View file @ 668e8ce6
import keras
import numpy as np
import cv2
from cvzone.HandTrackingModule import HandDetector
class Classifier:
......@@ -20,7 +21,8 @@ class Classifier:
else:
print("No Labels Found")
def getPrediction(self, img, draw=True, pos=(50, 50), scale=2, color=(0, 255, 0)):
def getPrediction(self, img):
cv2.imshow("imgFixed classifier", img)
img_resized = cv2.resize(img, (224, 224))
image_array = np.asarray(img_resized)
normalized_image_array = (image_array.astype(np.float32) / 127.0) - 1
......@@ -30,30 +32,29 @@ class Classifier:
prediction = self.model.predict(self.data)
index_val = np.argmax(prediction)
if draw and self.labels_path:
label_text = str(self.list_labels[index_val])
cv2.putText(img, label_text, pos, cv2.FONT_HERSHEY_COMPLEX, scale, color, 2)
return list(prediction[0]), index_val
def main():
cap = cv2.VideoCapture(0)
detector = HandDetector(maxHands=1)
mask_classifier = Classifier('Model/keras_model.h5', 'Model/labels.txt')
while True:
ret, frame = cap.read()
hands, img = detector.findHands(frame)
if not ret:
print("Failed to capture frame")
break
prediction = mask_classifier.getPrediction(frame)
prediction = mask_classifier.getPrediction(img)
print("Prediction:", prediction)
cv2.imshow("Image", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
......
Func/DrawImages.py 0 → 100644
+ 20
− 0
View file @ 668e8ce6
import matplotlib.pyplot as plt
import numpy as np
def plot_images(images, labels, class_indices):
num_images = len(images)
grid_size = int(np.ceil(np.sqrt(num_images)))
plt.figure(figsize=(15, 15))
for i in range(num_images):
plt.subplot(grid_size, grid_size, i + 1)
img = images[i]
plt.imshow(img)
label = np.argmax(labels[i])
label_name = list(class_indices.keys())[list(class_indices.values()).index(label)]
plt.title(label_name)
plt.axis('off')
plt.tight_layout()
plt.show()
\ No newline at end of file
Func/Helpers.py
+ 3
− 2
View file @ 668e8ce6
......@@ -21,7 +21,8 @@ def CalculateHeight(size, h, w, imgCropped, imgFixed):
def GetPrediction(classifier, imgFixed):
prediction, index = classifier.getPrediction(imgFixed, draw=False)
cv2.imshow('imgFixed helper', imgFixed)
prediction, index = classifier.getPrediction(imgFixed)
return prediction, index
......@@ -35,4 +36,4 @@ def GetLabels(path):
letter = parts[1]
letters.append(letter)
return letters
return letters
\ No newline at end of file
Model/labels.txt
+ 3
− 1
View file @ 668e8ce6
0 A
1 B
2 C
3 D
\ No newline at end of file
3 D
4 E
5 F
\ No newline at end of file
main.py
+ 2
− 1
View file @ 668e8ce6
......@@ -45,6 +45,7 @@ while True:
else:
CalculateHeight(size, h, w, imgCropped, imgFixed)
cv2.imshow("imgFixed", imgFixed)
prediction, index = GetPrediction(classifier, imgFixed)
print('pred', prediction)
......@@ -52,7 +53,7 @@ while True:
cv2.putText(imgOutput, letters[index], (x, y), cv2.FONT_HERSHEY_TRIPLEX, 2, (255, 0, 255), 2)
cv2.imshow("img", imgOutput)
cv2.imshow("img main", imgOutput)
key = cv2.waitKey(1)
if key == ord('p'):
......
trainModel.ipynb
+ 68
− 46
View file @ 668e8ce6
%% Cell type:code id:62c6c5c3-d2ba-4e79-b533-828c3083e8ea tags:
``` python
import time
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.losses import CategoricalCrossentropy
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.optimizers import Adam
import tensorflow as tf
from keras import layers, models
from Func.getSubFolders import count_sub_folders
path = 'Data'
output = 'Model/keras_model.h5'
start_time = time.time()
# runtime error
# physical_devices = tf.config.experimental.list_physical_devices('GPU')
# print("Num GPUs Available: ", len(physical_devices))
# if len(physical_devices) > 0:
# tf.config.experimental.set_memory_growth(physical_devices[0], True)
# else:
# print("No GPU available. Using CPU.")
physical_devices = tf.config.list_physical_devices('GPU')
print("Num GPUs Available: ", len(physical_devices))
if len(physical_devices) > 0:
try:
# Set memory growth to true
for device in physical_devices:
tf.config.experimental.set_memory_growth(device, True)
# Optionally, you can set a memory limit if necessary
# tf.config.set_logical_device_configuration(
# physical_devices[0],
# [tf.config.LogicalDeviceConfiguration(memory_limit=4096)]) # Set to 4GB
except RuntimeError as e:
print(e)
else:
print("No GPU available. Using CPU.")
# Step 1: Load and Preprocess Images
datagen = ImageDataGenerator(
rescale=1. / 255,
validation_split=0.2,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
)
test_datagen = ImageDataGenerator(rescale=1. / 255)
# Step 2: Label the Data
train_set = datagen.flow_from_directory(
path,
target_size=(224, 224),
batch_size=32,
target_size=(300, 300),
batch_size=64,
class_mode='categorical',
subset='training'
)
test_set = datagen.flow_from_directory(
path,
target_size=(224, 224),
batch_size=32,
target_size=(300, 300),
batch_size=64,
class_mode='categorical',
subset='validation'
)
# draw Images
# images, labels = next(test_set)
# class_indices = test_set.class_indices
# plot_images(images, labels, class_indices)
# Step 4: Build the Model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(224, 224, 3), activation='relu'))
model.add(Conv2D(32, (3, 3), input_shape=(300, 300, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(units=256, activation='relu'))
model.add(Dense(units=128, activation='relu'))
model.add(Dense(units=count_sub_folders(path), activation='softmax'))
# def createLayers(input_shape=(224, 224, 3)):
# inputs = tf.keras.Input(shape=input_shape)
#
# x = layers.Conv2D(48, (1, 1), padding='same', use_bias=False, name='block_1_expand')(inputs)
# x = layers.BatchNormalization(name='block_1_expand_BN')(x)
# x = layers.ReLU(6., name='block_1_expand_relu')(x)
#
# x = layers.DepthwiseConv2D((3, 3), padding='same', use_bias=False, name='block_1_depthwise')(x)
# x = layers.BatchNormalization(name='block_1_depthwise_BN')(x)
# x = layers.ReLU(6., name='block_1_depthwise_relu')(x)
#
# x = layers.Conv2D(8, (1, 1), padding='same', use_bias=False, name='block_1_project')(x)
# x = layers.BatchNormalization(name='block_1_project_BN')(x)
#
# for i in range(2,5):
# x1 = layers.Conv2D(48, (1, 1), padding='same', use_bias=False, name=f'block_{i}_expand')(x)
# x1 = layers.BatchNormalization(name=f'block_{i}_expand_BN')(x1)
# x1 = layers.ReLU(6., name=f'block_{i}_expand_relu')(x1)
#
# x1 = layers.DepthwiseConv2D((3, 3), padding='same', use_bias=False, name=f'block_{i}_depthwise')(x1)
# x1 = layers.BatchNormalization(name=f'block_{i}_depthwise_BN')(x1)
# x1 = layers.ReLU(6., name=f'block_{i}_depthwise_relu')(x1)
#
# x1 = layers.Conv2D(8, (1, 1), padding='same', use_bias=False, name=f'block_{i}_project')(x1)
# x1 = layers.BatchNormalization(name=f'block_{i}_project_BN')(x1)
#
# x = layers.Add(name=f'block_{i}_add')([x, x1])
#
# x = tf.keras.layers.GlobalAveragePooling2D()(x)
# outputs = tf.keras.layers.Dense(count_sub_folders(path), activation='softmax')(x)
# model = models.Model(inputs, outputs, name='testModel')
#
# return model
#
#
# model = createLayers()
# Compile the Model after pruning
model.compile(optimizer=Adam(learning_rate=0.001),
loss=CategoricalCrossentropy(from_logits=False),
metrics=['accuracy'])
# Step 6: Train the Model
early_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
model.fit(train_set, validation_data=test_set, epochs=10, callbacks=early_stopping)
# Step 7: Evaluate the Model
loss, accuracy = model.evaluate(test_set)
print(f'Test loss: {loss}, Test accuracy: {accuracy}')
# Save the trained model
model.save(output)
end_time = time.time()
execute_time = (end_time - start_time) / 60
model.summary()
# Print the result
print(f"It took: {execute_time:0.2f} minutes")
```
%% Output
Num GPUs Available: 1
Physical devices cannot be modified after being initialized
Found 1529 images belonging to 6 classes.
Found 380 images belonging to 6 classes.
Epoch 1/10
48/48 [==============================] - 29s 470ms/step - loss: 1.0985 - accuracy: 0.5284 - val_loss: 0.7411 - val_accuracy: 0.6868
24/24 [==============================] - 21s 851ms/step - loss: 1.1108 - accuracy: 0.5134 - val_loss: 0.8370 - val_accuracy: 0.6842
Epoch 2/10
48/48 [==============================] - 20s 417ms/step - loss: 0.5369 - accuracy: 0.7757 - val_loss: 0.5103 - val_accuracy: 0.7921
24/24 [==============================] - 21s 862ms/step - loss: 0.6156 - accuracy: 0.7613 - val_loss: 0.4063 - val_accuracy: 0.8447
Epoch 3/10
48/48 [==============================] - 20s 417ms/step - loss: 0.2837 - accuracy: 0.8875 - val_loss: 0.8421 - val_accuracy: 0.7105
24/24 [==============================] - 22s 915ms/step - loss: 0.2704 - accuracy: 0.9006 - val_loss: 0.2283 - val_accuracy: 0.9316
Epoch 4/10
48/48 [==============================] - 20s 417ms/step - loss: 0.1952 - accuracy: 0.9228 - val_loss: 0.2502 - val_accuracy: 0.8947
24/24 [==============================] - 22s 909ms/step - loss: 0.1532 - accuracy: 0.9477 - val_loss: 0.1145 - val_accuracy: 0.9579
Epoch 5/10
48/48 [==============================] - 20s 419ms/step - loss: 0.1007 - accuracy: 0.9647 - val_loss: 0.0922 - val_accuracy: 0.9632
24/24 [==============================] - 22s 905ms/step - loss: 0.1324 - accuracy: 0.9516 - val_loss: 0.2525 - val_accuracy: 0.9026
Epoch 6/10
48/48 [==============================] - 19s 404ms/step - loss: 0.0690 - accuracy: 0.9719 - val_loss: 0.1608 - val_accuracy: 0.9316
24/24 [==============================] - 22s 912ms/step - loss: 0.0737 - accuracy: 0.9719 - val_loss: 0.0519 - val_accuracy: 0.9816
Epoch 7/10
48/48 [==============================] - 19s 406ms/step - loss: 0.0707 - accuracy: 0.9745 - val_loss: 0.1129 - val_accuracy: 0.9500
24/24 [==============================] - 23s 952ms/step - loss: 0.0663 - accuracy: 0.9797 - val_loss: 0.0544 - val_accuracy: 0.9842
Epoch 8/10
48/48 [==============================] - 19s 401ms/step - loss: 0.0674 - accuracy: 0.9791 - val_loss: 0.0428 - val_accuracy: 0.9868
24/24 [==============================] - 22s 918ms/step - loss: 0.0482 - accuracy: 0.9817 - val_loss: 0.0489 - val_accuracy: 0.9711
Epoch 9/10
48/48 [==============================] - 19s 400ms/step - loss: 0.0260 - accuracy: 0.9922 - val_loss: 0.0619 - val_accuracy: 0.9711
24/24 [==============================] - 22s 928ms/step - loss: 0.0240 - accuracy: 0.9908 - val_loss: 0.0337 - val_accuracy: 0.9868
Epoch 10/10
48/48 [==============================] - 20s 404ms/step - loss: 0.0142 - accuracy: 0.9961 - val_loss: 0.0146 - val_accuracy: 0.9947
12/12 [==============================] - 4s 329ms/step - loss: 0.0094 - accuracy: 0.9974
Test loss: 0.009386303834617138, Test accuracy: 0.9973683953285217
Model: "sequential"
24/24 [==============================] - 22s 911ms/step - loss: 0.0224 - accuracy: 0.9922 - val_loss: 0.0411 - val_accuracy: 0.9895
6/6 [==============================] - 4s 717ms/step - loss: 0.0078 - accuracy: 1.0000
Test loss: 0.007844111882150173, Test accuracy: 1.0
Model: "sequential_32"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 222, 222, 32) 896
conv2d_128 (Conv2D) (None, 222, 222, 32) 896
max_pooling2d (MaxPooling2D (None, 111, 111, 32) 0
)
max_pooling2d_128 (MaxPooli (None, 111, 111, 32) 0
ng2D)
conv2d_1 (Conv2D) (None, 109, 109, 64) 18496
conv2d_129 (Conv2D) (None, 109, 109, 64) 18496
max_pooling2d_1 (MaxPooling (None, 54, 54, 64) 0
2D)
max_pooling2d_129 (MaxPooli (None, 54, 54, 64) 0
ng2D)
conv2d_2 (Conv2D) (None, 52, 52, 128) 73856
conv2d_130 (Conv2D) (None, 52, 52, 128) 73856
max_pooling2d_2 (MaxPooling (None, 26, 26, 128) 0
2D)
max_pooling2d_130 (MaxPooli (None, 26, 26, 128) 0
ng2D)
conv2d_3 (Conv2D) (None, 24, 24, 256) 295168
conv2d_131 (Conv2D) (None, 24, 24, 256) 295168
max_pooling2d_3 (MaxPooling (None, 12, 12, 256) 0
2D)
max_pooling2d_131 (MaxPooli (None, 12, 12, 256) 0
ng2D)
flatten (Flatten) (None, 36864) 0
flatten_32 (Flatten) (None, 36864) 0
dense (Dense) (None, 256) 9437440
dense_96 (Dense) (None, 256) 9437440
dense_1 (Dense) (None, 128) 32896
dense_97 (Dense) (None, 128) 32896
dense_2 (Dense) (None, 6) 774
dense_98 (Dense) (None, 6) 774
=================================================================
Total params: 9,859,526
Trainable params: 9,859,526
Non-trainable params: 0
_________________________________________________________________
It took: 3.55 minutes
It took: 3.74 minutes
%% Cell type:code id:67803a21-51f7-4bec-98fc-4efa8f75bab9 tags:
%% Cell type:code id:ec102c63-b7d9-4f22-9f3e-a6bd12995a4f tags:
``` python
```
......
trainModel.py
+ 2
− 2
View file @ 668e8ce6
......@@ -37,7 +37,7 @@ train_set = datagen.flow_from_directory(
test_set = datagen.flow_from_directory(
path,
target_size=(224, 224),
target_size=(300, 300),
batch_size=32,
class_mode='categorical',
subset='validation'
......@@ -45,7 +45,7 @@ test_set = datagen.flow_from_directory(
# Step 4: Build the Model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(224, 224, 3), activation='relu'))
model.add(Conv2D(32, (3, 3), input_shape=(300, 300, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment