Update app.py

app.py

@@ -1,75 +1,31 @@
 import tensorflow as tf
-import efficientnet.tfkeras as efn
 import numpy as np
 import gradio as gr
-import plotly.express as px
 
-# Dimensões da imagem
-IMG_HEIGHT = 224
-IMG_WIDTH = 224
+# Carregue o modelo treinado com catarata
+loaded_model = tf.keras.models.load_model('modelo_treinado.h5')
 
-# Função para construir o modelo
-def build_model(img_height, img_width, n):
-    inp = tf.keras.layers.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)
-    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)
-    model.compile(optimizer=opt, loss=loss, metrics=['accuracy'])
-    return model
+# Crie uma lista de classes
+class_names = ["Normal", "Cataract"]
 
-# Carregue o modelo treinado
-loaded_model = build_model(IMG_HEIGHT, IMG_WIDTH, 3)
-loaded_model.load_weights('modelo_treinado.h5')
+# Defina a função de classificação
+def classify_image(inp):
+    # Reshape a imagem de entrada para o formato esperado pelo modelo
+    img = inp.reshape((-1, 224, 224, 3))
 
-# Função para realizar o pré-processamento da imagem de entrada
-def preprocess_image(input_image):
-    # Redimensione a imagem para as dimensões esperadas pelo modelo
-    input_image = tf.image.resize(input_image, (IMG_HEIGHT, IMG_WIDTH))
-    
-    # Normalização dos valores de pixel para o intervalo [0, 1]
-    input_image = input_image / 255.0
+    # Faça uma previsão usando o modelo treinado
+    prediction = loaded_model.predict(img).flatten()
 
-    # Outras transformações, se necessárias (por exemplo, normalização adicional)
+    # Retorna a classe prevista
+    return class_names[np.argmax(prediction)]
 
-    return input_image
-
-# Função para fazer previsões usando o modelo treinado
-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 = loaded_model.predict(input_image)
-
-    # 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"]
-    predicted_class = class_names[np.argmax(prediction)]
-    probability = prediction[0][np.argmax(prediction)]
-
-    # Retorna a previsão em formato de string
-    return f"""
-Predicted Class: {predicted_class}
-Probability: {probability:.2%}
-"""
-
-# Crie uma interface Gradio para fazer previsões
+# Crie uma interface Gradio
 iface = gr.Interface(
-    fn=predict_image,
-    inputs=gr.inputs.Image(label="Upload an Image", type="pil"),
-    outputs=gr.outputs.Output(label="Prediction", type="string"),
-    interpretation="text",
-    custom_interpretation_fn=predict_image
+    fn=classify_image,
+    inputs=gr.inputs.Image(shape=(224, 224)),
+    outputs=gr.outputs.Label(),
+    capture_session=True
 )
 
-# Execute a interface Gradio
-iface.launch()
+# Inicie a interface Gradio
+iface.launch(debug=True, share=True)