Upload 4 files

README.md

@@ -1,12 +1,38 @@
----
-title: Image Classification
-emoji: 🐢
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-sdk_version: 5.34.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Cat vs Dog Classifier
+emoji: 🐱🐶
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.21.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Cat vs Dog Image Classifier
+
+A deep learning model that classifies images of cats and dogs with TensorFlow/Keras.
+
+![Demo](https://example.com/demo.gif)  <!-- Replace with actual demo GIF -->
+
+## 🚀 Try it out!
+
+[![Open in Spaces](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue.svg)](https://huggingface.co/spaces/Ahmedhassan54/Image-Classification)
+
+## 🛠️ Technical Details
+
+### Model Architecture
+```python
+Sequential([
+    Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)),
+    MaxPooling2D((2,2)),
+    Conv2D(64, (3,3), activation='relu'),
+    MaxPooling2D((2,2)),
+    Conv2D(128, (3,3), activation='relu'),
+    MaxPooling2D((2,2)),
+    Flatten(),
+    Dense(512, activation='relu'),
+    Dropout(0.5),
+    Dense(1, activation='sigmoid')
+])

app.py

@@ -0,0 +1,80 @@
+
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+from huggingface_hub import hf_hub_download
+import os
+
+# Configuration
+MODEL_REPO = "Ahmedhassan54/Image-Classification"  # Replace with your HF username and repo
+MODEL_FILE = "best_model.h5"
+
+# Download model from Hugging Face Hub
+def load_model_from_hf():
+    try:
+        # Check if model exists locally first
+        if not os.path.exists(MODEL_FILE):
+            print("Downloading model from Hugging Face Hub...")
+            model_path = hf_hub_download(
+                repo_id=MODEL_REPO,
+                filename=MODEL_FILE,
+                cache_dir="."
+            )
+            # Copy to current directory for easier access
+            os.system(f"cp {model_path} {MODEL_FILE}")
+        
+        # Load the model
+        model = tf.keras.models.load_model(MODEL_FILE)
+        print("Model loaded successfully!")
+        return model
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        raise
+
+# Load the model when the app starts
+model = load_model_from_hf()
+
+# Image classification function
+def classify_image(image):
+    try:
+        # Preprocess the image
+        image = image.resize((150, 150))  # Match model's expected input size
+        image_array = np.array(image) / 255.0  # Normalize
+        image_array = np.expand_dims(image_array, axis=0)  # Add batch dimension
+        
+        # Make prediction
+        prediction = model.predict(image_array)
+        confidence = float(prediction[0][0])
+        
+        # Format results
+        if confidence > 0.5:
+            return {
+                "Dog": confidence * 100,
+                "Cat": (1 - confidence) * 100
+            }
+        else:
+            return {
+                "Cat": (1 - confidence) * 100,
+                "Dog": confidence * 100
+            }
+    except Exception as e:
+        return f"Error processing image: {str(e)}"
+
+# Gradio interface
+demo = gr.Interface(
+    fn=classify_image,
+    inputs=gr.Image(type="pil", label="Upload Image"),
+    outputs=gr.Label(num_top_classes=2, label="Predictions"),
+    title="🐱 Cat vs Dog Classifier 🐶",
+    description="Upload an image to classify whether it's a cat or dog",
+    examples=[
+        ["https://upload.wikimedia.org/wikipedia/commons/1/15/Cat_August_2010-4.jpg"],
+        ["https://upload.wikimedia.org/wikipedia/commons/d/d9/Collage_of_Nine_Dogs.jpg"]
+    ],
+    allow_flagging="never"
+)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(debug=True, server_port=7860)

model.py

@@ -0,0 +1,188 @@
+# Image Classification for Cat vs Dog Dataset (Fixed Version)
+# Run in Google Colab with GPU
+
+## 1. Setup Environment
+!nvidia-smi
+!pip install tensorboard-plugin-profile
+
+## 2. Import Libraries
+import tensorflow as tf
+from tensorflow.keras import layers, models, callbacks
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+import numpy as np
+import matplotlib.pyplot as plt
+import datetime
+from sklearn.metrics import classification_report, confusion_matrix
+import seaborn as sns
+import os
+import zipfile
+from google.colab import files
+from shutil import move
+from pathlib import Path
+
+print("TensorFlow version:", tf.__version__)
+
+## 3. Upload and Reorganize Your Dataset
+# Upload your zip file
+uploaded = files.upload()
+zip_filename = list(uploaded.keys())[0]
+
+# Extract the zip file
+with zipfile.ZipFile(zip_filename, 'r') as zip_ref:
+    zip_ref.extractall('extracted_dataset')
+
+# Verify extraction
+!ls extracted_dataset
+
+# Your dataset has images directly in custom_dataset/train/ (not in cat/dog subfolders)
+# We need to reorganize them into proper class folders
+def organize_dataset(input_dir, output_dir):
+    # Create class directories
+    os.makedirs(os.path.join(output_dir, 'cat'), exist_ok=True)
+    os.makedirs(os.path.join(output_dir, 'dog'), exist_ok=True)
+    
+    # Move cat images
+    for file in Path(input_dir).glob('cat.*.jpg'):
+        move(str(file), os.path.join(output_dir, 'cat', file.name))
+    
+    # Move dog images
+    for file in Path(input_dir).glob('dog.*.jpg'):
+        move(str(file), os.path.join(output_dir, 'dog', file.name))
+
+# Reorganize the dataset
+input_path = 'extracted_dataset/custom_dataset/train'
+output_path = 'organized_dataset/train'
+organize_dataset(input_path, output_path)
+
+# Verify the new structure
+!ls organized_dataset/train
+!ls organized_dataset/train/cat | head -5
+!ls organized_dataset/train/dog | head -5
+
+## 4. Create Data Generators
+# Parameters
+IMG_SIZE = (150, 150)
+BATCH_SIZE = 32
+
+# Data generators with augmentation
+train_datagen = ImageDataGenerator(
+    rescale=1./255,
+    rotation_range=20,
+    width_shift_range=0.2,
+    height_shift_range=0.2,
+    shear_range=0.2,
+    zoom_range=0.2,
+    horizontal_flip=True,
+    validation_split=0.2  # 20% for validation
+)
+
+# Training generator
+train_generator = train_datagen.flow_from_directory(
+    'organized_dataset/train',
+    target_size=IMG_SIZE,
+    batch_size=BATCH_SIZE,
+    class_mode='binary',
+    subset='training',
+    shuffle=True
+)
+
+# Validation generator
+validation_generator = train_datagen.flow_from_directory(
+    'organized_dataset/train',
+    target_size=IMG_SIZE,
+    batch_size=BATCH_SIZE,
+    class_mode='binary',
+    subset='validation',
+    shuffle=True
+)
+
+# Get class names
+class_names = list(train_generator.class_indices.keys())
+print("\nDetected classes:", class_names)
+print("Number of training samples:", train_generator.samples)
+print("Number of validation samples:", validation_generator.samples)
+
+# Visualize samples
+plt.figure(figsize=(12, 9))
+for i in range(9):
+    img, label = next(train_generator)
+    plt.subplot(3, 3, i+1)
+    plt.imshow(img[i])
+    plt.title(class_names[int(label[i])])
+    plt.axis('off')
+plt.suptitle("Sample Training Images")
+plt.show()
+
+## 5. Build Model
+def build_model(input_shape):
+    model = models.Sequential([
+        layers.Conv2D(32, (3,3), activation='relu', input_shape=input_shape),
+        layers.MaxPooling2D((2,2)),
+        
+        layers.Conv2D(64, (3,3), activation='relu'),
+        layers.MaxPooling2D((2,2)),
+        
+        layers.Conv2D(128, (3,3), activation='relu'),
+        layers.MaxPooling2D((2,2)),
+        
+        layers.Flatten(),
+        layers.Dense(512, activation='relu'),
+        layers.Dropout(0.5),
+        layers.Dense(1, activation='sigmoid')  # Binary output
+    ])
+    
+    model.compile(
+        optimizer='adam',
+        loss='binary_crossentropy',
+        metrics=['accuracy']
+    )
+    return model
+
+model = build_model(input_shape=(IMG_SIZE[0], IMG_SIZE[1], 3))
+model.summary()
+
+## 6. Train Model
+log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+
+callbacks = [
+    callbacks.EarlyStopping(patience=5, restore_best_weights=True),
+    callbacks.ModelCheckpoint('best_model.h5', save_best_only=True),
+    callbacks.TensorBoard(log_dir=log_dir),
+    callbacks.ReduceLROnPlateau(factor=0.1, patience=3)
+]
+
+history = model.fit(
+    train_generator,
+    steps_per_epoch=train_generator.samples // BATCH_SIZE,
+    epochs=30,
+    validation_data=validation_generator,
+    validation_steps=validation_generator.samples // BATCH_SIZE,
+    callbacks=callbacks
+)
+
+## 7. Evaluate Model
+# Plot training history
+plt.figure(figsize=(12, 4))
+plt.subplot(1, 2, 1)
+plt.plot(history.history['accuracy'], label='Train')
+plt.plot(history.history['val_accuracy'], label='Validation')
+plt.title('Accuracy')
+plt.legend()
+
+plt.subplot(1, 2, 2)
+plt.plot(history.history['loss'], label='Train')
+plt.plot(history.history['val_loss'], label='Validation')
+plt.title('Loss')
+plt.legend()
+plt.show()
+
+## 8. Save Model
+model.save('cat_dog_classifier.h5')
+
+# Convert to TFLite
+converter = tf.lite.TFLiteConverter.from_keras_model(model)
+tflite_model = converter.convert()
+with open('cat_dog.tflite', 'wb') as f:
+    f.write(tflite_model)
+
+print("\nModel saved in HDF5 and TFLite formats")

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow
+gradio
+pillow
+numpy
+huggingface-hub