I am new to the box and the A.I program, and I don't know how to solve this problem:
!rm -f winequality-red.csv winequality-white.csv
!wget https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv
!wget https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv
import pandas as pd
import numpy as np
import math, random
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
df_red = pd.read_csv('winequality-red.csv',delimiter=";")
#Como estamos realizando una tarea de clasificación, les asignaremos a todos los vinos tintos la etiqueta 1
df_red["color"] = 1
#El método .head() es muy útil para previsualizar los datos
df_red.head()
df_white = pd.read_csv('winequality-white.csv',delimiter=";")
df_white["color"] = 0 #Asignaremos a todos los vinos blancos la etiqueta 0
df_white.head()
df = pd.concat([df_red, df_white])
#Y mezclamos los datos de los vinos blancos y los tintos
df = df.sample(frac=1).reset_index(drop=True)
df.head()
#Elegimos tres atributos en los que basar la predicción
input_columns = ["citric acid", "residual sugar", "total sulfur dioxide"]
output_columns = ["color"]
#Extraemos los atributos relevantes en los arrays x e y
X = df[input_columns].to_numpy()
Y = df[output_columns].to_numpy()
print("Shape of X:", X.shape)
print("Shape of Y:", Y.shape)
in_features = X.shape[1]
class SingleNeuronModel():
def __init__(self, in_features):
#self.w = np.zeros(in_features)
#self.w_0 = 0.
# Es preferible definir los pesos iniciales como valores pequeños distribuidos de forma normal
self.w = 0.01 * np.random.randn(in_features)
self.w_0 = 0.01 * np.random.randn()
self.non_zero_tolerance = 1e-8 # add this to divisions to ensure we don't divide by 0
def forward(self, x):
# Calcular y guardar la preactivación z
self.z = x @ self.w.T + self.w_0
# Aplicar la función de activación y devolver
self.a = self.activation(self.z)
return self.a
def activation(self, z):
raise ImplementationError("activation method should be implemented by subclass")
# Calcular y guardar el gradiente del output respecto a los pesos
def gradient(self, x):
raise ImplementationError("gradient method should be implemented by subclass")
# Actualizar los pesos en función de los gradientes y la tasa de aprendizaje
def update(self, grad_loss, learning_rate):
model.w -= grad_loss * self.grad_w * learning_rate
model.w_0 -= grad_loss * self.grad_w_0 * learning_rate
# Reimplementar el modelo de regresión de una sola neurona usando la base SingleNeuronModel
class SingleNeuronRegressionModel(SingleNeuronModel):
# Función de activación lineal para el modelo de regresión
def activation(self, z):
return z
# Gradiente del output respecto a los pesos para la activación lineal
def gradient(self, x):
self.grad_w = x
self.grad_w_0 = 1.
# ¡Nueva implementación! Modelo de clasificación de una sola neurona
class SingleNeuronClassificationModel(SingleNeuronModel):
# Función de activación sigmoide para la clasificación
def activation(self, z):
return 1 / (1 + np.exp(-z) + self.non_zero_tolerance)
# Gradiente del output respecto a los pesos para la activación sigmoide
def gradient(self, x):
self.grad_w = self.a * (1-self.a) * x
self.grad_w_0 = self.a * (1-self.a)
def train_model_NLL_loss(model, input_data, output_data,
learning_rate, num_epochs):
non_zero_tolerance = 1e-8 # Añadir esto a los cálculos de log para garantizar que no tomamos el log de 0
num_samples = len(input_data)
for epoch in range(1, num_epochs+1):
total_loss = 0 # Hacer un seguimiento de la pérdida total en todo el conjunto de datos
for i in range(num_samples):
x = input_data[i,...]
y = output_data[i]
y_predicted = model.forward(x)
# Función de pérdida de NLL
loss = -(y * np.log(y_predicted + non_zero_tolerance) + (1-y) * np.log(1-y_predicted + non_zero_tolerance))
total_loss += loss
# Gradiente de la predicción respecto a los pesos
model.gradient(x)
# Gradiente de la pérdida respecto a la predicción para NLL
grad_loss = (y_predicted - y)/(y_predicted * (1-y_predicted))
#Actualizar el modelo en función del gradiente
model.update(grad_loss, learning_rate)
report_every = max(1, num_epochs // 10)
if epoch == 1 or epoch % report_every == 0: # Cada pocos ciclos, generar un informe
print("epoch", epoch, "has total loss", total_loss)
# Utilizaremos esta función para evaluar el rendimiento de nuestro clasificador entrenado
def evaluate_classification_accuracy(model, input_data, labels):
# Contar el número de muestras clasificadas correctamente dado un conjunto de pesos
correct = 0
num_samples = len(input_data)
for i in range(num_samples):
x = input_data[i,...]
y = labels[i]
y_predicted = model.forward(x)
label_predicted = 1 if y_predicted > 0.5 else 0
if label_predicted == y:
correct += 1
accuracy = correct / num_samples
print("Our model predicted", correct, "out of", num_samples,
"correctly for", accuracy*100, "% accuracy")
return accuracy
input_data = np.array(["citric acid", "residual sugar", "total sulfur dioxide"])
labels = ["color"]
def plot_3d_dataset(x, y):
x_np_3d = np.array(x)
x_np_3d.reshape(len(x),3)
colors = []
for label in y:
if label == 0:
colors.append("red")
else:
colors.append("blue")
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.scatter3D(x_np_3d[...,0], x_np_3d[...,1],x_np_3d[...,2], color = colors)
return ax
def plot_3d_decision_boundary(ax, w, w_0):
x = np.linspace(-1,4,10)
y = np.linspace(-1,6,10)
X,Y = np.meshgrid(x,y)
Z = (-X*w[0] - Y*w[1] - w_0)/w[2]
surf = ax.plot_surface(X, Y, Z)
ax.set_zlim(-10,5)
return
model = SingleNeuronClassificationModel(in_features=len(input_data[0]))
learning_rate =0.001
epochs = 200
train_model_NLL_loss(model, input_data, labels, learning_rate, epochs)
print("\nFinal weights:")
print(model.w, model.w_0)
evaluate_classification_accuracy(model, input_data, labels)
ax=plot_3d_dataset(input_data, labels)
plot_3d_decision_boundary(ax, model.w, model.w_0)
plt.show()
Utilice Pandas para leer el archivo cvs en un marco de datos Proceso de entrenamiento, utilizando la pérdida de log-verosimilitud negativa,más adecuada para problemas de clasificación The class implementation of the single neuron classifier must be trained to carry out a binary classification of wine by color according to its characteristics. I need help beacouse i´m new in this language.
The error is :
-------------------------------------------------------------------
enter code here ValueError Traceback (most recent call last)
<ipython-input-19-e78d64c8d9e7> in <module>
5 epochs = 200
6
----> 7 train_model_NLL_loss(model, input_data, labels, learning_rate, epochs)
8 print("\nFinal weights:")
9 print(model.w, model.w_0)
1 frames
<ipython-input-14-654d498667a7> in train_model_NLL_loss(model, input_data, output_data, learning_rate, num_epochs)
68 x = input_data[i,...]
69 y = output_data[i]
---> 70 y_predicted = model.forward(x)
71
72 # Función de pérdida de NLL
<ipython-input-14-654d498667a7> in forward(self, x)
11 def forward(self, x):
12 # Calcular y guardar la preactivación z
---> 13 self.z = x @ self.w.T + self.w_0
14
15 # Aplicar la función de activación y devolver
ValueError: matmul: Input operand 0 does not have enough dimensions (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)
