Visualização de Dados - Princípio de Pareto aplicado no Calc (LibreOffice)

Existe uma lei natural que foi descoberta por Vilvredo Pareto (1848-1923) que é verdadeira por natureza, denominada a lei do desequilíbrio. Essa lei diz que uma determinada produção é produzida por um pequeno número de partes. Ou com estatísticas mais detalhadas: 80% dos resultados da produção são criações de 20% de certas partes.

Podemos criar um diagrama de Pareto com três elementos básicos:

• Os fatores, classificados pela magnitude de sua contribuição;
• Os fatores expressos numericamente; e
• O efeito cumulativo da porcentagem total dos fatores classificados.

Vamos com calma que na prática isso se traduz de forma muito mais fácil, logicamente devemos começar pelos nossos dados. Vamos imaginar que nossa Organização possua um registro dos erros no Sistema de Sustenção e são apresentados da seguinte forma:

Tipo Erro	Quantidade
A	143
B	34
C	230
D	42
E	28
F	58
G	8
H	3

Uma vez que montamos uma planilha com esses dados, para fins de entendimeto consideremos que a Coluna A contém o Tipo do Erro e B a Quantidade (a linha 0 o cabeçalho). Ordenamos descendentemente pela quantidade: selecionar a coluna B e a partir do Menu selecionar a opção: Data | Sort Selection, na janela que é mostrada pressionar o botão Extend Selection.

Precisamos do somatório da quantidade, posicionar em B10 (considerando esses dados) e pressionar o botão com o símbolo de SOMATÓRIO.

Agora vamos criar uma terceira coluna que representa o percentual de contribuição de cada elemento (sendo este acumulativo) - iremos considerar que esta foi criada na coluna C. Na célula C2 aplicamos a fórmula: =B2/$B$10. Porém para C3 aplicamos a fórmula: =(B2/$B$10)+c2. A diferença está pois desejamos que seja acumulativo, copiar o conteúdo dessa célula para todas abaixo. Selecionar todas essas células e clicar no botão com o símbolo %.

Está pronto mas como ver os dados assim não tem graça, criaremos um gráfico. A partir do Menu selecionar a opção: Insert | Chart, selecionar o tipo Column and Line. Pressionar Next. Nossa seleção de dados vai de A1 a C9. Pressionar Next. Nenhuma troca em Data Series. Pressionar Next. Colocar as descrições das colunas. Pressionar Finish.

Observamos que a linha do Percentual está estranha, dar um duplo-clique nessa para abrir a janela "Data Series". Na aba Options marcar Secondary Y axis e pressionar o botão OK. E agora temos o gráfico visualizado de forma correta.

Porém ainda observamos um pequeno erro que pode comprometer toda uma apresentação 120%. Dar um duplo-clique nessa coluna para abrir a janela "Secondary Y Series". Na aba Scale desmarcar a opção Automatic de Maximum e acertar para 100%.

E agora podemos mostrar claramente que os erros tipo C e A devem ser combatidos primeiro pela Organização.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

Robótica - Sensores 4 de 37

No artigo anterior falamos sobre os módulos de Som, nesse vamos para o nosso quarto módulo denominado KY-033 Hunt sensor module/Tracking sensor/Infrared Tracking Sensor, lembra daquele sonho de construir um carrinho que pode seguir uma linha?

04. Módulo Sensor de Trilha

A primeira coisa que pensei quando vi esse módulo foi: "Existe alguma coisa errada", se parar para analisar o sensor consta de dois LEDs, um que emite uma luz infravermelha (o azul) e um que a recebe (o preto), só que o botão de ajuste está do mesmo lado para o qual os LEDs estão apontados, e é isso que parece estranho.

Além disso é um sensor extremamente sensível a mudança de luz, pessoalmente não o utilizaria em um projeto de um carro segue trilha (vai ter que adiar o sonho para mais tarde), existem soluções muito melhores com um FotoResistor.

A ligação é extremamente simples:

• GND para o GND (Ground) do Arduino
• OUT para uma porta Digital PWM (estão identificadas com um ~) usaremos a porta 10.
• VCC para o 5V

Regular a emissão do LED Infravermelho é a parte mais importante do seu funcionamento, para isso utilize a câmera de um celular e coloque em modo filmar, apague as luzes do quarto e regule até ver a luz emitida, que será roxa.

