Home.py

from core.controllers.pages_controller import Page
from core.controllers.main_process import Generador


class Home(Page):
    variables_globales = {
        "img_bytes": None,
        "img_src": None,
        "settings": {
            "model": str("google/vit-base-patch16-224"),
            "tokenizer": str("google/vit-base-patch16-224"),
        },
        "img_output": None,
        "predicciones": None,
        "fuentes": [
            {"titulo": "Analysis of Classification by Supervised and Unsupervised Learning",
             "url": "https://www.computer.org/csdl/proceedings-article/iccima/2007/30500280/12OmNzxyiHV"},
            {"titulo": "Implementation of Interval Arithmetic Algorithms on FPGAs",
             "url": "https://dl.acm.org/doi/10.1109/ICCIMA.2007.237"},
            {"titulo": "Transformers",
             "url": "https://huggingface.co/docs/transformers/v4.32.1/en/index"},
            {"titulo": "Modelo Google/ViT",
             "url": "https://huggingface.co/google/vit-base-patch16-224"},
            {"titulo": "ImageNet DataSet",
             "url": "https://www.image-net.org/download.php"},
            {"titulo": "ImageNet clases",
             "url": "https://deeplearning.cms.waikato.ac.nz/user-guide/class-maps/IMAGENET/"},
            {"titulo": "PIL",
             "url": "https://pypi.org/project/Pillow/"},
            {"titulo": "requests",
             "url": "https://pypi.org/project/requests/"}]
    }

    archivos_css = ["main",
                    "home"]

    def __init__(self, title=str("Bienvenido"), icon=str("🖼️"), init_page=False):
        super().__init__()
        if init_page:
            self.new_page(title=title,
                          icon=icon)
        self.init_globals(globals=self.variables_globales)
        for archivo in self.archivos_css:
            self.cargar_css(archivo_css=archivo)
        self.about()

    def about(self):
        self.builder().sidebar.markdown(unsafe_allow_html=False,
                                        help=None,
                                        body="""
                               ## Clasificación de imágenes

                               La clasificación de imágenes, es una rama esencial de la visión artificial, se refiere a la capacidad de las computadoras para identificar y categorizar objetos en imágenes visuales. 

                               Consiste en enseñar a una computadora a identificar la categoría general de una fotografía, como "perro" o "coche", en lugar de analizar detalles específicos o ubicar objetos.

                               ## Recursos
                               """)

        for fuente in self.get_global('fuentes'):
            self.builder().sidebar.markdown(
                unsafe_allow_html=False,
                help=None,
                body=f"""
                * **{fuente.get('titulo')}** - {fuente.get('url')}
                """
            )
        self.builder().sidebar.markdown(
            unsafe_allow_html=False,
            help=None,
            body="""
            ###### Es **importante** mencionar que esta **compilación** se encuentra en proceso de **construcción**.
            
            *Si deseas **participar**, eres **bienvenido** de aportar en el repositorio oficial:*
            
            https://github.com/coder160/cuadernos/
            """)

    def obtener_bytes(self, archivo):
        self.set_global(key='img_src',
                        value=archivo)

    def actualizar_modelo_tokenizer(self, modelo, tokenizer):
        self.set_global(key='settings',
                        value={'model': modelo,
                               'tokenizer': tokenizer})

    def procesar_imagen(self):
        proceso = Generador(configuraciones=self.get_global('settings'))
        proceso.generar_prediccion(imagen_bytes=self.imgg.open(
            self.get_global('img_src')).convert("RGB"))
        self.set_global(key='predicciones', value=proceso.prediccion)

    def expander_instrucciones(self, placeholder):
        instrucciones = placeholder.expander(expanded=False,
                                             label="Instrucciones")
        instrucciones.markdown(unsafe_allow_html=False,
                               help=None,
                               body="""
                               1.   **Cargue su Imagen Base**:

                               Elija cualquiera de las dos opciones para cargar su imagen:

                               *    **Desde su Galería**: cargue la imagen desde la galería de su teléfono o computadora.

                               *    **Desde su Cámara**: cargue la imagen directamente desde la cámara de su teléfono o computadora.


                               2.   **Clasificar / Predecir**:

                               Realice la **clasificación de su imagen** con base a las predicciones realizadas por el **modelo** pre-entrenado seleccionado.

                               A partir del dataset con el que fue pre-entrenado el modelo, tratará de predecir cuales son los objetos en la imagen cargada.


                               *    **Configuraciones Avanzadas**:

                               *Elija un modelo y procesador de la lista disponible, o elija uno directamente de la base de modelos disponible en HuggingFace.*
                               """)

    def expander_imagen_base(self, placeholder):
        imagen_base = placeholder.container()
        imagen_base.markdown(unsafe_allow_html=False,
                             help=None,
                             body="""
                             **Cargue su Imagen Base**:
                             """)
        archivo_expander = imagen_base.expander(expanded=False,
                                                label="Desde su Galería")
        _archivo = archivo_expander.file_uploader(label="Galería",
                                                  on_change=None,
                                                  accept_multiple_files=False,
                                                  label_visibility="visible")
        if (archivo_expander.button(label="Cargar Archivo", type="secondary", use_container_width=True,
                                    help="Suba un archivo.") and _archivo is not None):
            self.obtener_bytes(_archivo)

        camara_expander = imagen_base.expander(expanded=False,
                                               label="Desde su Cámara")
        _captura = camara_expander.camera_input(label="Cámara",
                                                on_change=None,
                                                label_visibility="visible")
        if (camara_expander.button(label="Cargar Captura", type="secondary", use_container_width=True,
                                   help="Tome una fotografía.") and _captura is not None):
            self.obtener_bytes(_captura)

    def expander_configuraciones(self, placeholder):
        configuraciones = placeholder.expander(
            expanded=False, label="Configuraciones Avanzadas")
        modelo = configuraciones.text_input(
            label="MODELO", on_change=None, label_visibility="visible",
            value=self.get_global('settings').get('model'))
        tokenizer = configuraciones.text_input(
            label="TOKENIZER", on_change=None, label_visibility="visible",
            value=self.get_global('settings').get('tokenizer'))

        if configuraciones.button(label="Configurar", type="secondary", use_container_width=True,
                                  help="Actualice configuraciones"):
            self.actualizar_modelo_tokenizer(modelo, tokenizer)

    def resultados(self, placeholder):
        resultados = placeholder.container()

        if self.get_global('img_src', None) is not None:
            resultados.image(
                image=self.get_global('img_src').getvalue(),
                caption="Su resultado",
                use_column_width="auto",
                channels="RGB",
                output_format="auto"
            )
            if self.get_global('predicciones', None) is not None:
                resultados.success(body=self.get_global(
                    'predicciones'), icon=None)

    def agregar_card_base(self, columna):
        card_principal = columna.container()

        columna_inputs, columna_outputs = card_principal.columns(
            [0.3, 0.7], gap="small")

        self.expander_instrucciones(columna_inputs)
        self.expander_imagen_base(columna_inputs)
        self.expander_configuraciones(columna_inputs)
        if columna_inputs.button(label="Clasificar / Predecir", help="Realizar Predicciones",
                                 type="secondary", use_container_width=True):
            self.procesar_imagen()
        self.resultados(columna_outputs)

    def build(self):

        columna_principal = self.get_body().columns(1, gap="small")[0]
        self.agregar_card_base(columna_principal)


if __name__ == "__main__":
    Home(init_page=True).build()