<jupyter_start><jupyter_text>Visualizando o datasetComo feito no notebook passado, as amostras são visualizadas com o `scatter`. A cor de cada amostra é selecionada pela sua classe: 0: red, 1: yellow: 2: blue. A cor é indexada pelo vetor `Y` das classes.<jupyter_code># normalização global - não deve ser usada
X_a = X - X.min()
X_a /= X_a.max()

# normalização correta - por coluna
X_c = X - X.min(axis=0,keepdims=True)
X_c /= X_c.max(axis=0,keepdims=True)<jupyter_output><empty_output><jupyter_text>Visualização dados normalizados<jupyter_code>f, (ax1, ax2) = plt.subplots(1, 2, sharey=False)
ax1.set_ylim(0,1)
ax1.set_xlim(0,1)
ax2.set_ylim(0,1)
ax2.set_xlim(0,1)
ax1.scatter(X_a[:, 0], X_a[:, 1], c=colors[Y])
ax2.scatter(X_c[:, 0], X_c[:, 1], c=colors[Y])
ax1.set_title('Normalizacao errada')
ax2.set_title('X_c: Normalizacao correta')<jupyter_output><empty_output><jupyter_text>def oneHotIt2(Y,n_classes):    Y = Y.reshape(-1,1)    i = np.arange(n_classes).reshape(1,n_classes)    Y_oh = (Y == i).astype(int)    return Y_ohdef oneHotIt(Y,n_classes):    n_samples = Y.size  número de amostras    i = np.arange(n_samples)    Y_oh = np.zeros(shape=(n_samples,n_classes))    Y_oh[i,Y] = 1    return Y_oh  Colocando a coluna 0 em X com 1s como o 'bias'Conforme visto no exercício da Regressão Linear, a equação linear de y em função de x0, x1, x_k tem um fator independente de x, denominado bias. Inserindo-se a coluna 0 de X com 1, é equivalente a definir o w0 como bias.<jupyter_code>X_bias = np.hstack([np.ones((150,1)),X_c]) # incluído X com coluna de 1s para gerar bias no W
print('X_bias[:5]=\n',X_bias[:5])<jupyter_output>X_bias[:5]=
 [[ 1.          0.22222222  0.06779661]
 [ 1.          0.16666667  0.06779661]
 [ 1.          0.11111111  0.05084746]
 [ 1.          0.08333333  0.08474576]
 [ 1.          0.19444444  0.06779661]]<jupyter_text>Este é o laço principal da Regressão Logística por SoftmaxOs pesos são inicializados em zero, sem fator de regularização.Em cada iteração, a função a ser minimizada é calculada e os pesos são ajustadospelo técnica de gradiente descendente.<jupyter_code>n_amostras = X_bias.shape[0] # number of training examples
n_atributos = X_bias.shape[1] # number of attributes (features, pixels + 1(bias))
n_classes = 3         # number of classes
WT = np.zeros((n_atributos,n_classes)) # n. de linhas é igual a número de atributos (features, pixels)
epochs = 3000
learningRate = 0.01

print('X.shape:',X.shape)
print('Y.shape:',Y.shape)


X_train_tensor = torch.from_numpy(X).type(torch.FloatTensor)
ones = torch.ones(X.shape[0],1)
ones = ones.type(torch.FloatTensor)
X_bias = torch.cat((ones, X_train_tensor), 1)
print(X_train_tensor.size())
print(X_bias.size())
Y_train_tensor = torch.from_numpy(Y).type(torch.LongTensor)
Y_tensor = oneHotIt_tensor(Y_train_tensor,3)
print(Y_tensor.size())
WT = torch.zeros((n_atributos,n_classes))

print(WT.size())
losses = []
for i in range(epochs):
    #Z = X_bias.dot(WT)
    Z = X_bias.mm(WT)
    Y_oh_hat = softmax(Z)
    loss = (-1. / n_amostras) * torch.sum(Y_tensor * torch.log(Y_oh_hat))
    Grad = (-1. / n_amostras) * (torch.t(X_bias)).mm(Y_tensor - Y_oh_hat)    

    WT = WT - (learningRate * Grad)
    losses.append(loss)
print('Final loss:',loss)<jupyter_output>Final loss: 0.3064621494275828<jupyter_text>Visualizando a minimização da Perda durante o treinamentoÉ fundamental acompanhar o comportamento da Perda durante o treinamento, pois é difícil prever se os parâmetros do gradiente descendente estão bons.<jupyter_code>plt.plot(losses)<jupyter_output><empty_output><jupyter_text>Predict  Colocando a coluna 0 em X com 1s como o 'bias'Conforme visto no exercício da Regressão Linear, a equação linear de y em função de x0, x1, x_k tem um fator independente de x, denominado bias. Inserindo-se a coluna 0 de X com 1, é equivalente a definir o w0 como bias.<jupyter_code>print('Training Accuracy: ', getAccuracy(X_bias,WT,Y_train_tensor), '%')
val, y_pred_max = predict(X_bias,WT)
y_pred_max = y_pred_max.numpy()
print(y_pred_max.shape)
print('Matriz de confusão (Treino):')
display(pd.crosstab(y_pred_max, Y_train_tensor.numpy()))<jupyter_output>Matriz de confusão (Treino):
{'fraction_non_alphanumeric': 0.12443059218412851, 'fraction_numerical': 0.044353871973147926, 'mean_word_length': 4.909348441926346, 'pattern_counts': {'":': 0, '<': 22, '<?xml version=': 0, '>': 22, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 2, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '111334', 'license': 'MIT', 'n_tokens_mistral': 1774, 'n_tokens_neox': 1674, 'n_words': 409, 'path': 'CIFAR_10/Other_pytorch/my_mapa_atributos.ipynb', 'repo_name': 'kaelgabriel/Neural_Networks_Pytorch', 'size': '4171'}