Modelo Simples de Rede Neural em Processing
O Perceptron é um modelo simples de rede neural que pode ser utilizado em problemas de classificação binária. Foi criado em 1958 por Rosenblatt, sendo a forma mais simples da configuração de uma rede neural artificial, uma vez que é constituída de um único neurônio.
É composto por uma camada de entrada de dados, uma camada de pesos e uma camada de saída. A camada de pesos é responsável por ajustar os valores dos dados de entrada para que a saída seja a mais precisa possível.
A figura ilustra a rede Perceptron de única camada, onde podemos ter N entradas, mas apenas uma única saída com um valor de 0 e 1 ou de -1 e 1.
Sendo a forma mais simples da configuração de uma rede neural artificial, uma vez que é constituída de uma única camada neural e de um único neurônio.
Utilizando um exemplo de classificação de pontos em um plano cartesiano, vou mostrar como implementar o Perceptron em Processing.
class Perceptron{
float[] weights = new float[2];
float lr = 0.1;
int sign(float n){
if(n>=0){
return 1;
}else{
return -1;
}
}
Perceptron(){
for(int i = 0; i < weights.length; i++){
weights[i] = random(-1,1);
}
}
int guess(float[] inputs){
float sum = 0;
for(int i = 0; i < weights.length; i++){
sum += inputs[i]*weights[i];
}
int output = sign(sum);
return output;
}
void train(float[] inputs, int target){
int guess = guess(inputs);
float error = target - guess;
for(int i = 0; i < weights.length; i++){
weights[i] += error * inputs[i] * lr;
}
}
}Explicando o código do Perceptron linha por linha.
Aqui é definido um array de floats com o nome weights e tamanho 2. Os pesos serão representados por weights:
1 float[] weights = new float[2];
1 float lr = 0.1; int sign(float n){
if(n>=0){
return 1;
}else{
return -1;
}
} Perceptron(){
for(int i = 0; i < weights.length; i++){
weights[i] = random(-1,1); // Inicializa os pesos com valores aleatórios entre -1 e 1.
}
}
int guess(float[] inputs){
float sum = 0;
for(int i = 0; i < weights.length; i++){
sum += inputs[i]*weights[i]; // Calcula a soma ponderada das entradas e pesos.
}
int output = sign(sum); // Aplica a função de ativação "sign" à soma
return output; // Retorna a previsão (1 ou -1)
}
void train(float[] inputs, int target){
int guess = guess(inputs);
float error = target - guess;
for(int i = 0; i < weights.length; i++){
weights[i] += error * inputs[i] * lr;
}
}
Criando uma Classe de Pontos com Rótulos
Agora vamos criar uma classe chamada Point em Processing que representa pontos com coordenadas x e y aleatórias e rótulos com base na relação entre essas coordenadas. Os pontos serão exibidos como elipses com cores diferentes com base em seus rótulos.
Defina a classe Point, que representa pontos com coordenadas x e y aleatórias e rótulos com base na relação entre essas coordenadas.
Vamos entender o que cada parte do código faz:
Configuração Inicial e Treinamento
- Crie uma classe chamada Point no seu projeto. Dentro desta classe, você definirá as propriedades e métodos necessários para representar os pontos.
class Point {
float x;
float y;
int label = 1;
Point() {
x = random(width);
y = random(height);
if (y > x) {
label = 1;
} else {
label = -1;
}
}
void show() {
stroke(0);
if (label == 1) {
fill(255);
} else {
fill(0);
}
ellipse(x, y, 8, 8);
}
}
- A classe Point possui três variáveis: x e y para as coordenadas do ponto e label para o rótulo do ponto.
- O construtor Point() é chamado quando um objeto da classe Point é criado. Ele atribui coordenadas x e y aleatórias e determina o rótulo com base na relação entre y e x.
- O método show() desenha o ponto na tela como uma elipse. A cor da elipse é definida com base no rótulo do ponto.
No método setup(), inicialize o Perceptron e crie uma matriz de objetos Point para representar os pontos. Treine o Perceptron com os dados.
Perceptron brain;
Point[] points = new Point[1000];
int trainingIndex = 0;
void setup() {
size(400, 400);
brain = new Perceptron();
for (int i = 0; i < points.length; i++) {
points[i] = new Point();
}
float[] inputs = {-1, 0.5};
int guess = brain.guess(inputs);
}
No método draw(), desenhe os pontos e continue treinando o Perceptron interativamente.
void draw() {
background(255);
for (Point p : points) {
p.show();
}
for (Point p : points) {
float[] inputs = {p.x, p.y};
int target = p.label;
int guess = brain.guess(inputs);
if (guess == target) {
fill(0, 255, 0);
} else {
fill(255, 0, 0);
}
noStroke();
ellipse(p.x, p.y, 5, 5);
}
Point training = points[trainingIndex];
float[] inputs = {training.x, training.y};
int target = training.label;
brain.train(inputs, target);
trainingIndex++;
if (trainingIndex >= points.length) {
trainingIndex = 0;
}
}
Agora você pode executar o código. Ele irá gerar pontos na tela, onde a cor da elipse indica a classificação do Perceptron ( verde para acertos e vermelho para erros ). O Perceptron continuará a ser treinado interativamente à medida que os pontos são exibidos.
.gif)
0 Comentários