Execute o algoritmo de treinamento para a rede Adaline, considerando (para cada execução do algoritmo de treinamento, especifique os valores atualizados dos parâmetros livres, o valor atualizado da variável época, dos erros quadráticos médios anterior e atual para cada época):

------------------------------ Inicialização-----------------------------------------
<1> Inicialmente, k amostras são escolhidas aleatoriamente para serem os centros de k grupos de
padrões. Dessa forma, inicialmente, o centro de cada grupo corresponde a uma amostra.
------------------------------ Processo Iterativo-----------------------------------------
// Alocação das P Amostras nos K grupos
<2> As amostras são alocadas ao grupo que tiver o centro mais próximo.
// Atualização dos centros dos K grupos
<3> Após a fase de alocação, os k centros (ou os centros dos k grupos) são recalculados para que
representem o “ponto” médio do seu grupo.
<4> Esse processo de redefinição dos centros e das amostras alocadas a cada grupo é repetido até a
estabilização dos centros dos grupos (convergência do algoritmo)
A finalidade do algoritmo é minimizar a soma das distâncias quadráticas entre as amostras de
entrada e o centro do conjunto (grupo) ao qual elas pertencem.

Execute cinco vezes o algoritmo K-Means, inicializando aleatoriamente os centros dos k grupos com as amostras. Se for o caso, reinicie o gerador de números aleatórios em cada execução de tal forma que as amostras escolhidas para inicialmente representarem os centros não sejam as mesmas. 20 Cidades ou 40 Cidades.

Trace, para cada execução do algoritmo, um gráfico que ilustra a soma das distâncias quadráticas (entre as amostras de entrada e o centro do conjunto (grupo) ao qual elas pertencem) em função do número de iterações (“época”).

O neurônio constituinte da rede Perceptron terá três entradas e uma saída.
Utilizando o algoritmo supervisionado de Hebb (regra de Hebb) para classificação de padrões e
assumindo a taxa de aprendizagem igual a 0.01...
Execute cinco treinamentos para a rede Perceptron inicializando o vetor de pesos (parâmetros
livres) em cada treinamento com valores aleatórios entre zero e um. Se for o caso, reinicie o gerador de números aleatórios em cada treinamento de tal forma que os elementos do vetor de pesos iniciais não sejam os mesmos.

<1> Obter o conjunto de amostras de treinamento {x
(k), d(k)}

<2> Inicializar os pesos sinápticos e os limiares de ativação com valores aleatórios pequenos
<3> Inicializar o contador do número de épocas {época ← 0}
<4> Repetir as instruções:
<4.1> erro ← falso;
<4.2> Para todas as amostras de treinamento {x

(k), d(k)}, fazer:

<4.2.1> Obter y
(k);
<4.2.2> Se y
(k) ≠ d(k)
<4.2.2.1> Então

i) Alterar aleatoriamente os valores dos pesos
sinápticos e dos limiares de ativação
ii) erro ← verdadeiro

<4.3> época ← época + 1
Até que (erro = falso) ou (época > número_máximo_épocas);
Fim {Algoritmo Aleatório para RNA com Arquitetura Feedforward de Camada Simples - Fase de
Aprendizado (Treinamento)}

Execute dez treinamentos (considere o algoritmo dado a seguir) para a RNA, considerando como
número máximo de épocas o valor 100. Reinicie o gerador de números aleatórios em cada
treinamento, de tal forma que os valores dos pesos sinápticos e dos limiares de ativação não sejam
os mesmos.

<1> Obter o conjunto de amostras de treinamento {x
(k), d(k)}

<2> Inicializar os pesos sinápticos e os limiares de ativação com valores aleatórios pequenos
<3> Inicializar o contador do número de épocas {época ← 0}
<4> Repetir as instruções:
<4.1> Eqmanterior ← Eqm(w)
<4.2> Para todas as amostras de treinamento {x

(k), d(k)}, fazer:

<4.2.1> Obter y
(k);

<4.2.2> Calcular erro: erro(k)=( d(k)- y
(k))

<4.2.3> Alterar aleatoriamente (considere r como um número real
aleatoriamente gerado para cada amostra, no intervalo
[0,1]) os valores dos pesos sinápticos e dos limiares de
ativação, proporcionalmente ao valor do erro calculado
watual ← want +(r/erro(k))
θatual ← θant +(r/erro(k))

