.

README.md

@@ -5,7 +5,7 @@ colorFrom: gray
 colorTo: indigo
 sdk: gradio
 sdk_version: 6.0.2
-app_file: app6.py
+app_file: app.py
 pinned: false
 ---
 

app.py

@@ -1,29 +1,37 @@
 import gradio as gr
-from diffusers import DiffusionPipeline
 from PIL import Image
-import torch
+from transformers import pipeline
 
-# Cargar pipeline (float32 para CPU)
-model_id = "stabilityai/stable-diffusion-x4-upscaler"
-pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-x4-upscaler", dtype=torch.bfloat16, device_map="cuda")
+captioner = pipeline("image-to-text", model="Salesforce/blip-image-captioning-large")
 
-# Función de Gradio
-def upscaler_gradio(imagen):
+def describir(imagen):
     if imagen is None:
-        return None
+        return "Sube una imagen."
 
-    img = Image.fromarray(imagen)  # convertir de NumPy a PIL
-    prompt = "A high quality, detailed, and visually clear image"
-    result = pipe(prompt=prompt, image=img).images[0]
+    img = Image.fromarray(imagen)
+    
+    result = captioner(img)[0]["generated_text"]
     return result
 
-# Interfaz Gradio
-demo = gr.Interface(
-    fn=upscaler_gradio,
-    inputs=gr.Image(type="numpy"),
-    outputs=gr.Image(),
-    title="Upscaler Difusión",
-    description="Sube una imagen y el modelo la mejorará y aumentará resolución 4×."
-)
+with gr.Blocks(title="Accesibilidad con Transformers") as demo:
+    gr.Markdown(
+        """
+        #Accesibilidad con Transformers
+        Sube una imagen y un modelo Transformer generará una descripción detallada 
+        para mejorar la accesibilidad del contenido visual.
+        """
+    )
 
-demo.launch()
+    with gr.Row():
+        image_input = gr.Image(type="numpy", label="Sube una Imagen")
+
+        text_output = gr.Textbox(label="Descripción Generada")
+
+    run_button = gr.Button("Generar Descripción")
+    run_button.click(
+        fn=describir,
+        inputs=image_input,
+        outputs=text_output
+    )
+    
+demo.launch()

app2.py

@@ -1,8 +1,6 @@
 from transformers import pipeline
 import gradio as gr
 
