{"id":4205,"date":"2020-08-24T20:35:33","date_gmt":"2020-08-24T18:35:33","guid":{"rendered":"https:\/\/mribeirodantas.xyz\/blog\/?p=4205"},"modified":"2025-01-31T04:37:50","modified_gmt":"2025-01-31T02:37:50","slug":"continuous-machine-learning-parte-i","status":"publish","type":"post","link":"https:\/\/mribeirodantas.xyz\/blog\/index.php\/pt\/2020\/08\/24\/continuous-machine-learning-parte-i\/","title":{"rendered":"Continuous Machine Learning \u2013 Parte I"},"content":{"rendered":"Reading time: <\/span> 11<\/span> minutes<\/b><\/span><\/span>\n
\"\"
Image by Taras Tymoshchuck<\/a> from here<\/a>.<\/figcaption><\/figure>\n\n\n\n

Esse texto faz parte de uma s\u00e9rie de 3 partes sobre Continuous Machine Learning. Voc\u00ea pode checar a parte II aqui e a parte III aqui.<\/p>\n\n\n\n

O que \u00e9 isso?<\/h2>\n\n\n\n

Continuous Machine Learning (CML<\/span>) segue o mesmo conceito de Continuous Integration and Continuous Delivery (CI\/CD)<\/a>, famosos concenitos da Software Engineering<\/a><\/span> \/ DevOps<\/a><\/span>, mas aplicado a projetos de Aprendizado de M\u00e1quina e Ci\u00eancia de Dados.<\/p>\n\n\n\n

O que vou aprender com esse post?<\/h2>\n\n\n\n

Eu irei abordar aqui um conjunto de ferramentas que podem fazer sua vida como Cientista de Dados muito mais interessante. N\u00f3s utilizaremos o MIIC<\/a>, um algoritmo de infer\u00eancia de redes causais, para inferir a rede de um famoso dataset<\/em> (alarm do pacote bnlearn<\/a>). A ideia \u00e9 utilizar (1) o git<\/a> para versionar nosso c\u00f3digo, (2) o DVC<\/a> para versionar nosso dataset<\/em>, arquivos de sa\u00edde e at\u00e9 o pipeline<\/em>! (3) Utilizaremos o GitHub<\/a> como git remote<\/em> e (4) o Google Drive<\/a> como DVC remote<\/em>. Pense nos remotes<\/em> como tendo uma c\u00f3pia do seu reposit\u00f3rio remotamente, em um outro computador. Eu tamb\u00e9m escrevi um tutorial sobre gerenciamento de projetos de ci\u00eancia de dados com o DVC e se voc\u00ea estiver interessado, clique aqui para abrir o tutorial em uma nova aba<\/a> para voc\u00ea l\u00ea-lo depois.<\/p>\n\n\n\n\n\n\n\n

Uma coias que me incomoda um pouco \u00e9 frequentemente ter que abrir a p\u00e1gina do GitHub e utilizar a interface deles. \u00c9 muito mais pr\u00e1tico poder fazer tudo pelo terminar e aqui vou te apresentar o gh<\/a>, a aplica\u00e7\u00e3o de linha de comando oficiial do GitHub. Tamb\u00e9m iremos utilizar o CML<\/span><\/a>, uma biblioteca open source<\/em> para implementar continuous integration & delivery<\/em> (CI\/CD) em projetos de aprendizagem de m\u00e1quina. O CML<\/span> ir\u00e1 conectar o git, DVC e GitHub Actions<\/em> (Sistema de CI\/CD built-in<\/em> do GitHub). A ideia \u00e9 criar um gatilho que ser\u00e1 disparado toda vez que voc\u00ea fizer uma determinada a\u00e7\u00e3o no seu reposit\u00f3rio, como um push<\/em>. Essa a\u00e7\u00e3o pode ser processamento, qualquer tipo de computa\u00e7\u00e3o, e ir\u00e1 por padr\u00e3o acontecer em um GitHub Runner (Esse \u00e9 o nome que o GitHub da a uma m\u00e1quina virtual na infraestrutura deles. Veja mais sobre isso aqui<\/a>). Um exemplo seria utilizar branches<\/em> do git como experimentos no seu projeto de ci\u00eancia de dados. Imagine executar seu c\u00f3digo uma vez, alterar algum par\u00e2metro do algoritmo, execut\u00e1-lo novamente, mais uma altera\u00e7\u00e3o qui e outra ali e assim por diante at\u00e9 voc\u00ea ter v\u00e1rias branches<\/em> e experimentos. Toda vez que voc\u00ea der um git push<\/em>, por exemplo, um GitHub Runner poderia ser acionado para comparar as m\u00e9tricas desse experimento com os outros e imprimir na tela (como um coment\u00e1rio na p\u00e1gina do Pull Request<\/em>) um relat\u00f3rio. Parece legal, n\u00e9?<\/p>\n\n\n\n

Hora de arrega\u00e7ar as mangas<\/h2>\n\n\n\n

Vamos criar nosso reposit\u00f3rio no GitHub e fazer uma c\u00f3pia local dele. Faremos isso a partir da linha de comando! (Instru\u00e7\u00f5es aqui<\/a> de como instalar o gh).<\/p>\n\n\n

\n\t\t\t\t
mkdir $HOME\/dev\r\ncd dev\r\ngh repo create dvc-miic-CML<\/span> -d 'GitHub repo to play with DVC, MIIC and CML<\/span>' --public<\/pre>\n\t\t\t<\/div>\n\n\n\n
Voc\u00ea ser\u00e1 perguntado se deseja criar uma c\u00f3pia local do reposit\u00f3rio. Se voc\u00ea disser n\u00e3o, voc\u00ea ter\u00e1 que clonar o reposit\u00f3rio mais tarde, portanto responda com Y<\/strong> e pressione enter<\/em>. Ap\u00f3s isso, entre no diret\u00f3rio.<\/p>\n\n\n
\n\t\t\t\t
cd dvc-miic-CML<\/span><\/pre>\n\t\t\t<\/div>\n\n\n\n
Vamos criar um arquivo LEIAME, onde iremos colocar uma descri\u00e7\u00e3o do nosso reposit\u00f3rio. No GitHub isso costuma ser colocado em um arquio chamado README.md, escrito com formata\u00e7\u00e3o Markdown<\/a>.<\/p>\n\n\n
\n\t\t\t\t
echo '# DVC-MIIC-CML<\/span>' > README.md\r\necho 'This is a sample repository for testing DVC, MIIC and CML<\/span> in GitHub.' >> README.md\r\necho 'The analyses will be performed using [MIIC](https:\/\/github.com\/miicTeam\/miic_R_package) to infer the network from the [alarm dataset](https:\/\/rdrr.io\/cran\/bnlearn\/man\/alarm.html).' >> README.md<\/pre>\n\t\t\t<\/div>\n\n\n\n
Tamb\u00e9m iremos fazer o download<\/em> de um arquivo de licen\u00e7a (GNU GPLv3) a partir do site do projeto GNU<\/a> e salv\u00e1-lo como um arquivo chamado LICENSE, como costuma ser feito em reposit\u00f3rios no GitHub.<\/p>\n\n\n
\n\t\t\t\t
wget -c https:\/\/www.gnu.org\/licenses\/gpl-3.0.txt -O LICENSE<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ap\u00f3s isso, iremos adicionar esses dois novos arquivos para o \u00edndice (index<\/em>) do nosso reposit\u00f3rio git atrav\u00e9s do comando git add<\/code> e ap\u00f3s isso fazer um commit<\/em> do estado atual do reposit\u00f3rio (uma esp\u00e9cie de snapshot<\/em>, caso voc\u00ea n\u00e3o tenha o workflow<\/em> \/ linguajar do git na ponta da l\u00edngua). Com o commit<\/em> realizado, iremos enviar o estado atual do reposit\u00f3rio para o remote no GitHub atrav\u00e9s do comando git push<\/code>. Desse modo, qualquer pessoa que solicite uma c\u00f3pia atual do reposit\u00f3rio para o GitHub, receber\u00e1 tamb\u00e9m as nossas modifica\u00e7\u00f5es. Como essa \u00e9 a primeira vez que estamos dando um git push<\/code>, precisamos informar ao git quem \u00e9 a branch<\/em> principal, padr\u00e3o, do nosso reposit\u00f3rio. Faremos isso atrav\u00e9s do par\u00e2metro --set-upstream<\/code><\/em>. No futuro, quando quisermos dar um novo git push<\/code>, n\u00e3o precisaremos desse par\u00e2metro. Apenas git push<\/code> ser\u00e1 suficiente.<\/p>\n\n\n
\n\t\t\t\t
# The dot when provided to git add means everything in the current folder\r\ngit add .\r\ngit commit -m 'Initial commit'\r\ngit push --set-upstream origin master<\/pre>\n\t\t\t<\/div>\n\n\n\n
Voc\u00ea pode checar o seu reposit\u00f3rio no GitHub agora. Ele deve estar atualizado! O meu est\u00e1<\/a>! O git n\u00e3o foi feito para versionar datasets e arquivos grandes, nem muito menos pipelines. \u00c9 nessa lacuna que o DVC cai como uma luva. Vamos come\u00e7ar a utiliz\u00e1-lo para versionar o dataset<\/em> que iremos analisar. Voc\u00ea pode baixar o dataset<\/em> alarm atrav\u00e9s do site oficial do MIIC clicando aqui<\/a>. Na linha de comando, voc\u00ea deve digitar:<\/p>\n\n\n
\n\t\t\t\t
wget -c https:\/\/miic.curie.fr\/datasets\/alarm1000samples.txt -O alarm.tsv<\/pre>\n\t\t\t<\/div>\n\n\n\n
Eu particularmente n\u00e3o gosto quando os reposit\u00f3rios git s\u00e3o u amontoado de arquivos jogados na base do diret\u00f3rio. Prefiro organizar em sub diret\u00f3rios. Vamos fazer isso.<\/p>\n\n\n
\n\t\t\t\t
mkdir data\r\nmv alarm.tsv data\/<\/pre>\n\t\t\t<\/div>\n\n\n\n
O DVC entra em cena<\/h2>\n\n\n\n
Se voc\u00ea digitar git status<\/code>, voc\u00ea ir\u00e1 ver que a pasta est\u00e1 como untracked<\/em>, n\u00e3o versionada, o que de certo modo \u00e9 um pouco irritante porque (a) git n\u00e3o deveria estar preocupado com arquivos de dados e (b) ainda que algumas pessoas forcem a barra e fa\u00e7am-no versionar datasets<\/em>, voc\u00ea n\u00e3o quer isso. Afinal, temos o DVC, certo? Uma das coisas que o DVC faz automaticamente, ap\u00f3s voc\u00ea inform\u00e1-lo que voc\u00ea quer que ele versione alguns arquivos, \u00e9 dizer para o git ignorar esses arquivos j\u00e1 que o DVC ir\u00e1 tomar conta deles. Assim como antes de come\u00e7ar a dizer o git o que fazer, com o DVC \u00e9 o mesmo: Voc\u00ea precisa inicializar o DVC no reposit\u00f3rio. Com o git, digitamos git init<\/code>, e com o DVC n\u00e3o ser\u00e1 diferente. Instru\u00e7\u00f5es sobre como instalar o DVC podem ser encontradas aqui<\/a>.<\/p>\n\n\n
\n\t\t\t\t
dvc init\r\ndvc add data\/alarm.tsv<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ap\u00f3s ser inicializado, o DVC ir\u00e1 criar arquivos arquivos. Esses meta-dados s\u00e3o arquivos que precisam ser versionados pelo git. Acho \u00fatil pensar no DVC como algo que complementa o git, portanto o git segue sendo o ator principal j\u00e1 que ele versiona os arquivos do DVC. Vamos adicionar esses arquivos ao \u00edndice do git, index<\/em>, e realizar um commit<\/em>. Nosso dataset<\/em> n\u00e3o ser\u00e1 adicionado nem comitado poqrue o DVC j\u00e1 o adicionou ao .gitignore, um arquivo oculto que o git uso para esse prop\u00f3sito: saber que arquivos deve ignorar.<\/p>\n\n\n
\n\t\t\t\t
git add .\r\ngit commit -m 'Initiates DVC and asks it to track alarm dataset'<\/pre>\n\t\t\t<\/div>\n\n\n\n
Dependendo do quanto voc\u00ea est\u00e1 familiarizado com o git, isso pode ser uma surpresa ou n\u00e3o mas voc\u00ea n\u00e3o precisa dar git push<\/code> (enviar a vers\u00e3o mais atual do reposit\u00f3rio para um git remote,<\/em> como o GitHub). N\u00f3s n\u00e3o iremos fazer isso agora, por exemplo (ainda que pud\u00e9ssemos). E do mesmo modo que o GittHub \u00e9 um remote<\/em> do git, voc\u00ea tamb\u00e1m pode ter um remote<\/em> do DVC. O Dropbox, um bucket<\/em> do Amazon S3, Google Drive ou at\u00e9 uma pasta no seu computador ou em um disco externo, qualquer uma dessas op\u00e7\u00f5es pode ser um DVC remote.<\/em> Por quest\u00f5es de simplicidade, iremos aqui utilizar o Google Drive.<\/p>\n\n\n\n
O primeiro passo \u00e9 ir ao site do Google Drive, autenticar-se na sua conta, e criar uma pasta. Eu criei uma com o nome dvc-miic-CML<\/span> example<\/em>. A URL na barra de endere\u00e7o do meu navegador ficou assim: https:\/\/drive.google.com\/drive\/u\/1\/folders\/188CmpQIYqKOgvcgaLZOxz1GqlwTasv8c<\/a><\/strong><\/p>\n\n\n\n
O pr\u00f3ximo passo \u00e9 extrair a \u00faltima parte dessa URL, ap\u00f3s o folders\/<\/strong>, ou seja, 188CmpQIYqKOgvcgaLZOxz1GqlwTasv8c<\/strong>. Vamos agora informar o DVC que queremos que essa pasta do Google Drive seja nosso DVC remote.<\/em><\/p>\n\n\n
\n\t\t\t\t
dvc remote add -d myremote gdrive:\/\/188CmpQIYqKOgvcgaLZOxz1GqlwTasv8c<\/pre>\n\t\t\t<\/div>\n\n\n\n
O par\u00e2metro -d<\/strong> \u00e9 importante pois ele diz ao DVC que esse \u00e9 nosso remote <\/em> padr\u00e3o. Assim como \u00e9 poss\u00edvel ter mais de um remote<\/em> no git, tamb\u00e9m \u00e9 poss\u00edvel ter mais de um no DVC. Sem informar qual o remote<\/em> padr\u00e3o, toda vez que d\u00e9ssemos um git push<\/code>, o DVC perguntaria qual o remote desejado. O pr\u00f3ximo passo \u00e9 enviar as atualiza\u00e7\u00f5es do nosso reposit\u00f3rio local para o GitHub, nosso git remote<\/em>, com o git push<\/code>. Consegue adivinhar qual o comando para enviarmos as atualiza\u00e7\u00f5es do reposit\u00f3rio local para o DVC remote<\/em>? Tenho certeza que voc\u00ea adivinhou corretamente!<\/p>\n\n\n
\n\t\t\t\t
dvc push<\/pre>\n\t\t\t<\/div>\n\n\n\n
Para ter certeza que est\u00e1 tudo claro pra voc\u00ea: Os c\u00f3digos fonte e meta dados do DVC ir\u00e3o para o GitHub remote<\/em>. Os dados, pipelines e sa\u00edda de algoritmos ir\u00e3o para o DVC remote<\/em>.<\/p>\n\n\n\n
Se voc\u00ea for conferir a sua pasta no Google Drive agora, voc\u00ea ver\u00e1 que a pasta n\u00e3o est\u00e1 mais vazia. O nome das pastas e seus conte\u00fados l\u00e1 n\u00e3o fazem muito sentido, mas acredite em mim: O DVC sabe como interpretar isso :P. Por for\u00e7a do h\u00e1bito, voc\u00ea digita git status<\/code> e percebe que algo mudou no seu reposit\u00f3rio. Como assim?! Ao adicionar um remote<\/em>, um arquivo de configura\u00e7\u00e3o do DVC foi alterado. Voc\u00ea poderia executar um git add<\/code> para adicionar o arquivo ao \u00edndice e um git commit<\/code> para salvar um novo snapshot<\/em> do seu reposit\u00f3rio, mas por uma quest\u00e3o did\u00e1tica, eu irei fazer algo diferente: Eu irei emendar o \u00faltimo commit<\/em>, e ao fazer isso atualizar a mensagem de commit<\/em>. Amending, ou emendamento, \u00e9 \u00fatil quando voc\u00ea realiza um commit<\/em> e pouco tempo depois percebe que esqueceu de algo, ou decide melhorar a mensagem do seu commit<\/em>. A ideia \u00e9 alterar o seu \u00faltimo commit<\/em>, em vez de fazer um novo.<\/p>\n\n\n
\n\t\t\t\t
git add .\r\ngit commit --amend -m 'Initiates DVC, sets the default remote and asks it to track alarm dataset'<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ok, vamos dar um git push<\/code> agora.<\/p>\n\n\n
\n\t\t\t\t
git push<\/pre>\n\t\t\t<\/div>\n\n\n\n
A p\u00e1gina do GitHub do seu reposit\u00f3rio deve estar parecida com essa aqui<\/a>. Talvez voc\u00ea esteja se perguntando por que existem dois arquivos na sua pasta data\/<\/code> do GitHub se eu te disse que o git n\u00e3o ir\u00e1 versionar datasets<\/em>. Um desses arquivos \u00e9 o .gitignore<\/code>, respons\u00e1vel por informar o git para ignorar arquivos nesse diret\u00f3rio. O arquivo com a extens\u00e3o .dvc<\/code> \u00e9 utilizado pelo DVC e cont\u00e9m uma hash<\/em> constru\u00edda a partir do conte\u00fado do dataset<\/em>. \u00c9 assim que o DVC sabe quando o dataset<\/em> mudou, porque a hash<\/em> ir\u00e1 mudar tamb\u00e9m.<\/p>\n\n\n\n
Nota sobre o DVC<\/h2>\n\n\n\n
Se algu\u00e9m estiver interessado neste reposit\u00f3rio (talvez voc\u00ea esteja), a ideia \u00e9 fazer como faria com qualquer outro reposit\u00f3rio do GitHub. \u00c9 s\u00f3 clon\u00e1-lo!<\/p>\n\n\n
\n\t\t\t\t
git clone https:\/\/github.com\/mribeirodantas\/dvc-miic-CML<\/span>.git\r\ncd dvc-miic-CML<\/span><\/pre>\n\t\t\t<\/div>\n\n\n\n
Ao listar os arquivos dentro do reposit\u00f3rio com o comando ls data<\/code>, voc\u00ea perceber\u00e1 que o dataset<\/em> n\u00e3o est\u00e1 l\u00e1. Bem, claro que ele n\u00e3o est\u00e1, certo? Voc\u00ea apenas clonou o reposit\u00f3rio git, com c\u00f3digo. Vamos executar o comando dvc pull<\/code> para baixar os dados versionados pelo DVC.<\/p>\n\n\n
\n\t\t\t\t
dvc pull<\/pre>\n\t\t\t<\/div>\n\n\n\n
Agora sim \ud83d\ude42 . Hora de come\u00e7ar a escrever nosso script<\/em> de infer\u00eancia de rede. Utilizaremos o MIIC (Multivariate information-based inductive causation) para isso. Crie um arquivo chamado infer_network.R<\/code> com o conte\u00fado abaixo:<\/p>\n\n\n
\n\t\t\t\t
library(miic)\r\nalarm_dataset <- read.table('data\/alarm.tsv', header = TRUE)\r\nres <- miic(input_data = alarm_dataset)\r\ntotal_edges <- nrow(res$all.edges.summary)\r\nretained_edges <- nrow(res$all.edges.summary[res$all.edges.summary$type == 'P', ])\r\nratio_edges <- paste0('Ratio of retained edges: ', retained_edges\/total_edges)\r\nwrite.table(ratio_edges, file = 'metrics.txt', col.names = FALSE, row.names = FALSE)<\/pre>\n\t\t\t<\/div>\n\n\n\n
Esse c\u00f3digo carrega o pacote do R miic<\/code>, l\u00ea o dataset<\/em>, trazendo-o para dentro do ambiente R, chama o algoritmo miic<\/code> para inferir a rede a partir desse dataset<\/em> e calcula a raz\u00e3o de arestas mantidas com rela\u00e7\u00e3o ao total poss\u00edvel. Ap\u00f3s isso, essa raz\u00e3o \u00e9 salva em um arquivo chamado metrics.txt<\/code>.<\/p>\n\n\n\n
GitHub Actions<\/h2>\n\n\n\n
Agora \u00e9 hora de come\u00e7ar a brincar com o GitHub Actions e deixar o CML<\/span> fazer sua m\u00e1gica. Toda vez que fizermos um novo commit<\/em> para esse reposit\u00f3rio e fazemos um push<\/em>, o modelo ser\u00e1 constru\u00eddo novamente e a m\u00e9trica ser\u00e1 recalculada.<\/p>\n\n\n\n
Para utilizar o GitHub Actions, precisamos criar um arquivo especial em uma pasta especial. O caminho dentro de nosso reposit\u00f3rio git \u00e9: .github\/workflows<\/strong><\/p>\n\n\n\n
Dentro da pasta, voc\u00ea precisar criar o arquivo que o GitHub Action ir\u00e1 buscar por instru\u00e7\u00f5es. Voc\u00ea pode escolher qualquer nome, mas precisa estar no formato YAML format<\/a>. Vamos come\u00e7ar criando o caminho para nosso arquivo do GitHub Action.<\/p>\n\n\n
\n\t\t\t\t
mkdir -p .github\/workflows\r\ncd .github\/workflows<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ap\u00f3s isso, criaremos um arquivo chamado CML<\/span>.yaml<\/code> e escreveremos o c\u00f3digo abaixo. Essas instru\u00e7\u00f5es basicamente pedem por uma m\u00e1quina rodando a \u00faltima vers\u00e3o do Ubuntu, com o R devidamente instalado, clona o nosso reposit\u00f3rio git, instala o MIIC, DVC, as suas depend\u00eancias, executa o comando dvc pull<\/code> para baixar nosso dataset<\/em>, e chama o script<\/em> infer_network.R<\/code> que ir\u00e1 inferir a rede e salvar a m\u00e9trica para um arquivo que, no final de tudo, ser\u00e1 impresso na tela.<\/p>\n\n\n
\n\t\t\t\t
name: dvc-CML<\/span>-miic\r\non: [push]\r\njobs:\r\n  run:\r\n    runs-on: [ubuntu-latest]\r\n    steps:\r\n      - uses: r-lib\/actions\/setup-r@master\r\n        with:\r\n          version: '3.6.1'\r\n      - uses: actions\/checkout@v2\r\n      - name: cml_run\r\n        env:\r\n          repo_token: ${{ secrets.GITHUB_TOKEN }}\r\n          GDRIVE_CREDENTIALS_DATA: ${{ secrets.GDRIVE_CREDENTIALS_DATA }}\r\n        run: |\r\n          # Install miic and dependencies\r\n          wget -c https:\/\/github.com\/miicTeam\/miic_R_package\/archive\/v1.4.2.tar.gz\r\n          tar -xvzf v1.4.2.tar.gz\r\n          cd miic_R_package-1.4.2\r\n          R --silent -e "install.packages(c(\\"igraph\\", \\"ppcor\\", \\"scales\\", \\"Rcpp\\"))"\r\n          R CMD INSTALL . --preclean\r\n          cd ..\r\n          # Install Python packages\r\n          pip install --upgrade pip\r\n          pip install wheel\r\n          pip install PyDrive2==1.6.0 --use-feature=2020-resolver\r\n          # Install DVC\r\n          wget -c https:\/\/github.com\/iterative\/dvc\/releases\/download\/1.4.0\/dvc_1.4.0_amd64.deb\r\n          sudo apt install .\/dvc_1.4.0_amd64.deb\r\n          # Run DVC\r\n          dvc pull\r\n          Rscript infer_network.R\r\n          # Write your CML<\/span> report\r\n          echo "MODEL METRICS"\r\n          cat metrics.txt<\/pre>\n\t\t\t<\/div>\n\n\n\n
Em vez de fazer um commit<\/em> com essas novas altera\u00e7\u00f5es na branch<\/em> principal,m a master<\/em>, n\u00f3s iremos criar uma banch<\/em> de experimento. \u00c9 assim que voc\u00ea deve usar o git com o DVC! N\u00f3s iremos analisar a vers\u00e3o raw<\/em>, bruta, do datase<\/em> alarm<\/em>, sem pr\u00e9-processamento, portanto eu irei chamar essa branch<\/em> de  raw_alarm_dataset<\/code>.<\/p>\n\n\n\n
Voc\u00ea j\u00e1 usou o dvc pull<\/code>, portanto sua m\u00e1quina j\u00e1 est\u00e1 autentiada com o Google Drive. Crie um GitHub secret<\/a> com o conte\u00fado do arquivo .dvc\/tmp\/gdrive-user-credentials.json<\/code> e nomeie esse GitHub secret<\/em> como GDRIVE_CREDENTIALS_DATA.<\/p>\n\n\n
\n\t\t\t\t
git checkout -b raw_alarm_dataset\r\n# infer_network.R is not in this folder, therefore `git add .` wouldn't\r\n# add it to the index of your git repository. -A adds everything.\r\ngit add -A\r\ngit commit -m 'Infers alarm network with MIIC and default parameters'\r\ngit push origin raw_alarm_dataset\r\ngh pr create --title 'Network inference of alarm dataset'<\/pre>\n\t\t\t<\/div>\n\n\n\n
Agora, v\u00e1 para o GitHub e veja o que est\u00e1 acontecendo<\/a>. Se tudo ocorrer de acordo com o plano, voc\u00ea ir\u00e1 ver algo parecido com a imagem abaixo quando a checagem estiver conclu\u00edda.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Ok… Voc\u00ea imprimiu sua m\u00e9trica no log<\/em>. Massa mas vamos l\u00e1, seria mais interessante ter algo ao menos um pouquinho mais interessante, n\u00e9? `^^<\/p>\n\n\n\n
Vamos adicionar mais algumas linhas no script<\/em> infer_network.R<\/code> para faz\u00ea-lo plotar a rede inferida para uma imagem, e alterar a parte final para fazer uso de algumas funcionalidades do CML<\/span>. O c\u00f3digo do novo infer_network.R<\/code> deve estar assim:<\/p>\n\n\n
\n\t\t\t\t
library(miic)\r\nalarm_dataset <- read.table('data\/alarm.tsv', header = TRUE)\r\nres <- miic(input_data = alarm_dataset)\r\ntotal_edges <- nrow(res$all.edges.summary)\r\nretained_edges <- nrow(res$all.edges.summary[res$all.edges.summary$type == 'P', ])\r\nratio_edges <- paste0('Ratio of retained edges: ', retained_edges\/total_edges)\r\nwrite.table(ratio_edges, file = 'metrics.txt', col.names = FALSE, row.names = FALSE)\r\n# Plot network\r\npng(file='network_diagram.png')\r\nmiic.plot(res)\r\ndev.off()<\/pre>\n\t\t\t<\/div>\n\n\n\n
E o novo arquivo CML<\/span>.yaml<\/code> deve estar como no c\u00f3digo abaixo. A altera\u00e7\u00e3o \u00e9 que agora iremos instalar o CML<\/span> para poder utiliz\u00e1-lo.<\/p>\n\n\n
\n\t\t\t\t
name: dvc-CML<\/span>-miic\r\non: [push]\r\njobs:\r\n  run:\r\n    runs-on: [ubuntu-latest]\r\n    steps:\r\n      - uses: r-lib\/actions\/setup-r@master\r\n        with:\r\n          version: '3.6.1'\r\n      - uses: actions\/checkout@v2\r\n      - name: cml_run\r\n        env:\r\n          repo_token: ${{ secrets.GITHUB_TOKEN }}\r\n          GDRIVE_CREDENTIALS_DATA: ${{ secrets.GDRIVE_CREDENTIALS_DATA }}\r\n        run: |\r\n\r\n          # Install miic and dependencies\r\n          wget -c https:\/\/github.com\/miicTeam\/miic_R_package\/archive\/v1.4.2.tar.gz\r\n          tar -xvzf v1.4.2.tar.gz\r\n          cd miic_R_package-1.4.2\r\n          R --silent -e "install.packages(c(\\"igraph\\", \\"ppcor\\", \\"scales\\", \\"Rcpp\\"))"\r\n          R CMD INSTALL . --preclean\r\n          cd ..\r\n          # Install Python packages\r\n          pip install --upgrade pip\r\n          pip install wheel\r\n          pip install PyDrive2==1.6.0 --use-feature=2020-resolver\r\n          # Install DVC\r\n          wget -c https:\/\/github.com\/iterative\/dvc\/releases\/download\/1.4.0\/dvc_1.4.0_amd64.deb\r\n          sudo apt install .\/dvc_1.4.0_amd64.deb\r\n          # Run DVC\r\n          dvc pull\r\n          Rscript infer_network.R\r\n\r\n          # Install CML<\/span>\r\n          npm init --yes\r\n          npm i @dvcorg\/CML<\/span>@latest\r\n          # Write your CML<\/span> report\r\n          echo "## Model Metrics" > report.md\r\n          cat metrics.txt >> report.md\r\n          echo "## Data visualization" >> report.md\r\n          npx CML<\/span>-publish network_diagram.png --md >> report.md\r\n          npx CML<\/span>-send-comment report.md<\/pre>\n\t\t\t<\/div>\n\n\n\n
Hora de fazer um commit<\/em>.<\/p>\n\n\n
\n\t\t\t\t
git add .\r\ngit commit -m 'Uses CML<\/span> to improve PR feedback'\r\ngit push origin raw_alarm_dataset<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ok, agora ap\u00f3s as checagens serem realizadas, voc\u00ea deve ver um coment\u00e1rio autom\u00e1tico no seu Pull Request<\/em> com a figura da rede, como abaixo.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Digamos que eu ache que muitas arestas foram removidas e talvez a rede n\u00e3o seja consistente. Irei alterar o c\u00f3digo do script<\/em> infer_network.R<\/code>  para fazer o MIIC buscar por uma rede consistente<\/a>. A terceira linha deve ser agora como abaixo:<\/p>\n\n\n
\n\t\t\t\t
res <- miic(input_data = alarm_dataset, consistent='orientation')<\/pre>\n\t\t\t<\/div>\n\n\n\n
Vamos salvar o estado atual do reposit\u00f3rio local com um commit<\/em>.<\/p>\n\n\n
\n\t\t\t\t
git add .\r\ngit commit -m 'Makes network consistent'\r\ngit push origin raw_alarm_dataset<\/pre>\n\t\t\t<\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Ok, agora est\u00e1 como eu queria e j\u00e1 posso aprovar o pull request<\/em> \ud83d\ude42 . Eu poderia fazer isso clicando no bot\u00e3o verde \u201cMerge pull request\u201d direto no site do GitHub ou eu poderia usar o gh<\/code> novamente.<\/p>\n\n\n
\n\t\t\t\t
gh pr merge 1<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ele ir\u00e1 te fazer duas perguntas. Eu escolhi criar um commit<\/em> de merge<\/em> (mesclagem) e n\u00e3o remover a branch<\/em>, nem localmente nem no GitHub. Para retornar a branch<\/em> principal, a master<\/em>, execute o seguinte comando:<\/p>\n\n\n
\n\t\t\t\t
git checkout master<\/pre>\n\t\t\t<\/div>\n\n\n\n
Usando containers do Docker<\/h2>\n\n\n\n
Voc\u00ea provavelmente reparou que o GitHub Runner demora um certo tempo para fazer as checagens e dependendo de quantos pacotes voc\u00ea quer instalar, essa checagem pode demorar bastante. Um modo de evitar essa demora toda vez que voc\u00ea fizer um push<\/em> \u00e9 utilizar um container<\/em> do Docker que j\u00e1 tem tudo instalado, softwares, pacotes, depend\u00eancias, tudo. O modo como temos feito at\u00e9 agora est\u00e1 pronto para voc\u00ea adicionar o seu container<\/em>, j\u00e1 que eu estou instalando o CML<\/span> manualmente. Se voc\u00ea n\u00e3o quiser usar um container<\/em> pr\u00f3prio, mas n\u00e3o quer ter que baixar e instalar o CML<\/span> em todo push<\/em>, podemos utilizar o container<\/em> oficial do projeto CML<\/span>.<\/p>\n\n\n\n
Se voc\u00ea se lembra bem, h\u00e1 pouco n\u00f3s aceitamos o pull request<\/em>, o que significa que mesclamos aquela branch<\/em> com a principal, a master<\/em>. Embora o remote<\/em> do GitHub esteja atualizado, a nossa c\u00f3pia local n\u00e3o. Vamos atualiz\u00e1-la com um git pull<\/code>, e ap\u00f3s isso criar uma nova branch<\/em>.<\/p>\n\n\n
\n\t\t\t\t
git pull\r\ngit checkout -b CML<\/span>_container<\/pre>\n\t\t\t<\/div>\n\n\n\n
Altere o arquivo CML<\/span>.yaml<\/code> para ficar como no c\u00f3digo abaixo.<\/p>\n\n\n\n
scripts<\/p>\n\n\n\n
Vamos adicionar esse arquivo ao \u00edndice do git, realizar um commit<\/em>, push<\/em> e criar um Pull Request<\/em> (PR).<\/p>\n\n\n
\n\t\t\t\t
git add .\r\ngit commit -m 'Makes use of CML<\/span> container'\r\ngit push origin CML<\/span>_container\r\ngh pr create --title 'Use CML<\/span> container'<\/pre>\n\t\t\t<\/div>\n\n\n\n
Ap\u00f3s isso, tudo deve correr tranquilamente, como aconteceu aqui<\/a>. Voc\u00ea pode mesclar o pull request<\/em> e executar um git pull<\/code> novamente para atualizar seu reposit\u00f3rio local.<\/p>\n\n\n
\n\t\t\t\t
gh pr merge 2\r\ngit pull<\/pre>\n\t\t\t<\/div>\n\n\n\n
O que mais?<\/h2>\n\n\n\n
O DVC n\u00e3o se limita a versionar datasets<\/em>. N\u00f3s tamb\u00e9m poder\u00edamos criar pipelines<\/em> (sequ\u00eancias de opera\u00e7\u00f5es, do download<\/em> de nossos dados, passando por pr\u00e9-processamento, infer\u00eancia, p\u00f3s-processamento, gera\u00e7\u00e3o de relat\u00f3rios, etc) e version\u00e1-los, assim como os arquivos de sa\u00edde desses scripts<\/em> como as imagens que o script<\/em> infer_network.R<\/code> gerou. Poder\u00edamos ter v\u00e1rios scripts<\/em> para etapas anterior e posterior a de infer\u00eancia e tudo pode ser orquestrado pelo DVC atrav\u00e9s de um simples comando: dvc repro<\/code>. Etapas que n\u00e3o precisam ser executadas (apenas datasets<\/em> que s\u00e3o utilizados em uma etapa maios tardia foram modificados) n\u00e3o s\u00e3o executados. Em vez de ter v\u00e1rios scripts<\/em> sendo chamados no seu GitHub Action file, teria apenas um dvc repro<\/code>.<\/p>\n\n\n\n
Al\u00e9m disso, poder\u00edamos ter um container<\/em> do Docker com tudo que n\u00e3o muda entre os commits<\/em> j\u00e1 instalado. R, DVC, CML<\/span>, MIIC, depend\u00eancias do MIIC, entre outras coisas. Isso definitivamente nos pouparia de uma espera nada prazerosa, dependendo do que voc\u00ea for fazer. No nosso caso aqui, baixar, compilar e instalar o MIIC leva alguns minutos que poderiam ser poupados. Para o nosso simples exemplos, acho que n\u00e3o \u00e9 o fim do mundo esperar alguns poucos minutos, mas se come\u00e7ar a ficar mais complexo, e com datasets <\/em>maiores, o tempo pode simplesmente se tornar invi\u00e1vel, o que tornaria indispens\u00e1vel criar o seu container<\/em> do Docker (Parte II dessa s\u00e9rie<\/a>) e utilizar sua pr\u00f3pria infraestrutura computacional sincronizada com o GItHub Actions (Parte III).<\/p>\n\n\n\n
Por hoje \u00e9 s\u00f3 pessoal! \ud83d\ude09<\/p>\n\n\n\n
Voc\u00ea provavelmente n\u00e3o estaria lendo esse texto se n\u00e3o fosse pela Elle O’Brien<\/a>, que me mostrou tantas coisas sobre o CML<\/span>, apresenta\u00e7\u00f5es e exemplos, e o David Ortega<\/a> que me ajudou a preparar o ambiente R dentro do container docker oficial do projeto CML<\/span>.<\/p>\n