added example of class creation

hepia_2024/pres.md

@@ -34,32 +34,28 @@
 
 . . .
 
-*Orestis donne une présentation sur l'intelligence*
+*Orestis donne une présentation sur* **l'intelligence**
 
 * Puis le mot suivant:
 
 . . .
 
-*Orestis donne un cours sur l'intelligence artificielle.*
+*Orestis donne un cours sur l'intelligence* **artificielle**.
 
 * Et ainsi de suite.
 
 
 # Fonctionnement des LLMs (2/5)
 
-## Contraintes sur la suite de mots
+## Contraintes sur le "mot suivant"
 
-* La suite de mots dépend:
-    * Des mots qui précèdent directement,
-    * Du contexte général,
+* Orthographe, syntaxe, grammaire,
+* Mots qui précèdent directement,
+* Du contexte général.
 
 . . .
 
-* Doivent aussi être corrects sytaxiquement, orthographiquement, et grammaticalement.
-
-. . .
-
-* Problème complexe à **formaliser** et donc à **implémenter** informatiquement.
+* Problème complexe à **formaliser** et donc à **implémenter** informatiquement (malgré beaucoup d'efforts).
 
 # Fonctionnement des LLMs (3/5)
 
@@ -73,7 +69,7 @@
     * présentation - nom
     * sur - préposition
 2. Un réseau de neurones prédit le mot suivant le plus *probable*.
-3. Mesures de protection pour empêcher les fuites dedonnées (pas à proprement parlé dans les LLMs)
+3. Mesures de protection pour empêcher les fuites dedonnées (pas à proprement parler dans les LLMs)
 
 . . .
 
@@ -94,7 +90,7 @@
     * Possède les biais de l'ensemble d'entraînement.
     * Pas de nouveautés une fois entraîné.
     * Sécurité faible.
-    * Droits d'auteurs?
+    * Droits d'auteur.
 
 # Fonctionnement de LLMs (5/5)
 
@@ -104,4 +100,151 @@
 * Gemini: $1.6\cdot 10^{12}$ paramètres
 * GPT-4: $1.7\cdot 10^{12}$ paramètres
 
+# Les modèles génératifs marchent bien
+
+## Efficacité
+
+* Résultats très bien écrits (orthographe, grammaire, style),
+* Arrive à imiter le "style" d'auteurs et autrices,
+* Textes générés sont généralement très convaincants.
+
+. . .
+
+## Bons cas d'usages
+
+* Reformuler un texte
+* Changer le "ton" d'un texte en gardant le sens
+* Corriger le style et l'orthographe
+
+## Résumer
+
+* Obtenir les points principaux d'un texte
+
+. . .
+
+## Attention
+
+* Dans **tous les cas** il est **impossible** d'avoir une garantie que le contenu est **équivalent** à celui de départ.
+
+# Cas d'utilisation concret (enseignant)
+
+* Utilisation de `bing.com` pour créer un cours d'introduction à l'algorithmique.
+* Questions posées:
+    * Créer un syllabus pour 14 séance de 135min chacune (3 périodes).
+    * Créer le contenu pour une séance données en 1e année à hepia
+* Comparaison avec la création d'un cours classique.
+
+# Cas d'utilisation: syllabus
+
+\footnotesize
+
+**Leçon 1 : Introduction à l'algorithmique**
+
+- Définition de l'algorithmique et histoire.
+- Exemples d'algorithmes simples.
+
+**Leçon 2 : Notions de base**
+
+- Termes clés et concepts fondamentaux.
+- Exercices pratiques.
+
+**Leçon 3 : Complexité algorithmique**
+
+- Analyse de la complexité en temps et en espace.
+- Exemples et exercices.
+
+**Leçon 4 : Tri et recherche**
+
+- Algorithmes de tri et de recherche.
+- Implémentation et comparaison.
+
+**Leçon 5 : Structures de données**
+
+- Listes, piles, files, arbres.
+- Exemples concrets.
+
+# Cas d'utilisation: séance (1/N)
+
+## Introduction à la Complexité des Algorithmes
+
+L'analyse de la complexité des algorithmes est essentielle pour évaluer leur performance en termes de temps d'exécution. 
+Elle nous permet de comprendre comment le temps nécessaire pour résoudre un problème évolue en fonction de la taille des données traitées. 
+Dans ce domaine, deux aspects sont particulièrement importants : la **complexité temporelle** et la **complexité spatiale**.
+
+## Complexité Temporelle
+
+La complexité temporelle mesure le nombre d'opérations élémentaires (comme les additions, les comparaisons, les affectations, etc.) 
+effectuées par un algorithme en fonction de la taille des données en entrée. 
+Plus précisément, nous nous intéressons au comportement asymptotique de l'algorithme lorsque la taille des données tend vers l'infini.
+
+. . .
+
+Note: pas mal du tout.
+
+# Cas d'utilisation: séance (2/N)
+
+### Notation "Grand O"
+
+La notation "grand O" (ou "O-notation") est couramment utilisée pour exprimer la complexité temporelle. 
+Elle permet de décrire la croissance relative du temps d'exécution en fonction de la taille des données. 
+Par exemple, si un algorithme a une complexité en "O(n)", cela signifie que le temps d'exécution est linéaire par rapport à la taille des données.
+
+. . .
+
+Note: On sait pas ce qu'est **n**, on sait pas non plus comment est définie la taille des données.
+
+# Cas d'utilisation : séance (3/N)
+
+## Exemple Simple
+
+Considérons un algorithme qui calcule la somme des éléments d'un tableau d'entiers. Voici un exemple en pseudo-code :
+
+```C
+Début
+  Somme <-- 0  // début et la boucle "Pour" est noté t1
+  Pour chaque élément T[i] du tableau // la comparaison dans la boucle est noté t2
+    Somme <-- Somme + T[i] // addition dans la boucle noté t3
+  FinPour // incrémentation de l'indice i est noté t4
+Fin
+```
+
+Le temps d'exécution total est donné par :
+
+$$ t(n) = t1 + \sum_{i=1}^{n} (t2 + t3 + t4) + t2 $$
+
+En supposant que `t1, t2, t3, t4` sont des constantes (indépendantes de `n`), nous pouvons dire que l'algorithme est asymptotiquement linéaire en `n`. 
+Autrement dit, lorsque `n` tend vers l'infini, le temps d'exécution est proportionnel à `n`.
+
+. . .
+
+Note: La formule est fausse, le deuxième `t2` ne devrait pas être là.
+
+# Cad d'utilisation : séance (4/N)
+
+Il est important de noter que cette évaluation en "pire des cas" ignore la nature des données (par exemple, si le tableau est trié ou non). 
+Cependant, elle nous donne une idée générale de la performance de l'algorithme.
+
+. . .
+
+Note: Cette remarque n'a rien à faire là et n'est pas du tout reliée à ce qui précède.
+
+# Cas d'utilisation: séance (5/N)
+
+## Bibliographie
+
+Source : conversation avec Copilot, 6/2/2024
+
+1. Complexité des Algorithmes A) Introduction. <https://lipn.univ-paris13.fr/~banderier/P13/Algo/cours_complexite.pdf>.
+2. Comprendre la complexité des algorithmes. <https://bing.com/search?q=introduction+%c3%a0+la+complexit%c3%a9+d%27un+algorithme+avec+un+exemple+simple>.
+3. Complexité d’un algorithme – l'Informatique, c'est fantastique. <https://info.blaisepascal.fr/nsi-complexite-dun-algorithme/>.
+4. Comprendre la complexité des algorithmes. <https://www.sfeir.dev/front/comprendre-la-complexite-des-algorithmes/>.
+5. Introduction à la complexité algorithmique - Université de Limoges. <https://www.irem.unilim.fr/OLD/fileadmin/documents/2015_01_04-Introduction_complexite_algorithmique.pdf>.
+6. undefined. https://bing.com/search?q=.
+
+# Comparaisonn avec une vraie création de cours
+
+1. Recherche bibliographique (anciens cours suivis, cours existants dans l'école, cours d'autres écoles, livres, ...).
+2. Création d'un syllabus réaliste basé sur **l'expérience acquise** dans le domaine.
+3. Création de zéro ou reformulation d'un contenu (et donc) **appropriation**.
+4. Citation des sources et des références pour les élèves.