L3 Informatique

Ce cours présente les principaux aspects des systèmes d'exploitation :

• Notion de processus, ordonnancement et programmation concurrente
• Allocation de resources
• Notion de section critique et d'interblocage

Conception d'un schéma relationnel, décompositions SPI, manipulations et interrogations de données en SQL.

• Etude des problèmes de bases de données ci-dessus, avec la partie du langage SQL pour les traiter.
• Bases du langage PL/SQL : procédures stockées, curseurs, gestion des transactions, triggers.
• Initiation à l'accès à une base depuis un langage généraliste (PHP) : modifications, requêtes select et curseurs, appels de fonctions et procédures stockées.

Etre capable de programmer, en SQL, PL/SQL et PHP, une application de base de données relationnelle complète gérant en particulier les contraintes d'intégrité, la confidentialité, l'indépendance des niveaux, la reprise sur panne, et le contrôle de concurrence.

L'UE s'organise en cours accompagnés de séances de TD/TP.

UE Réseaux du L2 Informatique ou équivalent

Pour fonctionner correctement, les réseaux nécessitent un grand nombre d'équipements et de processus, rendant leur architecture souvent complexe. Pour réduire cette complexité, les différentes fonctions ont été décomposées en niveaux protocolaires. Après avoir posé les fondements des télécommunications et rappelé les bases de la transmission de l’information, cette unité d'enseignement détaille les deux premiers niveaux des réseaux, à savoir « physique » (bande passante, débit binaire, codage, …) et « liaison » (codes détecteurs, codes correcteurs, techniques d'accès, …). Les principaux protocoles correspondants sont également présentés. Une série de travaux dirigés et de travaux pratiques permet d’assimiler et d’appliquer les différents concepts étudiés.

• Utilisation de technique de traîtement du signal (codes correcteurs, …)
• Connaissance du fonctionnement et des protocoles de la couche physique.
• Connaissance du fonctionnement et des protocoles de la couche de liaison.

Savoir développer dans un langage de programmation impératif ou objet; savoir développer en SQL (création de schémas, remplissage simple d'une base de données, interrogation simple).

• Introduction à la bioinformatique et à la biologie moléculaire.
• Deux mini projets encadrés représentatifs des analyses de données bioinformatiques.
• Interrogation de bases de données biologiques réelles et mise en évidence des caractéristiques fortes (massives, hétérogènes) de ces données;
• Conception et implémentation d’une base de données biologique fonctionnelle depuis des données réelles (format XML), développement d'un parseur en Python pour le remplissage de la base, interfacage de la base en PHP pour son interrogation via des formulaires.
• Analyse de données phylogénétiques. Introduction à la phylogénie, algorithmes de contruction d'arbres phylogénétiques, Implémentation d’un pipeline d’analyse phylogénétique.

Introduction aux problématiques de Bioinformatique. Mise en application des compétences acquises en bases de données et en programmation sur des projets impliquant des données massives et hétérogènes réelles de biologie moléculaire.

L'UE comporte des séances de cours en classe entière dédiée aux spécificités des données bioinformatique et des traitements algorithmiques sur ces données. Des exercices de mise en application en TD/TP suivent systématiquement. Les projets sont effectués à moitié sur les heures encadrés et à moitié sur le temps étudiants (hors présence enseignant).

Concept de base en langage Java (Classes, Héritage, Interfaces),
Algorithmique et structures de données de base (séquences, arbres, graphes)

Le cours aborde différents cadres de formalisation.

• La première partie étudie celui des jeux avec adversaires (e.g. Echecs, Dames, Othello, …). Elle présente la notion de stratégie de jeu, des techniques d'estimation de configuration, le principe d'une recherche Minimax et présente différents algorithmes permettant, à partir d'une simple description des règles d'un jeu, d'explorer efficacement l'ensemble des parties possibles (e.g. AlphaBeta, NegEchecAlphaBeta, MTDf,...).
• La seconde partie s'intéresse aux problèmes pouvant se formaliser en termes d’états et d’opérateurs de changements d’états. Leur résolution s'apparente alors à la recherche d'un chemin solution dans un graphe. Différents algorithmes d'exploration sont présentés et comparés. Certains d'entre eux exploitent des informations heuristiques sur les états pour les guider plus efficacement vers le but à atteindre.
• Le cours introduit également quelques notions de représentation de connaissance et de raisonnement.

Ce cours permet de se familiariser avec quelques cadres génériques de résolution de problèmes, dans le but de concevoir des agents intelligents. L'accent est mis sur des algorithmes de recherche permettant d'explorer efficacement des espaces de recherche (modélisés par des arbres et/ou des graphes) généralement de trop grande taille pour pouvoir être représentés exhaustivement.

Le cours équilibre les dimensions théoriques et pratiques. Les techniques présentées sont mise en oeuvre au travers d'un ou plusieurs projets, comme par exemple la réalisation de joueurs intelligents s'affrontant au travers d'un tournoi. Le langage de programmation utilisé est Java.

— Séance 1 : Introduction à la fairness, présentation de quelques éléments légaux, sensibilisation avec des exemples tels que les travaux de l’équipe FairSpeech de Stanfordhttps://fairspeech.stanford.edu et enfin définition des principales métriques. TD : calculer et manipuler ces métriques sur un cas jouet. — Séance 2 : Etude des données, lecture et prise en main d’un ’vrai’ jeu de données (des données sur l’admission en soin de patients diabétiques qui servira d’exemple tout le long du cours https://fairlearn.org/main/user_guide/datasets/diabetes_hospital_data.html). Nous verrons comment trouver des corrélations entre les attributs des instances et étudierons la recherche de biais par rapport aux attributs sensibles choisis (le genre, l’origine et l’âge). La partie pratique consistera à s’approprier les outils et refaire la recherche de biais avec un autre attribut que celui vu dans la partie ’cours’. Il en sera de même pour les séances suivantes. — Séance 3 : Apprentissage d’un modèle prédisant la réadmission ou non de la personne et étude des biais dans les prédictions des modèles. Étude de l’impact des corrélations présentes entres les attributs des données sur l’apprentissage des modèles. Le fait de retirer l’attribut sensible des données ne résout pas les biais observés dans les prédictions du modèle. — Séance 4 : Nous verrons les méthodes de pre-processing qui permettent de réduire les biais observés tel que le reweighing, ainsi que les méthodes de post-processing. Les avantages et inconvénients seront discutés. — Séance 5 : Nous verrons les méthodes in-processing. La partie pratique consistera à implémenter une méthode in-processing. Enfin, lors du projet, les étudiants devront par groupe, choisir un jeu de données parmi ceux proposés ou un de leur choix. Ils devront lui appliquer une approche similaire à celle vue durant le cours. L’objectif du projet est de détecter les biais dans les données, puis d’avoir une implémentation permettant de réduire ces biais dans les modèles appris sur ces données pour améliorer leur impartialité

La notion de fairness est intéressante et importante car elle permet de sensibiliser aux défauts et inconvénients de l’intelligence artificielle. Celle-ci a tendance à reproduire et amplifier les biais déjà présents dans les ensembles d’apprentissage. Cela est particulièrement vrai pour les données médicales où le biais de sélection des données est fort et l’impartialité indispensable

Le module comporte 12 séances de 4h, les 6 premières sont découpées en 2h de théorie et 2h de pratique, les autres étant principalement consacrées à l’encadrement de projet avec si besoin des rappels, précisions ou compléments théoriques

Avoir des notions d'algorithmique, distinguer le polynomial de l'exponentiel. Etre capable de faire des raisonnements (preuves par l'absurde, preuves parfois abstraites) et avoir un certain sens combinatoire.

Introduction rapide aux automates. Machines de Turing déterministes. Variantes. Indécidabilité. Problème de l'arrêt. Réductions. Rice. Post. Machines de Turing non-déterministes. NP. Certificats et vérifications. Réductions polynomiales. NPcomplétude. SAT. Cliques. Hamiltonien. 3Coloriages. SacADos. Algos d'approximation. Ardu : Autres classes: Hiérarchies, L, NL, PSPACE.

Connaitre les limites théoriques de l'algorithmique et comprendre pourquoi et à quel point certains problèmes sont intrinsèquement difficiles.

Cours et TD. Évaluation par un partiel et un examen terminal écrit.

UE Réseaux de L2 et Réseaux avancés de L3, UE Système de L3

Cette UE est structurée en séances de cours (en début d'UE pour présenter les concepts) suivi de séances de TP permettant de réaliser l'application choisie.

Elle est évaluée par des soutenances du projet et un examen.

Notions de base de l'algèbre linéaire, bases de la programmation

De nombreux problèmes réels sont intrinsèquement des problèmes d'optimisation combinatoire. L'idée de cette unité d'enseignement est d'aborder les problèmes classiques d'optimisation ainsi que ses techniques de résolution en partant d'applications que l'on retrouvent dans le monde réel (réseaux, Internet des Objets, traitement des données, gestion des stocks).

Partir de problèmes réels pour proposer des formulations mathématiques (modélisation sous forme de programmes mathématiques et graphes) traitées par des techniques d'optimisation combinatoire exactes et approchées.Une mise en œuvre informatique des méthodes sera réalisée.

Cours, TD, TP. Évaluation par controle continu (Partiel, interrogation, projets, …) et examen terminal écrit.

Projet de second semestre. Ce projet est usuellement réalisé en binôme. Plusieurs types de projets sont proposés, par exemple :

• Programmation Concurrente et Interfaces Interactives
• Génie Logiciel
• Programmation Fonctionnelle Avancée
• Bioinformatique
• Previsualization of Future User Interfaces
• Entrepreneuriat : création de micro-startup Chaque projet donne lieu à un rendu (code, rapport, support, ...) et à une soutenance. Les étudiants sont laissés en semi-autonomie (salles de TP réservées, points réguliers avec leur responsable de projet).

Autonomie Travail en groupes Rédaction et présentation Travail sur une base de code conséquente nécessitant l'utilisation de technique de génie logiciel et de conduite de projet.

• Maîtrise du paradigme fonctionnel
• Connaissance des structures de données avancées (persistante, mutables)
• Notion de sémantique des langages de programmation

Cours et TP notés ou interros + un examen final.

Introduction à l'Informatique et Python, Introduction à la programmation impérative, Calculus 1-2, Algèbre linéaire 1-2, Combi Proba

Ce cours a pour but d'introduire les concepts de bases de l'apprentissage statistique en les illustrant sur des réseaux de neurones simples et en les appliquants à la reconnaissance de caractères, et ensuite en analysant les résultats obtenus. Dans un second temps, on s'intéressera à l'apprentissage par renforcement consistant à guider l'apprentissage d'un agent autonome en interaction avec un environnement à partir d'expérience. Le cours se abordera les points suivants:

• La notion de gradient et d'optimisation de fonction de coût
• Le perceptron multiclasse, et multicouche
• Les ensembles pour valider l'apprentissage
• La notion d'agent en interaction avec un environnement
• Les équations de Bellman permettant d'évaluer la politique de mouvement pour l'agent
• L'apprentissage Q-learning et SARSA

Concepts fondamentaux de l'apprentissage automatique/statistique et application à des exemples simples.

L'UE s'organise en cours accompagnés de séances de (quelques) TD et de (nombreux) TP.

Programmation en Java, bases en modelisation UML, notions en logique (les pré-requis suivent le cours "Eléments de Logique" en parallele).

L'enseignement portera sur les techniques suivantes:

• Approfondir les techniques de modélisation en UML avec des annotations formelles
• Test de boite-noire à partir d'une spécification
• Sequence-Test boite-noire à partir d'une spécification State-Chart
• Test de boite-noire de sécurité
• Test de boite-blanche à partir de programmes
• Fuzz-Testing
• Vérification à base des methodes deductives preuves formelles

Dans le génie logiciel, on distingue plusieurs phases dans le processus de développement de logiciels: L'analyse, la conception, le codage, l'intégration, la validation et vérification des composants ou des systèmes entiers. Le cours se concentre sur les deux dernières phases dans du processus de développement, en traitant en profondeur l'aspect modélisation lors de l'analyse, sous l'aspect des méthodes automatisées et des outils. Afin de vérifier un systeme grâce à la génération de tests, par exemple, on a besoin de modèles suffisamment précis.

L'UE est organisée de manière classique avec des séances de cours et exercices en classe entière suivies de séance de TD ou TP. Quelques activités d'apprentissage autonome en ligne sont proposées. L'évaluation repose sur un partiel et un examen final.

Premières expériences en algorithmique, programmation et complexité (en L1 et L2).

• Petits programmes (puissance(x,n) (ardu: en itératif de complexité log), Hanoï, Ackermann...) et complexités (linéaires, quadratiques, logarithmiques, exponentielles par "effet Fibonacci", etc.)
• Programmes sur les listes pile (type listes chainées). Itératif, récursif, récursif terminal. Paramètres in, inout et out (calculs depuis la tête et le fond de liste, exemple ardu: "EstPalindrome" en une passe sur listes simplement chainées). Diviser pour régner (exemple ardu: générer par récursivité et DPR la liste des permutations de [1..n])
• Pointeurs, listes chaînées, pointeurs de pointeurs.
• Tableaux. Sélections. Parcours (exemple: détecter si un mot donné par tableau est sans carré, en cubique puis, ardu, en quadratique). Dichotomie. Tris simples, rapide, par tas, fusion. Hachage.
• Arbres. Programmes sur les arbres. Informations ascendantes et descendantes. (Ardu: donnez une demi-douzaine de façons de faire "EstComplet(A)" en temps linéaire). Parcours et notations.

Programmer proprement et efficacement : Programmation, Algorithmes, Structures de données, Complexités.

Cours, TD et projet C. Evaluation par partiel et examen terminal écrit.

Automates d'état fini, expressions rationnelles.

Le cours se développe comme suit :

• Automates finis : non déterminisme, expression rationnelle, preuve du théorème de Kleene (système d'équations associé à un automate), minimisation, résiduels, construction directe de l'automate minimal, lemme de l'étoile, pompage, propriétés de clôture, lien avec l'analyse lexicale.
• Grammaires : hiérarchie de Chomsky, grammaire régulière, grammaires hors contexte, Lemme de la double étoile pour les langages algébriques, propriétés de clôture. Illustration avec des grammaires de vrai langage de programmation, arbre de syntaxe abstraite.
• Automates à pile : fonctionnement non-déterministe, terminaison, lien avec les langages algébrique.
• Analyse syntaxique ascendante: calcul des tables d'analyse LR(0), SLR(1), gestion des conflits, le cas général LR(1), le cas utilisé en pratique LALR(1).
• Calculabilité: Machines de Turing , langage/problèmes indécidables. Le probléme de l'arrêt.

Notions théoriques sur les langages formels, techniques de preuve, principe de l'analyse syntaxique ascendante, notions élémentaires de calculabilité.

Le cours prépare aux TDs, lequels font digérer le cours. L'UE se termine par un TP d'analyse syntaxique. La note de Controle Continu comprends un devoir et/ou mini projet.

Les bases du calcul propositionnel (tables de vérité des connecteurs logiques). Les bases du raisonnement mathématique (définitions, énoncé, preuves).

Le programme du cours est le suivant :

• Langage logique (calul propositionnel et calcul des prédicats), modélisation à l'aide de la logique.
• Systèmes de règles logiques pour construire des preuves.
• Termes : signature, preuve par récurrence structurelle, définition récursive de fonctions.
• Calcul des prédicats : syntaxe, variables libres et liées, sémantique, équivalence.
• Modèle, modèle de Herbrand Exemples de théories :
• Démonstration automatique, formes normales, résolution, séquents.

L’objectif du cours est de se familiariser avec le formalisme de la logique du premier ordre. La logique est utilisée pour modéliser des problèmes informatiques et comme outil de spécification de contraintes sur des objets informatiques comme des bases de données ou des programmes. Ce cours aborde les notions de démonstration, de validité, le lien entre les objets physiques (syntaxe) et le sens qu'on leur donne (sémantique). Il présente plusieurs techniques de démonstration automatique comme le calcul des séquents et la résolution. Il met en pratique un certain nombre d’outils mathématiques utilisés en informatique, comme les définitions récursives de fonctions, les preuves par récurrence structurelle ou les définitions par règle d'inférence.

UE est organisée de manière classique avec des séances de cours et exercices en classe entière suivies de séance de TD. Quelques activités d'apprentissage autonome en ligne sont proposées. L'évaluation repose sur un partiel et un examen final.