gui/readme.md

## Protótipo para uso dos modelos

Neste diretório pode-se encontrar a implementação de um protótipo para a classificação de imagens de uva. Note que o _requeriments.txt_ é provido de modo que a instação dos requerimentos para executar o código seja feita rapidamente. 

O código está estuturado em uma forma model-view.

Sobre os arquivos:
* **App.py:** Arquivo principal do aplicativo, representando o view. A implementação doi feita utilizando PyQT5.
* **Relatorio.py:** Arquivo secundário da view que representa o relatório de uma classificação. Utilizado para melhor organização do código. 
* **explicador.py:** módulo que controla os explicadores disponíveis. Para adiconar um novo explicador ao software, deve criar uma classe, herdando de "base\_explainer.py" e implementar o método abstrato "_get\_explanation_". O método está feito de modo que elementos inerentes a cada explicador possam ser passsados através da variável props. O retorno desse método deve ser obrigatoriamente uma Imagem PIL. Pode-se utilizar o método "_keras.preprocessing.image.array\_to\_img_" do keras que automaticamente transforma um array numpy numa imagem deste tipo.
* **model\_manager.py**: módulo responsável por gerenciar os modelos. Para se adicionar um novo modelo, deve-se adicioná-lo ao arquivo _config.json_, indicanto a pasta onde o modelo está (a pasta deve ser extraída com formato [SavedModel do tensorflow](https://www.tensorflow.org/tutorials/keras/save_and_load#savedmodel_format)). Além disso um nome ("name"), o tamanho ("size"), um tipo do modelo ("type") devem ser providos. Note que caso pretenda-se utilizar métodos baseados em ativação por classe deve-se também fornecer o nome da camada convolucional que será utilizada para se obter os mapas de ativação ("last\_conv"). O tipo do modelo é utilizado para aplicar o preprocessamento. Caso algum tipo que não seja efficientnetb3, resnet101, ou xception seja setado, nenhum pre-processamento será aplicado às imagens na inferência e consequentemente, na hora de obter explicações com o LIME. É importante ressaltar que as classes e suas siglas devem ser fornecidas na mesma ordem em que o treinamento foi realizado. Caso tenha-se utilizado o ImageGenerator do keras, por padrão a ordem é alfabética. As classes devem ser fornecidas do mesmo formato em que está o arquivo _config.json_ fornecido.
* **util.py:** módulo com métodos de comum utilização entre diferentes classes.


Os arquivos restantes são implementações dos explicadores de modo que estes possam ser gerenciados pelo módulo "explainer". É importante observar como eles fucionam caso se pretenda adicionar um novo explicador ao programa.

### Adicionando um novo modelo ao programa

1. Adiciona-se o modelo ao arquivo _config.json_, fornecendo um nome, diretório (a pasta deve ser extraída com formato [SavedModel do tensorflow](https://www.tensorflow.org/tutorials/keras/save_and_load#savedmodel_format)), tamanho no formato "altura, largura", tipo e nome da camada convolucional que será usada pelo grad-cam. 

```javascript
{
            "name": "Xception",
            "directory":"C:\\Users\\Gabriel\\Xception",
            "size":"300, 300",
            "type":"xception",
            "last_conv": "block14_sepconv2_act"
}
```

2. Caso pretenda-se adiconar um novo tipo de modelo deve-se adicionar ao _model\_manager.py_ no método _add\_model()_ o tipo do modelo (mesma string especifica em **type** no _config.json_) e os métodos de pré processamento e de desfazer o pré processamento. Caso não seja adicionado, nenhum método vai ser aplicado, retornando a própria imagem em ambos os casos.

```python
elif type_model == $STRING_TYPE_DEFINIDA_EM_CONFIG:
            #método de pré proecessamento
            container["preprocessing"] = keras.applications.efficientnet.preprocess_input
            #método de desfazer préprocessamento
            container["undo_changes"] = self.efficientnet_undo_changes
```

3. Os elementos de interface gráfica são automáticamente preenchidos com os novos modelos providos, caso a descrição esteja correta.

### Adicionando um novo explicador ao programa

1. Cria-se uma nova classe herdando de **BaseExplainer** localizada no módulo "base\_explainer.py". A assinatura do método pode ser vista abaixo. O método deve retornar uma imagem PIL para que a interface gráfica funcione corretamente. Pode-se utilizar o método "_keras.preprocessing.image.array\_to\_img_()" para conveter uma array numpy para uma imagem PIL.

```python
@abstractmethod
def get_explanation(self, img, model, img_size, props, preprocess_input = None, index=None):
    pass
```

2. Deve-se adicionar à constante __explainers__ da classe Explicador no localizada no módulo "_explicador.py_" o nome do explicador e um objeto referente a ele. Três exemplos podem ser observados abaixo.

```python
class Explicador:
    explainers = {"LIME": LIMEExplainer(),
    "Grad-CAM": GradCAMExplainer(), 
    "Grad-CAM++":GradCAMPPExplainer()}
    ...
```

3. A interface gráfica é automaticamente preenchida com os nomes especificados na constante __explainers__. 

Shield: [![CC BY-NC-SA 4.0][cc-by-nc-sa-shield]][cc-by-nc-sa]

This work is licensed under a
[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].

[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]

[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
[cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg