Energyusage-testing

ae_create_train.py

@@ -10,23 +10,17 @@
 from tensorflow.keras.layers import Dense, Conv2D, Dropout, Flatten, MaxPooling2D, UpSampling2D, Activation
 from tensorflow.keras.preprocessing.image import ImageDataGenerator
 import sys
-#import ae_import_evaluate as aeie
 
-# Tensorflow configuration settings
-#tf.config.experimental_run_functions_eagerly(True)
-#gpu_devices = tf.config.experimental.list_physical_devices('GPU')
-#tf.config.experimental.set_memory_growth(gpu_devices[0], True)
-
-def import_classification_datasets(image_size, batch_size):
+def import_classification_dataset(image_size, batch_size):
 
     # Create an ImageDataGenerator to load the images
     image_datagen = ImageDataGenerator(rescale=1/255, validation_split=0.2)
     test_image_datagen = ImageDataGenerator(rescale=1/255)
 
-    no_fire_train_dir   = 'D:/UAF/CS Capstone/Datasets/No_Fire_Images/Training/'
-    no_fire_test_dir    = 'D:/UAF/CS Capstone/Datasets/No_Fire_Images/Training/'
-    fire_train_dir      = 'D:/UAF/CS Capstone/Datasets/Fire_Images/Training/'
-    fire_test_dir       = 'D:/UAF/CS Capstone/Datasets/Fire_Images/Test/'
+    no_fire_train_dir   = './No_Fire_Images/Training/'
+    no_fire_test_dir    = './No_Fire_Images/Test/'
+    fire_train_dir      = './Fire_Images/Training/'
+    fire_test_dir       = './Fire_Images/Test/'
 
     ### No Fire Datasets ###
     no_fire_train_ds = image_datagen.flow_from_directory(
@@ -78,54 +72,6 @@ def import_classification_datasets(image_size, batch_size):
 
     return no_fire_train_ds, no_fire_validation_ds, no_fire_test_ds, fire_train_ds, fire_validation_ds, fire_test_ds
 
-def import_segmentation_dataset(image_size, batch_size):
-
-    # Create an ImageDataGenerator to load the images
-    image_datagen = ImageDataGenerator(rescale=1/255, validation_split=0.2)
-    mask_datagen = ImageDataGenerator(rescale=1/255, validation_split=0.2)
-
-    image_dir = 'D:/UAF/CS Capstone/Datasets/Segmentation/Images'
-    mask_dir = 'D:/UAF/CS Capstone/Datasets/Segmentation/Masks'
-
-    ### Image Datasets ###
-    image_train_ds = image_datagen.flow_from_directory(
-        image_dir,
-        target_size=image_size,
-        batch_size=batch_size,
-        class_mode=None,
-        shuffle=True,
-        subset='training')
-
-    image_val_ds = image_datagen.flow_from_directory(
-        image_dir,
-        target_size=image_size,
-        batch_size=batch_size,
-        class_mode=None,
-        shuffle=True,
-        subset='validation')
-
-    ### Masks Datasets ###
-    mask_train_ds = mask_datagen.flow_from_directory(
-        mask_dir,
-        target_size=image_size,
-        batch_size=batch_size,
-        class_mode=None,
-        shuffle=True,
-        subset='training')
-
-    mask_val_ds = mask_datagen.flow_from_directory(
-        mask_dir,
-        target_size=image_size,
-        batch_size=batch_size,
-        class_mode=None,
-        shuffle=True,
-        subset='validation')
-
-    train_ds = zip(image_train_ds, mask_train_ds)
-    val_ds = zip(image_val_ds, mask_val_ds)
-
-    return train_ds, val_ds
-
 
 def create_ae_model(input_shape):
 
@@ -158,23 +104,25 @@ def create_ae_model(input_shape):
 
     return autoencoder
 
+
 # Structural Similarity Index Measure loss function
 def ssim_loss(y_true, y_pred):
     return 1 - image.ssim(y_true, y_pred, max_val=1.0)
 
 
-def train(model, train_ds, validation_ds, epochs):
+def ae_train(model, train_ds, validation_ds, epochs):
     model.fit(train_ds, validation_data=validation_ds, epochs=epochs)
     return model
 
 
 def main():
 
     # Train Setup
-    image_size = (254, 254)    #image_size = (3480, 2160) # Change padding on the last layer in the decoder to 'same' when doing 4K images
-    batch_size = 32            #batch_size = 4 
-    no_fire_train_ds, no_fire_validation_ds, no_fire_test_ds, fire_train_ds, fire_validation_ds, fire_test_ds = import_classification_datasets(image_size, batch_size)
-    #train_ds, val_ds = import_segmentation_dataset(image_size, batch_size)
+    image_size = (254, 254)
+    batch_size = 32
+    no_fire_train_ds, no_fire_validation_ds, no_fire_test_ds, fire_train_ds, fire_validation_ds, fire_test_ds = import_classification_dataset(image_size, batch_size)
+
+    # Check for available GPUs
     print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))
     print(tf.config.list_physical_devices('GPU'))
 
