# Réunion Multivues

## Objectif du papier 2

* Démontrer que l'apport en quantité d'information d'une observation multivues d'un objet permet de réduire significativement la quantité de ressources (en termes de #MAC) nécessaires pour classifier cet objet.

* Travaux précédents: nous avons démontré que le multi-vues permet de rapprocher le calcul des capteurs

## Méthode

* Tous autres paramètres fixés, obtenir la même accuracy avec un réseau multi-vues globalement plus petit que le réseau mono-vue (baseline).
* Pour parvenir à obtenir un réseau multivues globalement plus petit que le réseau monovue, on construit une expérimentation en 2 temps
1. on génère un réseau multi-vues
2. on ajoute des vues pour retrouver la performance $A$.
* Démontrer ce phénomène avec suffisamment de setups pour être convaincant.

### Visualisation des données recherchée

* Tracer la précision $A$ en fonction du taux de dégradation $\alpha_d$ et du nombre de vues $V$:

$$
\begin{align}
&\mathcal{A} = f(\alpha_d, V)\\
\end{align}
$$

## Hypothèses

### Objectifs

* Précision top-1 en termes de classification d'objet sur 40 classes

* Objectif en termes de ressources
* R0: Ressources en termes de #MAC (Multiply-Accumulate)
* R1: Ressources en termes de #LE (Logic Element)

### Dataset

* D0: ModelNet

### Types d'optimisation réseau

* Types de réseau
* N0: MobileNetV2
* N0.1 Monovue
* N0.2 Multi-vues merge première couche
* N0.3 Multi-vues merge dernière couche -> en aggrégeant à la 17ème couche, pour obtenir la meilleure accuracy
* N0.4 Multi-vues merge intermédiaire
* quel merge donne le meilleur compromis accuracy-taille de réseau

* Types de pruning
* P0: Sans Pruning
* P1: Dense Sparse Dense (DSD) (pruning global des couches en DHM)
* P1_1: pruning global vs chacune des couches (Pruning et ensuite dégradation multi vue)
* P2: Automatic Gradual Pruning (AGP) ("To Prune or not to Prune")
* P2_2 : pruning global graduel vs pruning couche par couche graduel

* Types de quantification
* Q0: Sans quantification (en float32) -> indisponible en DHM
* Q1: Post-training quantification
* Q2: Quantized aware training (Quantification "Nervana")
- **DECISION PAPIER: Toute les manips avec Q1: activations sur 8 bits, weights sur 4 bits**

### Imagerie multi-vues

- 1 à 8 vues planaires, séparées de $360/V$ degrès.

## Expérimentations

- La manip consiste à montrer l'apport (ou non) du multivue par rapport à la quantité de ressources utilisées.

### 1- Détermination du point de fusion

- Sans réduction du réseau, détermination du meilleur compromis ("taille du réseau" en #MAC,accuracy).
- Trouver un critère pour choisir le point de merge entre 1 et 17.
- Accuracy versus position du merge
- Attention: si on merge en layer 1;
- Optimal merge point = layer qui donne la plus faible perte d'accuracy quand le le nombre de vues baisse ???

### 2- Experimentation en pruné (AGP)

* Faire une manip en monovue : Noter les ressources $R_{mono}$ pour une précision $A_o$. $A_o$ sera la référence.
* Faire plusieurs manips en faisant varier le nombre de vues $V$ dans un cas non pruné et en réduisant de manière arbitraire les ressources. Cette réduction $\alpha$ pourra se faire de **manière globale ou par couche**. Cette dégradation $D$ de la quantité de ressources implique une dégradation de la précision.

**Il faut montrer qu'à précision $A_{multi}=A_o$ on a $\alpha>\frac{R_{mono}}{V}$.**

$$
\begin{align}
&\mathcal{R}_{D\ avec\ DSD}= f(\alpha_{D\ avec\ DSD}, V)
\end{align}
$$

### Lexique

$$
MVNET = \underbrace{FC \circ H^{N-1}_{N-M+1}}_{Back-End}\circ max({\underbrace{F_0^{M-1}(V_i)}_{Smart\ Camera}})
$$

- Front-end: part du réseau distribuée
- Back-end: part du réseau centralisé
- Couche de fusion (merge layer) (qui calcule le maximum de ses entrées et se trouve dans le back-end)
- $V$: le nombre de vues donc le nombre de caméras. Ce sera aussi le nombre de **branches** (identiques) du réseau.
- $M$: le nombre de couches dans chaque branche (fixé).
- $N$: le nombre total de couches dans le réseau.
- $\underline X$: les ressources maximum acceptables par FPGA. C'est un vecteur incluant plusieurs types (MAC, LE, IO,...).
- $\underline R_i$: les ressources consommées par la couche $i$ au sein d'une branche front-end (ALMs)
- $A$: la précision visée par le **réseau global**
- **Level Pruning** : supprimer les paramètres les plus faibles avec taux définis à l'avance
- **AGP (Automated Gradual Pruning)** : supprimer les paramètres les plus faibles graduellement (Beaucoup de poids sont enlevés au départ puis de moins en moins jusqu'au taux de pruning final. Les poids restants sont réentrainés entre chaque étape)
- **Pruning** : virer les paramètres qui ne servent à rien sans toucher à l'accuracy
- **Degradation**: virer les paramètres restants qui engendre une perte d'accuracy, rattrapable avec le multivue inchallah!!

# Résultats

### N0 (trainings):

#### N0.1 Monovue
Ci-contre pruning mono-vue en utlisant 2 méthodes, Level Pruner et AGP.
- A gauche la précision en fonction du taux de pruning (rouge et bleu).
- A droite, l'efficiacité du réseau en fonction du taux de suppression des poids.

A gauche de la droite $x=50\%$, on considère qu'on est en présence de pruning. A droite, on entre dans une phase de dégradation.


Le pruning AGP est la meilleure solution d'après les experiences, on garde ce schéma de pruning pour le reste des essais.

#### N0.4 Multi-vues merge intermédiaire SANS PRUNING


* le nombre de paramètres des $M$ premières couches est dupliqué dans chaque $V$
* les features finales de chaque vue sont regroupées par la fonction $maxpool$
* les setups avec 7 cameras sont les meilleures en terme d'accuracy.

il faut pouvoir trouver un point de merge et un nombre de vue idéale tels qu'à accuracy constante :

$$\sum^{l=M}_{l=1}\mathcal{R}_l \times V + \sum^{l=N}_{l=M+1}\mathcal{R}_l\ \le\ \sum^{l=N}_{l=1}\mathcal{R}_l(monovue)
$$

ou

$$
\sum^{l=N}_{l=1}\mathcal{R}_l(monovue) \times V + \sum^{l=N}_{l=M+1}\mathcal{R}_l\ \le\ \sum^{l=N}_{l=1}\mathcal{R}_l(monovue)
$$

Trouver la relation qui régit le nombre de ressources VS le nombre de vue à précision constante. necessite de faire plus de 400 trainings de 1h chacun

### P0 ()


## Plan de l'article

### Abstract, Intro
On cherche à démontrer qu'il est possible de dégrader un réseau grâce à la diversité d'informations apportée par un système multivue. Le résultat idéal serait de diviser le nombre de paramètres par le nombre de vues disponibles. A voir dans les expériences...

### Related works
CNNs Multivues
Pruning (structuré, non structuré)

### Problem statements
On cherche à implémenter $F_0^{M-1}$ couches du réseau en ayant $\mathcal{R}_{device}$ ressources disponible par caméra, avec :
* $M \leq N$, où $N$ est le nombre total de couche de convolution du CNN
* Pour un accélérateur à PE, on parle en termes de workload $\mathcal{W}$
* Pour un accélérateur statique sur FPGA ou ASIC, on parle en termes de Logic
elements ou portes logiques $LEs$

### Proposition
On introduit le terme de dégradation dans le réseau qui consiste à supprimer les poids de convolutions restant après une étape de pruning.
1. Network degradation path : $\mathcal{R}_{0} \rightarrow \mathcal{R}_{pruning} \rightarrow \mathcal{R}_{degradation}$

### Experiments
Mobilenetv2 de 2 à 8 vues. Les decripteurs de vues sont regroupés selon différentes position dans le réseaux (2, 7, 12 et avant la fully connected)