Pytorch Realization Logistic Return to

1. The import related api

import torch
import torch.nn as nn
import numpy as np
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

2. Prepare the data

bc = datasets.load_breast_cancer()
X, y = bc.data, bc.target

n_samples, n_features = X.shape# Obtain the number of samples and the number of sample characteristics 

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)# Set test set to 20%

3. Data preprocessing

3.1 Feature scaling

#  Must use first fit_transform(trainData), After that transform(testData)
#  If direct transform(testData), The program will report an error 
#  If fit_transfrom(trainData) after , Use fit_transform(testData) Instead of transform(testData), Although it can also normalize , But the two results are not in the same “ standard ” Under the , There are obvious differences .( Be sure to avoid this situation )
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

3.2 Data type conversion

X_train = torch.from_numpy(X_train.astype(np.float32))
X_test = torch.from_numpy(X_test.astype(np.float32))
y_train = torch.from_numpy(y_train.astype(np.float32))
y_test = torch.from_numpy(y_test.astype(np.float32))

3.3 Data format adjustment

tensor.view() Be similar to array.resize(), Here is to adjust the label line to 1 Column

# Be similar to resize()
y_train = y_train.view(y_train.shape[0], 1)
y_test = y_test.view(y_test.shape[0], 1)

4. Build a model

4.1 Define the basic network model

class Model(nn.Module):
    def __init__(self, n_input_features):
        super(Model, self).__init__()# For initialization nn.module
        self.linear = nn.Linear(n_input_features, 1)# Define a linear perceptron , Input is n_input_features, Output as a single value 

    def forward(self, x):
        y_pred = torch.sigmoid(self.linear(x))# Use sigmoid Output function 0~1 A value of 
        return y_pred

model = Model(n_features)

4.2 Define loss and optimizer

num_epochs = 100
lr = 0.01
criterion = nn.BCELoss()# Because this is the second category , So use Binary Cross Entropy
optimizer = torch.optim.SGD(model.parameters(), lr=lr)#lr For learning rate , Hyperparameters 

5. model training

for epoch in range(num_epochs):
    # Iterate forward and calculate the error 
    y_pred = model(X_train)
    loss = criterion(y_pred, y_train)

    # Reverse iteration 、 Update parameters 
    loss.backward()
    optimizer.step()

    #  Clear the gradient before updating the parameters once 
    optimizer.zero_grad()

    if (epoch+1) % 10 == 0:
        print(f'epoch: {
      epoch+1}, loss = {
      loss.item():.4f}')

6. Model test

with torch.no_grad():
    y_predicted = model(X_test)
    y_predicted_cls = y_predicted.round()# Yes 0~1 The results between are rounded , Get classification value 
    acc = y_predicted_cls.eq(y_test).sum() / float(y_test.shape[0])
    print(f'accuracy: {
      acc.item():.4f}')

y_predicted_cls.eq(y_test) When the prediction category is equal to the category of test data, it is 1, And count all the times of correct classification , Calculate the accuracy of the test set .