IA - Algorítimo Apriori

Motivação
Algorítimo criado para descobrir o comportamento do consumidor em um determinado mercado.
Maximizar a venda de um determinado produto colocando este determinado produto em promoção ou em evidência. 
Após encontrar um determinado padrão pode se organizar o determinando produto em uma determinada posição, lugar e até mesmo cor. O Objetivo é deixar o objeto de uma determinada forma que maximize sua venda.

Desvantagem
É necessário muitas interações no banco de dados para se chegar em um resultado positivo.
Não encontra eventos considerados RARO específicos. 

Vantagem
Fácil e simples para implementar


Conceito Básico
Frequência Mínima: É a frequência mínima que um item deve ter para que seja considerado frequente.

Confiança Mínima: É a confiança mínima que um item deve ter para que seja considerado confiável.  

Regra Forte: São aquelas que atingem o mínimo de frequência e o mínimo de confiabilidade.




REQUISITOS
1 - Gerar Itens Frequentes;
2 - Gerar grupo de Candidatos;
3 - Gerar grupo de Itens Frequentes;

4 - Grupo de Candidatos Gerados foi OK? Existe?;
4.1 - Se não, executar novamente o item 2;
4.2 - Se SIM, Gerar regras fortes;



Exemplo:



1 - Base de Dados

LEITE PÃO BOLACHA SUCO
LEITE SUCO
LEITE OVOS
PÃO BOLACHA CAFÉ





2 - Frequência Mínima

50%





3 - Confiança Mínima

75%






4 - Passos a serem realizados

4.1 - Em primeiro lugar temos que gerar a tabela de candidatos com a sua frequência

Leite = Freq: 75% - 3/4 (quantidade do item, dividido pela quantidade total de amostras)
Pão = Freq: 50% - 2/4 (quantidade do item, dividido pela quantidade total de amostras)
Bolacha = Freq: 50% - 2/4 (quantidade do item, dividido pela quantidade total de amostras)
Suco = Freq: 50% - 2/4 (quantidade do item, dividido pela quantidade total de amostras)
Café = Freq: 25% - 1/4 (quantidade do item, dividido pela quantidade total de amostras)
Ovos = Freq: 25% - 1/4 (quantidade do item, dividido pela quantidade total de amostras)

Amostras  = Linhas/Conjuntos








4.2 - Gerar tabela com itens frequentes, para isto temos que utilizar o parâmetro de FREQUÊNCIA MÍNIMA, onde o valor é de 50%.
Dado este parâmetro e a tabela do item 4.1, remos o resultado:

Leite
Pão
Bolacha
Suco



4.3 - Deverá ser gerado a tabela de candidatos a partir da combinação dos itens frequentes. Itens gerados na fase 4.2. ( Leite, Pão, Bolacha, Suco) E calcular a sua respectiva frequência.




4.3.1 - BANCO DE DADOS
LEITE PÃO BOLACHA SUCO
LEITE SUCO
LEITE OVOS
PÃO BOLACHA CAFÉ







4.3.2 - ITENS MAIS FREQUENTES
1 - Leite
2 - Pão
3 - Bolacha
4 - Suco
-----------
04 Itens



CANDIDATOS (para frequência)
Leite Pão             = 1/4 -> 25%
Leite Suco           = 2/4 -> 50%
Leite Ovos           = 1/4 -> 25%
Leite Bolacha      = 1/4 -> 25%
Pão Bolacha        = 2/4 -> 50%
Pão Suco             = 1/4 -> 25%
Bolacha Suco      = 1/4 -> 25% 







4.4 - Gerar tabela de grupos de itens frequentes. Dado a frequência mínima de 50%, teremos.

CANDIDATOS
Leite Suco     = 2/4 = 50%
Pão Bolacha  = 2/4 -> 50%







4.5 - Gerar tabela de candidatos a partir da combinação dos itens frequentes e calcular a sua respectiva frequência.
 
FREQUÊNCIA
Leite Suco
Pão Bolacha


FREQUÊNCIA EM ITENS
1 - Leite
2 - Suco
3 - Pão
4 - Bolacha
-----------------------
04 ITENS



