| from core.controllers.pages_controller import Page | |
| from core.controllers.main_process import Generador | |
| class Home(Page): | |
| variables_globales = { | |
| "prompt": "cat,fish,dog", | |
| "img_bytes": None, | |
| "img_src": None, | |
| "settings": { | |
| "model": str("CIDAS/clipseg-rd64-refined"), | |
| "tokenizer": str("CIDAS/clipseg-rd64-refined"), | |
| }, | |
| "img_output": None, | |
| "predicciones": None, | |
| "fuentes": [ | |
| {"titulo": "Papper", | |
| "url": "https://arxiv.org/abs/2112.10003"}, | |
| {"titulo": "Transformers", | |
| "url": "https://huggingface.co/docs/transformers/v4.32.1/en/index"}, | |
| {"titulo": "Modelo CIDAS/ClipSeg-rd64-refined", | |
| "url": "https://huggingface.co/CIDAS/clipseg-rd64-refined"}, | |
| {"titulo": "Repositorio", | |
| "url": "https://huggingface.co/CIDAS/clipseg-rd64-refined"}, | |
| {"titulo": "Material Apoyo", | |
| "url": "https://github.com/NielsRogge/Transformers-Tutorials/blob/master/CLIPSeg/Zero_shot_image_segmentation_with_CLIPSeg.ipynb"}, | |
| {"titulo": "IO", | |
| "url": "https://pypi.org/project/io/"}, | |
| {"titulo": "PIL", | |
| "url": "https://pypi.org/project/Pillow/"}, | |
| {"titulo": "requests", | |
| "url": "https://pypi.org/project/requests/"}, | |
| {"titulo": "timm", | |
| "url": "https://pypi.org/project/timm/"}, | |
| {"titulo": "matplotlib", | |
| "url": "https://pypi.org/project/matplotlib/"}] | |
| } | |
| 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=""" | |
| ## Tema | |
| La segmentación de imágenes es el proceso de dividir una imagen en segmentos o regiones significativas. | |
| Puede ser de diferentes tipos, como la segmentación semántica (asignación de etiquetas de clase a píxeles) o la segmentación basada en contornos (división de una imagen en áreas definidas por bordes). | |
| Esta técnica es ampliamente utilizada en visión por computadora para analizar y comprender imágenes. | |
| ## 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, prompt): | |
| proceso = Generador(configuraciones=self.get_global('settings')) | |
| proceso.generar_prediccion( | |
| imagen_bytes=self.imgg.open( | |
| self.get_global('img_src')).convert("RGB"), | |
| new_prompt=prompt | |
| ) | |
| 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. **Detectar / Predecir**: | |
| Realice la **detección de objetos** 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: | |
| for i, predict in enumerate(self.get_global('predicciones', [])): | |
| resultados.image( | |
| image=predict, | |
| caption=f"Su predicción {i}", | |
| use_column_width="auto", | |
| channels="RGB", | |
| output_format="auto" | |
| ) | |
| 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) | |
| columna_inputs.markdown(unsafe_allow_html=False, | |
| help=None, | |
| body=""" | |
| **Introduzca palabras de búsqueda**: | |
| """) | |
| prompt = columna_inputs.text_input( | |
| label="Prompt", on_change=None, label_visibility="visible", | |
| value=self.get_global('prompt')) | |
| if columna_inputs.button(label="Detectar / Predecir", help="Realizar Predicciones", | |
| type="secondary", use_container_width=True): | |
| self.procesar_imagen(prompt) | |
| 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() | |