<4.3> época ← época + 1
<4.4> Eqmatual ← Eqm(w)
Até que (|Eqmatual

• Eqmanterior | ≤ ɛ) ou (época > número_máximo_épocas);

Fim {Algoritmo Aleatório para RNA com Arquitetura Feedforward de Múltiplas Camadas - Fase de
Aprendizado (Treinamento)}

• Considere uma RNA com arquitetura feedforward de múltiplas camadas. Suponha que a RNA seja
  utilizada para mapear uma aplicação (processo/sistema) com uma entrada real, e uma saída real.
  Considere que a RNA tenha uma única camada escondida com três neurônios (função de ativação
  tangente hiperbólica: β = 1) e um único neurônio na camada de saída (com função de ativação
  linear).

Execute dez treinamentos (considere o algoritmo dado a seguir) para a RNA, considerando como
número máximo de épocas o valor 100 e como tolerância (ɛ)= 0,01. Reinicie o gerador de números
aleatórios em cada treinamento, de tal forma que os valores dos pesos sinápticos e dos limiares de
ativação não sejam os mesmos. Para cada treinamento, esboce o gráfico dos valores do erro
quadrático médio (Eqm) em função da época de treinamento.

a) Execute 5 treinamentos (Treinamento I) para a rede ADALINE, inicializando o vetor de pesos em cada treinamento com valores aleatórios entre zero e um. Se for o caso, reinicie o gerador de números aleatórios em cada treinamento de tal forma que os elementos do vetor de pesos iniciais não sejam os mesmos. Utilize taxa de aprendizado η = 0.0025 e precisão ε = 10^-6.
Observação 1: considere os sinais de entrada em sua forma original (ou seja, os sinais não
devem ser normalizados).
Observação 2: utilize o modo de aprendizagem sequencial (online, por padrão).
𝑤𝑎𝑡𝑢𝑎𝑙 = 𝑤𝑎𝑛𝑡𝑒𝑟𝑖𝑜𝑟 + η*(d(k)-u)*xk

dos valores do erro quadrático médio (EQM) em função de cada época de treinamento.

Trace, para cada execução do algoritmo, um gráfico bidimensional com as 20/40 amostras e os centros obtidos de cada um dos clusters.

Um sistema de gerenciamento automático de ajuste de duas válvulas situado a 500 metros de um processo industrial envia um sinal codificado constituído de quatro grandezas {x1, x2, x3 e x4}, as quais são necessárias para o acionamento de cada uma das válvulas. Conforme mostra a figura a seguir, uma mesma via de comunicação é utilizada para acionamento de ambas as válvulas, sendo
que o comutador localizado próximo das válvulas deve decidir se o sinal é para a válvula A ou B.

Entretanto, durante a comunicação, os sinais sofrem interferências que alteram o
conteúdo das informações originalmente transmitidas. Para resolver este problema a equipe de
engenheiros e cientistas pretende treinar uma rede ADALINE para classificar os sinais ruidosos,
cujo objetivo é então garantir ao sistema comutador se os dados devem ser encaminhados para o
comando de ajuste da válvula A ou B.
Assim, baseado nas medições de alguns sinais já com ruídos, compilou-se o conjunto de
treinamento (Arquivo Treinamento_Adaline_PPA.xls)

Inicio {Algoritmo Perceptron - Fase de Operação}
<1> Obter uma amostra a ser classificada {x};
<2> Utilizar o vetor w ajustado durante o treinamento;
<3> Executar as seguintes instruções:
<3.1>u <-w . x;
<3.2>y<-sinal(u);
<3.3>Se y = -1
<3.3.1> Então: amostra x ∈ {Classe A}
<3.4> Se y = 1
<3.4.1> Então: amostra x ∈ {Classe B}
Fim {Algoritmo Perceptron - Fase de Operação}

Após o treinamento do Perceptron aplique-o na classificação automática das seguintes amostras
de óleo (também presentes no Arquvo Teste_Perceptron.xls), indicando os resultados das saídas
(Classes) referentes aos cinco processos de treinamento realizados