BANCO DE DADOS
LEITE PÃO BOLACHA SUCO
LEITE SUCO
LEITE OVOS
PÃO BOLACHA CAFÉ

CANDIDATOS
Leite Suco Pão       - 1/4 - 25%
Leite Suco Bolacha- 1/4 - 25%
Leite Pão Bolacha  - 1/4 - 25%
Suco Pão Bolacha  - 1/4 - 25%







4.6 - Gerar tabela de Grupo de itens frequentes. Com base no percentual 50% de frequência mínima.


CANDIDATOS
Leite Suco Pão       - 1/4 - 25% - Não atende o mínimo de 50%
Leite Suco Bolacha- 1/4 - 25% - Não atende o mínimo de 50%
Leite Pão Bolacha  - 1/4 - 25% - Não atende o mínimo de 50%
Suco Pão Bolacha  - 1/4 - 25% - Não atende o mínimo de 50% 







5 - A partir do ultimo grupo de itens frequentes calcular suas respectivas confiabilidades.

Confiabilidade: A -> B = É o número de tuplas que contem A e B, divididos pelo total de tuplas que contem A.


BANCO DE DADOS
LEITE PÃO BOLACHA SUCO
LEITE SUCO
LEITE OVOS
PÃO BOLACHA CAFÉ


FREQUÊNCIA
Leite Suco
Pão Bolacha


Combinações da Frequência - Confiabilidade
Leite -> Suco     =  50% --  2/3 = 67%
Suco -> Leite     =  50% --  2/2 = 100%
------------------------
Pão -> Bolacha  =  50% --  2/2 = 100%
Bolacha  -> Pão =  50% --  2/2 = 100%




6 - Verificar regras fortes.
Sãos as regras que atingirem a frequência de confiança mínima.

Combinações da Frequência - Confiabilidade
1 - Leite -> Suco     =  50% --  2/3 = 67
2 - Suco -> Leite     =  50% --  2/2 = 100%
------------------------
3 - Pão -> Bolacha  =  50% --  2/2 = 100%
4 - Bolacha  -> Pão =  50% --  2/2 = 100%

Frequência Mínima = 50%
Confiança Mínima   = 70%


RESULTADO
1 - Leite -> Suco     =  50% --  2/3 = 67% <-----FORA
2 - Suco -> Leite     =  50% --  2/2 = 100% <----ok
------------------------
3 - Pão -> Bolacha  =  50% --  2/2 = 100% <----ok
4 - Bolacha  -> Pão =  50% --  2/2 = 100% <----ok





PODEMOS DIZER ENTÃO!

EM 50% DA VEZES

Quem compra SUCO compra LEITE
Quem compra PÃO compra BOLACHA
Quem compra BOLACHA compra PÃO





Meu entendimento do Algorítimo Apriori:  Ray da Costa 





















 

Rabbitmq

https://www.rabbitmq.com/install-debian.html#apt-bintray-quick-start

#!/bin/sh

## If sudo is not available on the system,
## uncomment the line below to install it
# apt-get install -y sudo

sudo apt-get update -y

## Install prerequisites
sudo apt-get install curl gnupg -y

## Install RabbitMQ signing key
curl -fsSL https://github.com/rabbitmq/signing-keys/releases/download/2.0/rabbitmq-release-signing-key.asc | sudo apt-key add -

## Install apt HTTPS transport
sudo apt-get install apt-transport-https

## Add Bintray repositories that provision latest RabbitMQ and Erlang 21.x releases
sudo tee /etc/apt/sources.list.d/bintray.rabbitmq.list <<EOF
## Installs the latest Erlang 21.x release.
## Change component to "erlang" to install the latest version (22.x or later).
## "bionic" as distribution name should work for any later Ubuntu or Debian release.
## See the release to distribution mapping table in RabbitMQ doc guides to learn more.
deb https://dl.bintray.com/rabbitmq-erlang/debian bionic erlang-21.x
deb https://dl.bintray.com/rabbitmq/debian bionic main
EOF

## Update package indices
sudo apt-get update -y

