Процесс глубокого машинного обучения — это не что иное, как получение данных, предварительная обработка данных, обучение модели, перекрестная проверка, выбор модели и окончательный прогноз.
чтение набора данных
пакет гида
import d2lzh as d2l
from mxnet import autograd,gluon,init,nd
from mxnet.gluon import data as gdata ,loss as gloss,nn
import numpy as np
import pandas as pd
Наши данные загружаются с Kaggle, и для загрузки данных не обязательно выходить в интернет, но, похоже, необходимо загрузить их позже.
читать после опрессовки
train_data= pd.read_csv('D:/dL/house_Data/train.csv')
test_data =pd.read_csv('D:/dL/house_Data/test.csv')
Количество данных и их размеры (80+1, 80 функций и 1 метка)
all_features = pd.concat((train_data.iloc[:,1:-1],test_data.iloc[:,1:]))
предварительная обработка данных
непрерывное значениеСтандартизация признаков: среднее значение признака по всему набору данных равно μ, а стандартное отклонение — σ.
Мы обрезаем μ от каждого значения и делим на σ, чтобы получить нормализованное значение каждого собственного значения.
Замените пропущенные значения собственными значениями
numeric_features =all_features.dtypes[all_features.dtypes !='object'].index
all_features[numeric_features] = all_features[numeric_features].apply(lambda x:(x-x.mean())/(x.std()))
# 标准化后，每个特征的均值表位0，所以可以直接用0来替换缺失值
all_features[numeric_features] = all_features[numeric_features].fillna(0)
дискретное значениеПревратиться в просто особенность. Например, открытый размер, только большой или маленький, поэтому измените его на open size_large = 0 || 1 и open size_small = 0 || 1 два набора собственных значений
all_features = pd.get_dummies(all_features,dummy_na=True)
all_features.shape
Наконец, получите данные в формате NumPy через атрибут values
n_train=train_data.shape[0]
train_features = nd.array(all_features[:n_train].values)
test_features = nd.array(all_features[n_train:].values)
train_labels = nd.array(train_data.SalePrice.values).reshape((-1,1))
Обучите модель
определить сеть
loss = gloss.L2Loss()
def get_net():
net =nn.Sequential()
net.add(nn.Dense(1))
net.initialize()
return net
Реализация логарифмической среднеквадратичной ошибки
def log_rmse(net,features,labels):
clipped_preds=nd.clip(net(features),1,float('inf'))# 让里面的特征值小于1的改1，无上限
rmse = nd.sqrt(2*loss(clipped_preds.log(),labels.log()).mean())
return rmse.asscalar()
numpy.clip(a, a_min, a_max, out=None)[source]
где a — массив, а последние два параметра представляют минимальное и максимальное значения соответственно.
import numpy as np
x=np.array([1,2,3,5,6,7,8,9])
np.clip(x,3,8)
Out[88]:
array([3, 3, 3, 5, 6, 7, 8, 8])#1，2 变3,，，9变8
Используйте Адама для оптимизации алгоритма (относительно неясно о скорости обучения)
def train(net,train_features,train_labels,test_features,test_labels,num_epochs,learning_rate,weight_decay,batch_size):
train_ls, test_ls=[] ,[]
train_iter =gdata.DataLoader(gdata.ArrayDataset(
train_features,train_labels),batch_size,shuffle=True)
trainer =gluon.Trainer(net.collect_params(),'adam',{'learning_rate':learning_rate,'wd':weight_decay})
for epoch in range(num_epochs):
for X,y in train_iter:
with autograd.record():
l = loss(net(X),y)
l.backward()
trainer.step(batch_size)
train_ls.append(log_rmse(net,train_features,train_labels))
if test_labels is not None:
test_ls.append(log_rmse(net,test_features,test_labels))
return train_ls,test_ls
k-кратная перекрестная проверка
def get_k_fold_data(k,i,X,y):
assert k>1
fold_size =X.shape[0]//k
X_train,y_train =None,None
for j in range(k):
idx =slice(j* fold_size,(j+1)*fold_size)
X_part,y_part=X[idx,:],y[idx]
if j==i:
X_valid,y_valid =X_part,y_part
elif X_train is None:
X_train,y_train = X_part,y_part
else:
X_train = nd.concat(X_train,X_part,dim=0)
y_train = nd.concat(y_train,y_part,dim=0)
return X_train,y_train,X_valid,y_valid
Обучите k раз и верните среднюю ошибку обучения и проверки
def k_fold(k,X_train,y_train,num_epochs,learning_rate,weight_decay,batch_size):
train_l_sum,valid_l_sum =0,0
for i in range(k):
data = get_k_fold_data(k,i,X_train,y_train)
net =get_net()
train_ls,valid_ls = train(net,*data,num_epochs,learning_rate,weight_decay,batch_size)
train_l_sum += train_ls[-1]
valid_l_sum += valid_ls[-1]
if i ==0:
d2l.semilogy(range(1,num_epochs+1),train_ls,'epochs','rmse',
range(1,num_epochs+1),valid_ls,
['train','valid'])
print('fold % d ,train rmse %f,valid rmse %f'%(i,train_ls[-1],valid_ls[-1]))
return train_l_sum / k,valid_l_sum/k
выбор модели
k,num_epochs,lr,weight_decay,batch_size = 5,100,5,0,64
train_l,valid_l = k_fold(k,train_features,train_labels,num_epochs,lr,weight_decay,batch_size)
print('%d-fold validation:avg train rmse%f,avg valid rmse %f' % (k,train_l,valid_l))
предсказывать
def train_and_pred(train_features,test_features,train_labels,test_data,num_epochs,lr,weight_decay,batch_size):
net = get_net()
train_ls,_= train(net,train_features,train_labels,None,None,num_epochs,lr,weight_decay,batch_size)
d2l.semilogy(range(1,num_epochs+1),train_ls,'epochs','rmse')
print('train rmse %f' % train_ls[-1])
preds = net(test_features).asnumpy()
test_data['SalePrice']=pd.Series(preds.reshape(1,-1)[0])
submission = pd.concat([test_data['Id'],test_data['SalePrice']],axis=1)
submission.to_csv('submission.csv',index=False)
train_and_pred(train_features,test_features,train_labels,test_data,num_epochs,lr,weight_decay,batch_size)