Update app.py

app.py

@@ -1,3 +1,218 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import PIL
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.models import Sequential
+import gdown
+import zipfile
+import pathlib
+
+# Define the Google Drive shareable link
+gdrive_url = 'https://drive.google.com/file/d/1HjHYlQyRz5oWt8kehkt1TiOGRRlKFsv8/view?usp=drive_link'
+
+# Extract the file ID from the URL
+file_id = gdrive_url.split('/d/')[1].split('/view')[0]
+direct_download_url = f'https://drive.google.com/uc?id={file_id}'
+
+# Define the local filename to save the ZIP file
+local_zip_file = 'file.zip'
+
+# Download the ZIP file
+gdown.download(direct_download_url, local_zip_file, quiet=False)
+
+# Directory to extract files
+extracted_path = 'extracted_files'
+
+# Verify if the downloaded file is a ZIP file and extract it
+try:
+    with zipfile.ZipFile(local_zip_file, 'r') as zip_ref:
+        zip_ref.extractall(extracted_path)
+    print("Extraction successful!")
+except zipfile.BadZipFile:
+    print("Error: The downloaded file is not a valid ZIP file.")
+
+# Optionally, you can delete the ZIP file after extraction
+os.remove(local_zip_file)
+
+# Convert the extracted directory path to a pathlib.Path object
+data_dir = pathlib.Path(extracted_path)
+
+# Print the directory structure to debug
+for root, dirs, files in os.walk(extracted_path):
+    level = root.replace(extracted_path, '').count(os.sep)
+    indent = ' ' * 4 * (level)
+    print(f"{indent}{os.path.basename(root)}/")
+    subindent = ' ' * 4 * (level + 1)
+    for f in files:
+        print(f"{subindent}{f}")
+
+# Path to the dataset directory
+data_dir = pathlib.Path('extracted_files/Pest_Dataset')
+data_dir = pathlib.Path(data_dir)
+
+image_count = len(list(data_dir.glob('*/*.jpg')))
+print(image_count)
+
+bees = list(data_dir.glob('bees/*'))
+print(bees[0])
+PIL.Image.open(str(bees[0]))
+
+batch_size = 32
+img_height = 180
+img_width = 180
+
+train_ds = tf.keras.utils.image_dataset_from_directory(
+  data_dir,
+  validation_split=0.2,
+  subset="training",
+  seed=123,
+  image_size=(img_height, img_width),
+  batch_size=batch_size)
+
+
+val_ds = tf.keras.utils.image_dataset_from_directory(
+  data_dir,
+  validation_split=0.2,
+  subset="validation",
+  seed=123,
+  image_size=(img_height, img_width),
+  batch_size=batch_size)
+
+
+class_names = train_ds.class_names
+print(class_names)
+
+plt.figure(figsize=(10, 10))
+for images, labels in train_ds.take(1):
+  for i in range(9):
+    ax = plt.subplot(3, 3, i + 1)
+    plt.imshow(images[i].numpy().astype("uint8"))
+    plt.title(class_names[labels[i]])
+    plt.axis("off")
+
+
+for image_batch, labels_batch in train_ds:
+  print(image_batch.shape)
+  print(labels_batch.shape)
+  break
+
+AUTOTUNE = tf.data.AUTOTUNE
+
+train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
+val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
+
+
+normalization_layer = layers.Rescaling(1./255)
+
+normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
+image_batch, labels_batch = next(iter(normalized_ds))
+first_image = image_batch[0]
+# Notice the pixel values are now in `[0,1]`.
+print(np.min(first_image), np.max(first_image))
+
+data_augmentation = keras.Sequential(
+  [
+    layers.RandomFlip("horizontal",
+                      input_shape=(img_height,
+                                  img_width,
+                                  3)),
+    layers.RandomRotation(0.1),
+    layers.RandomZoom(0.1),
+  ]
+)
+
+plt.figure(figsize=(10, 10))
+for images, _ in train_ds.take(1):
+  for i in range(9):
+    augmented_images = data_augmentation(images)
+    ax = plt.subplot(3, 3, i + 1)
+    plt.imshow(augmented_images[0].numpy().astype("uint8"))
+    plt.axis("off")
+
+
+from tensorflow.keras.applications import EfficientNetB0
+
+base_model = EfficientNetB0(weights='imagenet', include_top=False, input_shape=(img_height, img_width, 3))
+
+# Freeze the pre-trained weights
+base_model.trainable = False
+
+# Create new model on top
+inputs = keras.Input(shape=(img_height, img_width, 3))
+x = data_augmentation(inputs)  # Apply data augmentation
+x = base_model(x, training=False)
+x = keras.layers.GlobalAveragePooling2D()(x)
+x = keras.layers.Dropout(0.2)(x)
+outputs = keras.layers.Dense(len(class_names), activation='softmax')(x)
+
+
+# Compile the model
+model = keras.Model(inputs, outputs)
+model.compile(optimizer='adam',
+              loss='sparse_categorical_crossentropy',
+              metrics=['accuracy'])
+
+model.summary()
+
+# Train the model
+epochs = 10
+history = model.fit(
+  train_ds,
+  validation_data=val_ds,
+  epochs=epochs
+)
+
+
+# Plot training history
+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()
+
+
+# Evaluate the model on the validation dataset
+results = model.evaluate(val_ds, verbose=0)
+
+print("Validation Loss: {:.5f}".format(results[0]))
+print("Validation Accuracy: {:.2f}%".format(results[1] * 100))
+
+
+import gradio as gr
+import numpy as np
+import tensorflow as tf
+
+def predict_image(img):
+    img = np.array(img)
+    img_resized = tf.image.resize(img, (180, 180))
+    img_4d = tf.expand_dims(img_resized, axis=0)
+    prediction = model.predict(img_4d)[0]
+    return {class_names[i]: float(prediction[i]) for i in range(len(class_names))}
+
+image = gr.Image()
+label = gr.Label(num_top_classes=1)
+
+
 # Define custom CSS for background image
 custom_css = """
 body {