## Install rabbitmq-server and its dependencies
sudo apt-get install rabbitmq-server -y --fix-missing

rabbitmqctl status

sudo service rabbitmq-server stop

sudo service rabbitmq-server start

sudo service rabbitmq-server status

sudo rabbitmq-diagnostics ping

sudo rabbitmq-diagnostics status

sudo rabbitmq-diagnostics environment

sudo rabbitmq-diagnostics node_health_check

14 dicas para sucesso nos projetos de RFID

Caused by: java.lang.IllegalAccessException: class com.sun.javafx.application.LauncherImpl (in module javafx.graphics)

Caused by: java.lang.IllegalAccessException: class com.sun.javafx.application.LauncherImpl (in module javafx.graphics)


SOLUÇÃO
 exports org.demo;
Colocar este comando no final do arquivo module.

module SEU_APLICATIVO {
    requires javafx.swt;
    requires javafx.base;
    requires javafx.controls;
    requires javafx.fxml;
    requires javafx.graphics;
    requires javafx.media;
    requires javafx.swing;
    requires javafx.web;
    exports org.demo;
}

Unable to determine hardware version. I see: Hardware : BCM2835

Unable to determine hardware version. I see: Hardware   : BCM2835

Encontrei este error ao tentar acessar o GPIO da rasp: 
Raspberry Pi 3 Model B Plus Rev 1.3

gpio -v
gpio version: 2.50
Copyright (c) 2012-2018 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.
For details type: gpio -warranty

Raspberry Pi Details:
  Type: Pi 3B+, Revision: 03, Memory: 1024MB, Maker: Sony 
  * Device tree is enabled.
  *--> Raspberry Pi 3 Model B Plus Rev 1.3
  * This Raspberry Pi supports user-level GPIO access.

SOLUÇÃO DO:  BCM2835 
Obs.: Depois de tentar VÁRIAS esta foi a única que funcionou.

EECUTAR OS COMANDOS ABAIXO NA SEQUENCIA. 

sudo apt-get purge wiringpi
hash -r
sudo apt-get install git-core
cd ~
git clone git://git.drogon.net/wiringPi
cd ~/wiringPi
git pull origin
./build
gpio -v
gpio readall
cd ~

pi4j -v

//this command doesn't get the latest for some reason
curl -s get.pi4j.com | sudo bash
//use this instead:
get the file from here http://get.pi4j.com/download/pi4j-1.2-SNAPSHOT.deb
sudo apt-get remove pi4j
curl -s get.pi4j.com/uninstall | sudo bash
sudo dpkg -i pi4j-1.2-SNAPSHOT.deb
pi4j -v

O MQTT é um protocolo de mensagens leve de publicação / assinatura. É útil para uso com sensores de baixa potência, mas é aplicável a muitos cenários.
Para informações mais completas sobre o MQTT, consulte http://mqtt.org/ .

Publicar / Assinar

O protocolo MQTT é baseado no princípio de publicar mensagens e assinar tópicos, ou "pub / sub". Vários clientes se conectam a um broker e se inscrevem em tópicos nos quais estão interessados. Os clientes também se conectam ao broker e publicam mensagens nos tópicos. Muitos clientes podem se inscrever nos mesmos tópicos e fazer as informações que desejarem. O broker e o MQTT atuam como uma interface simples e comum para tudo para se conectar. Isso significa que se você tiver clientes que descarregam mensagens assinadas para um banco de dados, para o Twitter, Cosm ou até mesmo um arquivo de texto simples, torna-se muito simples adicionar novos sensores ou outra entrada de dados a um banco de dados, Twitter ou assim por diante.

Tópicos / Assinaturas

Mensagens no MQTT são publicadas nos tópicos. Não há necessidade de configurar um tópico, publicar nele é o suficiente. Os tópicos são tratados como uma hierarquia, usando uma barra (/) como separador. Isso permite que uma organização sensata de temas comuns seja criada, da mesma maneira que um sistema de arquivos. Por exemplo, vários computadores podem publicar suas informações de temperatura do disco rígido no tópico a seguir, com seu próprio computador e o nome do disco rígido sendo substituído conforme apropriado:

