{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "SBQNyCjqGSiT" }, "source": [ "# PM2.5浓度估计\n", "\n", "**目标:**\n", "\n", "\n", "1. 使用深度神经网络(Deep Neural network, DNN)来解决回归问题\n", "2. 学习基本的DNN训练方法\n", "3. 熟悉目前主流的深度学习框架Pytorch\n", "\n", "本次作业我们提供了训练集、验证集(均带有标签)以及测试集(不带标签),你可以通过训练集和验证集寻找最好的模型,并在测试集上得到你的预测结果。\n", "\n", "最后你需要将预测结果提交到kaggle上(https://www.kaggle.com/competitions/dl-geo-2025fall-homework3), 系统会自动返回给你测试集误差(MSE)。\n", "\n", "总的来说,本次作业的目标就是基于我们给定的代码,发挥你在课堂上学习到的知识,修改代码,从而得到尽可能低的**测试集**误差。\n", "\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 研究准备" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "6hJni8BhI6iu" }, "source": [ "### 下载数据\n", "在这里,我们从google drive上下载本次作业需要的数据,包括train.csv, val.csv, test.csv\n", "\n", "下载完成后,![1.jpg](data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoMDAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsNFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAARCACyAFADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9U6KKKACiiigAooooAKpaT/x6v/13m/8ARrVdqlpP/Hq//Xeb/wBGtQBdooooAKKKKACiiigDjvEWq+KbXW76HS38OrZJp8ctuupXEqTfaDNtcyBQQItnQjnfx0rB/wCEg+Iv/PXwJ/4H3P8A8RUnjnwqdZ8Qaw7/AA70zxJBcaVBCby7vI4zdstyG+zOrKcKgAlDHIJAH04b/hVNr/0QHwx/4MoP/jNAH0JVLSf+PV/+u83/AKNartZWjahBI89ork3Ec0zMu08DzW74x3FAGrRRRQAUUUUAFFFFABRRRQAVmaNaovnzgfO08wJ/7at/hWnVLSf+PV/+u83/AKNagC7RRRQAUUUUAFFFFABRXC+NviBqWk+JNP8ADPhvRU13xDd273jrc3X2a2tLdWC+bK+1jyx2hVUk4PTFS+APH954m1LV9D1zSP7B8SaT5T3NolwJ4ZYpA3lzRSYXcjFHGCAVKkGgDtapaT/x6v8A9d5v/RrVdqlpP/Hq/wD13m/9GtQBdooooAKKKKACiiigDgvG3gnXbjxVYeK/CeoWdprlvatp9xa6ojvaXdsW3hW2Hcjq/KsM9SCCDXHabceJvhr8S/7a8ZQQ6xB4pS2046po0EnlaXKjuIbcxksxicyk+b/fbBAG2vbqKACqWk/8er/9d5v/AEa1XapaT/x6v/13m/8ARrUAXaKKKACiiigAooooAKKKKACqWk/8er/9d5v/AEa1XapaT/x6v/13m/8ARrUAXaKKKACiiigAooooAwF8aWMnjS48MxxzyX1tZJfXMwCiGCN2ZUDEsCSxR/ug42844zX8XfELSvB/hm612Vm1GztoTdSrYPG8ggUgPKAXG5VzzjJ7AE8V56dUGifGb4izX2mXXiBpNI0tIrPTbYSM1u8lwhRo2b5juLMzZA2n7owc+f2fgtvBvwl+L0Gv+DxY3MNvqUlvqETKVFrcIJktreUgtsR2fcAAu5M4JY4APqaGZLiFJY23RuoZW9QRkGquk/8AHq//AF3m/wDRrVW8Jx3UfhfSEvZori7W0iEssMZjRm2DJClmIHtk1Z0n/j1f/rvN/wCjWoAu0UUUAFFFUda1zT/Dumy3+p3kNjZxfemmYKuTwAPUk8ADkk4FJtJXZUYynJRirtl6iuGg8WeKvE2JtA8Ow2GmMMpfeIZpLeWUcYKWyoXAPP8ArDGwx93nNTbfiGf+Wnhlf+2dwf8A2YVn7RPZNne8FOOlScYvs2r/ADte3o9Td/4RXTP+En/4SFbdk1c2ws3uI5XUSRBiwV0B2vgliCwJG44Iyad4k8Nad4u0efStWga60+fAlgErxrIAfuttIyp7qeD0INYG34hj/lp4Zb/tncD/ANmNNOofEGz+Z9E8PanGOv2fU5reT/gKtAyk+xYfWj2ndP7hfU2/hqRf/byX52OzVVjUKqhVUYCgYAFVNJ/49X/67zf+jWrlR8VbHS5BF4n06/8ACTnpPqUatZn/ALeYy0S9ejsp68cGum0G4ivNN8+CVJ4ZJpmSSNgysDK2CCOoqozjLZmFbDVqFnUjZPZ7p+jWj+TNGiiirOYy/E3iSy8J6NNqV+zCGMqixxjdJLI7BI40Hd2ZlUDuSK5/Q/B0+r6lb+I/FccdxrETGSxsA2+30oEEYTs8uCd0pGeSFwvBhuF/4Sz4pJbvl9M8MwJcMvGx76YNsyO5ihBb/t4U9Rx3VYL947vZHqSk8HTUIaTkrt9k9or1Wr7p273KKKK3PLCisfWPGWgeHbhINW1zTdMndd6x3l3HCzL0yAxGRWsrLIoZSGVhkMDkEUAZHifWLrRbNJrfQ7vXYmbbPDZNF5iJjlgsjLvH+yDn0BPFc18OvF3g/wAl9I0i4t9Lu3ubif8Ase4iazuAXlYsRBIFYcnnAxmu+rBm8O6V4n0iWz1jTbTVLU3E37m8hWVf9a3OGB596ylGV+aL/r+vU7qVWj7P2VWLXmn+cXo7dLOPqb1FefvoOs/DljceH3m1rw4u559CuHaW5gBOS1pIxJIAyfJfIPRGXhT2ej6xZeINLttR064S7srhN8U0fRh/MEHIIPIIIPNOM7uzVmTWw/s4qpTlzQfXt5NdH96fRuxy/wAMwPM8XyN/x9P4guTOe/CxrHn/ALZLFj2xXa1wOteZ8O/E2oeJVjkn8PaoI21dIhlrOZEEa3e0DLIY1RJO6iJGAwGruoJ47qGOaGRZYZFDpJGwZWUjIII6gipp6Lke6NsanOSrx1jJL5NJXj8vys9miSiiitjzT5+8QfAvwf8AGH41eNJvFFhLeyWFrpyQGO5ki2h0lLfdIz90da0fGHwD8N+E/h/rl1pV/wCJLOTTdMnltVj8QXgSIxxMUAXzMYBA46cV2Xij4PWPiTxHc63B4g8RaBe3UUcVz/YuoGBJhHkIWXaeQGI4rJuv2f7fULWa1u/Hfji6tZkaOaCXWcpIhGGVhs6EEg/WgDvvCNzLeeFNFuJ3aWaWyhkeRjksxjUkn8as6T/x6v8A9d5v/RrVNY2UOm2NvaW67Le3jWKNck4VQABk9eBUOk/8er/9d5v/AEa1AF2uDuof+EH+IFhPbfu9H8TTNbXNuvCRXwjeRJwO3mLG6N0ywjPUnPeVxXxMbzJPCNonN1ca/beUvr5avNJ/5DjkrGr8N+qPRwLvVdN/DJNP7r3+T1+R2hGRgjIrhZPA+q+E7qa68FXdrbW0zGSbQdS3myLHvAy5a2JPXCuh5OwEknu6KuUFLc56OInQuo6p7p6p+q/J7ro0cQPieukny/E2g6r4dccG4Nubu0PuJodwVfeQJ9Ku2PxW8Fal/wAevi7Q5znBVNRhLA+hG7IPsa6qql5pFhqPN3ZW91/12iV/5ip5ai2d/l/X5G/tMJPWVNxflLT7mm//ACYrL4o0Zow66vYlD0YXKY/PNRN4y8PqcNrmmg+93H/jUDfD3ws7728NaOz/AN42EWf/AEGpV8D+HEGF0DS1HtZR/wDxNH7zyD/Y+8vwF/4TXw9/0HtM/wDAyP8A+KrKj+JHhPR9PeW+8TaRaxm4mAMt9Eu4mVsAfNyT2A61q/8ACF+Hv+gDpn/gHH/8TTPDnh3StNR57TTLO1m86ZfMht0RseY3GQKP3nkF8GtbSf3L8bP8jEb4kXOtBo/Cnh6+1tjwt9eK1hYg+plkXe6+8Ub96u+H/CN7/a39u+JLuDU9bVTHbJbRsltYxn7yxKxJLN/FIeW4ACr8tdXRQoO95O/5Clioxi4UIcqe73k12v8A5JXWjuFFFFanAFFFFABRRRQAVS0n/j1f/rvN/wCjWoooAu0UUUAf/9k=)点击左边此处可以找到三个csv文件,双击文件可以预览其结构,其中,每一行为一个观测数据,每一列为一个特征,具体地:\n", "\n", "station:站点编号\n", "\n", "date:数据采集日期\n", "\n", "lat、lon:站点经纬度\n", "\n", "AOD:气溶胶光学厚度\n", "\n", "ET:蒸发量\n", "\n", "BLH:边界层高度\n", "\n", "TEM:温度\n", "\n", "NDVI:植被指数\n", "\n", "SP:海平面气压\n", "\n", "RH:相对湿度\n", "\n", "DEM:地面高程\n", "\n", "NTL:夜间灯光指数\n", "\n", "LUC:土地覆盖类型\n", "\n", "PRE: 降水\n", "\n", "WS、WD:风速风向" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1Zh3cOfPGOgo", "outputId": "0c70e90b-8e0e-4c79-efd4-642a2b929a04" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/usr/local/lib/python3.7/dist-packages/gdown/cli.py:131: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n", " category=FutureWarning,\n", "Downloading...\n", "From: https://drive.google.com/uc?id=15BfpT7ieOq_RaMKz9fZQF1gpQLEu83be\n", "To: /content/train.csv\n", "100% 1.72M/1.72M [00:00<00:00, 115MB/s]\n", "/usr/local/lib/python3.7/dist-packages/gdown/cli.py:131: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n", " category=FutureWarning,\n", "Downloading...\n", "From: https://drive.google.com/uc?id=1w4v26_bRzrIUTKQSTtPl7Klu1XZtZITX\n", "To: /content/val.csv\n", "100% 520k/520k [00:00<00:00, 97.9MB/s]\n", "/usr/local/lib/python3.7/dist-packages/gdown/cli.py:131: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n", " category=FutureWarning,\n", "Downloading...\n", "From: https://drive.google.com/uc?id=1KRFj-T2fS_K8-4tOX_pN7ugQNz8bseVn\n", "To: /content/test.csv\n", "100% 657k/657k [00:00<00:00, 88.5MB/s]\n" ] } ], "source": [ "train_path = 'train.csv'\n", "val_path = 'val.csv'\n", "test_path = 'test.csv'\n", "!gdown --id 15BfpT7ieOq_RaMKz9fZQF1gpQLEu83be --output 'train.csv'\n", "!gdown --id 1w4v26_bRzrIUTKQSTtPl7Klu1XZtZITX --output 'val.csv'\n", "!gdown --id 1KRFj-T2fS_K8-4tOX_pN7ugQNz8bseVn --output 'test.csv'" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "b0X_UOeQ9H_W" }, "source": [ "### 设置环境\n", "接下来,我们导入代码所需要的运行环境" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "y-wT4-NFJt2b" }, "outputs": [], "source": [ "# 如果你引入了新的库,可以从这里导入\n", "import pandas # 提供dataframe,用来处理csv数据\n", "import torch # pytorch,目前主流的深度学习框架\n", "from torch.utils import data # 从torch.utils导入data模块,用来构建pytorch中的数据结构--->dataloader\n", "from torch import nn # 从torch导入nn模块,用来提供基本的神经网络接口,如全连接层nn.Linear()\n", "import numpy as np # 导入numpy,并将其重命名为np,numpy是一个高效的用来处理矩阵的库\n", "from tqdm import tqdm # tqdm是一个可视化代码进程的模块\n", "import os # os库用来处理磁盘读写过程\n", "from sklearn.preprocessing import StandardScaler # 这是一个用来数据标准化的模块\n", "import csv # 读写csv文件的库\n", "normalize = StandardScaler() # 实例化StandardScaler\n", "# 为了处理大批量数据,在目前主流的深度学习框架下,数据都是以矩阵的形式表示的\n", "# 而对于CPU来讲,其对于矩阵数据处理效率欠佳,而GPU(显卡)则擅长处理矩阵,因此深度学习模型都会部署到GPU上\n", "# 这段代码的意思是,判断目前的设备中是否有安装CUDA(GPU加速模块)。\n", "# 如果有的话,我们就让模型部署到GPU上,如果没有,我们继续用CPU(速度会慢一点)\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") \n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 进行实验" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "S-2T75R6-SY5" }, "source": [ "### 构建数据" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "cWCJUpfu9Sgr" }, "outputs": [], "source": [ "# 这段代码用来创建pytorch所需的基本数据结构,data.Dataset\n", "class PM2_5Dataset(data.Dataset):\n", " def __init__(self, csv_path, mode=\"train\"):\n", " super(PM2_5Dataset, self).__init__()\n", " self.csv_content = pandas.read_csv(csv_path)\n", " self.used_column = [\"AOD\", \"ET\", \"BLH\", \"TEM\", \"NDVI\", \"SP\", \"RH\", \"DEM\", \"NTL\", \"PRE\", \"WS\", \"WD\"] # TODO:这些特征都是有用的吗?修改这行代码,可以修改模型输入的特征\n", " self.target_column = \"PM2.5\" \n", " self.mode = mode\n", " self.dim = len(self.used_column)\n", " if mode in [\"train\", \"val\"]:\n", " self.input_data, self.target_data = self.process_csv_with_gt()\n", "\n", " else:\n", " self.input_data = self.process_csv_without_gt()\n", "\n", " def process_csv_with_gt(self):\n", " input_data = [list(self.csv_content[i]) for i in self.used_column]\n", " input_data = np.array(input_data)\n", " input_data = input_data.T\n", " input_data = normalize.fit_transform(input_data)\n", " target_data = np.array(self.csv_content[self.target_column])\n", " return input_data, target_data\n", "\n", " def process_csv_without_gt(self):\n", " input_data = [list(self.csv_content[i]) for i in self.used_column]\n", " input_data = np.array(input_data)\n", " input_data = input_data.T\n", " input_data = normalize.fit_transform(input_data) \n", " return input_data\n", "\n", " def __getitem__(self, index):\n", " if self.mode in [\"train\", \"val\"]:\n", " data, gt = self.input_data[index, :], self.target_data[index]\n", " data = torch.from_numpy(data)\n", " gt = torch.tensor(gt)\n", " return data, gt\n", " else:\n", " data = self.input_data[index, :]\n", " return torch.from_numpy(data)\n", "\n", " def __len__(self):\n", " return self.input_data.shape[0]\n", "\n", "def prepare_dataset(csv_path, batch_size, mode):\n", " dataset = PM2_5Dataset(csv_path, mode)\n", " # 在pytorch中,dataset需要用dataloader封装\n", " if mode in [\"train\", \"val\"]:\n", " dataloader = data.DataLoader(dataset, batch_size, num_workers=0, pin_memory=True)\n", " else:\n", " dataloader = data.DataLoader(dataset, 1, num_workers=0, pin_memory=True, shuffle=False)\n", " return dataloader\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "0xeaKlhm_2Pe" }, "source": [ "### 构建模型" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "By2CUgX5AEL3" }, "outputs": [], "source": [ "# 这是一个基本的神经网络模型,包含三个全连接层,激活函数为Relu\n", "class MyNeuralNet(nn.Module):\n", " # TODO:增加约束,如添加dropput,batchnorm等。增删全连接层数。修改神经元数量。修改连接方式等。\n", " def __init__(self, input_dim):\n", " super(MyNeuralNet, self).__init__()\n", " self.net = nn.Sequential(\n", " nn.Linear(input_dim, 64),\n", " nn.ReLU(),\n", " nn.Linear(64, 32),\n", " nn.ReLU(),\n", " nn.Linear(32, 1),\n", " )\n", "\n", " def forward(self, input):\n", " predict = self.net(input)\n", " return predict\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "rLcXW-gEAnYr" }, "source": [ "### 训练、验证与测试\n", "这部分提供了训练、测试、验证的代码,你可以修改。例如修改训练代码部分的损失函数,测试代码中的推理策略(boosting,bagging),将验证集并入到训练集中一起训练,等" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "hBnuhdTTAs8c" }, "outputs": [], "source": [ "def train(train_dataset, val_dataset, config, model):\n", " \"\"\"训练代码\"\"\"\n", " n_epochs = config['n_epochs'] # 训练次数\n", " optimizer = getattr(torch.optim, config['optimizer'])(model.parameters(), **config['optim_hparas']) # 优化器\n", " model.train() # 设置模型为训练模式(梯度可以回传)\n", " pbar = tqdm(total=n_epochs, desc=\"Train Mode\", unit=\"epoch\") \n", " loss = nn.MSELoss() # 损失函数为MSE(均方误差)\n", " loss_log = {\"train_loss\": [], \"val_loss\": []} \n", " min_mse = 1e16\n", " for epoch in range(n_epochs):\n", " pbar.update()\n", " epoch_mse = 0.0\n", " for x, y in train_dataset:\n", " optimizer.zero_grad() # 将优化器里储存的梯度清零\n", " x, y = x.to(device).float(), y.to(device).float()\n", " y = y.unsqueeze(1) \n", " pred = model(x) \n", " mse_loss = loss(pred, y) # 计算损失\n", " mse_loss.backward() # 损失回传\n", " optimizer.step() # 梯度更新\n", " loss_log[\"train_loss\"].append(mse_loss.detach().cpu().item())\n", " epoch_mse += mse_loss.detach().cpu().item()\n", " pbar.set_postfix(epoch=epoch + 1, mse=epoch_mse / len(train_dataset))\n", " val_mse = val(val_dataset, model)\n", " if val_mse < min_mse:\n", " min_mse = val_mse\n", " torch.save(model.state_dict(), config['save_path'])\n", " print(f\"best model saved! val mse:{val_mse},epoch:{epoch + 1}\")\n", " loss_log[\"val_loss\"].append(val_mse)\n", " return min_mse, loss_log\n", "def val(val_dataset, model):\n", " \"\"\"验证代码\"\"\"\n", " model.eval() # 设置为验证模式(梯度不回传)\n", " total_loss = 0\n", " loss = nn.MSELoss()\n", " for x, y in val_dataset:\n", " x, y = x.to(device).float(), y.to(device).float()\n", " y = y.unsqueeze(1)\n", " with torch.no_grad():\n", " pred = model(x) # 预测结果\n", " mse_loss = loss(pred, y) # 计算损失\n", " total_loss += mse_loss.detach().cpu().item()\n", " total_loss = total_loss / len(val_dataset)\n", " return total_loss\n", "\n", "\n", "def test(test_set, model):\n", " \"\"\"测试代码\"\"\"\n", " model.eval() #\n", " preds = []\n", " for x in test_set:\n", " x = x.to(device).float()\n", " with torch.no_grad():\n", " pred = model(x)\n", " preds.append(pred.detach().cpu())\n", " return preds" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "BrNTu87TA3Md" }, "source": [ "### 处理预测结果" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "Vh6KVNYkVKsR" }, "outputs": [], "source": [ "# 这部分不需要修改\n", "def process_preds_to_csv(preds):\n", " with open(\"MyPred.csv\", \"w\", newline='') as f:\n", " writer = csv.writer(f)\n", " writer.writerow(['id', 'PM2.5'])\n", " for i, p in enumerate(preds):\n", " p = p.cpu().item()\n", " writer.writerow([i, p])" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "nvIF8HRGVM6i" }, "source": [ "### 主程序" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "21I1WRmJVYph", "outputId": "961e78eb-ab4c-451b-95b8-1fcf972a842d" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\n", "Train Mode: 0%| | 0/200 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "\rTrain Mode: 11%|█ | 109/1000 [16:12<2:12:33, 8.93s/epoch, epoch=109, mse=795]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt # 用来绘制曲线\n", "from matplotlib.pyplot import figure\n", "\n", "def plot_learning_curve(loss_record, title=''):\n", " ''' 绘制损失函数曲线 '''\n", " total_steps = len(loss_record['train_loss'])\n", " x_1 = range(total_steps)\n", " x_2 = x_1[::len(loss_record['train_loss']) // len(loss_record['val_loss'])]\n", " figure(figsize=(6, 4))\n", " plt.plot(x_1, loss_record['train_loss'], c='tab:red', label='train')\n", " plt.plot(x_2, loss_record['val_loss'], c='tab:cyan', label='val')\n", " plt.ylim(0.0, 1000.)\n", " plt.xlabel('Training steps')\n", " plt.ylabel('MSE loss')\n", " plt.title('Learning curve of {}'.format(title))\n", " plt.legend()\n", " plt.show()\n", "\n", "def plot_pred(dv_set, model, device, lim=35., title=\"\", preds=None, targets=None):\n", " ''' 绘制你的预测结果和真实结果之间的分布情况 '''\n", " if preds is None or targets is None:\n", " model.eval()\n", " preds, targets = [], []\n", " for x, y in dv_set:\n", " x, y = x.to(device), y.to(device)\n", " with torch.no_grad():\n", " pred = model(x.float())\n", " preds.append(pred.detach().cpu())\n", " targets.append(y.detach().cpu())\n", " preds = torch.cat(preds, dim=0).numpy()\n", " targets = torch.cat(targets, dim=0).numpy()\n", "\n", " figure(figsize=(5, 5))\n", " plt.scatter(targets, preds, c='r', alpha=0.5)\n", " plt.plot([-0.2, lim], [-0.2, lim], c='b')\n", " plt.xlim(-0.2, lim)\n", " plt.ylim(-0.2, lim)\n", " plt.xlabel('ground truth value')\n", " plt.ylabel('predicted value')\n", " plt.title(title)\n", " plt.show()\n", "\n", "\n", "plot_learning_curve(loss_log,\"DNN\")\n", "\n", "plot_pred(train_dataset,model,device,35., 'Ground Truth of Train v.s. Prediction')\n", "\n", "plot_pred(val_dataset,model,device,35.,'Ground Truth of Val v.s. Prediction')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": { "id": "oY_11C6ba-E2" }, "source": [ "## 你需要做什么\n", "\n", "**基本要求**\n", "\n", "\n", "* 弄明白这些代码都在干什么\n", "\n", "* 代码中有一处小错误,你能找出来吗(提示:构建数据部分的特征标准化)\n", "\n", "\n", "**中等要求**\n", "\n", "\n", "* 特征选择:我们使用了csv文件中提供的所有特征用来预测pm2.5,他们都是有用的吗?如果只用部分特征会不会更好?为什么呢?\n", "\n", "\n", "* 参数调整:在主程序中,有一个config变量,它存储了我们的很多超参数,如learning rate,batch size等,调整他们会改进模型的精度吗。关于优化器(optimizer),我们使用的是SGD(随机梯度下降),有没有其它的优化器可以使用呢,这些优化器里的超参数(如momentum)需要怎么设置呢?\n", "\n", "\n", "* L2标准化:训练过程中,让模型的神经元的权值波动不要过大会提高模型的泛化性能,L2标准化是对模型神经元的权值的惩罚项。\n", "\n", "**终极要求**\n", "\n", "* 模型修改:更深的神经网络,更多的神经元会带来更好的效果吗?有没有什么办法对抗过拟合(如dropout,batchnorm)?\n", "\n", "* 地理位置与时间:地理位置(lon,lat),以及时间信息(date)会提升PM2.5的估计精度吗?如果可以的话,该怎么使用它们呢?\n", "\n", "* 其它:发挥你的想法,尽可能地减小测试集误差,并解释为什么\n", "\n", "\n", "\n", "\n", "\n" ] } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 0 }