https://miro.medium.com/max/1400/1*w0-0TorO1hvYjX-2TYak2A.png

Cada dia mais as pessoas se encontram nas redes sociais, compartilhando momentos, pratos e filtros engraçados. Recentemente uma onda de compartilhamentos das edições com o aplicativo FaceApp circularam nos feeds de postagens e motivaram o primeiro artigo da Série #BrincandoComVisãoComputacional: “Misturando Faces”.

Utilizando Python, OpenCV, dlib e NumPy, além de alguns conhecimentos matemáticos, é possível “brincar” com as transformações em imagens, gerando resultados como o da imagem acima.

Além do exemplo acima, contei também com uma brincadeira com as fotos minha e de minha namorada, onde repetimos o processo e tivemos esse resultado:

<img alt="" class="t u v ik aj" src="https://miro.medium.com/max/700/1*xj0SD6WsoFE-YUBSmLZctA.png"/>

Lennon & Diana

<img alt="" class="t u v ik aj" src="https://miro.medium.com/max/700/1*U-lggsZph3uc7jr8N4KI_w.png"/>

Lennon Diana & Diana Lennon

Com alguns ajustes é possível melhorar o encaixe entre as faces, porém já é possível entender o seu funcionamento e fazer algumas misturar diretamente pelo Python.

O repositório completo da #SérieBVC você pode encontrar em:

