Update app.py

app.py

@@ -1,102 +1,83 @@
-import cv2
-import gradio as gr
-import tensorflow as tf
 import numpy as np
-from PIL import Image
+import tensorflow as tf
+from tensorflow import keras
+import gradio as gr
 
-title = "Welcome on your first sketch recognition app!"
+# Load and preprocess the MNIST dataset
+def load_data():
+    """Load and preprocess the MNIST dataset."""
+    (X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
+    X_train = X_train.astype("float32") / 255
+    X_test = X_test.astype("float32") / 255
+    X_train = X_train.reshape(-1, 28, 28, 1)
+    X_test = X_test.reshape(-1, 28, 28, 1)
+    return (X_train, y_train), (X_test, y_test)
 
-head = (
-    "<center>"
-    "The robot was trained to classify numbers (from 0 to 9). To test it, write your number in the space provided."
-    "</center>"
-)
+# Build the CNN model
+def build_model(input_shape, num_classes):
+    """Build the CNN model."""
+    inputs = keras.layers.Input(input_shape)
+    x = keras.layers.Conv2D(28, kernel_size=(3, 3), activation='relu')(inputs)
+    x = keras.layers.MaxPooling2D(pool_size=(2, 2))(x)
+    x = keras.layers.Flatten()(x)
+    x = keras.layers.Dense(128, activation='relu')(x)
+    outputs = keras.layers.Dense(num_classes, activation='softmax')(x)
+    return keras.models.Model(inputs=inputs, outputs=outputs)
 
-# Model yükleniyor
-model = tf.keras.models.load_model("./number_recognition_model_colab.keras")
+# Preprocess input for prediction
+def preprocess_image(image):
+    """Resize and normalize the input image for prediction."""
+    image = np.array(image.convert('L'))  # Convert to grayscale
+    image = image.astype("float32") / 255  # Normalize
+    image = image.reshape(1, 28, 28, 1)  # Reshape to model's input
+    return image
 
+# Predict digit
+def predict_digit(image):
+    """Predict the digit in the uploaded image."""
+    processed_image = preprocess_image(image)
+    prediction = model.predict(processed_image)
+    class_id = np.argmax(prediction)
+    confidence = prediction[0][class_id]
+    label = classes_names[class_id]
+    results = {name: float(prediction[0][i]) for i, name in enumerate(classes_names)}
+    return label, results
 
-img_size = 28
+if __name__ == "__main__":
+    # Parameters
+    classes_names = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
+    input_shape = (28, 28, 1)
+    num_classes = len(classes_names)
 
-labels = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
+    # Load data
+    (X_train, y_train), (X_test, y_test) = load_data()
 
-def predict(img):
-    try:
-        # Enhanced image validation and conversion
-        if img is None:
-            raise ValueError("No image provided")
-        
-        # Convert to numpy array if it's a PIL Image
-        if isinstance(img, Image.Image):
-            img = np.array(img)
-        
-        # Handle base64 image strings
-        elif isinstance(img, str):
-            # Check if it's a base64 data URL
-            if img.startswith('data:image'):
-                # Split and decode base64 part
-                img = img.split(',')[1]
-            
-            # Decode base64 to image
-            try:
-                img = Image.open(io.BytesIO(base64.b64decode(img)))
-                img = np.array(img)
-            except Exception as e:
-                print(f"Base64 decoding error: {e}")
-                raise ValueError("Invalid base64 image")
-        
-        # Validate numpy array
-        if not isinstance(img, np.ndarray):
-            raise ValueError("Input could not be converted to a valid image")
-        
-        # Print initial image details for debugging
-        print(f"Initial image type: {type(img)}, shape: {img.shape}")
-        
-        # Handle color channels
-        if img.ndim == 3:
-            if img.shape[-1] == 3:  # Color image
-                img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-            elif img.shape[-1] == 4:  # RGBA image
-                img = cv2.cvtColor(img, cv2.COLOR_RGBA2GRAY)
-        
-        # Ensure single channel
-        if img.ndim == 2:
-            img = np.expand_dims(img, axis=-1)
-        
-        # Resize and normalize
-        img = cv2.resize(img, (img_size, img_size))
-        img = img.astype('float32') / 255.0
-        img = img.reshape(1, img_size, img_size, 1)
-        
-        # Print processed image details
-        print(f"Processed image shape: {img.shape}")
-        
-        # Get predictions from the model
-        preds = model.predict(img)[0]
-        
-        # Print predictions for debugging
-        print("Predictions:", preds)
-        
-        # Return predictions as a dictionary
-        return {label: float(pred) for label, pred in zip(labels, preds)}
-    
-    except Exception as e:
-        # Comprehensive error logging
-        print(f"Full error during prediction: {e}")
-        return {"Error": str(e)}
-            
-   
+    # Build and train model
+    model = build_model(input_shape, num_classes)
+    model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+    print("Training model...")
+    model.fit(X_train, y_train, epochs=3, batch_size=64)  # Quick training for demonstration
 
-# Set up the Gradio interface with the input as a sketchpad and output as labels
-label = gr.Label(num_top_classes=3)
+    # Gradio Interface
+    title = "Welcome to Your First Sketch Recognition App!"
+    description = (
+        "The robot was trained to classify numbers (from 0 to 9). To test it, draw your number in the space provided."
+    )
+    examples = [["example_image.png"]]  # You can add example images here.
 
-# Gradio arayüzü
-interface = gr.Interface(
-    fn=predict,
-    inputs=gr.Sketchpad(type="pil"),
-    outputs=label,
-    title="Sketch Recognition App",
-    description="Draw a number (0-9) and see the model's top predictions."
-)
+    interface = gr.Interface(
+        fn=predict_digit,
+        inputs=gr.inputs.Image(shape=(28, 28), image_mode="L", invert_colors=True, label="Draw a Digit"),
+        outputs=[
+            gr.outputs.Textbox(label="Predicted Digit"),
+            gr.outputs.Label(num_top_classes=10, label="Prediction Confidence"),
+        ],
+        title=title,
+        description=description,
+        examples=examples,
+        live=True,
+    )
 
-interface.launch(debug=True, share=True)
+    # Launch Gradio interface
+    print("Launching Gradio interface...")
+    interface.launch()