-#Recomendador trabajar o estudiar transformer
-
 generator = pipeline(
     "text2text-generation",
     model="google/flan-t5-small"
@@ -24,16 +22,42 @@ Explain the reasoning behind your recommendation.
     result = generator(prompt, max_length=200)
     return result[0]['generated_text']
 
-interface = gr.Interface(
-    fn=career_advice,
-    inputs=[
-        gr.Number(label="Age"),
-        gr.Textbox(label="Academic level"),
-        gr.Textbox(label="Interests"),
-        gr.Dropdown(choices=["Yes", "No"], label="Needs income")
-    ],
-    outputs=gr.Textbox(label="Recommendation"),
-    title="Career Advisor for Students"
-)
+with gr.Blocks(title="Asesor de Carrera Profesional") as demo:
+    gr.Markdown(
+        """
+        #Asesor de Carrera Profesional con IA
+        Bienvenido al asesor de carrera basado en el modelo **FLAN-T5**. 
+        Introduce tus datos para recibir una recomendación personalizada sobre si deberías **continuar estudiando**, 
+        hacer **Formación Profesional (FP)** o **comenzar a trabajar**.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## 📝 Datos del Estudiante")
+            age_input = gr.Number(label="Edad", minimum=15, maximum=60, step=1)
+            academic_input = gr.Textbox(label="Nivel Académico (Ej: ESO, Bachillerato, Grado Universitario, etc.)", placeholder="Ej: Bachillerato de Ciencias")
+            interests_input = gr.Textbox(label="Intereses (Palabras clave)", placeholder="Ej: Tecnología, Diseño Gráfico, Cocina, Viajes")
+            income_input = gr.Dropdown(choices=["Sí", "No"], label="¿Necesitas generar ingresos inmediatamente?")
+            
+            run_button = gr.Button("Obtener Recomendación ✨", variant="primary")
+
+        with gr.Column(scale=2):
+            gr.Markdown("## 💡 Recomendación Personalizada")
+            output_textbox = gr.Textbox(label="Recomendación del Experto", lines=10, interactive=False)
 
-interface.launch()
+    run_button.click(
+        fn=career_advice,
+        inputs=[age_input, academic_input, interests_input, income_input],
+        outputs=output_textbox
+    )
+    
+    gr.Examples(
+        examples=[
+            [18, "High School Diploma", "Web design, programming", "No"],
+            [25, "University Degree (Incomplete)", "Project management, sales", "Yes"],
+            [16, "Compulsory Secondary Education (ESO)", "Mechanics, vehicle repair", "No"]
+        ],
+        inputs=[age_input, academic_input, interests_input, income_input]
+    )
+demo.launch()

app4.py

@@ -3,38 +3,34 @@ from huggingface_hub import InferenceClient
 import gradio as gr
 from dotenv import load_dotenv
 
-# Cargar variables del .env
+
 load_dotenv()
 HF_TOKEN = os.getenv("HF_TOKEN")
 
 if HF_TOKEN is None:
-    raise ValueError("❌ No se encontró la variable HF_TOKEN en el .env")
+    raise ValueError("No se encontró la variable HF_TOKEN en el .env")
+
 
-# Inicializar cliente de inferencia HF
 client = InferenceClient(provider="hf-inference", api_key=HF_TOKEN)
 
 def clasificar_imagen(imagen):
     if imagen is None:
         return "Sube una imagen para clasificar."
 
-    # Guardar temporalmente la imagen para enviarla al cliente
     temp_path = "temp_image.jpg"
     imagen.save(temp_path)
 
-    # Llamada a la API
     output = client.image_classification(temp_path, model="google/vit-base-patch16-224")
 
-    # Retornar la clasificación más probable
     if isinstance(output, list) and len(output) > 0:
         resultado = "\n".join([f"{item['label']}: {item['score']:.2f}" for item in output])
     else:
         resultado = "No se pudo clasificar la imagen."
     return resultado
 
-# Interfaz Gradio
 with gr.Blocks() as demo:
-    gr.Markdown("# 🖼️ Clasificador de Imágenes con ViT")
-    gr.Markdown("Sube una imagen y el modelo ViT-base de Google la clasificará usando HF Inference API gratuita.")
+    gr.Markdown("# Clasificador de Imágenes con ViT")
+    gr.Markdown("Sube una imagen y se clasificará.")
 
     img_input = gr.Image(type="pil", label="Sube tu imagen aquí")
     boton = gr.Button("Clasificar Imagen")

app5.py

@@ -3,29 +3,25 @@ from huggingface_hub import InferenceClient
 import gradio as gr
 from dotenv import load_dotenv
 
-# Cargar variables del .env
 load_dotenv()
 HF_TOKEN = os.getenv("HF_TOKEN")
 
 if HF_TOKEN is None:
-    raise ValueError("❌ No se encontró la variable HF_TOKEN en el .env")
+    raise ValueError("No se encontró la variable HF_TOKEN en el .env")
 
-# Inicializar cliente de inferencia HF
 client = InferenceClient(provider="hf-inference", api_key=HF_TOKEN)
 
 def generar_imagen(prompt):
     if not prompt.strip():
         return None
 
-    # Llamada a la API
     imagen = client.text_to_image(prompt, model="black-forest-labs/FLUX.1-schnell")
     
-    return imagen  # es un objeto PIL.Image
+    return imagen 
 
-# Interfaz Gradio
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎨 Generador de Imágenes con FLUX.1-schnell")
-    gr.Markdown("Escribe un prompt y el modelo generará la imagen usando HF Inference API gratuita.")
+    gr.Markdown("#Generador de Imágenes")
+    gr.Markdown("Escribe un prompt y el modelo generará la imagen usando Inference.")
 
     prompt_input = gr.Textbox(label="Escribe tu prompt aquí", lines=3)
     boton = gr.Button("Generar Imagen")

app6.py

@@ -1,35 +0,0 @@
-import gradio as gr
-from PIL import Image
-from diffusers import StableDiffusionImg2ImgPipeline
-import torch
-
-model_id = "runwayml/stable-diffusion-v1-5" 
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to(device)
-
-def convert_simple(input_image: Image.Image) -> Image.Image:
-    prompt = "A high contrast, dramatic photo, black and white, monochrome, grayscale"
-    strength = 0.95
-    
-    input_image = input_image.convert("RGB").resize((512, 512))
-    
-    output_image = pipe(
-        prompt=prompt,
-        image=input_image,
-        strength=strength, 
-        guidance_scale=7.5
-    ).images[0]
-    
-    final_bn_image = output_image.convert('L') 
-    
-    return final_bn_image
-
-iface = gr.Interface(
-    fn=convert_simple,
-    inputs=[gr.Image(type="pil")],
-    outputs="image",
-)
-
-if __name__ == "__main__":
-    iface.launch()