[lennonalvesdias/brincando-com-visao-computacional](https://github.com/lennonalvesdias/brincando-com-visao-computacional)

SérieBVC - Misturando Faces

Blog

Ciencia da Computação (UTFPR/PG - 2015). Inteligência Artifical e Aprendizado de Máquina (FIAP/SP - 2020).

Olá, eu sou o Lennon.

Profissional apaixonado por tecnologia e movido pelo propósito de impactar a vida das pessoas, criando ferramentas para que elas possam fazer melhor as suas atividades. Em minha experiência profissional descobri que mudanças acontecem e que tecnologias evoluem, com isso me tornei um profissional resiliente e flexível. Com essas mudanças é necessário o aprendizado e, para isso, conto com o autodidatismo e a organização. Passar por mudanças sempre é difícil, porém sozinho se torna ainda mais, por isso sempre prezo pela colaboração e o trabalho em equipe, afinal, "juntos somos mais fortes". Me formei em Ciência da Computação pela Universidade Tecnológica Federal do Paraná (UTFPR - 2015) e me especializei em Inteligência Artificial e Aprendizado de Máquina (Machine Learning) pela FIAP (2020), além de estar sempre me atualizando com cursos, palestras e artigos. Que tal aquela partidinha de FIFA? 🎮 Ou um joguinho de truco? 🃏 Vamos conversar! 💬

Sobre

Últimas postagens

Home

Análise (Classificador) de sentimentos com Python + Pandas + scikit-learn + spaCy

https://miro.medium.com/max/1400/1*oIxy3zkD2mNkbec27wRgpw.jpeg


Abordagem dos principais classificadores para solucionar o problema de análise de sentimentos utilizando [python](https://www.python.org/) com [pandas](https://pandas.pydata.org/), [numpy](https://numpy.org/), [scikit-learn](https://scikit-learn.org/stable/), [nltk](https://www.nltk.org/), e [spaCy](https://spacy.io/).

Para este artigo será utilizada a base de _reviews_ (análises) de filmes do [IMDb](https://www.imdb.com/).

> IMDb, também conhecido como Internet Movie Database, é uma base de dados online de informação sobre música, cinema, filmes, programas e comerciais para televisão e jogos de computador, hoje pertencente à Amazon. [\[Wikipedia\]](https://pt.wikipedia.org/wiki/IMDb)

## 🔎 Técnicas de pré processamento utilizadas:

-   Tratamento de valores nulos
-   _Upcase_/_Downcase (str.lower)_
-   Sinais de pontuação _(unidecode)_
-   Lematização\*

> \* Processo de **deflexionar** (provocar mudança ou alteração no posicionamento normal uma palavra) para determinar o seu **lema**. (Exemplo: palavras = tiver, tenho, tinha, tem; lema = ter)

## 🚀 Técnicas de classificação utilizadas:

-   Decision Tree
-   Random Forest
-   Multinomial Naive Bayes
-   Gradient Boosting
-   Support Vector Machine (SVM)
-   Multinomial Logistic Regression

# Considerações finais

A classificação utilizando regressão logística teve a melhor acurácia, chegando à 0.89506. Além da acurácia, destaca-se também o fato deste método possuir um tempo de processamento _(minutos)_ muito menor do que outros utilizados nesta comparação, como o SVM _(dias)_.

Para obter as melhores configurações ao `LogisticRegression` nós utilizamos o `GridSearchCV`. Essa função consiste em testar variadas combinações de parâmetros ao modelo, encontrando assim o melhor resultado.

> É possível que este arquivo evolua em técnicas de pré processamento e modelos de classificação.

# 👊 Agradecimentos

-   [Cintia Akie Nakano](https://www.linkedin.com/in/cintia-akie/)
-   [Mateus Aguiar Florentino](https://www.linkedin.com/in/mateus-florentino-53993513b/)
-   [Rafael Souza](https://www.linkedin.com/in/rafael-souza-6901aa15/)


Criando componentes customizados (Custom Activity) no Marketing Cloud

https://miro.medium.com/max/700/1*eG0HBdKYFmygQfZ7jxJszg.png

Com os componente customizados você pode integrar todo tipo de serviço nas jornadas do cliente.

# ☁ Salesforce Marketing Cloud

Junte-se aos seus clientes em uma jornada personalizada com sua marca. Com o Salesforce Marketing Cloud é possível personalizar experiências por e-mail, dispositivos móveis, redes sociais, publicidade e Web. Crie uma experiência unificada, conectando toda a sua empresa em todos os departamentos e disciplinas. [Clique aqui](https://www.salesforce.com/br/products/marketing-cloud/why-salesforce/#) e saiba o por que Salesforce Marketing Cloud.

## 🚀 O que vamos utilizar?

- [Salesforce Marketing Cloud](https://www.salesforce.com/products/marketing-cloud/overview/)
- [Heroku](https://www.heroku.com/)
- [NodeJS](https://nodejs.org/en/)

Para este artigo será demonstrada a criação de um componente customizado à ser embutido dentro de uma jornada. A configuração e execução desta jornada pode envolver particularidades e dados sensíveis, que podem ser tratados em um futuro artigo.

# 👨‍💻 Mão na massa!

Para este artigo, utilizaremos um template adaptado à partir do template da [Devs United](https://github.com/devsutd).

[## lennonalvesdias/journey-builder-custom-activity](https://github.com/lennonalvesdias/journey-builder-custom-activity)

Para que possamos realizar o deploy automático de acordo com o versionamento das nossas atualizações, é importante [fazer um _fork_](https://help.github.com/en/github/getting-started-with-github/fork-a-repo) do repositório acima.

## 📌 Configurando o web service

Após o _fork_, vamos criar uma nova aplicação no Heroku. Caso você ainda não tenha conta, é possível [criar uma de forma gratuita](https://signup.heroku.com/), caso contráro, basta realizarmos o [_login_](https://id.heroku.com/login) ao _dashboard_ da plataforma.

No [dashboard da plataforma](https://dashboard.heroku.com/apps), navegaremos em `New > Create new app`, nomearemos a nova aplicação e finalizaremos clicando em `Create app`.

<img alt="" src="https://miro.medium.com/max/700/1*SRoCMebroxY2ki1yKs_5nQ.png"/>

Print da criação de uma nova aplicação (parte 1).

<img alt="" src="hhttps://miro.medium.com/max/545/1*_xR-iMlkui8dCsL8C3pqNQ.png"/>

Criação de uma nova aplicação.

Com a aplicação criada, podemos escolher o método de _deploy_ que utilizaremos na aplicação. Para este artigo, utilizarei o GitHub, porém você pode escolher o seu preferido.

Ao selecionar o método de _deploy_, será necessário realizar a conexão com a minha conta e então procurar pelo repositório que eu queria conectar. Para este exemplo, escolhi conectar com o `journey-builder-custom-activity`, que refere-se ao link encontrado logo no começo desta sessão.

<img alt="" src="https://miro.medium.com/max/700/1*zLf098OcTE4vC0qjCzbz5g.png"/>

Configuração do deploy.

Com o repositório configurado, é possível realizar algumas outras configurações alternativas, como habilitar o _deploy_ automático, para que o conteúdo do servidor seja atualizado assim que for realizado uma atualização ([git _push_](https://git-scm.com/docs/git-push)) no controlador de versão. Caso prefira manter as atualizações automáticas desligadas, é possível utilizar o botão `Deploy Branch` para realizar a modificação de forma manual.

> Além da opção de deploy automático, é possível também configurar a branch que irá ser publicada (`Choose a branch to deploy`).

Com as configurações ajustadas, e realiado o seu concluído o seu primeiro deploy, é possível clicar no botão `Open App` para visualizar a sua aplicação no endereço provisinado pelo Heroku.

<img alt="" src="https://miro.medium.com/max/700/1*Uiy65R-TpJ47XEX9kiKacA.png"/>

Botão disponível para navegar ao endereço da aplicação.

## 📌 Configurando o Marketing Cloud

Com o _Heroku_ configurado, o próximo passo é criar um novo _package_ no ambiente do _Marketing Cloud_. Para isso, é necessário navegar em `Perfil > Setup` no menu superior direito e, após isso, em `Apps > Installed Packages` no menu à esquerda.

<img alt="" src="https://miro.medium.com/max/438/1*ahDbkA8GvmqT57Da2GJERg.png"/>

Configurações de Setup.

<img alt="" src="https://miro.medium.com/max/197/1*SFQTO3Zi-Rw-Objb5FGG-w.png"/>

Navegação de pacotes instalados.

Estará visível a lista com o nome de todos os pacotes criados, assim como sua descrição e a data de instalação. Nesse passo, criaremos um novo pacote clicando no botão `New`.

<img alt="" src="https://miro.medium.com/max/700/1*WuRMZ8WXIUuTq-9dwPfEXw.png"/>

Criação de um novo pacote.

Será então solicitado o nome e a descrição do novo pacote, após o preenchimento basta clicar no botão `Save` e ele estará criado.

A tela com as configurações do pacote estará disponível com o _status_, a _conta de serviço_, o _id do pacote_ e a _chave jwt_. É recomendado **salvar a _chave jwt_** em um outro arquivo, essa chave será utilizada na configuração do ambiente.

<img alt="" src="https://miro.medium.com/max/700/1*BuSI7V3UlKbrwa6LeqPgHA.png"/>

Painel de configurações do novo pacote.

O próximo passo é clicar no botão `Add Component` e iniciar a configuração do `Journey Builder Activity`.

<img alt="" src="https://miro.medium.com/max/509/1*NnuFAvvUgRBFTrZE3TytIA.png"/>

Criação de um componente (parte 1).

<img alt="" src="https://miro.medium.com/max/509/1*6D6tjQBRhhBIK_JdgryxWw.png"/>

Criação de um componente (parte 2).

Após a criação do componente, será exibida novamente a tela do painel com as informações do nova criação. Nesse painel estará visível a _Unique Key_, recomenda-se também **salvar esta chave**.

Com isso, a finalização do novo pacote dentro do _Marketing Cloud_ está finalizada. O próximo passo é configurar a _activity_, onde utilizaremos esta última chave salva.

## 📌 Configurando a Activity

Para a configuração da _activity_, é necessário alterar no `/public/config.json`a _applicationExtensionKey_ com o valor da _Unique Key_ salva, além de atualizar com o _url_ com o _endpoint_ da aplicação criada no _Heroku_.

[Modelo do arquivo .config](https://gist.github.com/lennonalvesdias/a17cf4512a9f80e4ae8bef1502cfda65#file-config-json)

Com essas alterações e eventuais personalizações do componente, é possível realizar o _deploy_ para que as configurações sejam aplicadas em produção. Este _deploy_ pode variar de acordo com as configurações demonstradas acima.

## 📌 Configurando o ambiente no Heroku

Para os ajustes finais, precisamos inserir a chave _jwt_ nas variáveis de ambiente da nossa aplicação no _Heroku_. As configurações destas variáveis são encontradas em `Settings`, no menu superior da aplicação.

```
[https://dashboard.heroku.com/apps/\[ID\_DA\_SUA\_APLICAÇÃO\]/settings](https://dashboard.heroku.com/apps/nova-atividade-customizada/settings)
```

O passo de inserir, deletar ou modificar uma variável de ambiente é à partir do botão `Reveal Config Vars`, onde serão listadas as variáveis cadastradas e exibidas as opções de manipulação entre elas.

<img alt="" src="https://miro.medium.com/max/700/1*ez6H9dFCwD4QlfiHjqTfVQ.png"/>

Configuração das variáveis de ambiente (passo 01).

<img alt="" src="https://miro.medium.com/max/700/1*pZqAXP-KkdcXUjnE5pptbg.png"/>

Configuração das variáveis de ambiente (passo 02).

Após inserir o código _jwt_ com a chave _jwtSecret_, é necessário clicar no botão `Add` para confirmar a inclusão da nova variável. Com a configuração aplicada, já será possível testar seu novo componente em uma jornada do _Marketing Cloud_.

## 📌 Executando a jornada

As jornadas podem ser acessadas pelo menu _Journey Builder_, onde existe o submenu _Automation Studio_(rotina de automação para execução da jornada) e _Journey Builder_ (configuração da jornada).

<img alt="" src="https://miro.medium.com/max/700/1*JzTwTuN61hOddoe86Bstbw.png"/>

Menu principal do Salesforce Marketing Cloud.

Ao acessar o _Journey Builder_, será possível configurar a sua jornada ou então criar uma nova. No exemplo abaixo é possível encontrar o novo componente, nomeado de ‘_Atividade Customizada_’, nas opções à esquerda. Ao clicar e arrastar, o componente fará parte da jornada desenhada.

<img alt="" src="https://miro.medium.com/max/700/1*tpKzmYKtvgie--fHKH18rQ.png"/>

Configuração da jornada incluindo componente customizado.

Após concluir o mapeamento da jornada, é possível salvar, validar e ativar. Assim que ativa, a jornada está pronta para ser executada de acordo com o [_schedule_](https://pt.wikipedia.org/wiki/Escalonamento_de_processos) configurado.

É possível encontrar um exemplo prático de uma atividade que realiza o disparo de templates _HSM_ do _Whatsapp_ acessando o repositório:

[## lennonalvesdias/journey-builder-custom-activity](https://github.com/lennonalvesdias/journey-builder-custom-activity/tree/whatsapp-hsm)

# 📃 Referências

- [Salesforce](https://developer.salesforce.com/docs/atlas.en-us.noversion.mc-apis.meta/mc-apis/getting-started-spec.htm?search_text=custom%20activity)

# 🤔 O que é o VJSCLI ?

O Vanilla JavaScript CLI é um projeto que tem como intuito disponibilizar uma CLI para projetos em ES6 utilizando WebPack e Babel. Foi utilizado sass no projeto, para testes unitários Jasmine + Karma. Para a documentação foi utilizado o docjs com template do docdash.

# 👨‍🏫 Introdução ao VJSCLI

O primeiro passo para a utilização do pacote é realizar a instalação através do gerenciador de pacotes [NPM](https://www.npmjs.com/package/vjscli), utilizando o comando abaixo

```
npm install -g vjscli
```

Para validar se a instalação ocorreu corretamente, basta utilizar um dos comandos abaixo

```
vjs -V
vjs --version
```

Uma imagem como essa deve aparecer após a execução

<img alt="" class="" src="https://miro.medium.com/max/700/1*ZVy-3XjWyLCSOWA_l-iZkg.png">

Versão do VJSCLI instalado na máquina

É possível também consultar o helper do pacote, onde você pode encontrar os comandos necessários para criação de um novo projeto ou um novo componente:

```
vjs -h
vjs --helper
```

<img alt="" class="" src="https://miro.medium.com/max/700/1*VVfWbXQRfO7jF1T4lsuhCw.png">

Helper do VJSCLI com a lista de funcionalidades e seus comandos

# 👨‍💻 Show Me the Command!

Com os comandos para visualizar a versão e identificar se estamos com a instalação do pacote atualizada e para visualizar as funcionalidades disponíveis no pacote, podemos iniciar a criação de um novo projeto

```
vjs -n projetovjs -a "Lennon Dias" -d "Projeto Exemplo VJS"
```

Em alguns instantes o projeto estará criado à partir da pasta onde você executou o comando acima:

<img alt="" class="" src="https://miro.medium.com/max/700/1*0rBDZLe8CwY3b_mG_ThJHQ.gif">

Criação de um novo projeto utilizando VJSCLI

<img alt="" class="" src="https://miro.medium.com/max/229/1*bZVSqf6E6s-Y1-TvYJfWKA.png">

Estrutura de pastas e arquivos gerada pelo VJSCLI

É possível também, gerar novos componentes dentro do projeto criado:

```
vjs -g login
```

<img alt="" class="" src="https://miro.medium.com/max/700/1*jroXxtngYAjPoLfyJE0xQQ.png">

<img alt="" class="" src="https://miro.medium.com/max/221/1*mINPy9VU7cW2ny1x0RHOSw.png">

Estrutura de pastas da criação do componente

# 🚀 Executando o projeto

Após gerar o projeto e os componentes conforme sua necessidade, você pode executar utilizando o comando:

```
npm run local
```

Após a execução, seu projeto estará disponível acessando o endereço [http://localhost:8080/](http://localhost:8080/)

<img alt="" class="" src="https://miro.medium.com/max/700/1*MJzuq4vQFTGKWqHtxgHE8A.png">

Visualização da tela default do projeto

Outros comandos úteis para o seu novo projeto são: o **_build_** (valida o seu projeto e gera os arquivos finais para utilização em ambiente de produção) e o **_docs_** (gera documentação do seu desenvolvimento).

```
npm run build
npm run docs
```

# 📝 Últimas considerações

O projeto foi disponibilizado dia 01/11/2019 e conta com seus mantenedores e a ajuda da comunidade para novas atualizações.

Para contribuir ou entender melhor sobre o VJSCLI você pode acessar a página oficial do projeto no GitHub através do link: [https://bit.ly/34Dv1zr](https://bit.ly/34Dv1zr) e a página NPM do projeto através do link: [https://bit.ly/2Nqomml](https://bit.ly/2Nqomml).

Criando um projeto VanillaJS com VJSCLI

Decisão de crédito utilizando machine learning e visão computacional

https://miro.medium.com/max/1400/1*6eUtcNtT4fJUrlmlcUlN0w.png


Neste projeto abordamos a utilização de APIs e bibliotecas de visão computacional e aprendizado de máquina para criação de um motor de decisão de crédito. As tecnologias que foram utilizadas neste projeto são: [_Python_](https://www.python.org/), [_Jupyter_](https://jupyter.org/), [_IBM Watson_](https://www.ibm.com/watson), [_Microsoft Azure Computer Vision_](https://azure.microsoft.com/en-us/services/cognitive-services/computer-vision/), [_Docker_](https://www.docker.com/) e [_GitHub Actions_](https://github.com/features/actions).

# ⚙ Setup

A instalação dos requisitos do projeto podem ser feitas utilizando o comando `python -m pip install -r requirements.txt`. Caso deseje, dentro da pasta `env`você pode acessar o [_environment (venv)_ virtual](https://docs.python.org/3/library/venv.html) com o comando `source ./env/Scripts/activate`.

Caso encontre algum problema com a instalação da biblioteca [dlib](http://dlib.net/), é possível realizar a instalação através do seguinte comando:

```
python -m pip install https://files.pythonhosted.org/packages/0e/ce/f8a3cff33ac03a8219768f0694c5d703c8e037e6aba2e865f9bae22ed63c/dlib-19.8.1-cp36-cp36m-win\_amd64.whl#sha256=794994fa2c54e7776659fddb148363a5556468a6d5d46be8dad311722d54bfcf
```

# 🧐 Visão Geral

Para a demonstração e visão geral do projeto, foi criado um vídeo apresentando o repositório e a execução do motor principal de decisão de crédito:

# 🧠 Modelo

O arquivo `[training.py](https://github.com/lennonalvesdias/credit-decisor/blob/master/model/training.py)`é responsável por criar e treinar os classificadores e regressores utilizados para os modelos 01 e 02. Nele são definidas as variáveis utilizadas para cada modelo, assim como é apresentada a acurácia atingida.

```
Modelo 01 (classificador), criado com acurácia de: \[0.99994\]
Modelo 02 (Regressor), criado com acurácia de: \[0.9378733530692113\]
```

# 🌎 API

Utilizando Flask, foi criado o arquivo `[server.py](https://github.com/lennonalvesdias/credit-decisor/blob/master/api/server.py)`para expor os _endpoints_ de predição dos modelos. Dessa forma é possível que o serviço seja utilizado em clientes web, aplicações console, …, ou até mesmo um Jupyter Notebook (como faremos neste projeto), com uma simples requisição [REST](https://pt.wikipedia.org/wiki/REST).

Exemplo de requisição utilizando [cURL](https://curl.haxx.se/):

```
curl --location --request POST '[https://creditdecisor.lennon.cloud/modelo01'](https://creditdecisor.lennon.cloud/modelo01') \\
\--header 'Content-Type: application/json' \\
\--data-raw '{
    "nome": {
        "1": "Lennon Alves Dias"
    },
    "renda": {
        "1": 1000
    },
    "idade": {
        "1": 25
    },
    "etnia": {
        "1": 0
    },
    "sexo": {
        "1": 0
    },
    "casapropria": {
        "1": 0
    },
    "outrasrendas": {
        "1": 0
    },
    "estadocivil": {
        "1": 0
    },
    "escolaridade": {
        "1": 2
    }
}'
```

# ⚖ Decisão de Crédito

O arquivo principal do projeto é o `[decisor.ipynb](https://github.com/lennonalvesdias/credit-decisor/blob/master/client/decisor.ipynb)`. Nele além de algumas funções utilitárias e definições de variáveis, são construídas as funções:

-   `validate_person`: Utiliza a API de classificação `default`de imagem da IBM, procura-se a identificação da classe `person`no retorno da chamada.
-   `validate_explicit`: Utiliza a API de classificação `explicit`de imagem da IBM, procura-se a identificação da classe `explicit`no retorno da chamada.
-   `facial_recognition`: Utiliza a API de reconhecimento facial da Azure, procura-se por faces na foto e, para cada face encontrada, é desenhado um retângulo em sua volta, assim como marcado os pontos fiduciais da foto.

> Por definição, um ponto fiducial facial (PFF) — em inglês, facial landmark, ou simplesmente landmark — é aquele localizado em uma posição específica da face humana que garanta sua existência na maioria das observações. Esses pontos normalmente marcam características salientes como: cantos e centros dos olhos, bordas da boca, centro do nariz e sobrancelhas, não se limitando a estes.
>
> KATSIKITIS, M. The human face: measurement and meaning. Kluwer Academic Publishers, 2003

-   `predict_model`: Utiliza a bilioteca `requests`para realizar a requisição que retorna a predição dos modelos.
-   `identify_face`: Utiliza a biblioteca `opencv`e o classificador `haarcascade`para reconhecimento e marcação de uma face.
-   `get_fiducial_points`e `identify_fiducial_points` : Utiliza a biblioteca `dlib`e o modelo `shape_predictor_68` para identificação e marcação dos pontos fiduciais faciais.

O último bloco do arquivo é responsável pela decisão lógica do empréstimo, baseado nas seguintes regras:

-   Validar se a imagem possui uma pessoa (se não, negar).
-   Validar se a imagem possui conteúdo explícito (se sim, negar).
-   Validar a idade da pessoa (se a imagem diferir em 5 anos da cadastrada, negar).
-   Validar o gênero da pessoa (se não for o mesmo do cadastro, negar).
-   Score de predição 01 igual à 0.
-   Score de predição 02 menor ou igual à 0.7.

# 🚀 Deploy

Foi construída uma esteira automatizada utilizando o GitHub Actions, com pouco esforço temos nossa API e/ou nosso modelo atualizado no servidor pronto para ser utilizado.

![](https://miro.medium.com/max/2000/1*sHn1A7InUwLvPTDB__kdOg.png)

Para essa esteira, temos os seguintes passos:

-   Setups do workflow.
-   Setup do Python.
-   Instalação dos requisitos necessários para execução dos scripts.
-   Execução do script de criação e treinamento do modelo.
-   Login do [Docker Registry](https://docs.docker.com/registry/) privado utilizando [secrets](https://help.github.com/en/actions/configuring-and-managing-workflows/creating-and-storing-encrypted-secrets).
-   Build do Dockerfile da API no ambiente do GitHub e criação e tagueamento da imagem para o servidor.
-   Deploy da aplicação atualizando o container no servidor.


https://miro.medium.com/max/1400/1*LYcQBFLsdXbaHc4N_k-g3w.png

A teoria dos grafos\* é um assunto antigo, porém com várias aplicações em nosso dia-a-dia. Foi introduzida no século XVIII pelo matemático suiço Leonhard Euler, que utilizou grafos para resolver o problema que conhecemos como [**As sete pontes de Königsberg**](https://pt.wikipedia.org/wiki/Sete_pontes_de_K%C3%B6nigsberg).

> \* Ramo da matemática que estuda as relações entre os objetos de um determinado conjunto.

# 🤔 Afinal, o que são grafos?

É uma estrutura composta por um conjunto (não vazio) de pontos **(vértices)** e um conjunto de linhas que ligam esses pontos **(arestas)**.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/664/1*mdRR7l3MtuFUiR4Ak5NUJQ.png"/>

Grafo com 3 vértices {0, 1, 2} e 3 arestas {a, b, c}

> Definição formal: Um grafo **G = (V(G), E(G))** é uma estrutura matemática composta por dois conjuntos: 
> **V(G)**, um conjunto de elementos que são chamados de **vértices**, 
> **E(G)**, um conjunto de pares de elementos de V(G), cada par é chamado de **aresta**

Está na hora de descomplicar! Mas não, sem antes, algumas definições sobre grafos:

- Dois vértices ligados por uma aresta dizem-se **adjacentes**.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/668/1*2uBt1vSzJrien90dvjB4tg.png"/>

Os vértices 0 e 1 são adjacentes

- Uma aresta que ligue dois vértices diz-se **incidente** de cada um dos vértices.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/664/1*SO1tKJ32rAf3G0VRZRiDFg.png"/>

A aresta ‘a’ é incidente de 0 e 1

- O número de arestas incidentes num vértice diz-se o **grau** **desse vértice**. O **grau máximo** do grafo é o maior dos graus dos vértices (∆(G)), consequentemente o **grau mínimo** (δ(G)) é o menor dos graus dos vértices.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/664/1*VZA-0GJv8n7JgKMkUzH7Nw.png"/>

O vértice 0 tem duas arestas incidentes, portanto grau 2. Os vértices 1 e 2 tem uma aresta incidente, sendo assim, ambos são grau 1. Dessa forma, o grau máximo do grafo é 2 e o grau mínimo é 1

- O subconjunto de arestas e vértices a elas associados diz-se **sub-grafo** do grafo original.

<img alt="" class="t u v jf aj" src="hhttps://miro.medium.com/max/664/1*y96hrBuvfYrn5Zjzpk42gw.png"/>

O conjunto V(G) = {0, 1} E(G) = {a} encontrado em G2 é subconjunto de V(G) = {0, 1, 2} E(G) = {a, b} encontrado em G1, portanto, pode-se dizer que G2 é subgrafo de G1

- Uma sequência de vértices na qual os vértices sucessivos estão ligados por arestas do grafo diz-se um **caminho**.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/664/1*Tocc_Nh0f_S2dIvhdrv2zA.png"/>

Os vértices 0–2–3–4 representados (figura à direita) formam um caminho encontrado no grafo G (à esquerda)

Além das definições acima, outros conceitos de grafos são de que: O conjunto dos vértices pode ser infinito, onde nesse caso, chama-se de **grafo infinito**. Quando existe mais de uma aresta entre o mesmo par de vértices, temos **arestas múltiplas** e, quando temos uma aresta definida por um par de vértices não distintos (ou seja, uma aresta que conecta no mesmo nó), diz-se um **laço**.

Existem também os grafos que possuem orientação nas arestas, conhecidos como **grafo orientado** ou **digrafo** ou **grafo direcionado**.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/640/1*S4b80YZAQ71d6YwDSw1zgg.png"/>

Grafo com orientação nas arestas. G = (V(G),E(G)), V(G) = {0, 1, 2, 3, 4}, E(G) = {(0, 1), (1, 3), (2, 0), (2, 3), (3, 0), (3, 4), (4, 0)}

Para grafos orientados, o grau de entrada de um vértice é o número de arestas que chegam nele e denota-se por `d-(v)`. O grau de saída é o número de arestas que partem do vértice em direção à outros, onde a denotação é `d+(v)`.

Quando o grau de entrada é igual a zero, o vértice é chamado de **fonte** e, quando o grau de saída é igual a zero é chamado de **semidouro** ou **sorvedouro**.

Ao remover a orientação das arestas de um grafo, resulta-se um **grafo subjacente**.

Além da orientação, é possível atribuir custo para o vértice, para a aresta ou para ambos. O grafo que recebe esses valores são os **grafos ponderados**.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/640/1*abvGQ8mJhDONj_vocIaVfg.png"/>

Grafo com custo em suas arestas

Para representação de grafos, as formas mais comuns são: **matriz de adjacências** (M|V (G)|×|V (G)|), onde `**m**_ij_ = 1` se existe aresta entre `**v**_i_**v**_j_` e caso contrário, e a **matriz de incidência** ( M|V (G)|×|E(G)|), onde `**m**_ij_ = 1` se `**v**_i_` é um dos vértices da aresta `**e**_j_`.

<img alt="" class="t u v jf aj" src="https://miro.medium.com/max/700/1*A1ANUxSJ1p8FWREFB1qmkg.png"/>

Grafo com matriz de adjacências e matriz de incidência

Os conceitos apresentados são as definições **básicas** de grafos, onde introduzimos a teoria afim de explicar alguns problemas que podemos modelar utilizando esta técnica. À partir deste momento, convido à explorar a vasta literatura com conceitos e definições adicionais.

# 🤸‍♂ Bora descomplicar? ✍ Deixa que eu desenho!

Grafos possui uma representação gráfica de fácil entendimento, podendo traduzir problemas mais complexos em visualizações triviais. Para exemplicar os conceitos apresentados neste artigo, utilizaremos exemplos que podem ser enxergados em nosso dia-a-dia.

# 👩‍🏫Exemplos de grafos

**_(objeto = nós, relacionamento = arestas)_**

- **Transporte aéreo** (_Objeto_: cidades, _Relacionamento_: vôo comercial entre duas cidades)
- **Atores e filmes** (_Objeto_: atores, _Relacionamento_: atores atuaram em um mesmo filme)
- **Web** (_Objeto_: páginas da web, _Relacionamento_: link de uma página para outra)
- **Grade escolar** (_Objeto_: professores e disciplinas, _Relacionamento_: disciplina lecionada pelo professor)
- **Pares em um relacionamento** (_Objeto_: rapazes e moças, _Relacionamento_: interesse mútuo em sair)
- **Robustez da malha elétrica** (_Objeto_: torres de transmissão, _Relacionamento_: linhas entre torres)

# 👥 Rede de Relacionamentos

Uma empresa decide realizar um evento com objetivo de apresentar e vender o seu novo portfólio, com diversas palestras, mesas redondas e stands com as maiores referências de especialistas no mercado. Além disso, o evento também busca conectar pessoas dessa área, visto que existem ramificações bem específicas tais como: exatas, biológicas e humanas.

Cada pessoa preenche seu nome, data de nascimento, email, cidade, estado e cargo que ocupa no momento. As empresas são registradas com nome, cidade, estado e área de atuação. As universidades possuem o registro do nome, estado e cidade.

![](https://miro.medium.com/max/2244/1*iTPtw2Kmev1IrRoAPlkOnA.png)Representação com participantes (laranja), universidades (vermelho) e empresas (azul)

Rita atua na área de humanas, porém, possui bastante curiosidade em exatas e ficou sabendo que Fabiana é uma grande especialista na área. Com esse interesse, Rita quer saber como ela poderia ser apresentada à Fabiana para poderem bater um papo.

**Problema:** Qual é o menor caminho entre Rita e Fabiana?

![](https://miro.medium.com/max/1400/1*LYcQBFLsdXbaHc4N_k-g3w.png)Representação do caminho entre Rita e Fabiana

A resposta para esse problema poderia ser bem custosa de acordo com a modelagem do mesmo, porém nota-se que com a utilização de grafos passa a ser um problema trivial. No exemplo utilizamos poucos objetos, porém a mesma resolução é escalável para **N pessoas, N empresas** e **N universidades**.

**Resolução:** Rita trabalha na mesma empresa que Nelson, que estuda na mesma universidade que Fabiana.

# 📃 Referências

- Introdução à Teoria dos Grafos, Profª Sheila Almeida e Mayara Omai (UTFPR/PG)
- Grafos e suas aplicações, Fabiana Nascimento Santos Cavalcante e Severino Domingos da Silva (PUC/RS)
- Aplicações da Matemática: Redes Sociais, Jogos, Engenharia, Profº Fábio Protti (IC-UFF/RJ)

Grafos, teoria e aplicações

Modelando e analisando relacionamentos em grafos com Docker + Python + Neo4J

https://miro.medium.com/max/2746/1*_li2QFQdrB29imigc3hD2Q.png

A **modelagem e análise de relacionamentos** é um dos [_cases_](https://neo4j.com/use-cases/) mais aplicados no mercado. A escolha de [qual produto recomendar](https://neo4j.com/use-cases/real-time-recommendation-engine/) ao cliente, definir [qual filme ou série sugerir](https://neo4j.com/use-cases/real-time-recommendation-engine/) ou [modelar a sua rede de contato](https://neo4j.com/use-cases/social-network/) com a proximidade das pessoas em relação ao seu perfil são exemplos que podemos encontrar nos principais serviços da internet.

Sobre este último, será a abordagem utilizada para este artigo. Para isso, será demonstrada a modelagem utilizando grafos e [_Neo4J_](https://neo4j.com/) (sistema de gerenciamento de banco de dados gráficos), a _API em_ [_Python_](https://www.python.org/) que irá gerar as entidades de formas aleatórias e a utilização de [_Docker_](https://www.docker.com/) para padronizar os ambientes.

# 👩‍🏫 O problema

Atualmente, uma rede de contatos de um profissional é muito relevante, principalmente em eventos corporativos. A importância de ter conexões no mesmo ramo de conhecimento traz benefícios, tais como: comunicação com pessoas que entendem do assunto e possíveis dúvidas podem ser esclarecidas, indicações de trabalhos disponíveis, entre outros.

Uma empresa de tecnologia decide realizar um evento com objetivo de apresentar e vender o seu novo portfólio, com diversas palestras, mesas redondas e stands com as maiores referências de especialistas no mercado. Além disso, o evento também busca conectar pessoas dessa área, visto que existem ramificações bem específicas tais como: exatas, biológicas e humanas.

Cada pessoa preenche seu nome, data de nascimento, email, cidade, estado e cargo que ocupa no momento. As empresas são registradas com nome, cidade, estado e área de atuação. As universidades possuem o registro do nome, estado e cidade.

# 😰 Mas o que são grafos?

Para entender melhor a teoria de grafos ou até mesmo relembrar seus principais conceitos, visite a breve introdução que preparamos no artigo [Grafos, teoria e aplicações](https://medium.com/@lennonalvesdias/grafos-teoria-e-aplicações-2a87444df855).

[## Grafos, teoria e aplicações](https://medium.com/@lennonalvesdias/grafos-teoria-e-aplicações-2a87444df855)

# 🌍 Modelando com Neo4J

O banco de dados de grafos é um dos tipos de bancos de dados [NoSQL](https://pt.wikipedia.org/wiki/NoSQL). Ele é diretamente relacionado a um modelo (_grafos_) de dados estabelecido, eles foram criado para possibilitar o armazenamento de relacionamentos e navegação por eles. As entidades são armazenadas como nós e os relacionamentos entre elas são as arestas, nas quais possuem direcionamento.

Dentre as opções de bancos de dados gráficos, destaca-se o Neo4J. Ele é um banco confiável, escalável e de alto desempenho, suas características adequadas de ACID são a base da confiabilidade dos dados. O banco garante que as operações que envolvem a modificação de dados ocorram dentro de uma transação para garantir dados consistentes.

> [**ACID** (**A**tomicidade, **C**onsistência, **I**solamento e **D**urabilidade)](https://pt.wikipedia.org/wiki/ACID) é um conjunto de propriedades que garante que as transações do banco de dados sejam processadas com confiabilidade, sendo a transação uma operação lógica única no banco de dados.

## 👨‍💻 Show Me the Code!

Antes de utilizar a _API_ para desenhar toda a complexidade do sistema, é importante passar pelos comandos básicos do banco, como criar os nós e os relacionamentos. Esses comandos podem ser executados diretamente na interface gráfica da ferramenta. Para este artigo, foi utilizada a [imagem Docker oficial do Neo4J, disponível no Docker Hub](https://hub.docker.com/_/neo4j).

![](https://miro.medium.com/max/2000/1*TbgQNCvagPUkNM7YqiO0dA.png)Interface do Neo4J acessada pelo endereço localhost:7474

Para interagir com os comandos, iremos modelas a mesma aplicação, porém com uma quantidade menor de objetos, depois apagamos tudo e deixamos que a _API_ faça todo o _‘trabalho grosso’_.

- Criando pessoas

```
CREATE (p1:Pessoa {Nome: 'Cintia'})
CREATE (p2:Pessoa {Nome: 'Lennon'})
CREATE (p3:Pessoa {Nome: 'Mateus'})
```

- Criando universidade

```
CREATE (u1:Universidade {Nome: 'FIAP'})
```

- Criando empresas

```
CREATE (e1:Empresa {Nome: 'FICO'})
CREATE (e2:Empresa {Nome: 'XP Inc'})
CREATE (e3:Empresa {Nome: 'Lumini'})
```

Após criar os nós, podemos visualizar graficamente as operações. 
Para isso executamos

```
MATCH(m1) WHERE id(m1) >= 0 RETURN m1
```

<img alt="" src="https://miro.medium.com/max/700/1*5sIpMqx7XSDt2TjTyn8VVA.png"/>

Visualização gráfica de pessoa(s), universidade(s) e empresa(s)

- Criando relacionamentos entre pessoas e universidade

```
MATCH(p1),(u1) WHERE p1.Nome='Cintia' AND u1.Nome='FIAP'
CREATE (p1)-\[r:ESTUDA\]->(u1)

MATCH(p2),(u1) WHERE p2.Nome='Lennon' AND u1.Nome='FIAP'
CREATE (p2)-\[r:ESTUDA\]->(u1)

MATCH(p3),(u1) WHERE p3.Nome='Mateus' AND u1.Nome='FIAP'
CREATE (p3)-\[r:ESTUDA\]->(u1)
```

- Criando relacionamentos entre pessoas e empresas

```
MATCH(p1),(e1) WHERE p1.Nome='Cintia' AND e1.Nome='FICO'
CREATE (p1)-\[r:TRABALHA\]->(e1)

MATCH(p2),(e2) WHERE p2.Nome='Lennon' AND e2.Nome='XP Inc'
CREATE (p2)-\[r:TRABALHA\]->(e2)

MATCH(p3),(e3) WHERE p3.Nome='Mateus' AND e3.Nome='Lumini'
CREATE (p3)-\[r:TRABALHA\]->(e3)
```

É possível visualizar de maneira gráfica as ligações entre os nós, formadas pelos relacionamentos cadastrados.

<img alt="" src="https://miro.medium.com/max/700/1*i7poxdhDSous0u5uIeg0zA.png"/>

Visualização gráfica dos objetos com os relacionamentos

- Criando/alterando atributos

```
MATCH(p1) WHERE p1.Nome='Lennon'
SET p1.Cidade = 'São Paulo'MATCH(u1) WHERE u1.Nome='FIAP'
SET u1.Cidade = 'São Paulo'
```

Com poucos nós cadastrados, já é possível realizar algumas consultas, como: “_Quais pessoas trabalham na empresa XP Inc?”_

<img alt="" src="https://miro.medium.com/max/530/1*6sLbl2-VXT9aU1MVNafqDA.png"/>

Visualização gráfica da consulta realizada pelo banco

Hora de usar a _API_ para gerar os dados, mas antes, utilizaremos alguns comandos para deletar a estrutura criada.

> Você pode encontrar uma introdução mais completa acessando a página de [treinamento online do Neo4J](https://neo4j.com/graphacademy/online-training/).

- Deletando relacionamento entre nós

```
MATCH (p1 {Nome: 'Lennon'})-\[r:ESTUDA\]->(u1 {Nome: 'FIAP'}) DELETE rMATCH (p1 {Nome: 'Lennon'})-\[r:TRABALHA\]->(u1 {Nome: 'XP Inc'}) DELETE r
```

- Deletando nós

```
MATCH (p1 {Nome: 'Lennon'}) DELETE p1MATCH (e1 {Nome: 'XP Inc'}) DELETE e1
```

Os comandos acima foram para exemplificar como deletar nós e/ou relacionamentos, sendo possível agrupá-los e deletar ambos de uma só vez. Para economizar tempo, podemos excluir todos os cadastros do banco com o seguinte comando:

```
MATCH (n) DETACH DELETE n
```

O restante do artigo utilizará a aplicação desenvolvida para gerar todos os registros. Entenderemos então como parametrizar a _API_ e como padronizamos os ambientes para que você possa executar em qualquer máquina que contenha _Docker_ e _Docker Compose_.

# 🚀 Escalando com Python API

Para simular os objetos e criar um ambiente mais próximo ao que costumamos encontrar em eventos, foi construida uma _API_ utilizando a linguagem _Python_. A função dessa API é receber parâmetros quantitativos e gerar aleatoriamente **n** pessoas, **n** empresas e **n** universidades. Com esses objetos gerados, a _API_ utiliza uma distribuição randômica para gerar os relacionamentos entre eles.

Com essa aplicação, é possível escalar a complexidade do modelo de acordo com os parâmetros informados no arquivo `app.py`.

# 🐋 Padronizando com Docker

Foi utilizado o _Docker_ (plataforma de código aberto para criação e administração de ambientes isolados) para manter a padronização do ambiente, das instalações e dos versionamentos das ferramentas e tecnologias utilizadas no projeto.

Para que os serviços mapeados no `docker-compose.yml` sejam _startados_, basta executar o comando após o clone do repositório da aplicação.

```
$ docker-compose up --build
```

> Para a execução do comando é necessário que o Docker e o Docker Compose estejam instalados e corretamente configurados em sua máquina.

# 💪 O poder das nossas buscas

Após a execução da _API_, temos o seguinte resultado ao consultar toda a nossa base de relacionamentos:

![](https://miro.medium.com/max/2746/1*_li2QFQdrB29imigc3hD2Q.png)Visualização gráfica dos objetos com os relacionamentos

É notável que a complexidade aumentou um pouco e que a _API_ se tornou bem útil ao não precisarmos realizar todas as operações de inserção na mão. Ao total temos 134 nós, sendo 60 pessoas, 44 empresas e 30 universidades e 120 relacionamentos, sendo 60 do tipo _‘ESTUDA’_ e 60 do tipo _‘TRABALHA’_.

Chegou a hora de ver o que podemos fazer: “_Quantos alunos cada universidade tem, em ordem decrescente e que sejam Top 5?”_

```
MATCH (p:Pessoa)-\[:ESTUDA\]->(u:Universidade)
RETURN u.Nome, count(\*) AS alunos
ORDER BY pessoas DESC
LIMIT 5
```

![](https://miro.medium.com/max/2000/1*rhho8GtkFONNGAnnI-JTUQ.png)
Resultado da consulta de universidades com mais alunos

E que tal _“Quais pessoas estudam ou trabalham com Thiago Hugo Paulo da Mota?”_

```
MATCH (p1:Pessoa)-\[:TRABALHA\]->(e:Empresa),
 (p1)-\[:ESTUDA\]->(u:Universidade),
 (p2:Pessoa)-\[:TRABALHA\]->(e),
 (p3:Pessoa)-\[:ESTUDA\]->(u)
WHERE p1.Nome = 'Thiago Hugo Paulo da Mota'
RETURN \*
```

![](https://miro.medium.com/max/1400/1*XzOzXgZsZP0DBGc5Us9atw.png)
Resultado da consulta de pessoas próximas ao Thiago

A utilização de um banco de dados gráfico resolve problemas mais complexos de relacionamento com facilidade e alta performance.

Por fim, o exemplo clássico da utilização de grafos, encontrar o caminho mais curto. _“Os alunos da Universidade Mackenzie gostariam de compartilhar conhecimento com os alunos da Universidade do Amazonas, qual é o caminho mais curto para que esse encontro seja possível?”_

```
MATCH p = shortestPath((u1:Universidade)-\[\*\]-(u2:Universidade))
WHERE u1.Nome = 'Universidade Mackenzie' AND
 u2.Nome = 'Universidade do Amazonas'
RETURN p
```

<img alt="" src="https://miro.medium.com/max/700/1*uQeIjFZ9x8g7HO9GOmmJHg.png"/>

Resultado da consulta de menor caminho entre um aluno da Universidade Mackenzie e um aluno da Universidade do Amazonas

É possível explorar o poder da performance de um banco de dados de grafos, alterando e incrementando os exemplos citados. Nos links disponíveis existem também treinamentos para extrair o máximo poder da ferramenta.

O projeto completo você pode encontrar no [repositório do GitHub](https://github.com/lennonalvesdias/fiap-8ia-arquitetura-de-dados).

[lennonalvesdias/fiap-8ia-arquitetura-de-dados](https://github.com/lennonalvesdias/fiap-8ia-arquitetura-de-dados)

Publicando meu site em Angular 8 no GitHub Pages com domínio customizado

https://miro.medium.com/max/1280/1*HGShqAPMdgsntCcNZDD-pg.jpeg

Utilizando a biblioteca [_angular-cli-ghpages_](https://www.npmjs.com/package/angular-cli-ghpages) para realizar o _deploy_ da minha aplicação Angular no [_GitHub Pages_](https://pages.github.com/) diretamente do terminal.

![](https://miro.medium.com/max/1280/1*HGShqAPMdgsntCcNZDD-pg.jpeg)

# 💁‍♂ Considerações iniciais

Neste artigo será abordada a instalação e configuração dos pacotes necessários assim como demonstrado o passo à passo do _build_ e _deploy_ da aplicação. Não será abordada a construção e/ou o desenvolvimento da mesma.

Para que o _GitHub_ entenda seu projeto como padrão do _GitHub Pages_, é necessário que ele respeite o formato **_O_QUE_VOCE_QUISER.github.io_**.

# 👣 Primeiros passos

O artigo utiliza como base para o processo de _deploy o angular-cli-ghpages_ e, como tarefa inicial, iremos realizar a instação global desta biblioteca.

```
npm install -g angular-cli-ghpages
```

## 📃 Anotações (dicas) úteis

Este artigo tem como base a utilização do [repositório do meu site pessoal](https://github.com/lennonalvesdias/lennonalvesdias.github.io), nele algumas estruturações de _branchs_ foram realizadas para facilitar a implementação e o desenvolvimento. Para que as alterações sejam aplicadas automaticamente na [página do site](https://lennonalves.com.br/#/user-profile), a _branch master_ foi reservada para os arquivos gerados pelo _deploy_ e, uma _branch_ de desenvolvimento chamada _develop_ foi criada (nela todas as alterações são realizadas).

No decorrer do artigo, algumas linhas de comandos são citadas. Para um uso mais simplificado no dia à dia, esses comandos foram mapeados no arquivo [_package.json_](https://github.com/lennonalvesdias/lennonalvesdias.github.io/blob/develop/package.json).

Dentro das configurações do [_angular.json_](https://github.com/lennonalvesdias/lennonalvesdias.github.io/blob/develop/angular.json) é possível configurar o _outputPath_ para que o conteúdo da sua aplicação seja distribuída na pasta raiz.

[lennonalvesdias/lennonalvesdias.github.io](https://github.com/lennonalvesdias/lennonalvesdias.github.io)

# ⚙ Build

Com a instalação realizada com sucesso, o próximo passo é a realização do _build_ do projeto. Caso a _URL_ do projeto seja a do _GitHub Pages_, o comando deverá ser parecido com:

```
ng build --prod --base-href [https://lennonalvesdias.github.io/](https://lennonalvesdias.github.io/)
```

Caso você opte por utilizar domínio personalizado para o seu site, o comando será apenas:

```
ng build --prod
```

## 🌎 Habilitando domínio personalizado no _GitHub_

O GitHub Pages permite que você utilize o domínio _O_QUE_VOCE_QUISER.github.io_ de forma gratuita, porém você ainda pode configurar um domínio próprio para exibição do seu site.

Para isso, na página do seu repositório clique na opção _Settings_. Nesta aba, rolando para baixo, estará visível a sessão _GitHub Pages_, onde você encontrará a opção _Custom Domain_. Nesta opção você deve informar o domínio que deseja utilizar e clicar na opção _Save_.

<img alt="" class="t u v lg aj" src="https://miro.medium.com/max/700/1*S5gR-N7lGxwIi0F67pWBpg.png"/>

<img alt="" class="t u v lg aj" src="https://miro.medium.com/max/700/1*-R6cq8RXKZf1D-umWliYoA.png"/>

É importante ressaltar que você deve ser proprietário deste domínio e configurar a Zona _DNS_ do mesmo. Caso você tenha segurança em alterar a Zona, basta criar registro do tipo `A` apontando para os seguintes endereços IP ([conforme página de ajuda do _GitHub_](https://help.github.com/en/github/working-with-github-pages/managing-a-custom-domain-for-your-github-pages-site)):

```
185.199.108.153
185.199.109.153
185.199.110.153
185.199.111.153
```

# 🚀 Deploy

Com a biblioteca _angular-cli-ghpages_ instalada de forma global e as _branchs_ configuradas conforme demonstrado acima, o comando de _deploy_ sem a utilização do domínio personalizado será:

```
ngh --branch=master
```

Caso opte por utilizar o domínio personalizado no site, o comando de _deploy_ será parecido com:

```
ngh --branch=master --cname=lennonalves.com.br
```

A biblioteca permite ainda a configuração da mensagem de implantação com o parâmetro `--message`, a utilização do parâmetro `--dry-run`para obter a saída antes de publicar a mudança além de outras opções que podem ser encontradas em sua [página no _NPM_](https://www.npmjs.com/package/angular-cli-ghpages).

Rapidinhas - Evitando armadilhas comuns com .NetCore Async

https://miro.medium.com/max/1400/1*wZb4MppIKgUSWw1QMKpqUQ.jpeg


Nessa primeira #rapidinha abordaremos armadilhas (algumas bem comuns) que devemos evitar na implementações de códigos assíncronos utilizando .NET Core.

## 1\. Usar `Task.Run()`na aplicação.

Cria uma thread não otimizada.  
Causa sobrecarga.  
Diminui a escalabilidade.

## 2\. `Task.Wait()` e `Task.Result()`bloqueiam o seguimento da chamada.

O encademanto não é retornado ao conjunto de encadeamento.  
Bloquear código assíncrono prejudica a escalabilidade.-  
O ASP.NET Core não possui um contexto de sincronização.

## 3\. Modificando o estado compartilhado.

Threads diferentes podem manipular o mesmo estado ao mesmo tempo.  
A correção não pode ser garantida.

Conhece alguma outra armadilha que não devemos cair? Já utilizou alguns desses recursos acima e não sabia disso? Compartilhe suas experiências e vamos trocar uma idéia.

Quer aprender mais sobre como montar uma API assincrona garantindo segurança, performance e escalabilidade? Confira esse curso:

[Building an Async API with ASP.NET Core](https://www.pluralsight.com/courses/building-async-api-aspdotnet-core)


XGBoost e LigthGBM no modelo de decisão de crédito


No artigo [“Decisão de crédito utilizando machine learning e visão computacional”](https://medium.com/@lennonalvesdias/decisão-de-crédito-utilizando-machine-learning-e-visão-computacional-d0a1e785ca80) foi demonstrada a utilização de técnicas de inteligência artificial para um sistema modelo de análise e decisão de crédito.

O artigo demonstra a utilização de APIs e bibliotecas para reconhecer uma pessoa à partir de uma foto, extrair idade e gênero e realizar marcações como os pontos fiduciais.

[

Decisão de crédito utilizando machine learning e visão computacional
--------------------------------------------------------------------

### Utilização de APIs e bibliotecas de visão computacional e aprendizado de máquina para criação de um motor de decisão de…

medium.comC

](https://medium.com/@lennonalvesdias/decisão-de-crédito-utilizando-machine-learning-e-visão-computacional-d0a1e785ca80)

Um dos pontos do artigo citado, no qual iremos abordar com mais detalhes, é a criação e treinamento de modelos de predição de score para tomada de decisão. Na primeira versão utilizamos os algoritmos _RandomForest_ e _GradientBoosting_, mas será que eles são mesmo a melhor opção? 🤔

![](https://miro.medium.com/max/2524/1*j4fXcaziurkVXNeS9l9hFw.png)

Nesta nova versão, novos algoritmos foram testados e o score de cada um deles foi comparado, tanto para classificação quanto para regressão.

> Uma lista com vários algoritmos implementados na biblioteca sklearn você pode encontrar pelo link: [https://scikit-learn.org/stable/modules/classes.html#module-sklearn.ensemble](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.ensemble)

_RandomForest_ e _GradientBoosting_ são “figurinhas carimbadas” nas disciplinas de _Machine Learning_, que resolvem grande parte dos problemas de mercado, entregando uma acurácia aceitável pelo seu tempo de treinamento.

Com base na indicação do professor [Me. Felipe Teodoro](https://www.linkedin.com/in/felipe-teodoro-87b25217/) e, nos recentes resultados destas bibliotecas em competições de aprendizado de máquina, os dois outros algoritmos são: [_XGBoost_](https://github.com/dmlc/xgboost/blob/master/demo/README.md)  e [_Light GBM_](https://github.com/microsoft/LightGBM/blob/master/README.md).

> É possível encontrar mais sobre as competições e os resultados nos links de cada um dos algoritmos acima.

Como explicado no [artigo anterior](https://medium.com/@lennonalvesdias/decisão-de-crédito-utilizando-machine-learning-e-visão-computacional-d0a1e785ca80) sobre o tema, com a atualização do modelo o GitHub Action se encarrega de realizar o _Build_ e o _Deploy_ da aplicação. Um dos passos deste processo é o treinamento do modelo, [disponível clicando aqui](https://github.com/lennonalvesdias/credit-decisor/runs/676849494?check_suite_focus=true), em que temos o seguinte resultado:

```
model\_1\_randomforest\_classifier accuracy: 0.8600333333333333  
model\_1\_xgboost\_classifier accuracy: 0.8746  
model\_1\_lightgbm\_classifier accuracy: 0.8762666666666666  
model\_1\_gradientboosting\_classifier accuracy: 0.8768333333333334  
model\_1\_randomforest\_regressor accuracy: 0.5901592249304006  
model\_1\_xgboost\_regressor accuracy: 0.6371604287220034  
model\_1\_lightgbm\_regressor accuracy: 0.6450610561426381  
model\_1\_gradientboosting\_regressor accuracy: 0.6329410198786587  
model\_2\_randomforest\_classifier accuracy: 0.8464333333333334  
model\_2\_xgboost\_classifier accuracy: 0.8633333333333333  
model\_2\_lightgbm\_classifier accuracy: 0.8649666666666667  
model\_2\_gradientboosting\_classifier accuracy: 0.8657666666666667  
model\_2\_randomforest\_regressor accuracy: 0.5519534871968672  
model\_2\_xgboost\_regressor accuracy: 0.6072325295143952  
model\_2\_lightgbm\_regressor accuracy: 0.6134725152532305  
model\_2\_gradientboosting\_regressor accuracy: 0.6069039918997955
```

Código completo: