solution_full-no_group0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b2662258",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import pymatgen\n",
    "\n",
    "from functions.prepare_data_and_sub import prepare_dataset, make_prediction, energy_within_threshold\n",
    "from functions.class2_features import unufication_class2, geometrical_features, distance_features\n",
    "from functions.classification import classificate_class2, classificate_class3, classificate_class4, classificate_class5\n",
    "from functions.classification import convert_group_to_target_class2, convert_group_to_target_class3, convert_group_to_target_class4, convert_group_to_target_class5\n",
    "from functions.strusture_analysis import decompose, make_masks, find_differ_sites, extract_ideal_structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "20389209",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f1e05c46173746c1a422053b338c5d9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/380 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = prepare_dataset('data/dichalcogenides_public/')\n",
    "data['decomposition'] = data.structures.apply(decompose)\n",
    "mask_list = make_masks(data)\n",
    "ideal_structure_sites = extract_ideal_structure(data)  \n",
    "data['representative'] = data['structures'].apply(lambda x: find_differ_sites(x.sites, ideal_structure_sites))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e5613dff",
   "metadata": {},
   "outputs": [],
   "source": [
    "test = prepare_dataset('data/dichalcogenides_private/', train=False)\n",
    "test['decomposition'] = test.structures.apply(decompose)\n",
    "mask_list_test = make_masks(test)\n",
    "test['representative'] = test['structures'].apply(lambda x: find_differ_sites(x.sites, ideal_structure_sites))\n",
    "\n",
    "test = make_prediction(test, ideal_structure_sites, mask_list_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9605e258",
   "metadata": {},
   "source": [
    "### Class2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e5cdaa5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/polli/IDAO-2022/functions/class2_features.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  sample['representative'] = sample['representative'].apply(lambda x: symmetry_transform_up(x.copy(), x[0].coords))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:6: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  sample['representative'] = sample['representative'].apply(lambda x: orange_closer(x.copy()))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:11: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['dist_to_diag_Mo'] = data['representative'].apply(lambda x: dist_to_diag(x[0].coords))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['dist_to_diag_S'] = data['representative'].apply(lambda x: dist_to_diag(x[1].coords))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:13: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['dist_to_diag_Se'] = data['representative'].apply(lambda x: dist_to_diag(x[2].coords))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:15: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Mo_S_dist'] = data['representative'].apply(lambda x: np.linalg.norm(x[0].coords - x[1].coords)**0.5)\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:16: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['S_Se_dist'] = data['representative'].apply(lambda x: np.linalg.norm(x[1].coords - x[2].coords)**0.5)\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:17: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Mo_Se_dist'] = data['representative'].apply(lambda x: np.linalg.norm(x[0].coords - x[2].coords)**0.5)\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:25: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Mo_coords_' + str(i)] = data['representative'].apply(lambda x: x[0].frac_coords[i])\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:28: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['S_coords_' + str(i)] = data['representative'].apply(lambda x: x[1].frac_coords[i])\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:31: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Se_coords_' + str(i)] = data['representative'].apply(lambda x: x[2].frac_coords[i])\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:33: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['M_is_boarder'] = data['representative'].apply(lambda x: is_boarder(x[0]))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:34: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['S_is_boarder'] = data['representative'].apply(lambda x: is_boarder(x[1]))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:35: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Se_is_boarder'] = data['representative'].apply(lambda x: is_boarder(x[2]))\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:36: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['M_is_boarder_0'] = data['M_is_boarder'] == 0\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:37: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['M_is_boarder_1'] = data['M_is_boarder'] == 1\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:38: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['S_is_boarder_0'] = data['S_is_boarder'] == 0\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:39: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['S_is_boarder_1'] = data['S_is_boarder'] == 1\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:40: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Se_is_boarder_1'] = data['Se_is_boarder'] == 1\n",
      "/home/polli/IDAO-2022/functions/class2_features.py:41: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data['Se_is_boarder_0'] = data['Se_is_boarder'] == 0\n"
     ]
    }
   ],
   "source": [
    "model = DecisionTreeClassifier(max_depth=15, random_state=13)\n",
    "\n",
    "class2 = data[mask_list[2]].copy()\n",
    "class2['group'] = class2['targets'].apply(classificate_class2)\n",
    "class2 = class2[class2.group != 0]\n",
    "\n",
    "class2 = unufication_class2(class2)\n",
    "class2 = geometrical_features(class2)\n",
    "\n",
    "test_class2 = unufication_class2(test[mask_list_test[2]])\n",
    "test_class2 = geometrical_features(test_class2)\n",
    "\n",
    "feature_list = ['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']\n",
    "model.fit(class2[feature_list], class2['group'])\n",
    "\n",
    "class2_predict_group3 = model.predict(test_class2[feature_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ca4739d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class2 = class2[(class2.group == 2) | (class2.group == 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ff3aa0c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17:08:03] WARNING: ../src/learner.cc:1115: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/polli/anaconda3/lib/python3.8/site-packages/xgboost/sklearn.py:1224: UserWarning: The use of label encoder in XGBClassifier is deprecated and will be removed in a future release. To remove this warning, do the following: 1) Pass option use_label_encoder=False when constructing XGBClassifier object; and 2) Encode your labels (y) as integers starting with 0, i.e. 0, 1, 2, ..., [num_class - 1].\n",
      "  warnings.warn(label_encoder_deprecation_msg, UserWarning)\n"
     ]
    }
   ],
   "source": [
    "from xgboost import XGBClassifier\n",
    "\n",
    "feature_list = list(class2.columns[5:])\n",
    "\n",
    "model = XGBClassifier(n_estimators=45, random_state=0xC0FFEE)\n",
    "model.fit(class2[feature_list], class2['group'])\n",
    "class2_predict_group12 = model.predict(test_class2[feature_list])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8398d6b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class2_predict_group = class2_predict_group12\n",
    "class2_predict_group[class2_predict_group3 == 3] = 3\n",
    "\n",
    "predictions_class2 = list(map(convert_group_to_target_class2, class2_predict_group))\n",
    "test.loc[mask_list_test[2], 'predictions'] = predictions_class2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a45b6ae",
   "metadata": {},
   "source": [
    "### Class3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0c583de6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17:21:51] WARNING: ../src/learner.cc:1115: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'multi:softprob' was changed from 'merror' to 'mlogloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n"
     ]
    }
   ],
   "source": [
    "class3 = data[mask_list[3]].copy()\n",
    "class3['group'] = class3['targets'].apply(classificate_class3)\n",
    "class3 = class3[class3.group != 0]\n",
    "class3 = distance_features(class3)\n",
    "\n",
    "test_class3 = test[mask_list_test[3]].copy()\n",
    "test_class3 = distance_features(test_class3)\n",
    "\n",
    "for i in range(3):\n",
    "    class3['dist' + str(i+1)] = class3[['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']].apply(lambda row: sorted(row)[i], axis=1)\n",
    "    test_class3['dist' + str(i+1)] = test_class3[['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']].apply(lambda row: sorted(row)[i], axis=1)\n",
    "    \n",
    "feature_list = ['dist1', 'dist2', 'dist3']\n",
    "model = XGBClassifier(n_estimators=10, random_state=0xC0FFEE)\n",
    "model.fit(class3[feature_list], class3['group'])\n",
    "\n",
    "class3_predict_group = model.predict(test_class3[feature_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a8f6ae1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_class3 = list(map(convert_group_to_target_class3, class3_predict_group))\n",
    "test.loc[mask_list_test[3], 'predictions'] = predictions_class3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3c0ca6f",
   "metadata": {},
   "source": [
    "### Class4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "57024f81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17:28:34] WARNING: ../src/learner.cc:1115: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'multi:softprob' was changed from 'merror' to 'mlogloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n"
     ]
    }
   ],
   "source": [
    "class4 = data[mask_list[4]].copy()\n",
    "class4['group'] = class4['targets'].apply(classificate_class4)\n",
    "class4 = class4[class4.group != 0]\n",
    "class4 = distance_features(class4)\n",
    "\n",
    "test_class4 = test[mask_list_test[4]].copy()\n",
    "test_class4 = distance_features(test_class4)\n",
    "\n",
    "for i in range(3):\n",
    "    class4['dist' + str(i+1)] = class4[['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']].apply(lambda row: sorted(row)[i], axis=1)\n",
    "    test_class4['dist' + str(i+1)] = test_class4[['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']].apply(lambda row: sorted(row)[i], axis=1)\n",
    "    \n",
    "feature_list = ['dist1', 'dist2', 'dist3']\n",
    "model = XGBClassifier(n_estimators=5, random_state=0xC0FFEE)\n",
    "model.fit(class4[feature_list], class4['group'])\n",
    "\n",
    "class4_predict_group = model.predict(test_class4[feature_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "e23d979a",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_class4 = list(map(convert_group_to_target_class4, class4_predict_group))\n",
    "test.loc[mask_list_test[4], 'predictions'] = predictions_class4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "240eba8f",
   "metadata": {},
   "source": [
    "### Class5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "bb080f0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17:30:01] WARNING: ../src/learner.cc:1115: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'multi:softprob' was changed from 'merror' to 'mlogloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n"
     ]
    }
   ],
   "source": [
    "class5 = data[mask_list[5]].copy()\n",
    "class5['group'] = class5['targets'].apply(classificate_class5)\n",
    "class5 = class5[class5.group != 0]\n",
    "class5 = distance_features(class5)\n",
    "\n",
    "test_class5 = test[mask_list_test[5]].copy()\n",
    "test_class5 = distance_features(test_class5)\n",
    "\n",
    "for i in range(3):\n",
    "    class5['dist' + str(i+1)] = class5[['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']].apply(lambda row: sorted(row)[i], axis=1)\n",
    "    test_class5['dist' + str(i+1)] = test_class5[['Mo_S_dist', 'S_Se_dist', 'Mo_Se_dist']].apply(lambda row: sorted(row)[i], axis=1)\n",
    "    \n",
    "feature_list = ['dist1', 'dist2', 'dist3']\n",
    "model = XGBClassifier(n_estimators=5, random_state=0xC0FFEE)\n",
    "model.fit(class5[feature_list], class5['group'])\n",
    "\n",
    "class5_predict_group = model.predict(test_class5[feature_list])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "9c3abf4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_class5 = list(map(convert_group_to_target_class5, class5_predict_group))\n",
    "test.loc[mask_list_test[5], 'predictions'] = predictions_class5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "ea652105",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f05d43a5880>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(np.arange(len(test)), test.predictions, s=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f526a504",
   "metadata": {},
   "source": [
    "## Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d78b2d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "test['predictions'].to_csv('best_submission_in_the_world_6classes.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3625488",
   "metadata": {},
   "outputs": [],
   "source": [
    "# our_submission = test[['predictions']].copy()\n",
    "# baseline = pd.read_csv('submission.csv', index_col=0)\n",
    "\n",
    "# unite_sub = our_submission.join(baseline, lsuffix='_our', rsuffix='_bas')\n",
    "# unite_sub.loc[mask_list_test[0] | mask_list_test[1] | mask_list_test[2], 'predictions'] = unite_sub['predictions_our']\n",
    "# unite_sub.loc[~(mask_list_test[0] | mask_list_test[1] | mask_list_test[2]), 'predictions'] = unite_sub['predictions_bas']\n",
    "# unite_sub['predictions'].to_csv('best_submission_in_the_world1_full.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7a69ff3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}