Update app.py

app.py

@@ -1,147 +1,61 @@
-import io
-import random
-from typing import List, Tuple
-
-import aiohttp
+import hvplot.pandas
+import numpy as np
 import panel as pn
-from PIL import Image
-from transformers import CLIPModel, CLIPProcessor
-
-pn.extension(design="bootstrap", sizing_mode="stretch_width")
-
-ICON_URLS = {
-    "brand-github": "https://github.com/holoviz/panel",
-    "brand-twitter": "https://twitter.com/Panel_Org",
-    "brand-linkedin": "https://www.linkedin.com/company/panel-org",
-    "message-circle": "https://discourse.holoviz.org/",
-    "brand-discord": "https://discord.gg/AXRHnJU6sP",
-}
-
-
-async def random_url(_):
-    pet = random.choice(["cat", "dog"])
-    api_url = f"https://api.the{pet}api.com/v1/images/search"
-    async with aiohttp.ClientSession() as session:
-        async with session.get(api_url) as resp:
-            return (await resp.json())[0]["url"]
+import pandas as pd
 
+xs = np.linspace(0, np.pi)
 
-@pn.cache
-def load_processor_model(
-    processor_name: str, model_name: str
-) -> Tuple[CLIPProcessor, CLIPModel]:
-    processor = CLIPProcessor.from_pretrained(processor_name)
-    model = CLIPModel.from_pretrained(model_name)
-    return processor, model
+# Widgets pour la fréquence et la phase
+freq = pn.widgets.FloatSlider(name="Frequence", start=0, end=10, value=2)
+phase = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
 
+# Widgets pour la saisie de données personnalisées
+custom_freq_widget = pn.widgets.FloatInput(name="Frequence", value=2)
+custom_phase_widget = pn.widgets.FloatInput(name="Phase", value=0)
 
-async def open_image_url(image_url: str) -> Image:
-    async with aiohttp.ClientSession() as session:
-        async with session.get(image_url) as resp:
-            return Image.open(io.BytesIO(await resp.read()))
+def sine(freq, phase):
+    return pd.DataFrame(dict(y=np.sin(xs*freq+phase)), index=xs)
 
+def cosine(freq, phase):
+    return pd.DataFrame(dict(y=np.cos(xs*freq+phase)), index=xs)
 
-def get_similarity_scores(class_items: List[str], image: Image) -> List[float]:
-    processor, model = load_processor_model(
-        "openai/clip-vit-base-patch32", "openai/clip-vit-base-patch32"
-    )
-    inputs = processor(
-        text=class_items,
-        images=[image],
-        return_tensors="pt",  # pytorch tensors
-    )
-    outputs = model(**inputs)
-    logits_per_image = outputs.logits_per_image
-    class_likelihoods = logits_per_image.softmax(dim=1).detach().numpy()
-    return class_likelihoods[0]
+dfi_sine = hvplot.bind(sine, freq, phase).interactive()
+dfi_cosine = hvplot.bind(cosine, freq, phase).interactive()
 
+dfi_custom_sine = hvplot.bind(sine, custom_freq_widget, custom_phase_widget).interactive()
+dfi_custom_cosine = hvplot.bind(cosine, custom_freq_widget, custom_phase_widget).interactive()
 
-async def process_inputs(class_names: List[str], image_url: str):
-    """
-    High level function that takes in the user inputs and returns the
-    classification results as panel objects.
-    """
-    try:
-        main.disabled = True
-        if not image_url:
-            yield "##### ⚠️ Provide an image URL"
-            return
-    
-        yield "##### ⚙ Fetching image and running model..."
-        try:
-            pil_img = await open_image_url(image_url)
-            img = pn.pane.Image(pil_img, height=400, align="center")
-        except Exception as e:
-            yield f"##### 😔 Something went wrong, please try a different URL!"
-            return
-    
-        class_items = class_names.split(",")
-        class_likelihoods = get_similarity_scores(class_items, pil_img)
-    
-        # build the results column
-        results = pn.Column("##### 🎉 Here are the results!", img)
-    
-        for class_item, class_likelihood in zip(class_items, class_likelihoods):
-            row_label = pn.widgets.StaticText(
-                name=class_item.strip(), value=f"{class_likelihood:.2%}", align="center"
-            )
-            row_bar = pn.indicators.Progress(
-                value=int(class_likelihood * 100),
-                sizing_mode="stretch_width",
-                bar_color="secondary",
-                margin=(0, 10),
-                design=pn.theme.Material,
-            )
-            results.append(pn.Column(row_label, row_bar))
-        yield results
-    finally:
-        main.disabled = False
+plot_opts = dict(responsive=True, min_height=115, min_width=10)
 
