Update app.py

app.py

@@ -1,23 +1,24 @@
-import gradio as gr
 import tensorflow as tf
 import efficientnet.tfkeras as efn
+from tensorflow.keras.layers import Input, GlobalAveragePooling2D, Dense
 import numpy as np
+import gradio as gr
 
 # Dimensões da imagem
-IMG_HEIGHT = 512
-IMG_WIDTH = 512
+IMG_HEIGHT = 224
+IMG_WIDTH = 224
 
-# Função para construir o modelo original
-def build_original_model():
-    inp = tf.keras.layers.Input(shape=(IMG_HEIGHT, IMG_WIDTH, 3))
-    efnet = efn.EfficientNetB3(  # Usando EfficientNetB3
-        input_shape=(IMG_HEIGHT, IMG_WIDTH, 3),
+# Função para construir o modelo
+def build_model(img_height, img_width, n):
+    inp = Input(shape=(img_height, img_width, n))
+    efnet = efn.EfficientNetB0(
+        input_shape=(img_height, img_width, n),
         weights='imagenet',
         include_top=False
     )
     x = efnet(inp)
-    x = tf.keras.layers.GlobalAveragePooling2D()(x)
-    x = tf.keras.layers.Dense(2, activation='softmax')(x)
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(2, activation='softmax')(x)
     model = tf.keras.Model(inputs=inp, outputs=x)
     opt = tf.keras.optimizers.Adam(learning_rate=0.000003)
     loss = tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.01)
@@ -25,8 +26,8 @@ def build_original_model():
     return model
 
 # Carregue o modelo treinado
-original_model = build_original_model()
-original_model.load_weights('modelo_treinado.h5')
+loaded_model = build_model(IMG_HEIGHT, IMG_WIDTH, 3)
+loaded_model.load_weights('modelo_treinado.h5')
 
 # Função para realizar o pré-processamento da imagem de entrada
 def preprocess_image(input_image):
@@ -36,46 +37,36 @@ def preprocess_image(input_image):
     # Normalização dos valores de pixel para o intervalo [0, 1]
     input_image = input_image / 255.0
 
+    # Outras transformações, se necessárias (por exemplo, normalização adicional)
+
     return input_image
 
 # Função para fazer previsões usando o modelo treinado
-def predict(input_image):
+def predict_image(input_image):
     # Realize o pré-processamento na imagem de entrada
     input_image = preprocess_image(input_image)
 
     # Faça uma previsão usando o modelo carregado
     input_image = tf.expand_dims(input_image, axis=0)
-    prediction = original_model.predict(input_image)
+    prediction = loaded_model.predict(input_image)
 
-    # A saída será uma matriz de previsões
+    # A saída será uma matriz de previsões (no caso de classificação de duas classes, será algo como [[probabilidade_classe_0, probabilidade_classe_1]])
+    # Adicione lógica para interpretar o resultado e formatá-lo para exibição
     class_names = ["Normal", "Cataract"]
-    probabilities = prediction[0]
-
-    # Determine a classe mais provável
-    predicted_class = class_names[np.argmax(probabilities)]
+    predicted_class = class_names[np.argmax(prediction)]
+    probability = prediction[0][np.argmax(prediction)]
 
-    # Adicione informações adicionais à saída
-    confidence = probabilities[np.argmax(probabilities)]
+    formatted_text = f"Predicted Class: {predicted_class}\nProbability: {probability:.2%}"
+    return formatted_text
 
-    return {
-        "Imagem de Entrada": input_image[0].numpy(),
-        "Classificação": predicted_class,
-        "Confiança": confidence,
-        "Probabilidades": {class_names[i]: probabilities[i] for i in range(len(class_names))}
-    }
 
 # Crie uma interface Gradio para fazer previsões
 iface = gr.Interface(
-    predict,
-    inputs=gr.inputs.Image(label="Carregue uma imagem da região ocular", type="pil"),
-    outputs=[
-        gr.outputs.Image(label="Imagem de Entrada"),
-        gr.outputs.Textbox(label="Classificação"),
-        gr.outputs.Textbox(label="Confiança"),
-        gr.outputs.Table(label="Probabilidades")
-    ],
-    theme="auto",  # Usar o tema padrão do Gradio
+    fn=predict_image,
+    inputs="image",
+    outputs="text",
+    interpretation="default"
 )
 
 # Execute a interface Gradio
-iface.launch()
+iface.launch()