Pytorch ResNeXt 32x8d CenterCrop－修改数据量 .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "This is a simple fork of my previous kernel (https://www.kaggle.com/taindow/pytorch-efficientnet-b0), \n",
    "\n",
    "except here we make use of ResNeXt and \"weakly supervised pre-training\" as opposed to EfficientNet. \n",
    "\n",
    "See https://github.com/facebookresearch/WSL-Images for model information. \n",
    "\n",
    "Note due to the number of parameters a single sweep of the data will take approx. \n",
    "\n",
    "每个epoch耗时4个小时"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sources\n",
    "\n",
    "Windowing functions for pre-processed data taken from the following:\n",
    "\n",
    "- https://www.kaggle.com/omission/eda-view-dicom-images-with-correct-windowing "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 读取224像素的图片数据\n",
    "dir_csv = '../input/rsna-intracranial-hemorrhage-detection'\n",
    "dir_train_img = '../input/rsna-train-stage-1-images-png-224x/stage_1_train_png_224x'#训练集\n",
    "dir_test_img = '../input/rsna-test-stage-1-images-png-224x/stage_1_test_png_224x'#测试集\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Parameters\n",
    "\n",
    "n_classes = 6\n",
    "n_epochs = 2\n",
    "batch_size = 64\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup\n",
    "\n",
    "Need to grab a couple of extra libraries\n",
    "\n",
    "- Nvidia Apex for mixed precision training (https://github.com/NVIDIA/apex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cd apex; ls -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_kg_hide-output": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "# CPU times: user 3.13 s, sys: 672 ms, total: 3.8 s\n",
    "# Wall time: 2min 46s\n",
    "# 混合权重精度训练，减少内存消耗，同时提升训练速度\n",
    "# Installing useful libraries\n",
    "\n",
    "!git clone https://github.com/NVIDIA/apex && cd apex && pip install -v --no-cache-dir --global-option=\"--cpp_ext\" --global-option=\"--cuda_ext\" ./\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import apex\n",
    "dir(apex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Libraries\n",
    "\n",
    "# 混合权重精度训练\n",
    "from apex import amp\n",
    "\n",
    "import os\n",
    "import cv2\n",
    "import glob\n",
    "import pydicom\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "\n",
    "# albumnetations是用于图像增强的库\n",
    "from albumentations import Compose, ShiftScaleRotate, Resize, CenterCrop, HorizontalFlip, RandomBrightnessContrast\n",
    "from albumentations.pytorch import ToTensor\n",
    "\n",
    "from torch.utils.data import Dataset\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "\n",
    "from torchvision import transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Functions\n",
    "\n",
    "# 下面这个类,就是用来读取类别标签以及图片数据的\n",
    "\n",
    "class IntracranialDataset(Dataset):\n",
    "\n",
    "    def __init__(self, csv_file, path, labels, transform=None):\n",
    "        \n",
    "        self.path = path\n",
    "        self.data = pd.read_csv(csv_file)#读取类别标签数据\n",
    "        self.transform = transform#这个transform其实是一个管道\n",
    "        self.labels = labels\n",
    "\n",
    "    def __len__(self):#获取数据的长度\n",
    "        \n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, idx):#图片读取数据\n",
    "        \n",
    "        img_name = os.path.join(self.path, self.data.loc[idx, 'Image'] + '.png')#读取图片\n",
    "        #print(\"img_name=\",img_name)\n",
    "        img = cv2.imread(img_name)   \n",
    "        \n",
    "        if self.transform:       #如果采用了图片数据增强\n",
    "            \n",
    "            augmented = self.transform(image=img)#使用了上面构造函数中定义的transform\n",
    "            #print(\"augmented=\",augmented)\n",
    "            img = augmented['image']#图片数据\n",
    "            \n",
    "        if self.labels:#判断是否ｔｒａｉｎ\n",
    "            \n",
    "            labels = torch.tensor(\n",
    "                self.data.loc[idx, ['epidural', 'intraparenchymal', 'intraventricular', 'subarachnoid', 'subdural', 'any']])\n",
    "            return {'image': img, 'labels': labels}    \n",
    "        \n",
    "        else:      \n",
    "            \n",
    "            return {'image': img}\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "train = pd.read_csv(os.path.join(dir_csv, 'stage_1_train.csv'))#标签文件\n",
    "test  = pd.read_csv(os.path.join(dir_csv, 'stage_1_sample_submission.csv'))#提交文件模板"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# Split train out into row per image and save a sample\n",
    "# 把上面的ID_2669954a7_intraventricular分成ID，2669954a7，intraventricular三列\n",
    "\n",
    "train[['ID', 'Image', 'Diagnosis']] = train['ID'].str.split('_', expand=True)\n",
    "#expand的作用是：\n",
    "#对下划线进行分割，Series类型转化为DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "train = train[['Image', 'Diagnosis', 'Label']]#扔掉ID列\n",
    "train.drop_duplicates(inplace=True)\n",
    "# inplace = True：\n",
    "# 不创建新的对象，直接对原始对象进行修改；\n",
    "# 删除重复数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.set_printoptions(threshold=2000)#全部输出 \n",
    "# pd.set_option('display.max_colwidth',2000)#全部输出 \n",
    "# pd.set_option('max_colwidth',2000)\n",
    "# pd.set_option('display.max_rows',None)\n",
    "# pd.set_option('display.max_columns',None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "train = train.pivot(index='Image', columns='Diagnosis', values='Label').reset_index()#透视表，进行独热编码\n",
    "train['Image'] = 'ID_' + train['Image']\n",
    "#这里的Image指的是图片的ＩＤ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.dtypes#7列，第一列是ID，其余６列是类别"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "undersample_seed=0\n",
    "train[\"any\"].value_counts()\n",
    "#“任意其他部位”的出血图片数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "num_ill_patients = train[train[\"any\"]==1].shape[0]\n",
    "#shape[0]是多少行数据，shape[1]是多少列数据\n",
    "num_ill_patients\n",
    "train[train[\"any\"]==1].head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# 下面两个代码块是为了统计健康病人和出血病人的分布数量\n",
    "healthy_patients = train[train[\"any\"]==0].index.values\n",
    "healthy_patients_selection = np.random.RandomState(undersample_seed).choice(\n",
    "    healthy_patients, size=num_ill_patients, replace=False\n",
    ")\n",
    "len(healthy_patients_selection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "sick_patients = train[train[\"any\"]==1].index.values\n",
    "selected_patients = list(set(healthy_patients_selection).union(set(sick_patients)))\n",
    "\n",
    "len(selected_patients)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "new_train = train.loc[selected_patients].copy()\n",
    "new_train[\"any\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "png = glob.glob(os.path.join(dir_train_img, '*.png'))#所有的路径放入到一个列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "png = [os.path.basename(png)[:-4] for png in png]\n",
    "#把文件名中的\".png\"去掉"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Some files didn't contain legitimate images, so we need to remove them\n",
    "\n",
    "\n",
    "png = np.array(png)#list转换成array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train['Image']\n",
    "print(\"-\")#减少占用网页内存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train['Image'].isin(png)\n",
    "#检查在路径中的.png的文件名是否都在stage_1_train.csv中\n",
    "print(\"--\")#减少占用网页内存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "train = train[train['Image'].isin(png)]\n",
    "\n",
    "# 下面是自己增加的代码,如果用于最终提交,那么下面5行代码必须注释掉!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",
    "# 96725条出血数据全部保留\n",
    "# 575071条健康数据取19345条健康数据\n",
    "train_healthy=train[train['any']==0].sample(n=19345,random_state=1)\n",
    "train_blood=train[train['any']==1]\n",
    "train=pd.concat([train_healthy,train_blood],sort=True).reset_index(drop=True) \n",
    "print(\"当前数据集的长度=\",len(train))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(train_blood)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del train_healthy\n",
    "del train_blood\n",
    "\n",
    "train.to_csv('train.csv', index=False)\n",
    "#把同时都在stage_1_train.csv且在路径中有相同名称png的文件名写入train.csv中\n",
    "del train\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Also prepare the test data\n",
    "\n",
    "test[['ID','Image','Diagnosis']] = test['ID'].str.split('_', expand=True)\n",
    "#expand表示series变换为DataFrame类型\n",
    "\n",
    "test['Image'] = 'ID_' + test['Image']\n",
    "test = test[['Image', 'Label']]\n",
    "\n",
    "test.drop_duplicates(inplace=True)\n",
    "#删除重复数据,inplace=True表示在原有数据上进行修改\n",
    "\n",
    "test.to_csv('test.csv', index=False)\n",
    "del test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DataLoaders(加载图片数据的部分,注释完毕)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Data loaders\n",
    "#－－－－－－－－－－－－－－－－－－－－－下面是训练集加载－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－\n",
    "transform_train = Compose([CenterCrop(200, 200), #猜测有应该是中间部分200*200的区域，这里也就是kernel标题说的CenterCrop，就是中间截取一大块\n",
    "                           #Resize(224, 224),\n",
    "                           HorizontalFlip(), #水平翻转用来图像强化\n",
    "                           RandomBrightnessContrast(), #来自于cafｆｅ的函数，调整对比度和亮度，怎么调整似乎是不可控的\n",
    "    ShiftScaleRotate(),\n",
    "    ToTensor()\n",
    "])\n",
    "# 上面的这个东西看起来有点像是管道\n",
    "\n",
    "train_dataset = IntracranialDataset(csv_file='train.csv', path=dir_train_img, transform=transform_train, labels=True)\n",
    "#csv_file:图片数据的类别标签\n",
    "#dir_train_img:图片数据\n",
    "data_loader_train = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=False, num_workers=4)\n",
    "#－－－－－－－－－－－－－－－－－－－－－－下面是测试集加载－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－\n",
    "\n",
    "transform_test= Compose([CenterCrop(200, 200),\n",
    "                         #Resize(224, 224),\n",
    "    ToTensor()\n",
    "])\n",
    "\n",
    "test_dataset = IntracranialDataset(csv_file='test.csv', path=dir_test_img, transform=transform_test, labels=False)\n",
    "data_loader_test = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Plot train example\n",
    "\n",
    "batch = next(iter(data_loader_train))\n",
    "fig, axs = plt.subplots(1, 5, figsize=(15,5))\n",
    "\n",
    "for i in np.arange(5):\n",
    "    axs[i].imshow(np.transpose(batch['image'][i].numpy(), (1,2,0))[:,:,0], cmap=plt.cm.bone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Plot test example\n",
    "\n",
    "batch = next(iter(data_loader_test))#注意这里是生成器generator\n",
    "fig, axs = plt.subplots(1, 5, figsize=(15,5))\n",
    "\n",
    "for i in np.arange(5):\n",
    "    \n",
    "    axs[i].imshow(np.transpose(batch['image'][i].numpy(), (1,2,0))[:,:,0], cmap=plt.cm.bone)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model(绝大部分注释完毕)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# Model\n",
    "\n",
    "device = torch.device(\"cuda:0\")#配置GPU设备\n",
    "\n",
    "# 下面的ｈｕｂ的意思是模型库\n",
    "model = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x8d_wsl')\n",
    "# 这里的ＷＳＬ-Images以及resｎｅｘｔ101_32x8d_wsl是什么意思？？？\n",
    "# 通过修改这里的32x8d为16d,32d,64d可以使用不同的预训练模型\n",
    "\n",
    "model.fc = torch.nn.Linear(2048, n_classes)\n",
    "# 2048是输出层的隐藏节点数\n",
    "# 这里的fc是全连接层(full connection)的意思\n",
    "# 参考\n",
    "# https://blog.csdn.net/MiniCnCoder/article/details/79920545\n",
    "\n",
    "\n",
    "model.to(device)\n",
    "\n",
    "criterion = torch.nn.BCEWithLogitsLoss() \n",
    "#到底哪里体现了权重[2,1,1,1,1,1]的权重关系???\n",
    "plist = [{'params': model.parameters(), 'lr': 2e-5}]\n",
    "\n",
    "\n",
    "optimizer = optim.Adam(plist, lr=2e-5)\n",
    "#优化器设定为adam\n",
    "\n",
    "model, optimizer = amp.initialize(model, optimizer, opt_level=\"O1\")\n",
    "# 这个amp和混合权重仿真到底是什么关系呢?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training(绝大部分注释完毕)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "# Train\n",
    "\n",
    "for epoch in range(n_epochs):\n",
    "    \n",
    "    print('Epoch {}/{}'.format(epoch, n_epochs - 1))\n",
    "    print('-' * 10)\n",
    "\n",
    "    model.train()    \n",
    "    tr_loss = 0\n",
    "    \n",
    "    tk0 = tqdm(data_loader_train, desc=\"Iteration\")\n",
    "    \n",
    "    #data_loader_train是在加载图片数据     \n",
    "    #用加载图片数据的进度来近似模拟训练进度，所以进度条只是一个epoch的训练速度\n",
    "#---------------------------------上面是训练--------------------------------------------------------\n",
    "#---------------------------------下面使用训练集来测试model的精度--------------------------------------\n",
    "    for step, batch in enumerate(tk0):\n",
    "        if step%5==0:\n",
    "            print(\"step=\",step)\n",
    "\n",
    "        inputs = batch[\"image\"]#图片\n",
    "        labels = batch[\"labels\"]#图片标签\n",
    "\n",
    "        inputs = inputs.to(device, dtype=torch.float)#输入图片\n",
    "        labels = labels.to(device, dtype=torch.float)#输入类别标签\n",
    "\n",
    "        outputs = model(inputs)#训练\n",
    "        loss = criterion(outputs, labels)#loss\n",
    "\n",
    "        with amp.scale_loss(loss, optimizer) as scaled_loss:\n",
    "            scaled_loss.backward()#??????\n",
    "\n",
    "        tr_loss += loss.item()\n",
    "\n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        if step%30==0:\n",
    "            epoch_loss=tr_loss/(step+1)\n",
    "            print('Training Loss: {:.4f}'.format(epoch_loss))\n",
    "            \n",
    "            \n",
    "# 下面是被自己注释掉的(如果epoch=2不成立,这个时候要注释掉下面代码的break)     \n",
    "#         if epoch == 1 and step > 6000:\n",
    "#             epoch_loss = tr_loss / 6000 #这里看的其实是平均值\n",
    "#             #threashold的意思是,下面进度条中, \n",
    "#             print('Training Loss: {:.4f}'.format(epoch_loss))\n",
    "#             break\n",
    "\n",
    "    epoch_loss = tr_loss / len(data_loader_train)\n",
    "    print('Epoch Training Loss: {:.4f}'.format(epoch_loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference(注释完毕)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inference\n",
    "\n",
    "for param in model.parameters():\n",
    "    param.requires_grad = False\n",
    "#不再计算导数,有网上的博客说,没有这两句也是可以的:\n",
    "# https://blog.csdn.net/york1996/article/details/83019978\n",
    "\n",
    "model.eval()\n",
    "# model.train() ：启用 BatchNormalization 和 Dropout\n",
    "# model.eval() ：不启用 BatchNormalization 和 Dropout\n",
    "\n",
    "test_pred = np.zeros((len(test_dataset) * n_classes, 1))#初始化测试集的预测结果\n",
    "# 因为上面是左侧ID,上侧是类别名的形式\n",
    "\n",
    "for i, x_batch in enumerate(tqdm(data_loader_test)):# 读取测试图片\n",
    "    \n",
    "    x_batch = x_batch[\"image\"]\n",
    "    x_batch = x_batch.to(device, dtype=torch.float)\n",
    "    \n",
    "    with torch.no_grad():   \n",
    "        pred = model(x_batch)#预测语句\n",
    "        \n",
    "        #对pred用sigmoid处理以及调整输出格式\n",
    "        test_pred[(i * batch_size * n_classes):((i + 1) * batch_size * n_classes)] = \\\n",
    "        torch.sigmoid(pred).detach().cpu().reshape((len(x_batch) * n_classes, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Submission（注释完毕）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Submission\n",
    "\n",
    "submission =  pd.read_csv(os.path.join(dir_csv, 'stage_1_sample_submission.csv'))#读取提交模板\n",
    "\n",
    "submission = pd.concat([submission.drop(columns=['Label']), pd.DataFrame(test_pred)], axis=1)\n",
    "#模板的Label这一列删除，然后拼接上预测结果\n",
    "submission.columns = ['ID', 'Label']\n",
    "# 设定列名\n",
    "\n",
    "submission.to_csv('submission.csv', index=False)\n",
    "submission.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clean Up# Submission（注释完毕）\n",
    "\n",
    "Have to clean up since Kaggle limits the number of files that can be output from a kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf /kaggle/working/apex\n",
    "!rm test.csv\n",
    "!rm train.csv"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}