+# Création du tableau de bord
+template = pn.template.ReactTemplate(
+    title='Platteforme pour la simulation de tests d’écoute avec le médecin ORL(Oto-Rhino-Laryngologiste et chirurgie de l’oreille)',
+    sidebar=[pn.pane.PNG('os-modified.png', width=250),
+  
+             
+             #pn.pane.Markdown("# INTERPRÉTATION GRAPHIQUE DU MODÈLE"), 
+             #pn.pane.Markdown("# of contention in international "), 
+             
+              pn.pane.Markdown("""
+                    ## INTERPRÉTATION GRAPHIQUE DU MODÈLE
 
-# create widgets
-randomize_url = pn.widgets.Button(name="Randomize URL", align="end")
+                    Le modèle que vous visualisez ici est basé sur des fonctions sinus et cosinus paramétrées par la fréquence et la phase. Les fonctions sinus et cosinus sont couramment utilisées pour modéliser divers phénomènes périodiques dans la vie pratique.
 
-image_url = pn.widgets.TextInput(
-    name="Image URL to classify",
-    value=pn.bind(random_url, randomize_url),
-)
-class_names = pn.widgets.TextInput(
-    name="Comma separated class names",
-    placeholder="Enter possible class names, e.g. cat, dog",
-    value="cat, dog, parrot",
-)
+                    **Frequency (Fréquence)** : La fréquence contrôle le nombre de cycles complets dans la période [0, π].
 
-input_widgets = pn.Column(
-    "##### 😊 Click randomize or paste a URL to start classifying!",
-    pn.Row(image_url, randomize_url),
-    class_names,
-)
-
-# add interactivity
-interactive_result = pn.panel(
-    pn.bind(process_inputs, image_url=image_url, class_names=class_names),
-    height=600,
-)
+                    **Phase (Phase)** : La phase détermine le décalage horizontal (ou la translation) de la fonction par rapport à l'origine.
 
-# add footer
-footer_row = pn.Row(pn.Spacer(), align="center")
-for icon, url in ICON_URLS.items():
-    href_button = pn.widgets.Button(icon=icon, width=35, height=35)
-    href_button.js_on_click(code=f"window.open('{url}')")
-    footer_row.append(href_button)
-footer_row.append(pn.Spacer())
+                    En ajustant ces paramètres, vous pouvez observer comment ils affectent les courbes sinus et cosinus. Ces concepts mathématiques sont utilisés pour modéliser des phénomènes périodiques tels que les ondes sonores, les oscillations de pendules, les signaux électriques, etc.
 
-# create dashboard
-main = pn.WidgetBox(
-    input_widgets,
-    interactive_result,
-    footer_row,
+                    Explorez différentes combinaisons de fréquence et de phase pour mieux comprendre comment ces paramètres influencent les modèles mathématiques utilisés dans la vie pratique.
+                    """, width=300)
+        
+             
+            ],
 )
+# Populate the main area with plots, to demonstrate the grid-like API
+template.main[:3, :6] = pn.Card(dfi_sine.hvplot(**plot_opts).opts(title='Sin'), dfi_cosine.hvplot(**plot_opts).opts(title='Cos'))
+template.main[:3, 6:] = pn.Card(dfi_custom_sine.hvplot(**plot_opts).opts(title='Sin'), dfi_custom_cosine.hvplot(**plot_opts).opts(title='Cos'))
 
-title = "Panel Demo - Image Classification"
-pn.template.BootstrapTemplate(
-    title=title,
-    main=main,
-    main_max_width="min(50%, 698px)",
-    header_background="#F08080",
-).servable(title=title)
+# Lancez le tableau de bord
+template.servable()