• sensors / COMPUTER_NAME / temperature / HARDDRIVE_NAME

Os clientes podem receber mensagens criando assinaturas. Uma assinatura pode ser para um tópico explícito, em cujo caso apenas mensagens para esse tópico serão recebidas ou podem incluir curingas. Dois curingas estão disponíveis, + ou # .
+ pode ser usado como curinga para um único nível de hierarquia. Pode ser usado com o tópico acima para obter informações sobre todos os computadores e discos rígidos da seguinte maneira:

• sensores / + / temperatura / +

Como outro exemplo, para um tópico de "a / b / c / d", as seguintes assinaturas de exemplo corresponderão:

• a / b / c / d
• + / b / c / d
• a / + / c / d
• um / + / + / d
• + / + / + / +

As seguintes assinaturas não serão correspondentes:

• abc
• b / + / c / d
• + / + / +

# pode ser usado como curinga para todos os níveis restantes de hierarquia. Isso significa que ele deve ser o caractere final de uma assinatura. Com um tópico de "a / b / c / d", as seguintes assinaturas de exemplo corresponderão:

• a / b / c / d
• #
• uma/#
• a / b / #
• abc/#
• + / b / c / #

Níveis de tópicos de comprimento zero são válidos, o que pode levar a um comportamento ligeiramente não óbvio. Por exemplo, um tópico "a // topic" corresponderia corretamente a uma inscrição de "a / + / topic". Da mesma forma, os níveis de tópico com comprimento zero podem existir no início e no final de uma sequência de tópicos, portanto "/ a / topic" corresponderia a uma inscrição de "+ / a / topic", "#" ou "/ #", e um tópico "a / topic /" corresponderia a uma assinatura de "a / topic / +" ou "a / topic / #".

Qualidade de serviço

O MQTT define três níveis de Qualidade de Serviço (QoS). A QoS define quão difícil o brocker / cliente tentará garantir que uma mensagem seja recebida. As mensagens podem ser enviadas em qualquer nível de QoS e os clientes podem tentar assinar tópicos em qualquer nível de QoS. Isso significa que o cliente escolhe o máximo de QoS que receberá. Por exemplo, se uma mensagem for publicada na QoS 2 e um cliente estiver inscrito com QoS 0, a mensagem será entregue a esse cliente com QoS 0. Se um segundo cliente também estiver inscrito no mesmo tópico, mas com QoS 2, ele receberá a mesma mensagem, mas com a QoS 2. Para um segundo exemplo, se um cliente estiver inscrito na QoS 2 e uma mensagem for publicada na QoS 0, o cliente a receberá na QoS 0.
Níveis mais altos de QoS são mais confiáveis, mas envolvem maior latência e maiores requisitos de largura de banda.

• 0: O brocker / cliente entregará a mensagem uma vez, sem confirmação.
• 1: O brocker / cliente entregará a mensagem pelo menos uma vez, com a confirmação necessária.
• 2: O brocker / cliente entregará a mensagem exatamente uma vez usando um handshake de quatro etapas.

Installing the MQTT

mosquitto
sudo wget https://repo.mosquitto.org/debian/mosquitto-repo.gpg.key
sudo apt-key add mosquitto-repo.gpg.key
cd /etc/apt/sources.list.d/
sudo wget http://repo.mosquitto.org/debian/mosquitto-stretch.list
sudo apt-get update
Cliente
sudo apt-get install mosquitto mosquitto-clients
sudo apt-get install python-pip   
sudo pip install paho-mqtt


Configuração
sudo /etc/init.d/mosquitto stop
sudo nano /etc/mosquitto/mosquitto.conf


# Place your local configuration in /etc/mosquitto/conf.d/
#
# A full description of the configuration file is at
# /usr/share/doc/mosquitto/examples/mosquitto.conf.example
pid_file /var/run/mosquitto.pid
persistence true
persistence_location /var/lib/mosquitto/
log_dest topic

log_type error
log_type warning
log_type notice
log_type information
connection_messages true
log_timestamp true
include_dir /etc/mosquitto/conf.d