@@ -192,12 +140,12 @@ def main():
     optimizer = 'adam'
     loss_function_name = 'ssim'
     loss_function = ssim_loss
+    epochs = 10
     metrics = ['accuracy']
-    epochs = 5
 
     # Train
     model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics)
-    model = train(model, no_fire_train_ds, no_fire_validation_ds, epochs)
+    model = ae_train(model, no_fire_train_ds, no_fire_validation_ds, epochs)
 
     # Save
     model.save(f'C:/Users/Hunter/Desktop/Spring 2023/CS Capstone/GitHub/ForestFireDetection/Models/weights/forest_fire_ae_{image_size[0]}x{image_size[1]}_{optimizer}_{loss_function_name}_{epochs}.h5')

ae_import_evaluate.py

@@ -7,24 +7,25 @@
 import tensorflow as tf
 import cv2
 import numpy as np
-import ae_create_train as aect
 import glob as gb
 import os
+import ae_create_train as aect
 
 
 def import_ae_model(model, path):
     model.load_weights(path)
     return model
 
-def evaluate(model, dataset):
+
+def ae_evaluate(model, dataset):
     model.evaluate(x=dataset)
 
 
 def main():
     # Setup
     image_size = (254, 254)
     batch_size = 32
-    no_fire_train_ds, no_fire_validation_ds, no_fire_test_ds, fire_train_ds, fire_validation_ds, fire_test_ds = aect.import_classification_datasets(image_size, batch_size)
+    no_fire_train_ds, no_fire_validation_ds, no_fire_test_ds, fire_train_ds, fire_validation_ds, fire_test_ds = aect.import_classification_dataset(image_size, batch_size)
     image_shape = image_size + (3, )
     model = aect.create_ae_model(image_shape)
     model.build((None, ) + image_shape)

pyJoules_demo.ipynb

@@ -0,0 +1,78 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import Library\n",
+    "import pyJoules"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Only works on:\n",
+    "* GNU/Linux\n",
+    "\n",
+    "It monitors the energy consumed by specific device of the host machine such as :\n",
+    "\n",
+    "* intel CPU socket package\n",
+    "* RAM (for intel server architectures)\n",
+    "* intel integrated GPU (for client architectures)\n",
+    "* nvidia GPU\n",
+    "\n",
+    "Requires:\n",
+    "* python >= 3.7\n",
+    "* nvml (if you want nvidia GPU support)\n",
+    "\n",
+    "Install:\n",
+    "* pip install pyJoules\n",
+    "* pip install pyJoules[nvidia] (Measures Nvidia GPU)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyJoules.energy_meter import measure_energy\n",
+    "\n",
+    "@measure_energy\n",
+    "# Test Function\n",
+    "def recursive_fib(n):\n",
+    "    if (n <= 2): return 1\n",
+    "    else: return recursive_fib(n-1) + recursive_fib(n-2)\n",
+    "\n",
+    "num = 40\n",
+    "recursive_fib(num)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "forestfiredetection_gpu",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

unet_create_train.py

@@ -170,12 +170,13 @@ def train(model, train_ds, validation_ds, epochs):
 def main():
 
     # Train Setup
-    #image_size = (3480, 2160)   # Delete cropped layer to make this dimensionally fit
     image_size = (254, 254)     
-    #batch_size = 1
-    batch_size = 16            
+    batch_size = 16
     no_fire_train_ds, no_fire_validation_ds, no_fire_test_ds, fire_train_ds, fire_validation_ds, fire_test_ds = import_classification_datasets(image_size, batch_size)
+    #image_size = (3480, 2160), #batch_size = 1, for segmentation dataset   # Delete cropped layer to make this dimensionally fit
     #train_ds, val_ds = import_segmentation_dataset(image_size, batch_size)
+
+    # Check for available GPUs
     print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))
     print(tf.config.list_physical_devices('GPU'))
 
@@ -193,8 +194,8 @@ def main():
     optimizer = 'adam'
     loss_function_name = 'ssim'
     loss_function = ssim_loss
-    metrics = ['accuracy']
     epochs = 5
+    metrics = ['accuracy']
 
     # Train
     model.compile(optimizer=optimizer, loss=loss_function, metrics=metrics)