Vamos criar um "Pulsômetro", em uma folha branca, desenhe uma grande linha preta (com 1 cm de largura) de uma ponta a outra do papel com um pincel atômico (ou algo do gênero), pode ter algumas curvas sem problemas (desde que seja mantida a largura). E vamos para a programação:

int sensorPin = 10;
int ledPin = 13;
int sensorValue = 0;

void setup() {
  pinMode(sensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  sensorValue = analogRead(sensorPin);
  Serial.println(sensorValue, DEC);
  if (sensorValue >= 280) {
    digitalWrite(ledPin, LOW);
  } else {  
    digitalWrite(ledPin, HIGH);
  }
  delay(200);
}

Carregue o programa e coloque os LEDs na linha (ou seja o sensor vai ficar de cabeça para baixo) e tente seguí-la, devagar. Se sair da linha ou se o sensor notar alguma mudança brusca de cor acenderá o LED padrão (Pino 13) da placa.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →

Robótica - Sensores 3 de 37

No artigo anterior falamos sobre o módulo Relay, nesse vamos para o nosso terceiro módulo denominado KY-038 Microphone sound sensor module, prepare a garganta e vamos ver como usar este módulo.

 03. Módulo Sensor de Som por Microfone

Nesta categoria temos 2 módulos quase idênticos, pelo menos na programação, a diferença entre eles está na sensibilidade de detecção do som.

Estes sensores podem detectar som e emitem um sinal analógico ou digital que pode ser usado, por exemplo, para criar um interruptor de luz ao bater palmas. No lado analógico mede a intensidade sonora do ambiente e do lado digital varia o estado caso seja detectado um sinal sonoro.

As ligações com o Arduino são:

• A0 - Para o pino analógico
• G  - Negativo do Arduino (ou GND)
• +  - Positivo do Arduino (ou 5V)
• D0 - Para o pino digital

Porém o mais importante desse módulo é o parafuso amarelo no topo da caixinha azul, o limite de detecção deve ser ajustado através desse potenciômetro presente no sensor, para regular a saída. Um simples programa para analisar a saída analógica, como:

#define SOM_AN A5;
 
void setup () {
  pinMode(ruido_an, INPUT);
  Serial.begin (9600);
}
void loop () {
  Serial.println(analogRead(SOM_AN), DEC);
  delay (100);
}

É o suficiente para procedermos os ajustes que deve estar com o valor em torno dos 500. Agora podemos realizar um projeto mais interessante, observe a figura com as ligações:

Temos 4 LEDs ligados nas digitais 3 a 6, todos estão em linha com o polo negativo juntamente com um resistor de 220Ω. A ligação com o sensor está ligado na porta analógica A5 e digital 7, além do GND e 5V.

Para a programação temos:

#define SOM_AN A5
#define SOM_DG 7
#define VERM 6
#define AZUL 5
#define AMAR 4
#define VERD 3

int ruido_an = 0;
int ruido_dg = 0;
int liguei = false;

void setup() {
  pinMode(SOM_AN, INPUT);
  pinMode(SOM_DG, INPUT);
  pinMode(VERM, OUTPUT);
  pinMode(AZUL, OUTPUT);
  pinMode(AMAR, OUTPUT);
  pinMode(VERD, OUTPUT);
}
 
void loop() {
  digitalWrite(VERM, LOW);
  digitalWrite(AZUL, LOW);
  digitalWrite(AMAR, LOW);
  digitalWrite(VERD, LOW);
  
  ruido_an = analogRead(SOM_AN);
  ruido_dg = digitalRead(SOM_DG);
  if (ruido_dg == 0) {
    liguei = true;
    digitalWrite(VERM, HIGH);
  }
  if (ruido_an > 510) {
    liguei = true;
    digitalWrite(AZUL, HIGH);
  }
  if (ruido_an > 520) {
    liguei = true;
    digitalWrite(AMAR, HIGH);
  }
  if (ruido_an > 530) {
    liguei = true;
    digitalWrite(VERD, HIGH);
  }    
  if (liguei) {
    delay(100);
    liguei = false;
  }
  delay(10);
}

Primeiro definimos e habilitamos todas as portas usadas, no método setup() indicamos quem são as entradas e as saídas. No método loop(), apagamos todos os LEDs; obtemos os valores da porta analógica e digital; se houver variação na digital acendemos o LED Vermelho, se a porta analógica ultrapassar os 510 acendemos o azul, se ultrapassar 520 o amarelo e se ultrapassar 530 o verde; caso qualquer LED tenha sido ligado aumentamos o tempo de espera.

Pronto, acabamos de criar um sequenciador de som, agora basta falar um pouco mais alto para ver os LEDs acendendo e apagando.

Obrigado e até o próximo sensor
Fernando Anselmo

Saiba mais →

Robótica - Sensores 2 de 37

No artigo anterior falamos sobre o módulo Joystick, nesse vamos para o nosso segundo módulo denominado KY-019 5V relay, um nome bem complicado para este interessante e útil módulo.

ATENÇÃO - Usaremos uma corrente de 110/220 Voltz todo cuidado é pouco - De maneira alguma isso deve ser usado por crianças (com ou sem supervisão de adultos).

02. Módulo Relé

Segundo a eletrônica sabemos que um Relé (ou Relê) é um interruptor eletromecânico que é acionado quando uma corrente elétrica passa por suas bobinas, isso cria um campo magnético, o resultado e a atração (ou repulção) de uma alavanca.

Traduzindo isso para o bom português quer dizer que podemos ligar ou desligar determinado componente elétrico (lâmpadas, alarme anti-roubo, controlar a abertura/fechamento de uma torneira, brinquedos ou uma tranca elétrica de porta) através do Arduino. Comumente isso é muito usado em circuitos de controle de automação, ou seja, uma pequena corrente para controlar uma grande operação através de um "interruptor automático".

Observe que o módulo possui 2 partes: um circuito de entrada (do lado esquerdo da figura) que permite uma corrente de 30V a 250V e 10A e um circuito de saída (que é ligado ao Arduino) com 3 pinos.

O esquema de ligação é o seguinte:

São três conectores de ligação de entrada do Relé, porém somente os dois primeiros são utilizados, um dos fios da tomada segue para essa entrada e outro fio vai para o dispositivo (que nesse caso é uma lâmpada de bancada). Do outro lado a entrada para o Arduíno é bem simples (boa parte dos outros sensores seguirá o mesmo padrão):

• - para o GND (ou terra)
• + para a 5V
• S para a digital (que iremos ligar no pino 10)

 Feita as ligações vamos para o programa:

#define RELAY 10

void setup() {   
  pinMode(RELAY,OUTPUT);
} 

void loop() {   
  digitalWrite(RELAY,HIGH);
  delay(5000);      
  digitalWrite(RELAY,LOW);
  delay(5000); 
} 

Se alguma vez já viu um programa para acender e apagar um LED verá que não existe a menor diferença. Estabelecemos uma constante RELAY com o valor 10 (isso é realizado somente para dar melhor clareza ao código), no método inicial (setup) definimos a pino 10 como saída. Durante o tempo de vida do programa (loop) ligamos o pino 10, esperamos 5 segundos, desligamos o pino 10 e esperamos mais 5 segundos.

Ou seja, se tudo estiver correto a lâmpada será ligada por 5 segundos e ficará apagada por 5 segundos, e essa ação será repetida. Esse é um componente muito utilizado (pessoalmente tenho mais alguns) principalmente em projetos que necessitam trabalhar com correntes bem mais altas que 5V (que é o padrão do Arduino).

Obrigado e até o próximo sensor
Fernando Anselmo

Dica: Se possui uma impressora 3D existe uma caixinha bem interessante para este módulo disponível gratuitamente na Thingverse.

Saiba mais →

Robótica - Sensores 1 de 37

Essa semana chegou pelo correio um pequeno pacote que tinha comprado mês passado da Ali Express, veio um Kit com 37 Sensores. O único problema básico quando se compra esse tipo de produto é que pode esquecer a documentação (é muito raro que exista alguma e se existir estará em Mandarim.

Então tive que correr atrás e localizar um jeito de fazer cada um dos meus novos bebês funcionar e pretendo compartilhar aqui como consegui com cada um deles (incluindo todo o código do Arduíno).

01. Módulo Joystick

O primeiro da lista é o KY-023 XY-axis joystick module, ou seja, um joystick  com 2 eixos e 1 botão. Este é um modelo analógico que pode ser usado para controlar qualquer coisa que se mova como um carrinho ou um robô articulado. O joystick é uma combinação de 2 potenciômetros analógicos e um interruptor digital.

Sua conexão com o Arduíno conta com 5 entradas:

• GND - Esse é o fio negativo
• +5V - Fonte de alimentação até 5 volts
• URx - Pino analógico para o eixo X (ligamos no pino A0)
• URy - Pino analógico para o eixo Y (ligamos no pino A1)
• SW - Switch, quando se presiona o botão (ligamos no pino 2)

Feita as ligações a programação é bem simples:

const int URx = 0;
const int URy = 1;
const int pres = 2;
 
void setup() {
  pinMode(pres, INPUT);
  digitalWrite(pres, HIGH);
  Serial.begin(9600);
}
 
void loop() {
  Serial.print("Pressionado: ");
  Serial.print(digitalRead(pres));
  Serial.print("\n");
  Serial.print("Eixo X: ");
  Serial.print(analogRead(URx));
  Serial.print("\n");
  Serial.print("Eixo Y: ");
  Serial.println(analogRead(URy));
  Serial.print("\n\n");
  delay(500);
}

JoySticks analógicos basicamente são potenciômetros, portanto retornam os valores que podem ser visualizados na janela do Serial Monitor (Ctrl+M). Os valores de X e Y vão de 0 a 1.023 (sendo o meio 503) e o pino Switch trará 1 ou 0 (quando pressionado).

Ao clicar no monitor serial, veremos os valores. Ao mover o JoyStick ou pressiná-lo, verá os valores sendo alterados.

Obrigado e até o próximo sensor
Fernando Anselmo

Saiba mais →

Ciência de Dados - Python e não Python

Com o advento da Ciência de Dados o mundo agora está redescobrindo a linguagem Python, e isso pode ser bem caótico para ela (assim como foi a explosão de Java). Calma que explico, existem muitas pessoas que fazem aqueles cursos de 6 hrs ou leem livros tipo "Python Fluente" e já se acham os donos da linguagem e que conseguem fazer relativamente TUDO. Isso é bem verdade pois o Google, fóruns e livros tipo "Cookbook" ajudam muito.

Com Java acontece muito disso (o mesmo ocorre com JavaScript), basta ver os modelos propostos e os que sumiram com uma velocidade assustadora, um pseudo Arquiteto leu uma trabalho de Pós Graduação, achou interessante e resolveu implantar isso sem fazer um estudo de caso, uma análise de impacto ou nada do gênero e pronto está criado aquele sistema com Wicket + Vue.js + MongoDB.

Em Ciência de Dados e Python penso que a coisa irá acontecer a nível de Modelos Implementados, veremos modelos que irão demorar horas (ou dias) para serem executados e ninguém se incomodará pois o "Cientista" falou que isso se deve por causa da quantidade de dados analisados que são enormes (pelo menos dessa vez ninguém culpará a linguagem, mas sim os dados ou as máquinas).

Falar Pythonico ou Não

Se Python é uma linguagem então devemos falar Pythonico, normalmente para aprendermos algo usamos a "Comparação", fazia assim, agora faço assim. A língua inglesa é difícil de aprender (para os brasileiros) pois sua estrutura gramatical muda. Em linguagens de programação isso também acontece (não, não existe uma Gramática de Python), calma não estou falando de tempos verbais, mas sim de formas no modo de programar.

Vamos falar do método zip() por exemplo, esse é quase exclusivo de Python, Java não isso (e se tem serve para aquilo que provavelmente você deve ter imaginado). Este método serve para iterar duas ou mais listas ao mesmo tempo, como por exemplo:

first = [1, 3, 5, 7, 9]
second = [2, 4, 6, 8, 10]
for x, y in zip(first, se0cond):
  print(x + y)

Ou seja, em a cada iteração um valor de cada uma das listas é puxado, outro método pouco conhecido é o map(), que serve para iterar métodos e listas, vamos imaginar que exista um método criado para calcular a Raiz Quadrada de um número (ou outro mais complexo que deseje):

def raiz(x): 
    return x**0.5

Simples assim, e se vem de outras linguagens provavelmente escreverá algo assim para iterar esse método com elementos de uma lista e colocá-los em outra lista:

raizes = []
nums = [4,9,27,32,78,98,45,22]
for num in nums:
    raizes.append(raiz(num))

Quando na verdade isso deveria ser escrito da seguinte forma:

nums = [4,9,27,32,78,98,45,22]
raizes = map(raiz, nums)

Não estou aqui para condenar ninguém ou qualquer curso ou livro, estou apenas chamando a atenção para um fato que vai ocorrer (sim, rodei um Modelo Preditivo para descobrí-lo) muito em breve, se já não está ocorrendo. Ou seja, não é necessário diminuir sua amostra, não é necessário aumentar seu cluster de máquinas apenas melhorar um pouco seu código. Não Fernando, você está falando besteira e sou EXCELENTE. Muito bem, vamos a um pequeno desafio, veja esse código:

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def pares(x):
    return x % 2 == 0

numsPares = []
for num in nums:
    if even(num):
        numsPares.append(num)

Como conhece bem a linguagem sabe que esse código está pegando somente os pares da lista de nums e jogando-os na lista numsPares. Suas opções são:

1. O código está bom do jeito que está.
2. Deve ser reescrito para ...
3. Esse corpo não me pertence.

Como disse não quero condenar ninguém, só quero apenas alertar para um fato e isso pode causar a decadência da linguagem em relação a outras que se mostram mais performáticas (mesmo usadas errôneamente).

Obrigado pela atenção
Fernando Anselmo

Spoiler.

O código em questão deveria ser reescrito usando o método filter(), da seguinte forma:

numPares = filter(pares, nums)

Saiba mais →

Ciência de Dados - Matematicamente Falando

Quando comecei a estudar as matérias de "Ciência de Dados" percebi algo bem simples e ao mesmo tempo bem complexo. A cadeira envolve 3 áreas de conhecimento:

Ciência da Computação, Conhecimento de Negócios e Matemática (e Estatística). Possuia as duas primeiras porém me faltava a terceira. E minha pergunta era: Como obter o conhecimento matemático necessário que me falta?

Existem milhares de respostas válidas bem como:

1. Estudar por conta própria.
2. Achar um bom curso (tipo Udemy).
3. Fazer uma Pós em Estatística. 

Optei pela terceira, já tinha feito vários cursos mas nenhum deles me trouxe um conhecimento muito profundo e apenas arranhavam a superfície do que planejava. Antes de continuar devo dizer que a segunda área do conhecimento cristalizei ela através de uma Pós em "Gestão Empresarial Avançada" que é totalmente voltada a problemas de negócio. Então nada mais lógico que procurar uma Pós que fosse totalmente prática e aplicada a problemas do dia a dia através de resoluções matemáticas.

Não pretendo fazer propagando de cursos, não é esse meu objetivo. Meu objetivo é que compreenda que para adquirir determinado conhecimento não basta apenas estudar por conta própria (pois o mercado infelizmente não reconhece esse tipo de ação e exige diplomas de formação acadêmica) ou realizar simples cursos de arranham a superfície (quando o que o mercado exige é que o profissional consiga se virar nas 11, ser o técnico e de preferência o Juiz).

Minha recomendação para essa terceira área do conhecimento é, comece com bons livros e ferramentas, três são essenciais para quem gosta do mundo livre:

PSPP

É uma alternativa ao IBM SPSS, pessoalmente diria uma cópia tipo Ctrl+C e Ctrl+V, tanto que houve a brincadeira das letras, para se ter uma ideia do que estou falando não existem muitos livros de PSPP então utilizo os livros de SPSS para estudar, a sintaxe é exatamente a mesma. Na essência é um software para Análise de Dados que permite análises descritivas e o uso de inferência.

Scilab

Esse é uma alternativa para o famoso Matlab e basicamente trata-se de um ambiente computacional para aplicações científicas totalmente orientado a análise numérica.

Octave

Esse é outra alternativa para o Matlab. Dos três é o mais conhecido e usado por quem conhece matemática, basicamente é quase uma linguagem tanto que é possível usar o Jupyter Notebook para executar seus comandos que podem envolver soluções lineares e não-lineares.

Dica: Se usa o Ubuntu o primeiro e o terceiro vem instalado por padrão (se não estiver procure na Loja com o nome GNU PSPP e GNU Octave - Isso mesmo ambos fazem parte do Projeto GNU) e quanto ao segundo utilize uma AppImage (que facilita muito o processo) através de dois comando no terminal:

$ wget https://github.com/davidcl/Scilab.AppDir/releases/download/6.0.2-1/Scilab-x86_64.AppImage
$ chmod +x Scilab-x86_64.AppImage

Ou baixe a imagem no endereço indicado e forneça permissão de execução no Nautilus.

Esses são apenas 3 dos vários softwares que passei a utilizar quando ingressei nesse mundo de ciência de dados, são gratuitos, leves e qualquer um pode ter no computador. E mais uma dica comece adquirindo um bom livro de Matemática:

E lembre-se que conhecimento nunca é demais.

Obrigado e até a próxima
Fernando Anselmo

Saiba mais →