Testando
sudo /etc/init.d/mosquitto start

Iniciando server
mosquitto_sub -d -t hello/world

Enviando mensagem
mosquitto_pub -d -t hello/world -m "Hello from Terminal window 2!"

Vendo logs
sudo mosquitto_sub -d -t hello/world


Java

Download de um cliente Java: https://www.eclipse.org/paho/
Sendo mais direto: https://repo.eclipse.org/content/repositories/paho-snapshots/org/eclipse/paho/mqtt-client

Publicar uma mensagem

Publicar uma mensagem é muito fácil, crie um MqttClient e use-o para postar em um tópico.

MqttClient client = new MqttClient("tcp://localhost:1883", MqttClient.generateClientId());
client.connect();
MqttMessage message = new MqttMessage();
message.setPayload("Hello world from Java".getBytes());
client.publish("test_java", message);
client.disconnect();

Você tem muitas outras opções, configurações que você pode usar ao postar uma mensagem como segurança, qualidade de serviço (QoS) e muito mais.

Mensagens Consumidoras

Para consumir mensagens, você precisa implementar uma org.eclipse.paho.client.mqttv3.MqttCallbackmensagem que receberá a mensagem e usou essa classe Callback no MqttClient do aplicativo Assinante.

A classe de retorno de chamada:

public class SimpleMqttCallBack implements MqttCallback {
  public void connectionLost(Throwable throwable) {
    System.out.println("Connection to MQTT broker lost!");
  }

  public void messageArrived(String s, MqttMessage mqttMessage) throws Exception {
    System.out.println("Message received:\n\t"+ new String(mqttMessage.getPayload()) );
  }
  public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
    // not used in this example
  }
}

Esta classe de retorno de chamada é usada no aplicativo Assinante da seguinte forma:

MqttClient client=new MqttClient("tcp://localhost:1883", MqttClient.generateClientId());
client.setCallback( new SimpleMqttCallBack() );
client.connect();

Como para o editor, estou usando o broker e o cliente sem nenhuma opção (QoS, segurança).

 

O Apache Kafka®

O Apache Kafka® é uma plataforma de streaming distribuída. O que exatamente isso significa?

Uma plataforma de streaming tem três recursos principais:

    Publique e inscreva-se em fluxos de registros, semelhantes a uma fila de mensagens ou sistema de mensagens corporativo.
    Armazene fluxos de registros de uma maneira durável e tolerante a falhas.
    Processe fluxos de registros conforme eles ocorrem.

 

O Kafka é geralmente usado para duas classes amplas de aplicações:

    Construindo pipelines de dados de fluxo em tempo real que confiantemente obtêm dados entre sistemas ou aplicativos
    Construindo aplicativos de streaming em tempo real que transformam ou reagem aos fluxos de dados

Para entender como Kafka faz essas coisas, vamos mergulhar e explorar os recursos de Kafka de baixo para cima.

Primeiro alguns conceitos:

    O Kafka é executado como um cluster em um ou mais servidores que podem abranger vários datacenters.
    O cluster Kafka armazena fluxos de registros em categorias denominadas tópicos.
    Cada registro consiste em uma chave, um valor e um registro de data e hora.

Kafka tem quatro APIs principais:

    A Producer API permite que um aplicativo publique um fluxo de registros em um ou mais tópicos do Kafka.
    A API do Consumidor permite que um aplicativo assine um ou mais tópicos e processe o fluxo de registros produzidos para eles.
    A API do Streams permite que um aplicativo atue como um processador de fluxo, consumindo um fluxo de entrada de um ou mais tópicos e produzindo um fluxo de saída para um ou mais tópicos de saída, transformando efetivamente os fluxos de entrada em fluxos de saída.
    A Connector API permite criar e executar produtores ou consumidores reutilizáveis ​​que conectam tópicos do Kafka a aplicativos ou sistemas de dados existentes. Por exemplo, um conector para um banco de dados relacional pode capturar todas as alterações em uma tabela.

Enviar feedback

Histórico

Salvas

Comunidade