Prises de notes fin d'annee + base infra
This commit is contained in:
parent
4829b19603
commit
ca857807e7
|
|
@ -0,0 +1,531 @@
|
||||||
|
# Anti virus
|
||||||
|
|
||||||
|
## Présentation
|
||||||
|
|
||||||
|
L'antivirus est un logiciel en charge de détecter les logiciels malveillants et douteux (malware), via diverses méthodes
|
||||||
|
|
||||||
|
Plusieurs types de malwares :
|
||||||
|
|
||||||
|
- Programmes simples (trojan, spywares, backdoors...)
|
||||||
|
- Programmes auto-reproducteurs (virus, vers)
|
||||||
|
- Botnet (IoT, DDOS, cryptomining)
|
||||||
|
- PUP (adwares)
|
||||||
|
- Autres (rootkit...)
|
||||||
|
|
||||||
|
Fonctionnement :
|
||||||
|
|
||||||
|
- Analyses scantime et runtime
|
||||||
|
- Principes on-demand scanners et/ou On-Access Scanners
|
||||||
|
- Dictionnaire de données
|
||||||
|
- Monitoring
|
||||||
|
- Contrôle d'intégrité
|
||||||
|
- Analyse spectrale
|
||||||
|
- Analyse heuristique
|
||||||
|
|
||||||
|
# SGBD
|
||||||
|
|
||||||
|
## Présentation
|
||||||
|
|
||||||
|
Principaux éléments du SGBD :
|
||||||
|
|
||||||
|
- Structure mémoire - Mémoires physiques et logiques du serveur
|
||||||
|
- Processus - Chargement des données en mémoire, gère l'écriture en mémoire des fichiers
|
||||||
|
- Instances - Créées par les users lorsqu'ils se connectent à la bdd
|
||||||
|
|
||||||
|
Il y a plusieurs types de SGBD :
|
||||||
|
|
||||||
|
- Relationnels : PostgreSQL, s'inspire d'Oracle, très complet
|
||||||
|
- autres types : noSQL, MongoDB, neo4J...
|
||||||
|
|
||||||
|
SGBD VS Feuille de calcul : pourquoi c'est mieux ?
|
||||||
|
|
||||||
|
- Haute disponibilité et répartition des charges
|
||||||
|
- Multi utilisateurs
|
||||||
|
- Vérifie l'intégrité des données
|
||||||
|
|
||||||
|
## Verrouillage
|
||||||
|
|
||||||
|
### ACID
|
||||||
|
|
||||||
|
- Atomicité
|
||||||
|
- Cohérence
|
||||||
|
- Isolation
|
||||||
|
- Durabilité
|
||||||
|
|
||||||
|
### Verrouillage pessimiste
|
||||||
|
|
||||||
|
- Verrouille l'enregistrement au moment de son édition
|
||||||
|
- Libéré après validation des changements
|
||||||
|
|
||||||
|
Méthode simple qui empêche la modification simultanée des enregistrements. Dit que lorsqu'une transaction se déclenche, on applique un verrouillage explique sur les ressources touchées par les transactions. Verrouillage très restrictif : on ne peut pas lire les éléments en cours de modifs. Ça peut être problématique si les transactions se "croisent" : elles s'interbloquent. On appelle ça un "verrou mortel".
|
||||||
|
|
||||||
|
### Verrouillage optimiste
|
||||||
|
|
||||||
|
Laisse les conflits se faire, puis les résout. Pose une sorte de "tag" (une estampille) sur éléments modifiés, et effectue les accès das l'ordre croissant des accès aux ressources. Lorsqu'il y a conflit, utilise l'ordonnancement. Ce verrouillage est plus rapide mais provoque trop de "reprises" et donc gourmand en ressources.
|
||||||
|
|
||||||
|
L'objectif d'un SGBD c'est que les transactions soient sérialisables. Protocole 2PL va permettre à deux entités t1 et t2 d'accéder à une ressources. Deux types de verrous : un verrou partagé et un verrou exclusif. L'exclusif intervient quand on veut faire une modif en écriture sur une ressource : la ressource est alors complètement inaccessible, il faut que l'entité relâche son verrou pour laisser les autres accéder. 2PL est là pour poser les verrous sur toutes les ressources nécessaires et ne les relâche pas jusqu'à ce qu le traitement soit terminé. Pendant ce temps les autres attendent.
|
||||||
|
|
||||||
|
### Noël
|
||||||
|
|
||||||
|
- optimiste implique du rollback, donc utile quand peu de congestion sur les donnés
|
||||||
|
- pessimiste utilisé quand utilisé quand beaucoup de transactions sur données en même temps (forte congestion sur les données)
|
||||||
|
|
||||||
|
C'est au niveau du commit qu tout se gère : opti/pessi encadre le commit
|
||||||
|
|
||||||
|
## Mémoire
|
||||||
|
|
||||||
|
Le SGA : Global System Area
|
||||||
|
|
||||||
|
Zones de mémoire les plus imporante : shared pool et
|
||||||
|
|
||||||
|
### PGA : process global area
|
||||||
|
|
||||||
|
Zone ou on stocke informations sur tout ce qui est SQL : le curseur... zone de travail pour executer le SQL.
|
||||||
|
|
||||||
|
Elle est alloué à chaque process, il y a une PGA pour tout ce qu'on veut travailler en mémoire
|
||||||
|
|
||||||
|
Comment fonctionnent ces processus ? Ils sont effectués en mémoire RAM puis synchronisés ensuite via l SGA.
|
||||||
|
|
||||||
|
### Noël
|
||||||
|
|
||||||
|
Un user qui se connecte crée un UGA, puis ses opérations des PGA dans le UGA. Ces PGA se connectent au SGA.
|
||||||
|
|
||||||
|
## Systèmes d'indexation
|
||||||
|
|
||||||
|
Dans les SGBD relationnels
|
||||||
|
|
||||||
|
### Définition
|
||||||
|
|
||||||
|
Aide à retrouver facilement et rapidement les données.
|
||||||
|
|
||||||
|
Exemple des panneaux dans un supermarché : permet de retrouver plus vite où sont les produits.
|
||||||
|
|
||||||
|
L'index indique donc où on peut trouver une donnée.
|
||||||
|
|
||||||
|
### Quand utiliser un index
|
||||||
|
|
||||||
|
Il faut calculer la Sélectivité, si elle est inférieure à 15% des lignes, c'est intéressant, sinon ça prendra plus de temps de faire un index.
|
||||||
|
|
||||||
|
$ sélectivité\ = \frac{Cardinalité}{Nombre\ total\ de\ lignes}$
|
||||||
|
|
||||||
|
L'optimiseur : pour une requête, regarde et retient toutes les actions qu'il a fallu faire pour obtenir la données, et calcule un coût pour la requête. Ensuite, quand on l'interroge, il dit comment on peut optimiser le coût de la requête, en mettant un index sur certaines colonnes par exemple. Attention, il peut aussi se tromper (rarement), on peut alors le forcer à utiliser un autre index.
|
||||||
|
|
||||||
|
### Différents types d'index
|
||||||
|
|
||||||
|
#### Le B tree
|
||||||
|
|
||||||
|
C'est un arbre hiérarchique équilibré. Par rapport à un arbre normal, se base plutôt sur un concept de "racine + branche" et de "feuilles"
|
||||||
|
|
||||||
|
#### Le bitmap
|
||||||
|
|
||||||
|
Destiné aux colonnes avec peu de valeurs distinctes et beaucoup d'enregistrement. Codé sur un bit (vrai ou faux) pour chaque entrée
|
||||||
|
|
||||||
|
Donc chacun est plus ou moins efficace en fonction de la cardinalité.
|
||||||
|
|
||||||
|
#### Index par hashage
|
||||||
|
|
||||||
|
on accède à la valeur par la clé , construction d'un tableau sans ordre. Il peut y avoir collision entre les clés de hashage, il faut donc mettre en place un système de résolution de collision pour gérer ces cas. Et bien choisir sa fonction de hashage pour pas se niquer en temps de calcul.
|
||||||
|
|
||||||
|
## Exécutions SQL
|
||||||
|
|
||||||
|
###
|
||||||
|
|
||||||
|
1.
|
||||||
|
|
||||||
|
D'abord, ordre donné. Avant de l'exécuter, le moteur vérifie la syntaxe, puis la sémantique (l'utilisateur a t il le droit?...), la requête a t elle déjà un plan d'exécution (dans le SGA) ?
|
||||||
|
|
||||||
|
2.
|
||||||
|
|
||||||
|
Puis optimisation : bind variables. SQL sensible à la casse, et pour une mêùme variable en min et maj, il est obligé de faire un hard pass ce qui est très couteux. Les bind variables font un truc qui permet d'économiser des ressources.
|
||||||
|
Elle permet de créer un seul et unique arbre de résolution de requête qui va être actualisé avec les nouvelles valeurs, autrement SQL créerait un nouvel arbre à chaque fois.
|
||||||
|
|
||||||
|
3.
|
||||||
|
|
||||||
|
Exécution du plan sélectionné.
|
||||||
|
|
||||||
|
En complément :
|
||||||
|
|
||||||
|
les hints. Syntaxe spécifique qui va permettre d'exécuter d'une façon spécifique, par exemple en demande un parcours complet de la table.
|
||||||
|
Plusieurs listes et jointures possibles listés sur le PDF
|
||||||
|
l'optimiseur : il aide et assiste. SQL TUNING ADVISOR donne des indications sur comment opti sa bdd
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Le CBO a de meilleures perfs mais a besoin de métadonnées sur les tables utilisées.Pour cela, Oracle a des tables cachées de stats sur les tables utilisables. Avant c'était RBO : rule-based organisation
|
||||||
|
|
||||||
|
# Pare-feu
|
||||||
|
|
||||||
|
## Présentation
|
||||||
|
|
||||||
|
But : se protéger des intrusions malveillantes et des fuites de sécurité / de données
|
||||||
|
|
||||||
|
Intervient sur les couches 3 et 4 du OSI, plus la 7 pour le filtrage applicatif
|
||||||
|
|
||||||
|
Le filtrage peut être :
|
||||||
|
|
||||||
|
- Stateless : couche 3-4, se fait en fonction du paquet
|
||||||
|
- Stateful : couche 7, se fait en fonction de l'état de la connexion
|
||||||
|
|
||||||
|
Trois types de pare feu :
|
||||||
|
|
||||||
|
- Logiciel, le plus répandu, déjà intégré à l'OS/au noyau
|
||||||
|
- Matériel, lié à la machine réseau (routeur), pas flexible
|
||||||
|
- Bridge
|
||||||
|
|
||||||
|
## Comment voit et gère-t-il les paquets ?
|
||||||
|
|
||||||
|
Paquet : données envoyées sur le réseaux découpées en pitits morcaux
|
||||||
|
|
||||||
|
Socket : Permet au développeur de manier les outils réseaux. Un socket contient ce qu'il faut pour les protocoles de la couche.
|
||||||
|
|
||||||
|
Communication peu être en TCP ou UDP (connecté / non connecté)
|
||||||
|
TCP : socket, bind, listen, accept, recv, send
|
||||||
|
UDP : socket, bind, recvfrom
|
||||||
|
|
||||||
|
Lorsque le paquet arrivé, il est mis en tampon, ou rejeté. Puis il y a génération ou interruption, on lui alloue le SK_buffer, appelle la fonction et on le met en file d'attente du CPU. Il est ensuite traité au niveau processeur, t c'est ici que le pare feu intervient pour filtrer les paquets : il peut lire ce qui se passe dans le processeur, et en fonction de ses règles il l'accepte ou le rejette.
|
||||||
|
|
||||||
|
SK_buffer conserve les données sur les paquets. c'est un objet qui permet à l'OS de se "représenter" le paquet : toutes les données (dont entête, tout ça) qui sont inscrite dedans.
|
||||||
|
|
||||||
|
## Netfilter
|
||||||
|
|
||||||
|
S'organise en couches la plus haute : utilisateur, puis les règles (tables), en dessous netfilter, le oyau, qui fait analyse pure du paquet, et enfin matérielle
|
||||||
|
|
||||||
|
### tables
|
||||||
|
|
||||||
|
ce sont les entités qui définissent le comportement de netfilter : des chaînes qui sont un ensemble de règles
|
||||||
|
|
||||||
|
Il y a des hooks, avec 5 points d'accroche : prerouting, inpout, forward, output, postrouting
|
||||||
|
|
||||||
|
## IDS
|
||||||
|
|
||||||
|
Intrusion Detection System
|
||||||
|
|
||||||
|
Logiciel qui fait de la détection d'intrusion : sniffe le réseau et détermine si qqch de suspect dessus. Utilisé en complément du pare feu et des antivirus.
|
||||||
|
|
||||||
|
### Ce qu'il fait
|
||||||
|
|
||||||
|
Surveille routeur, pare feu et les services
|
||||||
|
|
||||||
|
Permet de rendre plus clair des trucs via une interface.
|
||||||
|
|
||||||
|
Signale quand sécurité est violée, peut bloquer des intrusions.
|
||||||
|
|
||||||
|
### avantages
|
||||||
|
|
||||||
|
donne de la visibilité, automatise des tâches de surveillance, surveille les applications et les réseaux
|
||||||
|
|
||||||
|
### 3 familles, 2 techniques
|
||||||
|
|
||||||
|
NIDS : Network tournent en mode passif en utilisant de sports miroir
|
||||||
|
|
||||||
|
HIDS : Host ids surveillent réseau pour voir si compromis
|
||||||
|
|
||||||
|
Hybrides : regardent sur machines plus que réseau
|
||||||
|
|
||||||
|
Deux types d'approches : soit par signature soit par huristique, comme antivirus
|
||||||
|
|
||||||
|
### techniques
|
||||||
|
|
||||||
|
Comme celles des antivirus : scanne le réseau, vérifie si signatures correspondent à ses règles. Lance alertes en fonction de c qu'il a trouvé. Nécessite d'avoir une base ultra à jour, pas méga fiable.
|
||||||
|
|
||||||
|
Combiné donc avec analyse heuristique, l'IDS apprend en fonction du comportement du réseau, ce qui est normal et ce qui ne l'est pas. Gros travail d'origine à fournir pour indiquer ce qui est normal et ce qui ne l'est pas.
|
||||||
|
|
||||||
|
### NIDS
|
||||||
|
|
||||||
|
Analyse de manière passive les flux entrant et détecter intrusions en temps réel. Écoute tout le trafic réseau. Le NIDS est une machine à parti qui rajoute pas de la charge. Très efficace.
|
||||||
|
|
||||||
|
### HIDS
|
||||||
|
|
||||||
|
Analyse plus le trafic réseau mais uniquement le flux sur une machine. Vérifie intégrité des données mais a besoin d'un système sain.
|
||||||
|
|
||||||
|
### Softwares
|
||||||
|
|
||||||
|
NIDS : snort, bro, suricata, check point
|
||||||
|
|
||||||
|
HIDS : Fail2ban, rkhunter, chkrootkit
|
||||||
|
|
||||||
|
### Hybrides
|
||||||
|
|
||||||
|
Généralement utilisés dans envirnnements décentralisés. réunissent infos provenant de NIDS comme HIDS
|
||||||
|
|
||||||
|
### KIDS, KIPS
|
||||||
|
|
||||||
|
Systèmes de prévention d'intrusion Kernel.
|
||||||
|
|
||||||
|
Encore plus sécurisé et complémentaire à l'IDS. Peuvent faire pas mal de trucs mais solution rares qui utilisent des serveurs, des machines à part.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Nombreuses technologies complémentaires à voir sur PDF, dans l'objectif de décourager le hacker.
|
||||||
|
|
||||||
|
Pour le temps d'apprentissage n heuristique, faut bien compter 3 mois (commencer en IDS, pis au bout de 3 mois passer en IPS)
|
||||||
|
|
||||||
|
## WAF WAF
|
||||||
|
|
||||||
|
J'étais pas là
|
||||||
|
|
||||||
|
###
|
||||||
|
|
||||||
|
# OS
|
||||||
|
|
||||||
|
## Présentation
|
||||||
|
|
||||||
|
Bootloader avant l'OS
|
||||||
|
|
||||||
|
1965 : Multies par MIT
|
||||||
|
1980 : DOS
|
||||||
|
1990 : OS sous licence (Linux)
|
||||||
|
|
||||||
|
5 générations :
|
||||||
|
|
||||||
|
- Par lots
|
||||||
|
- Multitâches
|
||||||
|
- Temps partagé
|
||||||
|
- Temps réel
|
||||||
|
- Systèmes distribués
|
||||||
|
|
||||||
|
Les _system calls_ sont des appels système via le shell, possibles une fois l'OS lancé
|
||||||
|
|
||||||
|
Les couches :
|
||||||
|
|
||||||
|
- Hardware
|
||||||
|
- Kernel
|
||||||
|
- Shell
|
||||||
|
- Applications
|
||||||
|
|
||||||
|
Ne pas confondre shell et terminal ! Ce dernier exécute le shell mais n'en est pas un !
|
||||||
|
|
||||||
|
## La mémoire
|
||||||
|
|
||||||
|
J'ai oublié. De. Noter.
|
||||||
|
|
||||||
|
### Noël
|
||||||
|
|
||||||
|
Avant, pas plus de 640 kilooctets. Du coup les gars se sont dit "bon, bah on prend une page de cette taille, on la rempli, pis si ça fait plus on fait une deuxième page".
|
||||||
|
|
||||||
|
Le problème c'est que si quelqu'un arrive à percer le code il a accès à tout. Donc ils ont définit un espace mémoire, t dedans des blocs, qui sont des "segments". chacun avec ses propres règles et des tailles différentes. On a donc du paginé + segmenté.
|
||||||
|
|
||||||
|
## L'ordonnancement
|
||||||
|
|
||||||
|
### Politiques d'ordonnancement
|
||||||
|
|
||||||
|
- Premier arrivé, premier servi : pas le meilleur
|
||||||
|
- Plus court d'abord : le processus le plus court passe en prio. Assez efficace mais nécessite de savoir le temps du process, ce qui peut être copliqué
|
||||||
|
- Par priorité : l'OS détermine une prio par process
|
||||||
|
- Tourniquet (round Robin) : marche pour les OS à temps partagé
|
||||||
|
|
||||||
|
### Fork
|
||||||
|
|
||||||
|
Permet la création dynamique de nouveau processus par le système. Sort de division cellulaire : process père génère un process fils. Notion d'héritage présente : les attributs systèmes sont transmis du parent à l'enfant. Var globales t statiques ne sont pas transmises dans le fork.
|
||||||
|
|
||||||
|
Au démarrage du syst unix, le process INIT arrive et tous les autres process découlent de celui-ci : arborescence.
|
||||||
|
|
||||||
|
### Sémaphore
|
||||||
|
|
||||||
|
Outil système disposant d'une file d'attente, et d'un système de jetons. Initialement il distribue des jetons par processus, et consomme ces jetons, lorsqu'il n'a plus de jetons ils s'arrête. Il peut aussi réveiller des process.
|
||||||
|
|
||||||
|
### Thread
|
||||||
|
|
||||||
|
Proche du fork, mais cette fois ci le parent partage variables globales, statiques locales et descripteurs de fichiers avec l'enfant. C'est finalement un fork avancé.
|
||||||
|
|
||||||
|
### Noël
|
||||||
|
|
||||||
|
Le fork crée un autre process parallèle.
|
||||||
|
|
||||||
|
Le thread a un flux d'activité (maître), fait une copie avec la data du flux : reprise de l'exécution à partir de là ou s'ne était arrêté la première. Ce qui est intéressant c'est que le thread, une fois fini, peut potentiellement revenir sur la branche maître.
|
||||||
|
|
||||||
|
## Le kernel
|
||||||
|
|
||||||
|
### Introduction
|
||||||
|
|
||||||
|
Développé en C et en assembleur. Fait l'interface entr la couche software et la couche hardware. fournit une interface de programmation pour le matériel.
|
||||||
|
|
||||||
|
Créateur : L. Torvald en 1991. À la base pour une seule archi puis porté sur d'autres type ARM. Multi utilisateur, respecte les normes posix, certaines fonctionnalités peuvent être ajoutées ou envelvées à lavolée.
|
||||||
|
|
||||||
|
### Fonctions
|
||||||
|
|
||||||
|
Excécution des processus, gstion mémoire, gestion du matériel...
|
||||||
|
|
||||||
|
### Développement
|
||||||
|
|
||||||
|
Développé par la communauté originellement, puis de grosse boite s'y sont mises : Red Hat, Intel, IBM...
|
||||||
|
|
||||||
|
Sous licence GNU.
|
||||||
|
|
||||||
|
### Les types
|
||||||
|
|
||||||
|
Le monolithique : conception ancienne et considérée comme obsolète. Un seul gros bloc qui contient toutes les fonctions et pilotes et de quoi les compiler. Concept simple, excellente vitesse d'exécution. Mais forte augmentation de taille avec l temps (ajout de fonctionnalités).
|
||||||
|
|
||||||
|
Pour contrer ce dernier point, création ds monolithiques modulaires : noyau avec fonctionnalités principales, et plein de services différnts sous formes de modules. Tout est centralisé dans un seul noyau, donc une seul erreur dans un service facultatif peut mettr en péril toute la sécurité du système. Meilleures possiiblités de configuration et améliore temps de chargement mais encore des défauts.
|
||||||
|
|
||||||
|
Du coup invention des micronoyaux dans les années 90. Le nombre de fonctions principales et les dépendances du noyau est fortement réduite. Donc minimisation des risques d'erreurs pour meilleure robustesse, fiabilité, évolutivité et maintenance. Nécessite par contre un protocole de communication netre les processus (IPC), assez lourd qui finalement réduit les performances.
|
||||||
|
|
||||||
|
Enfin on ne arrive au noyau hybride qui combine avantages de monolithique et micronoyaux
|
||||||
|
|
||||||
|
### Caractéristiques techniques
|
||||||
|
|
||||||
|
le noyau doit être compilé pour être compris en binaire. On a donc besoin des sources et de GCC (Gnu Compiler Collection) qui embarque tous les outils nécessaires.
|
||||||
|
|
||||||
|
On place les sources dans `/usr/src/linux-(version)`, à partir de ces sources on peut compiler le noyau dans `/boot`, et les modules quant à eux sont placés dans `/lib/modules`
|
||||||
|
|
||||||
|
### Les modules
|
||||||
|
|
||||||
|
Code ajoutant des fonctionnalités au noyau. Ils sont exécutés dans l'espace mémoire du noyau : contrôle total sur la machine. Depuis version 2, il n'est plus nécessaire de recompiler le noyau pour chagrer un module (chargement dynamique), via `insmod` ou `modprobe`.
|
||||||
|
|
||||||
|
## Gestion des péripériques
|
||||||
|
|
||||||
|
Intro : udev gestionnaire de périph du kernel linux depuis 2.6
|
||||||
|
|
||||||
|
Concepts:
|
||||||
|
|
||||||
|
- /dev contient les périphériques sous forme de fichier
|
||||||
|
- udev nouveau système qui permet de les gérer là
|
||||||
|
-
|
||||||
|
|
||||||
|
Règles :
|
||||||
|
|
||||||
|
elles permettent de
|
||||||
|
|
||||||
|
- changer nom périph
|
||||||
|
- plein d’autres sur pdf
|
||||||
|
|
||||||
|
fichiers dans /etc/udev/rules.d
|
||||||
|
|
||||||
|
. on peut avoir plein de fichiers d'extension .rules
|
||||||
|
|
||||||
|
un périphérique peut être contrôlé par plusieurs règles
|
||||||
|
|
||||||
|
Sysfs quand Gaul le dit in dirait qu'il dit "si ses fesses". Exemple : "si, ses fesses on peut faire plein de choses avec".
|
||||||
|
|
||||||
|
Il est par exemple possible grâce aux règles udev de faire un script qui se déclenche en fonction du numéro de s"ri d'un périph branché. Mais ça marche pas toujours.
|
||||||
|
|
||||||
|
# Driver
|
||||||
|
|
||||||
|
## Présentation
|
||||||
|
|
||||||
|
Permet de faire fonctionner le matériel. Il est souvent embarqué avec l'OS, ou sinon est distribué autrement. **Tout périphérique** en a besoin ! Pour le matos de base (carte graphique, ...) c'est le BIOS qui prend la main.
|
||||||
|
|
||||||
|
Les pilotes évitent que l'OS ait à reconnaitre tous les matos, et évite ainsi beaucoup de mises à jour... Ils sont codés par les constructeurs.
|
||||||
|
|
||||||
|
Plug & play : contiennent un BIOS qui communique les infos à l'OS.
|
||||||
|
|
||||||
|
Chaque protocole a des pilotes (IP, TCP...)
|
||||||
|
|
||||||
|
Types :
|
||||||
|
|
||||||
|
- Drivers de masse
|
||||||
|
- Texte (GPS)
|
||||||
|
- Spécifiques (vidéo)
|
||||||
|
- USB (mix plug and play)
|
||||||
|
|
||||||
|
## Modules, utilité, fonctionnalités
|
||||||
|
|
||||||
|
Modules = morceau de code qui ajoutent fonctionnalité au noyau. On y retrouve différentes fonctions.
|
||||||
|
|
||||||
|
On parle uniquement des non plug and play.
|
||||||
|
|
||||||
|
Le noyau linux applle différents modules :
|
||||||
|
|
||||||
|
- modules de base : protocoles réseau, système de fichier
|
||||||
|
- modules périphériques : carte mère, vidéo, son réseau
|
||||||
|
- modules supplémentaires : carte vidéo (non-libre), cartes peu utilisées.
|
||||||
|
|
||||||
|
On peut spécifier les modules à charger au lancement du noyau. La liste des fichiers à charger est dans /etc/module . On peut aussi l'empêcher d'en charger : /etc/mprob/blacklist.conf
|
||||||
|
|
||||||
|
Il y a une structure file_operation qui permet de s'y retrouver dans l'orga communautaire de Linux
|
||||||
|
|
||||||
|
Les fichiers .ko sont des Kernel Objects chargeables parle noyau. plusieurs commandes permettent d'agir sur les modules chargés par le noyau.
|
||||||
|
|
||||||
|
### Noël
|
||||||
|
|
||||||
|
Le lien entre le fichier de code et le matériel se fait par un BUS qui va donner une adresse physique de périphérique. IRQ (Interrupt ReQuest), DMA (Direct Memory Access, zone de mémoire attribuée à un périphérique). Le kernel interagit avec le matériel via ces éléments là.
|
||||||
|
|
||||||
|
## Protocoles de communication
|
||||||
|
|
||||||
|
SPI : Sans Protocole d'Interface
|
||||||
|
|
||||||
|
Le noyau contient un genre
|
||||||
|
|
||||||
|
### MIDI
|
||||||
|
|
||||||
|
Format de fichier lié à la mudsique et utilisé comme potocole pour les instruments
|
||||||
|
|
||||||
|
### OSC
|
||||||
|
|
||||||
|
Contrôle en temps réel, successeur du MIDI. Open Sound Control
|
||||||
|
|
||||||
|
### RS-232
|
||||||
|
|
||||||
|
Norme ultra standard : le port série. N'est plus trop d'actualité, enfin si, enfin ça dépend des matos.
|
||||||
|
|
||||||
|
### DMX
|
||||||
|
|
||||||
|
Protocole pour le raccordement des lumières. Avant 86 c'était de l'analogique.
|
||||||
|
|
||||||
|
### SPI
|
||||||
|
|
||||||
|
Différents protocoles de communication selon le SPI. Master/slave, ou via l'horloge, peut être généré par le maître ou l'esclave. Le kernel dit au matos/logiciel où trouver l'info, ou dit à un truc de donner l'info au matos/logiciel
|
||||||
|
|
||||||
|
## Drivers Windows, signatures et certificats
|
||||||
|
|
||||||
|
C'est maintenant obligatoire sous Windows depuis Vista.
|
||||||
|
|
||||||
|
La signature vérifie si tout est approuvé, le logiciel, l'éditeur, et si y a 0 modifs depuis la certification.Pour obtenir un certif, on se rapproche d'une autorité de certif. Les certifs et centre approuvés sont regroupé dans une bibliothèque gérée par Windows.
|
||||||
|
|
||||||
|
# Compilateur
|
||||||
|
|
||||||
|
## Présentation
|
||||||
|
|
||||||
|
Le compilateur traduit du texte >> il le convertit.
|
||||||
|
|
||||||
|
Types ?
|
||||||
|
|
||||||
|
- Interpréteurs
|
||||||
|
- Formateurs de texte
|
||||||
|
- Préprocesseurs
|
||||||
|
|
||||||
|
Fonctionnement :
|
||||||
|
|
||||||
|
1. Analyse lexicale : scan du texte qui est regroupé pour former des mots, des blocs, et garde ce qui l'intéresse
|
||||||
|
2. Syntaxe (backend) : regarde comment sont formés les mots pour en déduire la "grammaire", la structure du texte. Création d'un arbre syntaxique, ou arbre de dépendance.
|
||||||
|
3. Analyse sémantique : vérifie que la syntaxe est OK puis checke le sens. Regarde le contexte, voit la globalité : est-ce **logique** ?
|
||||||
|
|
||||||
|
L'optimisation passe
|
||||||
|
|
||||||
|
- Par la vitesse d'exécution
|
||||||
|
- Par la taille du code (minify)
|
||||||
|
|
||||||
|
Le code est généré d'abord dans un langage intermédiaire, puis en code binaire pour la machine. À chaque fois il est généré puis optimisé.
|
||||||
|
|
||||||
|
## Analyse lexicale
|
||||||
|
|
||||||
|
C'est la première partie de la compilation, le point d'entrée, juste après le source code.
|
||||||
|
|
||||||
|
Un analyseur lexical est un automate fini
|
||||||
|
|
||||||
|
### Les REGEX
|
||||||
|
|
||||||
|
...explique ce que c'est.
|
||||||
|
|
||||||
|
### Les automates
|
||||||
|
|
||||||
|
DFA automate fini déterministe
|
||||||
|
|
||||||
|
NFA fini non déterministe
|
||||||
|
|
||||||
|
## Compilateur : Analyse syntaxique
|
||||||
|
|
||||||
|
Après l'analyse lexicale
|
||||||
|
|
||||||
|
Construit un arbre des relations grammaticales entre les mots.
|
||||||
|
|
||||||
|
Il définit ce qu'est un sujet, un verbe.. donc un objets, une classe... ?
|
||||||
|
|
||||||
|
### Rôle
|
||||||
|
|
||||||
|
prépare la traduction : si des mots sont pas compwris, communication possible via la table des symboles.
|
||||||
|
|
||||||
|
### Grammaires
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -380,3 +380,197 @@ On spécifie donc input_dim (talile) et activation qui est une fonction.I fauten
|
||||||
Keras est simple, si c'est pas suffisant on bascule sur Tensorflow, qui est plus compliqué. Pour l'instant, Keras est le mieux pour nous.
|
Keras est simple, si c'est pas suffisant on bascule sur Tensorflow, qui est plus compliqué. Pour l'instant, Keras est le mieux pour nous.
|
||||||
|
|
||||||
Pooling c'est juste un truc pour réduire lma taille.C'est pour ça qu'on utilise les convolutional
|
Pooling c'est juste un truc pour réduire lma taille.C'est pour ça qu'on utilise les convolutional
|
||||||
|
|
||||||
|
# ML pipeline
|
||||||
|
|
||||||
|
on a vu que SKlearn est bien pour les petits modèles (techniques) :
|
||||||
|
|
||||||
|
- linear
|
||||||
|
- tree
|
||||||
|
- ...
|
||||||
|
|
||||||
|
Le deep learning et les réseaux de neurones sont plus orientés pour la recherche en ML
|
||||||
|
|
||||||
|
On va voir aujourd'hui le gradient boosting : avec LightGBM and XGB (they are similar)
|
||||||
|
La clé est de créer de nouvelles et utiles features.
|
||||||
|
|
||||||
|
Sklearn : basic, simple, weak, "work not well"
|
||||||
|
|
||||||
|
deep learning : best for images, sounds, videos (maybe for text) => tuning parameters and architecture
|
||||||
|
|
||||||
|
Gradient boosting : utilisé en finance et autres domaines de la vie réelle. La data est tabulaire (nombre, categorical, ...). Le deep learning ne fonctionne pas bien sur ce type de données. Le tree-based gradient boosting est le meilleur pour ce type de données MAIS, le tree-based a besoin de bonne features.
|
||||||
|
DONC le feature engineering est la chose la plus importante
|
||||||
|
|
||||||
|
Un exmple très simple de feature engineering qu'on peut trouver dnas le TP :
|
||||||
|
|
||||||
|
- combiner plusieurs features pour en obtenir une nouvelle.
|
||||||
|
- modifier les features
|
||||||
|
|
||||||
|
Dans titnaic, on va jouer avec le nombre de siblings et le nombre de parents enfants pour obtenir une taille de famille et obtenir une feature "alone/not alone".
|
||||||
|
Aussi, on va modifier le nom pour mettre le titre (la civilité de la personne)
|
||||||
|
|
||||||
|
Passer une data qualitative en quantitative. Par exemple : nom d'une ville.
|
||||||
|
|
||||||
|
- On peut passer par exemple en one-hot (OO, O1, 1...) mais c'est pas élégant et y a trop de features : si y a K catégories il faudra K nouvelles features
|
||||||
|
- Ou bien en fréquence d’apparition : on met le nombre de fois que la ville apparaît dans la liste (paris 5, lyon 4, grenoble 4, marseille 2...)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
## Pourquoi le feature engineering ?
|
||||||
|
|
||||||
|
Avant de considérer cette question, on se penche sur le tree-based learning. C'est l'arbre décisionnel, tel qu'on l'a vu avec GN.
|
||||||
|
|
||||||
|
L'arbre de décision marche assez bien avec les données qualitatives. On a pas besoin de mettre les features à l'échelle.
|
||||||
|
|
||||||
|
Le tree-based gradient boosting n'a pas grand chose de plus à savoir : on construit un arbre et encore et encore, et on améliore le modèle en les combinant. C'est le bagging (empaquetage) : on construit plusieurs arbres **indépendants** puis on calcule la moyenne / la majority voting.
|
||||||
|
En soi, le bagging est proche du random forest la différence est que :
|
||||||
|
|
||||||
|
- random forest construit les arbres sur un sous-ensmble du total des features (et un sous-ensemble des data points)
|
||||||
|
- bagging construit les arbres sur la totalité des features (et tous les data points ?)
|
||||||
|
|
||||||
|
Boosting est proche du bagging aussi. cla fonctionn ainsi :
|
||||||
|
|
||||||
|
- On construit un arbre 1
|
||||||
|
- Puis un arbre 2 basé sur les erreurs de l'arbre 1
|
||||||
|
- Puis un 3 sur les erreurs du 2
|
||||||
|
- Etc
|
||||||
|
- on obtient une moyenne pondérée (weighted average)
|
||||||
|
|
||||||
|
Pour la moyenne, boosting est mieux que bagging. MAIS boosting peut être overfitté
|
||||||
|
|
||||||
|
Booting et bagging peuvent être utilisés pour n'importe quelle technique (pas forcément un arbre). Par exemple linear, logistic regression...
|
||||||
|
|
||||||
|
L'état de l'art du tree-based gradient boosting
|
||||||
|
|
||||||
|
- Libriaries : LightGBM (2016), XGB (2015)
|
||||||
|
- LightGBM est plus rapide et de façon globale, meilleure.
|
||||||
|
- Les deux sont dispo sur Anacondada
|
||||||
|
- Docs LightGBM : lightgbm.readthedoc.io // XGB xgboos.readthedoc.io
|
||||||
|
- Usages
|
||||||
|
- Simple:
|
||||||
|
- no architecture
|
||||||
|
- just tuning parameters
|
||||||
|
- 3e choix possible : Catboost.
|
||||||
|
|
||||||
|
## Final step
|
||||||
|
|
||||||
|
Étape finale :
|
||||||
|
|
||||||
|
- blending
|
||||||
|
- stacking
|
||||||
|
|
||||||
|
On entraine sur plein de moèdles différents, et on obtient plein de prédictions différentes ( $\hat y_1, \hat y_2, ...,\hat y_t$)
|
||||||
|
|
||||||
|
### Blending
|
||||||
|
|
||||||
|
C'est la prédiction finale, obtenue en faisant une moyenne pondérée :
|
||||||
|
|
||||||
|
$\hat y_{final} = weigthed\ average(\hat y_1, \hat y_2, ...,\hat y_t)$
|
||||||
|
|
||||||
|
Techniques des branlots et autres flemmards
|
||||||
|
|
||||||
|
### Stacking
|
||||||
|
|
||||||
|
On utilise toutes les prédictions y comme $t$ features pour entraîner un modèle final et **simple**, pour retourner une prédiction finale
|
||||||
|
|
||||||
|
$\hat y_{final} = model(\hat y_1, \hat y_2, ...,\hat y_t)$
|
||||||
|
|
||||||
|
Technique la plus utilisée. Les gens utilisent toujours le stacking.
|
||||||
|
|
||||||
|
# NLP and time series
|
||||||
|
|
||||||
|
NLP : Natural Language Processing
|
||||||
|
|
||||||
|
RNN : recurrent neural network
|
||||||
|
|
||||||
|
LSTM : Long Short Term Memory
|
||||||
|
|
||||||
|
GRU : Grate Recurrent Unit
|
||||||
|
|
||||||
|
## Pourquoi RNN
|
||||||
|
|
||||||
|
Un phrase = une séquence de données. Un élément dépend de l'élément prcédent. Un texte est donc une phrase mais un time series aussi.
|
||||||
|
|
||||||
|
- **Fully connected NN** : ne prend pas en compte la dépendance : c'st nul
|
||||||
|
|
||||||
|
- **Convolutionnal NN** : capture d'une structure locale (fenêtre de convolution parmi l'ensemble)). ainsi, pour un texte, la fenêtre sera une partie de ce texte. Mais c'est insuffisant !
|
||||||
|
|
||||||
|
- Ça suppose que toutes les relations locales sont les même tout le long du texte
|
||||||
|
- Ne capture jamais rien de plus grand que la taille de la fenêtre
|
||||||
|
|
||||||
|
DONC pas top
|
||||||
|
|
||||||
|
- **Recurrent NN** : est donc encore mieux
|
||||||
|
|
||||||
|
## Types de problèmes
|
||||||
|
|
||||||
|
### Many to one
|
||||||
|
|
||||||
|
classification à partir d'une phrase
|
||||||
|
|
||||||
|
ex : phrase qui donne une review Il faut en deviner la note sur 5.
|
||||||
|
|
||||||
|
On met plein de node en input, on fait passer dans le NN et on en ressort une note.
|
||||||
|
|
||||||
|
### one to many
|
||||||
|
|
||||||
|
génération de texte, génération de musique
|
||||||
|
|
||||||
|
en entrée on a un node aléatoire, ça passe dans le NN et il en ressort plein de nodes
|
||||||
|
|
||||||
|
### many to many
|
||||||
|
|
||||||
|
Language translation
|
||||||
|
|
||||||
|
Là on aura plein de nodes en entrée (ex: en anglais), passage dans le NN et plein de nodes en sortie (mais en français)
|
||||||
|
|
||||||
|
## ?
|
||||||
|
|
||||||
|
Y a donc une entré, le réseau, et une sortie
|
||||||
|
|
||||||
|
Prenons en exemple une phrase de 9 mots : The restaurant that I went to yesterday was good
|
||||||
|
|
||||||
|
En many to one , chaque mot va passer dans le NN, et sur le dernier il fait une normal classification with softmax et obtien la review. ssez proche du convolutional.
|
||||||
|
|
||||||
|
La différence entre RNN et CNN et FCN, c'est que l'état précédent du NN est l'input de l'état courant. Dans les autres, il y a seulement un calcul du gradient puis une update du NN, il ne prend pas le précédent comme input.
|
||||||
|
|
||||||
|
Ainsi, dans un many to many, il va prendre "the" et dire "ok c'est "le", pis passer à "restaurant" avec"le" en entrée, etc...
|
||||||
|
|
||||||
|
## Keras
|
||||||
|
|
||||||
|
Layer : RNN (...)
|
||||||
|
|
||||||
|
like conv2D(, Dens()
|
||||||
|
|
||||||
|
## LSTM and GRU
|
||||||
|
|
||||||
|
Le problème du RNN c'est que, dans notre exemple, quand la phrase atteint une certaine longueur, il commence à oublier les parties précédentes.
|
||||||
|
|
||||||
|
ça amène aux concepts de gradient vanishing et gradient exploding (mais je sais pas pourquoi)
|
||||||
|
|
||||||
|
Pour voir les mots importants, il compte la fréquence d'apparition, dans le texte mais surtout en général ! Apparaître plus souvent dans un texte n'est pas forcément un signe d'impotance (ex: "the")
|
||||||
|
|
||||||
|
LSTM et GRU sont assez similaires, LSTM a tendance a etre légèrement mieux de manière général. Les deux ont une ligne de mémoire (the gate) qui persiste au cours du texte pour garder en mémoire ce qui est important. Le gate est donc présent dans chaque NN à travers duquel on fout un input.
|
||||||
|
|
||||||
|
### Différences
|
||||||
|
|
||||||
|
Pas hyper importantr mais toujours ça à savoir :
|
||||||
|
|
||||||
|
- LSTM : 3 gates par node
|
||||||
|
- GRU 2 gate par node
|
||||||
|
|
||||||
|
### Comment les utiliser ?
|
||||||
|
|
||||||
|
Avec Keras, LSTM() et GRU(). Il est bon d'essayer les deux mais en général les gens préfèrent LSTM
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Il y a beaucoup d'informations à garder ! Par exemple en génération de texte, la grammaire : si "restaurant" est au singulier il faudrait mettre "bon" au singulier, mais l'accorder si "restaurant" est au pluriel
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
# Bibliography
|
||||||
|
|
||||||
|
Pour en savoir plus sur comment faire du feature engineering : *Feature engineering* by Alice Zheng, O'Reilly 2018
|
||||||
BIN
Performance des Architectures SI/Ressources/tp7.zip
Normal file
BIN
Performance des Architectures SI/Ressources/tp7.zip
Normal file
Binary file not shown.
BIN
Performance des Architectures SI/Ressources/tp8.zip
Normal file
BIN
Performance des Architectures SI/Ressources/tp8.zip
Normal file
Binary file not shown.
114
Techniques avancées de programmation/Cours TienNam.md
Normal file
114
Techniques avancées de programmation/Cours TienNam.md
Normal file
|
|
@ -0,0 +1,114 @@
|
||||||
|
# Plan
|
||||||
|
|
||||||
|
1. Data mining (web mining)
|
||||||
|
2. GAN
|
||||||
|
3. Auto encoder
|
||||||
|
4. Recommender systems
|
||||||
|
|
||||||
|
Ces 3 derniers points sont de l'apprentissage non supervisé : il n'y a pas de catégories définies.
|
||||||
|
|
||||||
|
# 1. Data mining - web mining
|
||||||
|
|
||||||
|
Le web mining intervient quand on a pas les donnés, pour un projet perso par exemple.
|
||||||
|
On y retrouve trois principaux outils :
|
||||||
|
|
||||||
|
## 1. Beautiful soup 4
|
||||||
|
|
||||||
|
La librairie python "Beautiful soup 4" // outils en découlant : Scrapy; Selenium.
|
||||||
|
|
||||||
|
Travaille avec le code source de base de la page (HTML). Extrait la plupart des informations (tables, images...)
|
||||||
|
Se trouve sur Internet; Utilise Python : tout est automatisé.
|
||||||
|
Tourne plusieurs jours pour extraire toutes les données
|
||||||
|
Enregistre les données : genre dans un CSV. Doit les enregistrer régulièrement
|
||||||
|
Exploitable avec pandas...
|
||||||
|
|
||||||
|
Peut par exemple s'exploiter avec un vieil ordi, qu'on fait tourner chaque jour pour recueillir chaque jour des données.
|
||||||
|
|
||||||
|
S'utilise dans un jupiter notebook par exemple
|
||||||
|
|
||||||
|
## 3. Scrapy
|
||||||
|
|
||||||
|
Dans un terminal
|
||||||
|
|
||||||
|
Même fonction que BS4, mais tourne plus vite car mis en parallèle. Par contre écrire en scrapy est plus compliqué.
|
||||||
|
|
||||||
|
## 2. Selenium
|
||||||
|
|
||||||
|
Peut faire des trucs que BS4 et Scrapy ne peuvent pas faire :
|
||||||
|
Le code source qu'on a habituellement côté client n'est pas le code source complet. Si on enregistre le fichier HTML depuis la page web, là on a le code source complet.
|
||||||
|
|
||||||
|
Selenium a la capacité d'interagir :
|
||||||
|
Ouvrir une page web depuis un vrai navigateur, scroller, entrer username et pswd, cliquer sur des boutons...
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Il y a une "éthique" du web mining :
|
||||||
|
|
||||||
|
1. Ne pas surcharger le serveur : pas plus d'un accès / seconde
|
||||||
|
2. Respecter la demande de certains sites de ne pas utiliser à but commercial (genre whois.net)
|
||||||
|
3. Certains site interdisent carrément le téléchargement d'informations de façon automatisée (genre unsplash)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
# Systèmes de recommandation
|
||||||
|
|
||||||
|
Genre Amazon, Netflix...
|
||||||
|
|
||||||
|
On part d'une liste de *m* films et *n* utilisateurs
|
||||||
|
|
||||||
|
Les données peuvent se présenter sous forme de liste (en colonne : user, film, note) ou bien de matrice (colonnes = m; lignes : n ; en entrées les notes.)
|
||||||
|
|
||||||
|
L'objectif à partir de ces données est de trouver 10 films à recommander pour chaque utilisateur, qu'il serait susceptible d'apprécier le plus.
|
||||||
|
|
||||||
|
## Technique classique
|
||||||
|
|
||||||
|
Multiplication de la matrice. en gros à partir de la data, on multiplie n par k et m par k et on obtient une prédiction. Rien compris.
|
||||||
|
|
||||||
|
TD : plusieurs exemples et techniques issues de Microsoft :
|
||||||
|
|
||||||
|
- Fast-AI notebook
|
||||||
|
- Wide-deep notebook
|
||||||
|
|
||||||
|
# GAN
|
||||||
|
|
||||||
|
C'est du "future faking everything". Ce qu'ils savent faire de mieux : de faux visage humains ! Impossible de distinguer un vrai humain d'un généré par GAN.
|
||||||
|
On s'attaque à la vidéo dans le jupyter notebook ?
|
||||||
|
|
||||||
|
Pour commencer à apprendre le "fake"
|
||||||
|
|
||||||
|
- news articles
|
||||||
|
- research articles
|
||||||
|
|
||||||
|
Petit schéma dur à refaire, mais globalement : un bruit aléatoire entre dans un générateur, ce qui génère de la fake data. Celle ci est comparée avec de la true data par un discriminateur (réseau de neurones), qui détermine la précision du réel vs fake.
|
||||||
|
|
||||||
|
En gros, c'est une compétition entre le générateur, qui essaye de produire la meilleure donnée pour tromper le discriminateur : le fraudeur ; et le discriminateur qui essaye de distinguer le vrai du faux : la police.
|
||||||
|
|
||||||
|
# Auto encoder
|
||||||
|
|
||||||
|
Encore un schéma. La data entre dans un compresseur, qui en fait une data bien plus petite, qui ensuite passe dans un décompresseur, qui ressort exactement la même donnée. Tout ceci constitue un réseau de neurones.
|
||||||
|
|
||||||
|
Ses utilisations sont pour compresser des données et enlever le bruit de données.
|
||||||
|
|
||||||
|
# TP9
|
||||||
|
|
||||||
|
# Reinforcement learning
|
||||||
|
|
||||||
|
On a donc apprentissage non supervisé, supervisé et par renforcement.
|
||||||
|
|
||||||
|
On y trouve deux acteurs : un agent, et l'environnement. L'agent effectue une action sur l'environnement, qui renvoie une récompense, ainsi qu'un feedback (une maj de l'état de l'environnement).
|
||||||
|
|
||||||
|
Ses applications sont par exemple : entraîner une IA à jouer à Dota2 ; robot qui ramasse les merdes das la maison ; construire un "stock portfolio" (portefeuille d'actions)
|
||||||
|
|
||||||
|
Ses différences :
|
||||||
|
|
||||||
|
- Pas de catégorisation de la data
|
||||||
|
- La récompense peut être repoussée : si on a besoin d'attendre de savoir si une décision était bonne ou mauvaise
|
||||||
|
- Le feedback est séquentiel : il faut attendre pour avoir plus de data : plus de puissance de calcul, un meilleur CPU n'aideront pas.
|
||||||
|
- L'action peut influencer sur l'environnement de façon presque certaine. Il n'y a pas de distribution statique comme en supervisé/ non supervisé.
|
||||||
|
|
||||||
|
Se jour principalement, pour le modèle, à trouver le meilleur compromis entre epxloration t exploitation.
|
||||||
|
exploration : Trouver une nouvelle action jamais essayée avant, sans connaitre le feedback/la reward.
|
||||||
|
exploitation : répéter un bon mouvement déjà appris auparavant. Feedback et reward connues.
|
||||||
|
|
||||||
|
# TP 10
|
||||||
|
|
||||||
73
Techniques avancées de programmation/Régressions.md
Normal file
73
Techniques avancées de programmation/Régressions.md
Normal file
|
|
@ -0,0 +1,73 @@
|
||||||
|
# Régressions
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
R² est un coefficient qui est le coefficient de la variable de corrélation. Il permet de maîtrise et de mesure la part de contribution du paramètre sur les variables. Regression linéaire (en bleu sur slide 1) indique qu'il joue pour 54% de la variable du prix. En gros le prix de la maison dépend à 54% du lower status of the population.
|
||||||
|
|
||||||
|
Pour la courbe rouge, regression quadratique (au carré), on monte à 64%, et on peut même monter au cube, à 66%.
|
||||||
|
|
||||||
|
Toute la question est l'overfitting. Et attention, un modèle n'est pas pour expliquer, mais pour modéliser ! Dans notre cas, si on regarde, la verte va passer en dessous de 0, la rouge remonte... ça n'a pas de sens !
|
||||||
|
|
||||||
|
## Choix de la régression
|
||||||
|
|
||||||
|
Schéma qui aide à choisir:
|
||||||
|
|
||||||
|
- Combien de variables de réponse ?
|
||||||
|
- Quel type de réponse (continu, qualitatif, évènements rares...)
|
||||||
|
- Combien de variables de prédiction ?
|
||||||
|
- Quels type de prédicteurs ?
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
## Principe de la régression linéaire
|
||||||
|
|
||||||
|
En anglais pour l vocabulaire. slope : pente.
|
||||||
|
|
||||||
|
La droite de la régression est représentée par ax + b. On pose la droite et on mesure l'écart en le point et la droite pour déterminer un coefficient de corrélation. On fait donc un calcul du "résidu" et elle doit normalement s'aligner sur 0 (correspond au graphique en bas de page) : plus les valeurs s'étalent pas contre, plus on s'écarte d'une prédiction juste. On détermine le R² à partir de ça.
|
||||||
|
|
||||||
|
Dans le tableau des "Sales" : observation des ventes en fonction des publicités. À chaque fois qu'on augmente de 1 les ventes, on augmente de 23,42 la pub. On voit que l R² est très important : R² à 0,97 !
|
||||||
|
|
||||||
|
## Régression polynomiale
|
||||||
|
|
||||||
|
On part de ax + b toujours, et on y ajoute le carré, un cube... jusqu'à un **degré** souhaité.
|
||||||
|
|
||||||
|
Attention, sujet à overfitting et underfitting
|
||||||
|
|
||||||
|
MSE est difficilement interprétable, il est préférable d'avoir un R. Toute la logique est de trouver le bon degré : clui qui présente le meilleur modèle.
|
||||||
|
|
||||||
|
## Régression multiple
|
||||||
|
|
||||||
|
À ne pas confondre avec la polynomiale : la première on élève le même x à un degré, là on va prendre différents x (plusieurs variables).
|
||||||
|
|
||||||
|
Comme on a plusieurs points (z = ax +by), on se retrouve dans un espace. alors 3 dimensions ça va, mais au dela c'est plus représentable.
|
||||||
|
|
||||||
|
$\beta$ = slope.
|
||||||
|
|
||||||
|
Si on regarde la table 3, on put retenir à partir des p les variables à retenir (donc on en retient 4)
|
||||||
|
|
||||||
|
Il est difficile de quantifier des variables qualitatives.
|
||||||
|
|
||||||
|
## Régression logistique
|
||||||
|
|
||||||
|
On a des variables, que l'on va pondérer, pis ça entre dans une "boite noire", t la machine ressort un booléen derrière. La machine vérifie si c'est 0 ou 1, si c'est pas bien elle modifie les poids et donc la pondération et recommence.
|
||||||
|
|
||||||
|
Ça rejoint donc le réseau de neurones. on a un exemple de comment
|
||||||
|
|
||||||
|
tableau indiquant le risque d'avoir une crise cardiaque en fonction de plein de paramètres. La pente indique la direction de l'influence : pour l'activité physique elle est négative, donc ça **réduit** les risque ! L'odd ratio c'est l'influence de la pente : en quoi ça augmente fortement ou non.
|
||||||
|
|
||||||
|
## Et python
|
||||||
|
|
||||||
|
Graph avec plein de façons de faire de la régression
|
||||||
|
|
||||||
|
curve_fit est intéressant si on veut pas faire du linear, on peut y mettre une fonction. Mais est peu pertinent.
|
||||||
|
|
||||||
|
Tableau OLS :
|
||||||
|
method least square = moindre carré
|
||||||
|
df model = nombre de variables
|
||||||
|
r square est indiquée
|
||||||
|
prob = proba du t
|
||||||
|
const = le $a$ du $ax+b$
|
||||||
|
|
||||||
|
# RStudio
|
||||||
|
|
||||||
|
Jambon : aucun facteur de corrélation ne semble se démarquer, mais tous ensemble ils représentent presque 70%. On pourrait faire un indice de corrélation pour voir lesquels garder (si on les garde tous c'est overfitté), mais on va plutôt récupérer une librairie pour ça : FactoMineR
|
||||||
|
|
@ -122,4 +122,4 @@ Il y a 5 étapes :
|
||||||
|
|
||||||
En gros, la p-value indique la chance que le résultat soit dû au hasard.
|
En gros, la p-value indique la chance que le résultat soit dû au hasard.
|
||||||
|
|
||||||
En testat une distribution normale, peu importe si la p-value est immense ou non tant qu'elle est supérieure à 0.05 : c'est binaire, ça n'indiqu pas une meileure distribution normale.
|
En testant une distribution normale, peu importe si la p-value est immense ou non tant qu'elle est supérieure à 0.05 : c'est binaire, ça n'indique pas une meilleure distribution normale.
|
||||||
Loading…
Reference in a new issue