提示:供自己学习,代码并不能跑通
下载
def download(name, cache_dir=os.path.join('..', 'data')): #@save
"""下载一个DATA_HUB中的文件,返回本地文件名"""
assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"
url, sha1_hash = DATA_HUB[name]
os.makedirs(cache_dir, exist_ok=True)
fname = os.path.join(cache_dir, url.split('/')[-1])
if os.path.exists(fname):
sha1 = hashlib.sha1()
with open(fname, 'rb') as f:
while True:
data = f.read(1048576)
if not data:
break
sha1.update(data)
if sha1.hexdigest() == sha1_hash:
return fname # 命中缓存
print(f'正在从{url}下载{fname}...')
r = requests.get(url, stream=True, verify=True)
with open(fname, 'wb') as f:
f.write(r.content)
return fname
代码思路:
从字典中寻找文件(字典里已经录入文件URL和hash值),获取URL和hash值
创建文件夹
获取存放的文件名(带路径)
若文件存在,读入文件,校验hash值,否则下创建文件并读入文件(相当于下载)
assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"
断言语句,若不满足则报错,打印字符。f字符串格式:f"{变量} 不存在于 {变量}",assert后面可以接f字符串,不能进行其它操作。
cache_dir=os.path.join('..', 'data')
os.makedirs(cache_dir, exist_ok=True)
os.path.exists(fname)
三个os.path函数,分别作用:返回文件路径字符串,创建文件夹,判断文件是否存在
url.split('/')[-1]
字符串处理方法,按/把字符串分割,返回被分开的字符串列,这里明显为了获得文件名
sha1 = hashlib.sha1()
with open(fname, 'rb') as f:
while True:
data = f.read(1048576)
if not data:
break
sha1.update(data)
if sha1.hexdigest() == sha1_hash:
return fname # 命中缓存
1.文件的使用:通过with open(文件名,‘打开方式’) as f 打开,通过f.read,f.write进行操作
2.哈希值验证:先用hashlib.sha1()建立一个哈希对象,读文件时每次用读出的内容去更新哈希对象,最后用sha1.hexdigest()取出
下载解压
def download_extract(name, folder=None): #@save
"""下载并解压zip/tar文件"""
fname = download(name)
base_dir = os.path.dirname(fname)
data_dir, ext = os.path.splitext(fname)
if ext == '.zip':
fp = zipfile.ZipFile(fname, 'r')
elif ext in ('.tar', '.gz'):
fp = tarfile.open(fname, 'r')
else:
assert False, '只有zip/tar文件可以被解压缩'
fp.extractall(base_dir)
return os.path.join(base_dir, folder) if folder else data_dir
def download_all(): #@save
"""下载DATA_HUB中的所有文件"""
for name in DATA_HUB:
download(name)
代码思路
获取文件名,指定解压地点(当前文件及和当前文件夹下指定文件夹),根据文件类型打开并解压文件,返回解压地点
base_dir = os.path.dirname(fname)
data_dir, ext = os.path.splitext(fname)
os.path.dirname() 获得文件所在文件夹名字,os.path.splitext()将文件(包含路径)和扩展名分开
fp = zipfile.ZipFile(fname, 'r')
fp = tarfile.open(fname, 'r')
fp.extractall(base_dir)
分别对应zip和tar打开方式和提取
字典构造
DATA_HUB['kaggle_house_train'] = ( #@save
DATA_URL + 'kaggle_house_pred_train.csv',
'585e9cc93e70b39160e7921475f9bcd7d31219ce')
DATA_HUB['kaggle_house_test'] = ( #@save
DATA_URL + 'kaggle_house_pred_test.csv',
'fa19780a7b011d9b009e8bff8e99922a8ee2eb90')
数据处理
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
# “Dummy_na=True”将“na”(缺失值)视为有效的特征值,并为其创建指示符特征
all_features = pd.get_dummies(all_features, dummy_na=True)
all_features.shape
n_train = train_data.shape[0]
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)
train_labels = torch.tensor(
train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)
代码思路:打印两个数据集的形状和第一行内容,我们只保留自己需要的数据作为输入(如id就明显不是影响房价的因素,还有房价作为我们最终要输出的部分,也不能包含在输入里)。将所有数值项标准化,并处理NA;非数值项进行one-hot编码,将数据0划分为训练输入和测试输入,将其和训练集的输出转为tensor
all_features = pd.concat((train_data.iloc[:, 1:-1], test_data.iloc[:, 1:]))
pd的concat函数,接受(,)形式的参数
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()))
all_features[numeric_features] = all_features[numeric_features].fillna(0)
标准化。dtypes是数据类型表格,all_features.dtypes是一个包含所有数据类型的列表(标明每一列是什么数据类型),
dtypes[all_features.dtypes != ‘object’]对应的就是列名和对应是否不为object(标明每一列是T或者F),.index对应其index对象
这里的numeric_features是一个index对象,不同于array,它并没有任何值,仅能用于检索。
apply函数是对每一个项进行操作应用。
lambda x: 匿名函数,只能进行一个运算语句
all_features = pd.get_dummies(all_features, dummy_na=True)
pd里的转one-hot编码
n_train = train_data.shape[0]
train_features = torch.tensor(all_features[:n_train].values, dtype=torch.float32)
test_features = torch.tensor(all_features[n_train:].values, dtype=torch.float32)
train_labels = torch.tensor(
train_data.SalePrice.values.reshape(-1, 1), dtype=torch.float32)
对于二维表,.shape[0]明显为表项数,shape[1]为属性数量。
all_features[:n_train].values是把数据表的项作为array取出。
train_data.SalePrice.values.reshape(-1, 1),可以指定表中的某列,虽然SalePrice貌似是个列向量,但实际我们获得的是一个行向量,需要用reshape(-1, 1)来改变形状。
关于列向量和行向量在python中的表示,注意到:
array([[208500],
[181500],
[223500],
…,
[266500],
[142125],
[147500]], dtype=int64)
array([208500, 181500, 223500, …, 266500, 142125, 147500], dtype=int64)
即使在列向量里,维度也是2,只是每行属性为1
网络构造,选择损失函数
loss = nn.MSELoss()
in_features = train_features.shape[1]
def get_net():
net = nn.Sequential(nn.Linear(in_features,1))
return net
损失值计算
def log_rmse(net, features, labels):
# 为了在取对数时进一步稳定该值,将小于1的值设置为1
clipped_preds = torch.clamp(net(features), 1, float('inf'))
rmse = torch.sqrt(loss(torch.log(clipped_preds),
torch.log(labels)))
return rmse.item()
采用loss函数计算损失值,均方损失。torch.clamp(net(features), 1, float(‘inf’))函数,将通过网络获得的预测值进行裁剪,返回的是rmse的数值
训练函数
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 = d2l.load_array((train_features, train_labels), batch_size)
# 这里使用的是Adam优化算法
optimizer = torch.optim.Adam(net.parameters(),
lr = learning_rate,
weight_decay = weight_decay)
for epoch in range(num_epochs):
for X, y in train_iter:
optimizer.zero_grad()
l = loss(net(X), y)
l.backward()
optimizer.step()
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
代码思路:建立训练和测试的损失列表;三板斧:迭代器,优化器,for循环(梯度清理,损失函数,反向传播,参数更新),返回损失列表。
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 = torch.cat([X_train, X_part], 0)
y_train = torch.cat([y_train, y_part], 0)
return X_train, y_train, X_valid, y_valid
代码思路:断言k>1,按照k的大小将确定每一折的大小(整除,多的忽略掉),利用slice函数返回每一折的index对象。如果不是当前折,就进行拼接torch.cat([X_train, X_part], 0),与pd的concat一样,接受的是[,]形状的参数,0代表加表项,1代表拼属性
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.plot(list(range(1, num_epochs + 1)), [train_ls, valid_ls],
xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
legend=['train', 'valid'], yscale='log')
print(f'折{i + 1},训练log rmse{float(train_ls[-1]):f}, '
f'验证log rmse{float(valid_ls[-1]):f}')
return train_l_sum / k, valid_l_sum / k
代码思路:对每一折,获取折数据和网络,进行训练,取所有折训练的最后一个epoch的损失值的总和,返回验证和训练的平均损失值
训练预测
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.plot(np.arange(1, num_epochs + 1), [train_ls], xlabel='epoch',
ylabel='log rmse', xlim=[1, num_epochs], yscale='log')
print(f'训练log rmse:{float(train_ls[-1]):f}')
# 将网络应用于测试集。
preds = net(test_features).detach().numpy()
# 将其重新格式化以导出到Kaggle
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)
代码思路:对训练集进行训练,保存损失列表,将测试集送入网络进行预测(net(test_features).detach().numpy()转为numpy形式方便写入csv),对于 test_data[‘SalePrice’] = pd.Series(preds.reshape(1, -1)[0]),我们的到的预测值是列向量,同样我们需要转为行向量再协会dataframe。submission.to_csv(‘文件名’),