# import gradio as gr
# import tensorflow as tf
# import numpy as np

# # Defina a camada personalizada FixedDropout
# class FixedDropout(tf.keras.layers.Dropout):
#     def _get_noise_shape(self, inputs):
#         if self.noise_shape is None:
#             return self.noise_shape
#         symbolic_shape = tf.shape(inputs)
#         noise_shape = [symbolic_shape[axis] if shape is None else shape
#                        for axis, shape in enumerate(self.noise_shape)]
#         return tuple(noise_shape)

# # Registre a camada personalizada FixedDropout
# tf.keras.utils.get_custom_objects()['FixedDropout'] = FixedDropout

# # Carregue seu modelo TensorFlow treinado
# model = tf.keras.models.load_model('modelo_treinado.h5')

# # Defina uma função para fazer previsões
# def classify_image(input_image):
#     # Redimensione a imagem para as dimensões corretas (192x256)
#     input_image = tf.image.resize(input_image, (192, 256))  # Redimensione para as dimensões esperadas
#     input_image = (input_image / 255.0)  # Normalize para [0, 1]
#     input_image = np.expand_dims(input_image, axis=0)  # Adicione a dimensão de lote

#     # Faça a previsão usando o modelo
#     prediction = model.predict(input_image)

#     # Assumindo que o modelo retorna probabilidades para duas classes, você pode retornar a classe com a maior probabilidade
#     class_index = np.argmax(prediction)
#     class_labels = ["Normal", "Cataract"]  # Substitua pelas suas etiquetas de classe reais
#     predicted_class = class_labels[class_index]

#     return predicted_class

# # Crie uma interface Gradio
# input_interface = gr.Interface(
#     fn=classify_image,
#     inputs="image",  # Especifique o tipo de entrada como "image"
#     outputs="text"   # Especifique o tipo de saída como "text"
# )

# # Inicie o aplicativo Gradio
# input_interface.launch()

import gradio as gr
import tensorflow as tf
import numpy as np

# Defina a camada personalizada FixedDropout
class FixedDropout(tf.keras.layers.Dropout):
    def _get_noise_shape(self, inputs):
        if self.noise_shape is None:
            return self.noise_shape
        symbolic_shape = tf.shape(inputs)
        noise_shape = [symbolic_shape[axis] if shape is None else shape
                       for axis, shape in enumerate(self.noise_shape)]
        return tuple(noise_shape)

# Registre a camada personalizada FixedDropout
tf.keras.utils.get_custom_objects()['FixedDropout'] = FixedDropout

# Carregue seu modelo TensorFlow treinado
model = tf.keras.models.load_model('modelo_treinado.h5')

# Defina uma função para fazer previsões
def classify_image(input_image):
    # Redimensione a imagem para as dimensões corretas (192x256)
    input_image = tf.image.resize(input_image, (192, 256))  # Redimensione para as dimensões esperadas
    input_image = (input_image / 255.0)  # Normalize para [0, 1]
    input_image = np.expand_dims(input_image, axis=0)  # Adicione a dimensão de lote

    # Faça a previsão usando o modelo
    prediction = model.predict(input_image)

    # Assumindo que o modelo retorna probabilidades para duas classes, você pode retornar a classe com a maior probabilidade
    class_index = np.argmax(prediction)
    class_labels = ["Normal", "Cataract"]  # Substitua pelas suas etiquetas de classe reais
    predicted_class = class_labels[class_index]

    # Retorne a classe prevista e as probabilidades das classes
    class_probabilities = {class_labels[i]: round(float(prediction[0][i]), 4) for i in range(len(class_labels))}
    return predicted_class, class_probabilities

# Crie uma interface Gradio
input_interface = gr.Interface(
    fn=classify_image,
    inputs="image",  # Especifique o tipo de entrada como "image"
    outputs=["text", "text"],  # Especifique dois tipos de saída: classe e probabilidades
    output_labels=["Predicted Class", "Class Probabilities"]  # Rotule as saídas
)

# Inicie o aplicativo Gradio
input_interface.launch()