securite rm tp2

bus/02_multiplexage.md

@@ -176,3 +176,66 @@ Selon le protocol, il est également possible d'avoir des bits de 'stuffing' alt
 
 > Note :
 > Le 'stuffing' peut servir de synchronisation d'horloge car il assure une alternance dans le signal.
+
+## transmission des messages
+
+Il est possible d'interfacer entre plusieurs bus grâce à un controlleur.
+- exemple : VAN 1 -> CAN -> VAN 2
+
+Les IDs doivent être traduits d'une manière cohérente aux deux protocoles interfaçés.
+
+## Réseaux terrain
+
+Les réseaux terrain permettent l'interconnexion entre plusieurs entités d'un même système.
+
+Cette communication se déroule sur une zone limitée set sur laquelle on désire une réduction maximale de la longueur des liaisons entre les différents éléments grace à un médium commun den transmission.
+
+Cette réduciton est liée à une volonté de sécurité (sur des automates d'usine par exemple).
+
+---
+
+L'utilisateur ne se soucie pas du chemin suivi par les informations, de la conversion des formats type de l'interlocuteur ou bien du type de constructeur d'un élément.
+Les tecnhiques de réseaux facilitent grandement l'insertion ou la suppression d'élements au sein d'un même système.
+
+Un bus de terrein permet de transférer das la plupart des cas les informations de maniere séquentielle, ou bien par paquet de bits.
+Il faut savoir que le bus de terrain permet un échange de données qui serait difficile (voire impossibl) par un autre moyen.
+
+Derrière ce concept technologique se cachent de réels protocoles de communications qui n'ont fait qu'évoluer depuis 15 ans.
+
+Basés sur l'optimisation de place et de temps, on a vu apparaitre des controles-commandes de plus en plus perfectionnés.
+Ces technologies ne cessent d'etre améliorées et sont de plus en plus utilisés pour des raisons de cout, de confort et de flexibilité.
+
+### Le système OSI
+
+Le multiplexage se fait selon les principes des couches du modèle OSI.
+
+1. la couche physique
+2. la couche de liaison
+
+Les autres couches ne sont pas présentes dans une communication BUS.
+
+### Temps réel
+
+Un système est dit 'temps réel' lorsqu'il a besoin de s'exécuter en un temps maximal pour assurer sa fiabilité / intégrité.
+
+Ce qui ressort est la notion de synchronisation entre le traitement de l'information et la génération issue du monde extérieur.
+En effet, ce qui prete souvent à confusion est le temps de réponse de la macjine par rapport au temps effectif qui s'écoule par l'environnement.
+Naturellement, on pense à des ordres de grandeurs infinitésimale, de l'ordre du millième de secondes.
+
+Deux types de systèmes :
+
+- Transactionnel, ou 'temps réel mou'
+	- le système tolère des dépassements et les traitera comme des exception potentiellement récupérables. Cela ne déstabilisera par nécessairement le système.
+
+- Commande, ou 'temps réel dur'
+	- Les invariances du système dépendent du respect de la temporalité du programme, et un dépassement sera perçu comme une erreur fatale.
+	- Nous cherchons à concevoir des systèmes déterministes et prévisible.
+
+Différentes urgences vont devoir être gérées et priorisés (maintient de la synchronicité du BUS, attentes I/O, gestion d'erreurs)
+
+Synchronisation des orloges :
+
+- Différents calculateurs ne produirons pas les données à un débit égal. Mais la vitesse d'une transmission entre deux controleurs doit être unifiée / synchronisée.
+- La vitesse de transfert dépends donc de la distance, mais aussi de la fréquence des horloges des partis.
+- La synchronisation se fait au début du flux, mais elle doit également se faire en cas de resynchronisation en plein transfert de message.
+

bus/init.md

@@ -1,98 +0,0 @@
-# Multiplexage
-
-## Pourquoi ?
-
-Machines à plusieurs objectifs.
-
-- sécurisation
-- réduction de consomation
-- confort de conduite
-
-Grand nombre de périphériques à connecter.
-
-### Conventionnalité : une connection par liaison nécessaire :
-
-```
-+---+   +---+
-| A |---| B |
-|   |-+ |   |
-+---+ | +---+
-      |   |
-      | +---+
-      +-| C |
-        +---+
-```
-
-- Nombre de connections exponentelle.
-- Difficile à mettre à jour.
-
-### Multiplexage : une connection commune en 'réseau'.
-
-```
-+---+   +---+
-| A |-+-| B |
-+---+ | +---+
-      |
-      | +---+
-      +-| C |
-        +---+
-```
-
-- Nombre de connections linéaire.
-- Disponibilité de l'information.
-
-## Avantages
-
-- moins de capteurs et de nombres de liaisons
-- le poids et les couts diminuent
-- extensibilité avec un cout minimal
-- reconnu par une norme iso de fiabilité
-
-## Principes
-
-- un capteur par donnée nécessaire
-- échange de donnée sur un cannal global.
-
-### Détail
-
-- Un réseau unifié
-	- Structuration des trames
-	- Synchronisation des horloges
-	- Arbitrage, priorisation de l'accès au Bus
-
-## Architecture en couches
-
-### étage d'entrée
-
-Interface avec les capteurs
-
-### étage de calcul
-
-Le microprocesseur
-
-- contient possiblement des mémoires
-
-### étage de sortie
-
-Interface avec les actionneurs
-
-## Architecture réseau
-
-- maitre esclave
-- multi-maitre
-- mixte
-
-## Protocole
-
-- l'acheminement des trames
-- synchronisation d'horloges
-- deux trames peuvent être émise en même temps
-	- l'arbitrage détermine celle qui est transmise
-	- la seconde sera ré-émise ensuite pour ne pas perdre d'information
-
-### Méthode CSMA
-
-- chaque message a un ID, un ID faible donne une plus haute priorité
-- un temps est réservé pour la lecture des messages à envoyer
-	- un hashset des IDs supperposés est écrit sur le BUS,
-	- l'ID le plus faible enverra son message au temps suivant

gpu/tp2/.gitignore

@@ -0,0 +1,2 @@
+bin/
+*.zip

gpu/tp2/c/build.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+cd "$(dirname "$(realpath "$0")")"
+set -e
+
+TARGET="ex1.cu ex2.cu ex3.cu ex4.cu"
+
+if [ $# -gt 0 ]
+then TARGET=$1
+fi
+
+rm -fr bin
+mkdir -p bin
+
+for target in $TARGET
+do nvcc src/$target -o bin/${target%.cu}.out
+done
+
+for target in $TARGET
+do ./bin/${target%.cu}.out
+done

gpu/tp2/c/src/Matrix.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <vector>
+#include <iostream>
+
+#define CUDA_CHECK(code) { cuda_check((code), __FILE__, __LINE__); }
+inline void cuda_check(cudaError_t code, const char *file, int line) {
+    if(code != cudaSuccess) {
+        std::cout << file << ':' << line << ": [CUDA ERROR] " << cudaGetErrorString(code) << std::endl; 
+        std::abort();
+    }
+}
+
+namespace linalg {
+
+//
+// Generic matrix of type T (int, float, double...)
+//
+template<typename T>
+class Matrix
+{
+public:
+    // construct matrix, allocate the 2D pitched memory on the device
+    __host__ Matrix(int rows, int cols);
+
+    // free allocated device memory
+    __host__ void free();
+
+public:
+    // copy values from host std::vector to device Matrix
+    // values must be a vector of size rows x cols
+    // allocation is already done in the constructor
+    __host__ void to_cuda(const std::vector<T>& values);
+
+    // copy values from device Matrix to host std::vector
+    // values may not ne resized
+    __host__ void to_cpu(std::vector<T>& values) const;
+
+public:
+    // accessor at row i and column j
+    __device__ const T& operator()(int i, int j) const;
+    __device__       T& operator()(int i, int j);
+
+public:
+    __host__ Matrix operator + (const Matrix<T>& other) const;
+    __host__ Matrix operator - (const Matrix<T>& other) const;
+    __host__ Matrix operator * (const Matrix<T>& other) const;
+    __host__ Matrix operator / (const Matrix<T>& other) const;
+
+private:
+    // apply binary functor f on all pairs of elements
+    // f must provide the following operator 
+    //
+    //     T operator()(T a, T b)
+    //
+    // template<typename BinaryFunctor>
+    // __host__ Matrix apply(const Matrix<T>& other, BinaryFunctor&& f) const;
+
+public:
+    __host__ __device__ inline int rows() const {return m_rows;}
+    __host__ __device__ inline int cols() const {return m_cols;}
+
+private:
+    T* m_data_ptr; // device pointer
+    int m_rows;
+    int m_cols;
+    size_t m_pitch;
+};
+
+} // namespace linalg
+
+#include "Matrix.hpp"

gpu/tp2/c/src/Matrix.hpp

@@ -0,0 +1,99 @@
+#include "Matrix.h"
+
+namespace linalg {
+
+namespace kernel {
+
+//
+// step 10
+// CUDA kernel add
+//
+
+
+
+//
+// step 12
+// CUDA kernel apply
+//
+
+
+
+
+} // namespace kernel
+
+
+template<typename T>
+__host__ Matrix<T>::Matrix(int rows, int cols) :
+    m_data_ptr(nullptr),
+    m_rows(rows),
+    m_cols(cols),
+    m_pitch(0)
+{
+    // step 07
+
+}
+
+template<typename T>
+__host__ void Matrix<T>::free()
+{
+    // step 07
+
+}
+
+template<typename T>
+__host__ void Matrix<T>::to_cuda(const std::vector<T>& values)
+{
+    // step 08
+
+}
+
+template<typename T>
+__host__ void Matrix<T>::to_cpu(std::vector<T>& values) const
+{
+    // step 08
+
+}
+
+template<typename T>
+__device__ const T& Matrix<T>::operator()(int i, int j) const
+{
+    // step 09
+
+}
+
+template<typename T>
+__device__ T& Matrix<T>::operator()(int i, int j)
+{
+    // step 09
+
+}
+
+template<typename T>
+__host__ Matrix<T> Matrix<T>::operator + (const Matrix<T>& other) const
+{
+    // step 11
+
+}
+
+template<typename T>
+__host__ Matrix<T> Matrix<T>::operator - (const Matrix<T>& other) const
+{
+    // step 12
+
+}
+
+template<typename T>
+__host__ Matrix<T> Matrix<T>::operator * (const Matrix<T>& other) const
+{
+    // step 12
+
+}
+
+template<typename T>
+__host__ Matrix<T> Matrix<T>::operator / (const Matrix<T>& other) const
+{
+    // step 12
+
+}
+
+} // namespace linalg

gpu/tp2/c/src/ex1.cu

@@ -0,0 +1,78 @@
+#include <iostream>
+
+//
+// example: CUDA_CHECK( cudaMalloc(dx, x, N*sizeof(int) );
+//
+#define CUDA_CHECK(code) { cuda_check((code), __FILE__, __LINE__); }
+inline void cuda_check(cudaError_t code, const char *file, int line) {
+    if(code != cudaSuccess) {
+        std::cout << file << ':' << line << ": [CUDA ERROR] " << cudaGetErrorString(code) << std::endl; 
+        std::abort();
+    }
+}
+
+
+//
+// step 01
+// return the linear index corresponding to the element at row i and column j
+// in a matrix of size rows x cols, using row-major storage
+//
+__device__ int linear_index(int i, int j, int rows, int cols) {
+    
+}
+
+//
+// step 02
+// CUDA kernel add 
+//
+
+
+int main()
+{
+    constexpr int rows = 200;
+    constexpr int cols = 80;
+    int* x = (int*)malloc(rows*cols*sizeof(int));
+    int* y = (int*)malloc(rows*cols*sizeof(int));
+    for(int i = 0; i < rows*cols; ++i) {
+        x[i] = i;
+        y[i] = std::pow(-1,i) * i;
+    }
+
+    //
+    // step 03
+    //
+    int* dx;
+    int* dy;
+    // 1. allocate on device
+
+    // 2. copy from host to device
+
+    // 3. launch CUDA kernel
+    // const dim3 threads_per_bloc{32,32,1};
+
+    // 4. copy result from device to host
+
+    // 5. free device memory
+
+
+
+    // checking results
+    bool ok = true;
+    for(int i = 0; i < rows*cols; ++i) {
+        const int expected_result = std::pow(-1,i) * i + i;
+        if(y[i] != expected_result) {
+            std::cout << "Failure" << std::endl;
+            std::cout << "Result at index i=" 
+                << i << ": expected " 
+                << std::pow(-1,i) * i << '+' << i << '=' << expected_result << ", got " << y[i] << std::endl;
+            ok = false;
+            break;
+        }
+    }
+    if(ok) std::cout << "Success" << std::endl;
+
+    free(x);
+    free(y);
+    
+    return 0;
+}

gpu/tp2/c/src/ex2.cu

@@ -0,0 +1,80 @@
+#include <iostream>
+
+//
+// example: CUDA_CHECK( cudaMalloc(dx, x, N*sizeof(int) );
+//
+#define CUDA_CHECK(code) { cuda_check((code), __FILE__, __LINE__); }
+inline void cuda_check(cudaError_t code, const char *file, int line) {
+    if(code != cudaSuccess) {
+        std::cout << file << ':' << line << ": [CUDA ERROR] " << cudaGetErrorString(code) << std::endl; 
+        std::abort();
+    }
+}
+
+//
+// step 04
+// return a pointer to the value at row i and column j from base_address 
+// with pitch in bytes
+//
+__device__ inline int* get_ptr(int* base_address, int i, int j, size_t pitch) {
+    
+}
+
+//
+// step 05
+// CUDA kernel add 
+//
+
+
+
+
+int main()
+{
+    constexpr int rows = 200;
+    constexpr int cols = 80;
+    int* x = (int*)malloc(rows*cols*sizeof(int));
+    int* y = (int*)malloc(rows*cols*sizeof(int));
+    for(int i = 0; i < rows*cols; ++i) {
+        x[i] = i;
+        y[i] = std::pow(-1,i) * i;
+    }
+
+    //
+    // step 06
+    //
+    int* dx;
+    int* dy;
+    size_t pitch;
+    // 1. allocate on device
+
+    // 2. copy from host to device
+
+    // 3. launch CUDA kernel
+    // const dim3 threads_per_bloc{32,32,1};
+
+    // 4. copy result from device to host
+
+    // 5. free device memory
+
+
+
+    // checking results
+    bool ok = true;
+    for(int i = 0; i < rows*cols; ++i) {
+        const int expected_result = std::pow(-1,i) * i + i;
+        if(y[i] != expected_result) {
+            std::cout << "Failure" << std::endl;
+            std::cout << "Result at index i=" 
+                << i << ": expected " 
+                << std::pow(-1,i) * i << '+' << i << '=' << expected_result << ", got " << y[i] << std::endl;
+            ok = false;
+            break;
+        }
+    }
+    if(ok) std::cout << "Success" << std::endl;
+
+    free(x);
+    free(y);
+    
+    return 0;
+}

gpu/tp2/c/src/ex3.cu

@@ -0,0 +1,148 @@
+#include "Matrix.h"
+
+int main()
+{
+    {
+        const int rows = 4;
+        const int cols = 4;
+        // instantiate two matrices of integers on the device
+        linalg::Matrix<int> A(rows, cols);
+        linalg::Matrix<int> B(rows, cols);
+        // fill the two matrices
+        A.to_cuda({ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16});
+        B.to_cuda({16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
+
+        // compute the sum
+        auto C = A + B;
+
+        // transfert the result on the host
+        std::vector<int> c_res;
+        C.to_cpu(c_res);
+        C.free();
+       
+        // check results
+        const std::vector<int> c_expected{17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17};
+        if(c_res != c_expected) {
+            std::cout << __FILE__ << ":" << __LINE__ << ": Failure (+):" << std::endl;
+            std::cout << "  expected: ";
+            for(int i : c_expected) std::cout << i << " ";
+            std::cout << std::endl;
+            std::cout << "  got:      ";
+            for(int i : c_res) std::cout << i << " ";
+            std::cout << std::endl;
+        } else {
+            std::cout << "Success" << std::endl;
+        }
+
+        // compute the difference
+        auto D = A - B;
+
+        // transfert the result on the host
+        std::vector<int> d_res;
+        D.to_cpu(d_res);
+        D.free();
+
+        // check results
+        const std::vector<int> d_expected{-15, -13, -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11, 13, 15};
+        if(d_res != d_expected) {
+            std::cout << __FILE__ << ":" << __LINE__ << ": Failure (-):" << std::endl;
+            std::cout << "  expected: ";
+            for(int i : d_expected) std::cout << i << " ";
+            std::cout << std::endl;
+            std::cout << "  got:      ";
+            for(int i : d_res) std::cout << i << " ";
+            std::cout << std::endl;
+        } else {
+            std::cout << "Success" << std::endl;
+        }
+    }
+    // ------------------------------------------------------------------------
+    {
+        const int rows = 89;
+        const int cols = 128;
+        linalg::Matrix<float> A(rows, cols);
+        linalg::Matrix<float> B(rows, cols);
+        std::vector<float> a_values(rows*cols);
+        std::vector<float> b_values(rows*cols);
+        for(int i = 0; i < rows*cols; ++i) {
+            a_values[i] = 1 + float(i) / 100;
+            b_values[i] = std::pow(-1, i) * float(i)/(rows*cols) * 100;
+        }
+        A.to_cuda(a_values);
+        B.to_cuda(b_values);
+
+        auto C = A + B;
+        auto D = A - B;
+        auto E = A * B;
+        auto F = A / B;
+
+        std::vector<float> c_values;
+        C.to_cpu(c_values);
+        std::vector<float> d_values;
+        D.to_cpu(d_values);
+        std::vector<float> e_values;
+        E.to_cpu(e_values);
+        std::vector<float> f_values;
+        F.to_cpu(f_values);
+
+        C.free();
+        D.free();
+        E.free();
+        F.free();
+
+        const float epsilon = 0.001;
+        bool ok = true;
+        for(int i = 0; i < rows*cols; ++i) {
+            const float diff = std::abs( c_values[i] - (a_values[i] + b_values[i]) );
+            if(diff > epsilon) {
+                std::cout << __FILE__ << ":" << __LINE__ << ": Failure (+):" << std::endl;
+                std::cout << "  expected: " << a_values[i] + b_values[i] << std::endl;
+                std::cout << "  got: "      << c_values[i] << std::endl;
+                ok = false;
+                break;
+            }
+        }
+        if(ok) std::cout << "Success" << std::endl;
+        
+        ok = true;
+        for(int i = 0; i < rows*cols; ++i) {
+            const float diff = std::abs( d_values[i] - (a_values[i] - b_values[i]) );
+            if(diff > epsilon) {
+                std::cout << __FILE__ << ":" << __LINE__ << ": Failure (-):" << std::endl;
+                std::cout << "  expected: " << a_values[i] - b_values[i] << std::endl;
+                std::cout << "  got: "      << d_values[i] << std::endl;
+                ok = false;
+                break;
+            }
+        }
+        if(ok) std::cout << "Success" << std::endl;
+
+        ok = true;
+        for(int i = 0; i < rows*cols; ++i) {
+            const float diff = std::abs( e_values[i] - (a_values[i] * b_values[i]) );
+            if(diff > epsilon) {
+                std::cout << __FILE__ << ":" << __LINE__ << ": Failure (*):" << std::endl;
+                std::cout << "  expected: " << a_values[i] * b_values[i] << std::endl;
+                std::cout << "  got: "      << e_values[i] << std::endl;
+                ok = false;
+                break;
+            }
+        }
+        if(ok) std::cout << "Success" << std::endl;
+
+        ok = true;
+        for(int i = 0; i < rows*cols; ++i) {
+            const float diff = std::abs( f_values[i] - (a_values[i] / b_values[i]) );
+            if(diff > epsilon) {
+                std::cout << __FILE__ << ":" << __LINE__ << ": Failure (/):" << std::endl;
+                std::cout << "  expected: " << a_values[i] / b_values[i] << std::endl;
+                std::cout << "  got: "      << f_values[i] << std::endl;
+                ok = false;
+                break;
+            }
+        }
+        if(ok) std::cout << "Success" << std::endl;
+    }
+
+    return 0;
+}

ia/tp2/.gitignore

@@ -0,0 +1,4 @@
+/__pycache__
+/.pytest_cache
+/env
+/*.zip

ia/tp2/main.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env -S python
+
+import pandas
+import numpy
+import seaborn
+import matplotlib.pyplot
+import sklearn.model_selection 
+import sklearn.linear_model
+import sklearn.ensemble
+import sklearn.metrics
+
+DATA_COLUMNS = [ "fixed acidity", "volatile acidity", "citric acid", "residual sugar", "chlorides", "free sulfur dioxide", "total sulfur dioxide", "density", "pH", "sulphates", "alcohol", "quality" ]
+HAHA_FUNI_NUMBER = 42
+
+def main():
+    wine_quality = q_01_01_load_data("./winequality-red.csv")
+
+    # q_01_02_print_raw_data(wine_quality)
+    #
+    # > __q_02_print_raw_data__
+    # >        fixed acidity  volatile acidity  citric acid  ...  sulphates  alcohol  quality
+    # > 0               7.4             0.700         0.00  ...       0.56      9.4        5
+    # > 1               7.8             0.880         0.00  ...       0.68      9.8        5
+    # > ...                                                 ...                                                                                                                     
+    #
+    # note :
+    # - Les colomnes "citric acid" (2) et "quality" (11) ont des valeur discrètes, donc des indices de cathégories.
+    # - Les autres colomnes sont numériques.
+
+    # q_01_03_plot_raw_data(wine_quality)
+    #
+    # note :
+    # Aucune correllation n'est évidente.
+
+
+    (quality_categories, parameters) = q_02_01_split_set(wine_quality)
+    # print("quality_categories", quality_categories.shape, "parameters", parameters.shape)
+    #
+    # > quality_categories (1599, 1) parameters (1599, 11)
+
+    (training_set, validation_set) = q_02_02_model_sets(parameters, quality_categories)
+    # print("training_set", training_set.shape, "validation_set", validation_set.shape)
+    #
+    # > training_set (1199, 11) validation_set (400, 11)
+
+    linear_model = q_02_03_train_linear_model(*training_set)
+    linear_accuracy = q_02_04_evaluate_error(linear_model, *validation_set)
+    # print("linear_accuracy", linear_accuracy)
+    #
+    # > linear_accuracy 0.38830173868689244
+
+    # q_02_05_print_one_prediction(linear_model, training_set[0])
+    # 
+    # > q_02_05_print_one_prediction 5.23381934012872
+    #
+    # note :
+    # Nous cherchons des valeurs discrètes pour procéder à une catégorisation, la nature de la prédiction est incorrecte.
+
+
+    forest_model = q_03_01_train_forest_model(*training_set)
+    forest_training_accuracy = q_03_02_evaluate_error(forest_model, *training_set)
+    forest_validation_accuracy = q_03_02_evaluate_error(forest_model, *validation_set)
+    # print("forest_training_accuracy", forest_training_accuracy, "forest_validation_accuracy", forest_validation_accuracy)
+    #
+    # > forest_training_accuracy 0.0 forest_validation_accuracy 0.42
+    #
+    # note :
+    # Le modèle semble sur-spécialisé pour le set d'entrainement.
+
+    confusion = q_03_03_confusion_matrix(forest_model, *validation_set)
+    # print("confusion", confusion)
+    # 
+    # > confusion [[  0   0   1   0   0   0]
+    # >            [  0   0   5   8   0   0]
+    # >            [  0   0 123  39   2   0]
+    # >            [  0   0  37 122  10   0]
+    # >            [  0   0   0  24  23   1]
+    # >            [  0   0   0   1   4   0]]
+    #
+    # note :
+    # Les occurences de classes fortement représentées statistiquement sont presque évaluées correctement.
+    # Cependant le modèle tend à classifier les valeurs peu représentées dans les catégories fortement représentées.
+
+
+    training_alternate_expects_set = q_04_01_reclassify_expects(training_set[1])
+    validation_alternate_expects_set = q_04_01_reclassify_expects(validation_set[1])
+    alt_forest_model = q_04_02_train_forest_model(training_set[0], training_alternate_expects_set)
+    alt_forest_training_accuracy = q_04_03_evaluate_error(alt_forest_model, training_set[0], training_alternate_expects_set)
+    alt_forest_validation_accuracy = q_04_03_evaluate_error(alt_forest_model, validation_set[0], validation_alternate_expects_set)
+    # print("alt_forest_training_accuracy", alt_forest_training_accuracy, "alt_forest_validation_accuracy", alt_forest_validation_accuracy)
+    # 
+    # > alt_forest_training_accuracy 0.0 alt_forest_validation_accuracy 0.085
+    #
+    # note :
+    # Le modèle obtient un bien meilleur score pour une tache plus simple et un set avec une représentation plus uniforme.
+    # Le modèle ne souffre pas de sur-spécialisation.
+
+    alt_confusion = q_04_04_confusion_matrix(alt_forest_model, validation_set[0], validation_alternate_expects_set)
+    # print("alt_confusion", alt_confusion)
+    # 
+    # > alt_confusion [[338   9]
+    # >                [ 25  28]]
+    #
+    # Tip top.
+
+
+    q_05_01_read_doc()
+    search_grid = q_05_02_make_search_grid(alt_forest_model)
+    q_05_03_k()
+    # best_estimator = q_05_04_get_best_params(search_grid, training_set[0], training_alternate_expects_set)
+    # print("best_estimator", best_estimator)
+    # 
+    # > best_estimator RandomForestClassifier(bootstrap=False, min_samples_leaf=2, n_estimators=200, random_state=42)
+
+    # définition alternative pour 'best_estimator'
+    best_estimator = sklearn.ensemble.RandomForestClassifier(bootstrap=False, min_samples_leaf=2, n_estimators=200, random_state=42).fit(training_set[0], training_alternate_expects_set)
+    best_estimator_accuracy = q_05_05_evaluate_error(best_estimator, validation_set[0], validation_alternate_expects_set)
+    # print("best_estimator_accuracy", best_estimator_accuracy)
+    # 
+    # > best_estimator_accuracy 0.0975
+
+
+
+def q_01_01_load_data(path: str):
+    return pandas.read_csv(path, sep=';')
+
+def q_01_02_print_raw_data(data: pandas.DataFrame):
+    print("__q_02_print_raw_data__\n", data)
+
+def q_01_03_plot_raw_data(data: pandas.DataFrame):
+    seaborn.pairplot(data)
+    matplotlib.pyplot.show()
+
+
+def q_02_01_split_set(data: pandas.DataFrame):
+    quality_categories = data["quality"]
+    parameters_columns = [ name for name in DATA_COLUMNS if name != "quality" ]
+    parameters = data[parameters_columns]
+    return (quality_categories, parameters)
+
+
+def q_02_02_model_sets(parameters: pandas.Series, expects: pandas.Series):
+    (
+        training_parameters_set, validation_parameters_set,
+        training_expects_set,    validation_expects_set
+    ) = sklearn.model_selection.train_test_split(parameters, expects, random_state=HAHA_FUNI_NUMBER)
+
+    assert type(training_parameters_set) is pandas.DataFrame
+    assert type(validation_parameters_set) is pandas.DataFrame
+    assert type(training_expects_set) is pandas.Series
+    assert type(validation_expects_set) is pandas.Series
+    return ((training_parameters_set, training_expects_set), (validation_parameters_set, validation_expects_set))
+
+def q_02_03_train_linear_model(training_parameters_set: pandas.DataFrame, training_expects_set: pandas.Series):
+    model = sklearn.linear_model.LinearRegression()
+    model.fit(training_parameters_set, training_expects_set)
+    return model
+
+def q_02_04_evaluate_error(
+        model: sklearn.linear_model.LinearRegression,
+        validation_parameters_set: pandas.DataFrame,
+        validation_expects_set: pandas.Series
+    ):
+    predictions = model.predict(validation_parameters_set)
+    error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
+    return error
+
+def q_02_05_print_one_prediction(model: sklearn.linear_model.LinearRegression, parameter_set: pandas.DataFrame):
+    parameters = parameter_set.head(1)
+    [prediction, *_] = model.predict(parameters)
+    print("q_02_05_print_one_prediction", prediction)
+
+
+def q_03_01_train_forest_model(training_parameters_set: pandas.DataFrame, training_expects_set: pandas.Series):
+    model = sklearn.ensemble.RandomForestClassifier(random_state=HAHA_FUNI_NUMBER)
+    model.fit(training_parameters_set, training_expects_set)
+    return model
+
+def q_03_02_evaluate_error(
+        model: sklearn.ensemble.RandomForestClassifier,
+        validation_parameters_set: pandas.DataFrame,
+        validation_expects_set: pandas.Series
+    ):
+    predictions = model.predict(validation_parameters_set)
+    error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
+    return error
+
+def q_03_03_confusion_matrix(
+        model: sklearn.ensemble.RandomForestClassifier,
+        validation_parameters_set: pandas.DataFrame,
+        validation_expects_set: pandas.Series
+):
+    predictions = model.predict(validation_parameters_set)
+    confusion = sklearn.metrics.confusion_matrix(validation_expects_set, predictions)
+    return confusion
+
+
+def q_04_01_reclassify_expects(quality_series: pandas.Series):
+    QUALITY_THRESHOLD = 7
+    high_quality_series = quality_series.map(lambda quality: 1 if quality >= QUALITY_THRESHOLD else 0)
+    return high_quality_series
+
+def q_04_02_train_forest_model(training_parameters_set: pandas.DataFrame, training_expects_set: pandas.Series):
+    model = sklearn.ensemble.RandomForestClassifier(random_state=HAHA_FUNI_NUMBER)
+    model.fit(training_parameters_set, training_expects_set)
+    return model
+
+def q_04_03_evaluate_error(
+        model: sklearn.ensemble.RandomForestClassifier,
+        validation_parameters_set: pandas.DataFrame,
+        validation_expects_set: pandas.Series
+    ):
+    predictions = model.predict(validation_parameters_set)
+    error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
+    return error
+
+def q_04_04_confusion_matrix(
+        model: sklearn.ensemble.RandomForestClassifier,
+        validation_parameters_set: pandas.DataFrame,
+        validation_expects_set: pandas.Series
+):
+    predictions = model.predict(validation_parameters_set)
+    confusion = sklearn.metrics.confusion_matrix(validation_expects_set, predictions)
+    return confusion
+
+
+def q_05_01_read_doc():
+    pass
+
+def q_05_02_make_search_grid(base_model: sklearn.ensemble.RandomForestClassifier):
+    param_grid = {
+        "n_estimators": [100, 200, 300],
+        "max_depth": [None, 10, 20, 30],
+        "min_samples_split": [2, 5, 10],
+        "min_samples_leaf": [1, 2, 4],
+        "bootstrap": [True, False]
+    }
+    grid_search = sklearn.model_selection.GridSearchCV(base_model, param_grid, n_jobs=-1)
+    return grid_search
+
+def q_05_03_k():
+    pass
+
+def q_05_04_get_best_params(
+        grid_search: sklearn.model_selection.GridSearchCV,
+        training_parameters_set: pandas.DataFrame,
+        training_expects_set: pandas.Series
+    ):
+    grid_search.fit(training_parameters_set, training_expects_set)
+    return grid_search.best_estimator_
+
+def q_05_05_evaluate_error(
+        model: sklearn.ensemble.RandomForestClassifier,
+        validation_parameters_set: pandas.DataFrame,
+        validation_expects_set: pandas.Series
+    ):
+    predictions = model.predict(validation_parameters_set)
+    error = sklearn.metrics.mean_squared_error(validation_expects_set, predictions)
+    return error
+
+
+if __name__ == "__main__": main()

ia/tp2/requirements.txt

@@ -0,0 +1,6 @@
+pandas
+numpy
+seaborn
+matplotlib
+scikit-learn
+PyQt5

os/01_init.md

@@ -0,0 +1,103 @@
+
+# Systèmes d'exploitation et Programmation temps-réel
+
+> Note :
+> - 12 h de cours
+> - 10 h de TP
+>
+> 1. Introduction
+> 2. Système d'exploitation et temps réel
+> 3. Interuptions de processus
+> 4. Outils de synchronisation et de communication des taches
+> 5. Gestion de la mémoire
+> 6. Ordonancement et gestion des taches, ordonancement temps réel
+
+# Introduction
+
+Des domaines d'application :
+
+- automatisme
+	- avionique
+	- robotique
+	- villes intelligentes
+	- armement
+
+- multimédia
+	- télécommunications
+	- e-commerce
+	- santé, implants
+	- domotique
+
+## Exemple d'une voiture moderne
+
+- 30        calculateurs
+- 100       capteurs
+- 1 000 000 lignes de code
+
+## Définitions
+
+Un système embarqué
+- dispositif matériel comportant des parties logicielles
+- utilisé pour controler et agir sur son environnement
+- observe les variations de son environnement grace à des capteurs et agir sur lui grace à des actionneurs
+
+contraintes physiques peuvent s'appliquer :
+- résistance à des températures extrêmes
+- résistance aux champs magnétiques
+- résistance aux vibrations
+
+Les termes de système embarqué désignent aussi bien le matériel que le logiciel utilisé.
+Pour concevoir un système embarqué, il faut généralement combiner des compétences en électronique, en informatique industrielle et en automatique.
+
+Un système embarqué est un système informatisé spécialisé qui constitue une partie intégrante d'un système plus large ou une machine.
+Typiquement, c'est un système sur un seul processeur et dont les programmes sont stockés en mémoire non volatile.
+
+## Histoire
+
+- Le premier système à être embarqué a été le système de guidage de la mission apolo en 1967.
+- Le premier processeur spécialisé pour l'embarqué, le Intel 4004 est sorti en 1971.
+- Le premier appareil commercial piloté par ordinateur était l'airbus A320 en 1984.
+- Le premier métro autonome a été le métro de lile en 1983.
+- L'émergeance des IoT en 1999.
+- Premier smartphone tactile correctement commercialisé en 2007 (après philips).
+- Premières attaques d'envergures par bot internet en 2016.
+
+## Caractéristiques
+
+- Encombrement de l'équipement (mémoire limitée pas de disque en général)
+- Consommation d'énergie et autonomie (batterie)
+- Mobilité
+- Communication
+- Contraintes de sécurité
+- Contraintes de temps réel
+- Ergonomie
+- Impacts : éthiques et sociétaux
+- coût de produits en relation avec le secteur cible
+
+- intégration assive de composants embarqués répartis pour batir la société de l'information
+	- téléphones cellulaires
+	- tablettes
+	- automobile
+	- appareils médicaux
+	- photo/vidéo/hifi
+	- électroménager
+	- avionique
+	- spacial
+	- jouets
+
+- outils théorques pratiques our l'intégration permettantn de prendre en compte tous ces critères
+
+- construire des systèmes de fonctionnalité et qualité déterminée et agarantie, à cout acceptable.
+
+
+## Considérations
+
+- Techniqeus :       conception conjointe
+- économiques :      optimisation par rapport au marché, entre cout, qualité et spécialisation
+- multi compétence : combinaison de compétences en logiciel, controle, réseaux, ingénierie en électronique, ihm, automatique, médecine, mécanique
+
+## Problématiques
+
+- Hétérogénéité : Construire des systèmes complexes par intégration de composants hétérogènes
+- Complexité :    L'effort de développement augmente exonsentiellement avec le nombre de composantsi intégrés, d'où la nécessité de remplacer les méthodes de validation postérieure par des méthodes de validation incrémentale.
+- Intelligence :  Moyen d'améliorer la qualité de systèmes : autodiagnostic, auto configuration, adaptabilité à l'environnement, évaluation des risques.

reseau/02_net.md

@@ -8,7 +8,7 @@ on utilise une onde qui est modulée avec le signal d'entrée dans le but de tra
 
 +-----+  +-----+  +--------------+       +--------------+  +-----+  +-----+
 | DTE |--| DCE |--| Modulateur & |. . . .| Modulateur & |--| DCE |--| DTE |
-+-----+  +-----+  | Démodulateur |       | Démodulateur |  +-----+  +-----+
++-----+  +-----+  | Démodulateur | canal | Démodulateur |  +-----+  +-----+
                   +--------------+       +--------------+
 
 ```
@@ -387,3 +387,6 @@ Exemple : USB, token-ring 802.5 (IBM).
 Une station qui veut émettre écoute le medium.
 - si celui-ci est libre, elle commence sa transmission, tout en vérifiant qu'auune autre station n'est en train d'émettre.
 - en cas de collision, les stations interromptent leur communication et attendent un délai aléatoire (rng back-off) puis la première ayant passé ce délai peut réémettre.
+
+Une analogie serait la colision dans une discussion entre humain :
+- lorsque deux personnes se mettent à parler simultanément, ils se coupent et un des deux, chois au hasard, reprends.

reseau/03_net.md

@@ -0,0 +1,327 @@
+# Detection des collisions
+
+Influende du temps de propagation.
+
+```
+Postes : A   B   C   D   E
+         *---*---*---*---*
+         .   .   .   .   .
+T0 :     ####.___.___.___.
+         .   .   .   .   .
+T0+x :   .___.####___._xxx
+         .   .   .   .   .
+T0+y :   .___.__####_xxx_.
+         .   .   .   .   .
+T0+z :   .___.____#x#x___.
+         .   .   .   .   .
+```
+
+à T0+z, la collision à lieu, A et E ont fini d'émettre et n'ont pas détecté la collision,
+elles pensent pouvoir continuer à envoyer des trames sur le médium.
+
+## Solution : slot-time
+
+Pour éviter ce genre de collision, nous introduisons un délai avant chaque nouvelle transmission
+pour s'assurer que l'information ait pu rejoindre tout le réseau avant d'émettre à nouveau.
+
+Ce délai (slot-time) est généralement choisi à deux fois le temps de parcours de l'information sur tout le médium.
+
+## Taille minimum d'une trame
+
+Pour que l'on puisse détecter la collision, il faut que la station émettrice
+soit toujours en train d'émettre lorsque la station la plus éloignée détecte l'émission.
+
+Il faut donc que le temps d'émission d'un trame de longueur minimale soit supérieure au slot-time.
+
+ex :
+
+vitesse | taille mini | slot time
+
+...
+
+## Reprise après collision (binary exponential backoff)
+
+Après la détection de la collision, la station doit retransmettre la même trame au bout d'un temps aléatoire dépassant le slot-time  et du nombre de collisions successives déjà subies.
+
+Le nompre de collisions successives est proportionnel au  temps de retransmission.
+
+Calcul du temps d'attente : M x slot Time
+- 0 =< M < 2^k
+	- 0 < k < 2^(n-1).
+		- n est le nombre de collision par rapport à la station
+
+
+- le nombre aléatoire est d'abord choisi dans [0, 1]
+- puis dans [0, 3]
+- puis [0, 7]
+- ...
+- à la 10e tentative, [0, 1023]
+- à la 16e tentative, la transmission est abandonnée.
+
+## Exemple
+
+```
+station :  A   B   C   D   E
+          -*---*---*---*---*-
+
+```
+
+A et E subissent une collision :
+
+### Cas 1
+
+```
+station :  A               E
+          -*---*-#####-*---*-
+n :        1               1
+k :      [0,1]           [0,1]
+```
+
+règles :
+
+- k_A = 0 & k_E = 0 => collision
+- k_A = 0 & k_E = 1 => pas de collision
+- k_A = 1 & k_E = 0 => pas de collision
+- k_A = 1 & k_E = 1 => pas de collision
+
+valeurs de k
+
+| A | E |
+|---|---|
+| 0 | 0 |
+| 0 | 1 |
+| 1 | 0 |
+| 1 | 1 |
+
+
+probabilité que A gagne : 1/4
+probabilité que E gagne : 1/4
+probabilité de collision à nouveau : 1/2
+
+
+### Cas 2
+
+```
+station :  A               E
+          -*---*-#####-*---*-
+n :        1               2
+k :      [0,1]         [0,1,2,3]
+```
+
+valeurs de k
+
+| A | E |
+|---|---|
+| 0 | 0 |
+| 0 | 1 |
+| 0 | 2 |
+| 0 | 3 |
+| 1 | 0 |
+| 1 | 1 |
+| 1 | 2 |
+| 1 | 3 |
+
+probabilité que A gagne : 5/8
+probabilité que E gagne : 3/8
+probabilité de collision à nouveau : 2/8 : 1/4
+
+
+## Domaine de collision
+
+- sur une topologie BUS, ou sur une topologie étoile constituée d'un HUB, le signal ethernet est ...
+
+## Conclusion
+
+le CSMA/CD n'est potentiellement pas adapté aux applications temps réel car non déterministe
+
+
+# CSMA/CR (Collision .. with Collision Resolution)
+
+dans la méthode CSMA/CR, la station utilises des fonctionnalité plus élabotées pour détecter une collision dès que possible.
+
+Pour éviter les collisions en chaine, une station qui transmet une trame cesse d'émettre si elle recoit un bit différent du sien ; 
+- Une station qui émet un bit à 1 s'arrete si elle voir passer sur le support un bit à zéro.
+- Une station qui recoit un bit identique à celui qu'elle a émis continue à émettre.
+
+## Évolutions
+
+| Port        | mode        |
+|-------------|-------------|
+| 10BT        | Half-duplex |
+| 100BASETx   | Full-duplex |
+| GB ethernet | Full-duplex |
+
+### Switch
+
+```
+[ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ]
+  |     |     :     |     |
+  A     B     C     D     E
+```
+
+| Port | Mac |
+|------|-----|
+| 1    | A   |
+| 2    | B   |
+| 3    | C   |
+| 4    | D   |
+| 5    | E   |
+| 6    |     |
+
+chaque port du switch est un domaine de collision.
+Le switch n'envoie le trafic que sur le port concerné.
+
+# Trame ethernet
+
+```
++-----------+-----+-----------+----------+------+----------+-----+-----+
+| préambule | SFD | Dést. MAC | Src. MAC | Type |  donnée  | FCS | IPG |
++-----------+-----+-----------+----------+------+----------+-----+-----+
+```
+
+- préambule :             7 octets pour synchroniser les horloges du traget.
+- Start Frame DElimiter : 1 octet qui indique au récepteur que le champ destination MAC démarre au prochain octet (synchro)
+
+- Dest : 6 octets d'une addresse MAC
+- Src :  6 octets d'une addresse MAC
+
+## Domaine de Broadcast
+
+Au contraire d'une communication unicast, il est possible d'adresser des trames de données
+à tous les membred d'un même réseau uniquement par des adresses spécifiques.
+
+Adresse MAC de diffusion générale est FF.FF.FF.FF.FF.FF
+
+Un switch recevant une trame broadcast sur l'un de ses ports la diffusera sur tous les autres ports.
+
+> note :
+> un broadcast propagé dans un réseau contenant un cycle risque de se répéter à l'infini sur ce dernier.
+> La solution est d'utiliser des switch implémentant le protocole spanning tree ;
+> Qui réduit le nombre de récepteur des paquets broadcast à un réseau ne contenant pas de cycles entre les switchs.
+
+Un routeur ne propage pas de broadcast car il interface deux réseaux différents, et un broadcast est adressé à un seul réseau.
+
+## VLAN
+
+un VLAN permet de, virtuellement, utiliser une seule liaison pour véhiculer deux réseaux séparés entre deux switchs qui le supportent.
+
+```
+[ switch A ] =trunk= [ switch B ]
+    |  |                 |  |
+    |  |                 |  |
+   [A][X]               [B][Y]
+   /    \               /    \
+vlan1  vlan2         vlan1  vlan2
+  .      .              .    .
+  . . . . . . . . . . . .    .
+         . . . . . . . . . . .
+```
+
+Sur un switch, chaque VLAN est un domaine de broadcast.
+
+Il est possible de joindre des VLAN avec un Routeur ;
+mais il est préférable de contrôler l'accès entre deux VLAN
+de responsabilités différentes avec un Routeur configuré en pare-feu.
+
+> note : LAN est une norme 802
+
+# Réseau WIFI
+
+## Topologies
+
+### Ad-Hoc / indépendant
+
+```
+ A
+ | \
+ |  \
+ B -- C
+```
+
+Les enteines de chaques membre peut communiquer dirrectement avec celles des autres membres du réseau.
+
+### Infrastructure
+
+```
+    A
+    |
+B --o-- C
+    ^\_ point d'accès
+```
+
+Les membres du réseau sont tous connectés à un point d'accès.
+
+## Utilisation des ondes
+
+Comme la bande FM, les réseaux wifi sont divisées en canaux se chevauchant.
+
+```
+ -------------------------------------------------
+  ......1...... ........6..... .......11.....
+    ......2....... .......7...... .....12......
+      .......3....... ......8....... .....13.....
+        .......4....... ......9.......
+          ........5....... ....10.......
+ 
+  ^^^^^^^^^^^^^\_ 22 Mhz
+```
+
+- 13 bandes
+-  3 bandes distinctes
+- 22 Mhz de longueur
+- 2.4 Ghz
+
+## Codages
+
+- DSSS
+- FHSS
+- OFDM :  Orthogonal Frequency Division Multiplexing
+- OFDMA : Orthogonal Frequency Division Multiple Access
+
+## Les couches 802.11
+
+- Liaison
+	- LLC : 802.2
+	- MAC : 802.11
+- Physique
+	- FHSS
+	- ...
+	- OFDMA
+
+## Standards
+
+| Nom           |  802.11b | 802.11a | 802.11g |  802.11n | 802.11ac |     802.11ax |
+|---------------|----------|---------|---------|----------|----------|--------------|
+| Fréquences    |  2.4 Ghz |       5 |     2.4 | 2.4 ou 5 |        5 |     2.4 ou 5 |
+| Transfert max |    11 Mb |      54 |      54 |      150 |   3.4 Gb |         10.5 |
+| Modulation    |     DSSS |    OFDM |    OFDM |     OFDM |     OFDM | OFDL / OFDMA |
+| Portée        | 35-140 m |  35-120 |  35-140 |   50-250 |   20-300 |       20-300 |
+| année         |     1999 |    1999 |    2003 |     2009 |     2013 |         2021 |
+
+## Méthode d'accès au médium
+
+CSMA/CD inapproprié
+- dificile d'écouter le médium lors de la transmission
+- 2 stations peuvent être visibles l'une de l'autre
+
+CSMA/CA méthode adapté
+- carrier sense multiple access
+- collision avoidance : évitement des collisions
+- méthode par compétition
+
+### principe du CSMA/CA
+
+1. Une station souhaitant émettre écoute si le médium est libre.
+	- si c'est le cas, elle attend pendant un temps fixe (DIFS) + temps aléatoire.
+2. si le média est toujours libre, alors elle émet.
+
+acquittement (ack) après un silence SIFS.
+
+```
+ ------------------------------
+ Source :        .###..........
+ Destination :   .....#........
+ Autre station : .......###....
+                     ^\_ ACK
+```
+

securite/02_securite_des_info.md

@@ -0,0 +1,57 @@
+## Qu est-ce qu'une info ?
+
+- Actif essentiel
+- Stockée sous différentes formes (num, materiel, intangigle)
+- Transmise par différents moyens
+- Dépendant des tech de l'information
+
+La sécurité de l'information, c'est garantir la disponibilité de l'information ; par l'application et le management de mesures de sécurité appropriées.
+
+
+## Un ensemble de mesures de sécurité applicables.
+
+- Management du risque
+- Gérées à l'aide d'un SMSi:
+	- Politiques, Processus, procédures, structures organisationelles, logiciels et matériels
+- mesures spécifiées, mises en oeuvre, surveillées, réexaminées et améliorées si nécessaires.
+
+## Objectifs
+
+3 objectifs premiers :
+
+- disponibilité
+- intégrité
+- confidentialités
+
+5 objectifs accessoires :
+
+- Traçabilité :                      Garder des traces des évènements et des action
+- non-répudiation :                  Permet de prouver qu'une personne ou entité eest à l'origine d'un évènement ou d'une action
+- imputabilité :                     Responsabilité d'une entité par rapport à ses actions et décisions
+- opposabilité :                     Possibilité d'opposer une action à son auteur devant un juge
+- irréfutabilité / irréfragabilité : Après être passé devant un juge
+
+## RASCI (fruit du rasciste)
+
+- Responsible
+- Accountable
+- Support
+- Consulted
+- Informed
+
+## Quel management ?
+
+- sécurité du système en conception et 
+	- s'assurer que les résultats des travaux d'ingéneierie de conception et d'intégration sont d'un niveau de sécurité suffisant ; et fournir toutes les informations nécessaires.
+	- Métiers
+		- gestion de la sécurité et pilotage des projets de sécurité
+		- conception
+
+- sécurité de l'entreprise régulière
+	- s'assurer que les activités menées sont réalisées de manière sécurisée
+
+## Cyber sécurité embarqué
+
+Différences
+- production pour une série
+

securite/vm/.gitignore

@@ -0,0 +1,2 @@
+/labtainer-vbox.ova
+/labtainer

securite/vm/setup.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+wget -O ./labtainer-vbox.ova "https://nps.box.com/shared/static/dn636n6h2d556nwqezx5w6cfc4cfeacl.ova"
+vboxmanage import --basefolder=./labtainer labtainer-vbox.ova