#O problema AND e OR é realizada pela rede neural artificial, pela função MLPClassifier() do pacote sklearn.neural_network. Essa função cria uma rede neural com uma única camada oculta que utiliza o algoritmo de backpropagation para aprender a relação entre os dados de entrada e as respectivas saídas.

# Para o problema de AND e OR, o código recebe como entrada os dados de treino e teste, que consistem em uma matriz com N linhas e 2 colunas contendo os valores binários de entrada para cada problema (AND ou OR) e uma matriz com N linhas contendo a saída esperada para cada entrada. Esses dados são utilizados para treinar e avaliar o modelo.

#Após a criação do modelo, a função fit() é utilizada para treinar o modelo com os dados de treino, e a função predict() é utilizada para gerar as previsões para os dados de teste. A acurácia do modelo é avaliada através da função accuracy_score() do pacote sklearn.metrics e a matriz de confusão é gerada utilizando a classe ConfusionMatrix() do pacote yellowbrick.classifier

import pandas as pd
import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
from google.colab import drive

# Caminho para o arquivo de dados
caminho_arquivo = '/content/drive/MyDrive/dados_and_or.csv'

# Carrega os dados do arquivo
dados = pd.read_csv(caminho_arquivo)

# Pergunta qual problema resolver
problema = input("Qual problema você deseja resolver? (AND ou OR)")

# Pergunta quantos valores binários o problema deve ter
n_valores = int(input("Quantos valores binários o problema deve ter?"))

# Cria as colunas de entrada e saída
X = dados.iloc[:, :n_valores]
y = dados[problema]

# Instancia e treina o modelo de rede neural
modelo = MLPClassifier(max_iter=1000, verbose=True, tol=0.00000000000001, solver='adam', activation='relu', hidden_layer_sizes=9)
modelo.fit(X_treino, y_treino)

# Faz as previsões e exibe a acurácia do modelo
previsoes = modelo.predict(X_teste)
acuracia = accuracy_score(y_teste, previsoes)
print("A acurácia do modelo é:", acuracia)

#O código que foi mostrado abaoxp cria um desenho que mostra pontos que representam diferentes combinações dos valores X1 e X2 e as cores indicam se a resposta para aquela combinação é 0 ou 1. Quando olhamos para esse desenho, podemos notar que não é possível encontrar uma linha reta que possa separar os pontos em duas classes diferentes. Essa é a razão pela qual o Perceptron não é capaz de resolver o problema XOR.

import matplotlib.pyplot as plt

# Dados do problema do XOR
X = [[0, 0], [0, 1], [1, 0], [1, 1]]
y = [0, 1, 1, 0]

# Plot dos dados
plt.scatter([x[0] for x in X], [x[1] for x in X], c=y)
plt.xlabel('X1')
plt.ylabel('X2')
plt.show()