Увеличение скорости линейной регрессии

Question

Я новичок в машинном обучении, и это мой первый раз, когда я создаю модель линейной регрессии для набора данных (что для меня является большим шагом). Я создал свои ссылочные строки и изменил их форму. Единственная проблема в том, что это слишком медленно. Есть ли какой-нибудь код или лучший способ, который я могу использовать. Было бы здорово, если бы у вас была возможность пересмотреть мой код. Спасибо.

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torch.utils.data import TensorDataset
db = pd.read_csv("Melbourne_housing_FULL.csv")
db2 = pd.read_csv("MELBOURNE_HOUSE_PRICES_LESS.csv")

"""['Suburb', 'Address', 
'Rooms', 'Type', 'Price', 
'Method', 'SellerG',
'Date', 'Distance', 
'Postcode', 'Bedroom2', 'Bathroom', 'Car',
'Landsize', 'BuildingArea', 
'YearBuilt', 'CouncilArea', 
'Lattitude','Longtitude', 
'Regionname', 'Propertycount'] 

column names for Full.csv"""

rooms_properties = db[["Rooms","Landsize","Bathroom","Car","YearBuilt"]].copy()
rooms_properties.fillna(rooms_properties.mean(),inplace=True)
rooms_price = db[["Price"]].copy()
rooms_price.fillna(rooms_price.mean(),inplace=True)

room_array_properties = rooms_properties.to_numpy()
room_array_price = rooms_price.to_numpy()

##Splitted list with percentage
def indice_splitter(array_prop,x=0.2):
       val = np.random.permutation(len(array_prop))
       percent_1 = val[:int(len(val) * x)]
       percent_2 = val[int(len(val)*x):]
       return percent_2,percent_1
## Converted df as tensor

train_indices,validation_indices = indice_splitter(room_array_price)
train_data,targets1 = room_array_properties[train_indices], room_array_price[train_indices]

validation_data ,targets2 = torch.from_numpy(room_array_properties[validation_indices]).float(), torch.from_numpy(room_array_price[validation_indices]).float()
t_data, tar1 = torch.tensor(train_data,requires_grad=True).float(), torch.tensor(targets1,requires_grad=True).float()
# rooms_price = rooms_price[rooms_price.notnull()]
# r_nonull = [rooms_properties.loc[rooms_properties[i].notnull()]  for i in rooms_properties.columns]
# r_nonull = r_nonull[len(r_nonull)-1]
# r_array = r_nonull.to_numpy()

# weight = torch.rand(5,1, dtype=float,requires_grad=True)
# bias = torch.randn(len(train_data),dtype=float,requires_grad=True)

## my model and result
model = nn.Linear(5,1)
weight, bias = model.parameters()

train_ds = TensorDataset(t_data,tar1)
batch_size = 10
train_dl = DataLoader(train_ds,batch_size,shuffle=True)

preds = model(t_data)
loss_fn = F.mse_loss
opt = torch.optim.SGD(model.parameters(), lr= 1e-5)

#
def fit(num_epochs, model, loss_fn, opt):
       for epochy in range(num_epochs):
              for xb,yb in train_dl:
                     #increase the model accuracy
                     pred = model(xb)
                     loss = loss_fn(pred,yb)
                     loss.backward()
                     #upgrade the stoachaistic grad descent
                     opt.step()
                     #refresh the data
                     opt.zero_grad()
              if (epochy +1) % 10 == 0:
                     print("{}/{}, Loss:{:.4f}".format(epochy+1,num_epochs,loss.item()))

fit(10,model, loss_fn,opt)

Результат = 10/10, Потери: nan

Мой ожидаемый результат должен каждый раз уменьшать значение функции потерь.

Я хочу повторить эта регрессия не менее 1000 раз.

У меня ноутбук 1660Ti, i7 9-го поколения, 16 ГБ оперативной памяти