Prediction-Revised-Edition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict the vx value based on the selected model\n",
    "\n",
    "import os\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torchvision\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from autogluon.tabular import TabularDataset, TabularPredictor\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_path(mtype = 'high', cycle = 1):\n",
    "    if mtype == 'high':\n",
    "        path1='sr_C1_20'\n",
    "        swirl = '20'\n",
    "    elif mtype == 'medium':\n",
    "        path1= 'sr_C4_12'\n",
    "        swirl = '12'\n",
    "    elif mtype == 'low':\n",
    "        path1 = 'sr_C6_01'\n",
    "        swirl = '01'\n",
    "    path2=\"./dataset/\"+path1+\"/Cycle-\"+str(cycle).zfill(3)+\"/\"\n",
    "    path =  path2\n",
    "    return path\n",
    "\n",
    "def get_res_path(mtype = 'high', cycle = 1):\n",
    "    if mtype == 'high':\n",
    "        path1='sr_C1_20'\n",
    "        swirl = '20'\n",
    "    elif mtype == 'medium':\n",
    "        path1= 'sr_C4_12'\n",
    "        swirl = '12'\n",
    "    elif mtype == 'low':\n",
    "        path1 = 'sr_C6_01'\n",
    "        swirl = '01'\n",
    "    path2=path1+\"/Cycle-\"+str(cycle).zfill(3)+\"/\"\n",
    "    path =  path2\n",
    "    return path\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_stable_point(md = 'x', mode = 'low', phase = 1):\n",
    "    res = np.zeros(625)\n",
    "    res=res-99\n",
    "#     print(res)\n",
    "    if md=='x':\n",
    "        path1 ='x/result-'+mode+'-'+str(phase)+'/'\n",
    "    if md == 'y':\n",
    "        path1 ='y/result-'+mode+'-'+str(phase)+'/'\n",
    "    b=[]\n",
    "    xm=[]\n",
    "    ym=[]\n",
    "    filename= './dataset/sample.dat'\n",
    "    data=pd.read_csv(filename,index_col = 0).values\n",
    "    # print(data)\n",
    "    for k in range(25):\n",
    "        for i in range(1,24):\n",
    "            for j in range(1,24):\n",
    "                #for any sequence in i and j\n",
    "                if data[i][j]!=0:\n",
    "                    if data[i-1][j]==0 or data[i+1][j]==0 or data[i][j-1]==0 or data[i][j+1]==0:\n",
    "                        b.append(i*25+j)\n",
    "\n",
    "                        xm.append(i)\n",
    "                        ym.append(j)\n",
    "        # print(b)\n",
    "        for i in range(len(xm)):\n",
    "            data[xm[i]][ym[i]]=0\n",
    "                    \n",
    "    # np.random.shuffle(b)\n",
    "    b=np.flipud(b)\n",
    "    b=np.append(b,range(625))\n",
    "    l1=list(b)\n",
    "    for el in range(len(l1)-1, -1, -1):\n",
    "        if l1.count(l1[el]) > 1:\n",
    "            l1.pop(el)\n",
    "    # print(l1)\n",
    "\n",
    "    return l1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_data(model = 'x',mtype = 'high',cycle = 10, phase = 5):\n",
    "    series = pd.DataFrame(None,columns=range(625))\n",
    "    path1 = get_path(mtype,cycle)\n",
    "    for i in range(int(121/phase)):\n",
    "        j = i*phase+1;\n",
    "        read_path = path1+str(j)\n",
    "        #print(read_batch('B'+str(batch).zfill(5)))\n",
    "        series= series.append(read_batch(read_path,model))\n",
    "#         #print(series)\n",
    "        \n",
    "    return series\n",
    "\n",
    "def check_data(model = 'x',mtype = 'high',cycle = 10, phase = 1):\n",
    "    series = pd.DataFrame(None,columns=range(625))\n",
    "    path1 = get_path(mtype,cycle)\n",
    "    for i in range(int(121/phase)):\n",
    "        j = (i+1)*phase+1;\n",
    "        read_path = path1+str(j)\n",
    "        #print(read_batch('B'+str(batch).zfill(5)))\n",
    "        series= series.append(read_batch(read_path,model))\n",
    "#         #print(series)\n",
    "        \n",
    "    return series\n",
    "\n",
    "def read_data(model = 'x',mtype = 'high',cycle = 10, phase = 5, time_series = 0):\n",
    "#     series = pd.DataFrame(None,columns=range(625))\n",
    "    path1 = get_path(mtype,cycle)\n",
    "\n",
    "    j = time_series*phase+1;\n",
    "    read_path = path1+str(j)\n",
    "    #print(read_batch('B'+str(batch).zfill(5)))\n",
    "    series= read_batch(read_path,model)\n",
    "    return series\n",
    "\n",
    "def check_data(model = 'x',mtype = 'high',cycle = 10, phase = 1, time_series = 0):\n",
    "#     series = pd.DataFrame(None,columns=range(625))\n",
    "    path1 = get_path(mtype,cycle)\n",
    "\n",
    "    j = (time_series+1)*phase+1;\n",
    "    read_path = path1+str(j)\n",
    "    #print(read_batch('B'+str(batch).zfill(5)))\n",
    "    series= read_batch(read_path,model)\n",
    "        \n",
    "    return series\n",
    "\n",
    "def read_batch(str = 'B00001',model = 'x'):\n",
    "    suf_1 = '.dat'\n",
    "    data1 = pd.read_csv(str+suf_1,skiprows = 3,header = None,delimiter = ' ')\n",
    "    value = data1.values.reshape(25,25,-1)\n",
    "    if model == 'x':\n",
    "        vx=pd.DataFrame(value[:,:,2].reshape(-1)).transpose()\n",
    "    if model == 'y':\n",
    "        vx=pd.DataFrame(value[:,:,3].reshape(-1)).transpose()\n",
    "#     y=value[:,:,1]\n",
    "#     vx=value[:,:,2]\n",
    "#     vy = value[:,:,3]\n",
    "    return vx\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>615</th>\n",
       "      <th>616</th>\n",
       "      <th>617</th>\n",
       "      <th>618</th>\n",
       "      <th>619</th>\n",
       "      <th>620</th>\n",
       "      <th>621</th>\n",
       "      <th>622</th>\n",
       "      <th>623</th>\n",
       "      <th>624</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 625 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1    2    3    4    5    6    7    8    9    ...  615  616  617  618  \\\n",
       "0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  ...  0.0  0.0  0.0  0.0   \n",
       "\n",
       "   619  620  621  622  623  624  \n",
       "0  0.0  0.0  0.0  0.0  0.0  0.0  \n",
       "\n",
       "[1 rows x 625 columns]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "read_data('x','high',10,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def phase_prediction(mode,target_column,data1):\n",
    "# def phase_prediction(mode,target_column,mtype,phase,batch,data1,nxt_phase,scope):\n",
    "    if mode == 'y':\n",
    "#         path1='./y/result-'+mtype+'-'+str(phase)+'/'+str(phase-scope+1)+'-'+str(phase)+'-'+str(nxt_phase)+'/'\n",
    "        #edited\n",
    "        path1='./model/y/clone-low-1/' # training model path\n",
    "    if mode == 'x':\n",
    "#         path1='./x/result-'+mtype+'-'+str(phase)+'/'+str(phase-scope+1)+'-'+str(phase)+'-'+str(nxt_phase)+'/'\n",
    "        #editted\n",
    "        path1='./model/x/clone-low-1/'\n",
    "    save_path = path1 +'tgModels'+str(target_column-625) #training model path\n",
    "    isExists=os.path.exists(save_path)\n",
    "    if not isExists:\n",
    "        return 0.0\n",
    "    predictor = TabularPredictor.load(save_path,require_version_match=False) \n",
    "    \n",
    "    vx=data1\n",
    "    y_test = vx[target_column]\n",
    "\n",
    "    test_data_nolab = vx.drop(columns=[target_column])\n",
    "    test_data_nolab.columns = range(target_column)\n",
    "    y_pred = predictor.predict(test_data_nolab)\n",
    "    \n",
    "    #Testing code\n",
    "    print(y_test,'\\n',y_pred)\n",
    "    # perf = predictor.evaluate_predictions(y_true=y_test, y_pred=y_pred, auxiliary_metrics=True)\n",
    "    return y_pred\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def batch_prediction(mtype='high',phase = 1,batch=1, cycle = 10 ,scope = 5, time_series = 0):\n",
    "# def batch_prediction(mtype='high',phase = 1,batch=1,predict_phase = 1, next_phase =2,scope = 5):\n",
    "    result_y = np.zeros(625)\n",
    "    result_x = np.zeros(625)\n",
    "    stable_priority_x = find_stable_point()\n",
    "    stable_priority_y = find_stable_point()\n",
    "    pre_data_x = read_data('x',mtype,cycle,scope, time_series)\n",
    "    pre_data_y = read_data('y',mtype,cycle,scope, time_series)\n",
    "    \n",
    "    series_num = int(121/scope)\n",
    "#     print(pre_data_x)\n",
    "    \n",
    "#     pre_data_x.index= range(series_num*batch)\n",
    "#     pre_data_y.index=range(series_num*batch)\n",
    "    \n",
    "    nxt_data_x = check_data('x',mtype,cycle,scope, time_series)\n",
    "    nxt_data_y = check_data('y',mtype,cycle,scope, time_series)\n",
    "#     pre_data_x.index= range(series_num*batch)\n",
    "#     pre_data_y.index=range(series_num*batch)\n",
    "#     nxt_data_x.index= range(series_num*batch)\n",
    "#     nxt_data_y.index=range(series_num*batch)\n",
    "    for i in range(625):\n",
    "        \n",
    "       \n",
    "        pre_data_x.insert(len(pre_data_x.columns),i+625,nxt_data_x[stable_priority_x[i]])\n",
    "        pre_data_y.insert(len(pre_data_y.columns),i+625,nxt_data_y[stable_priority_y[i]])\n",
    "#         print(pre_data_x.head(1))\n",
    "#         print(phase_prediction('x',i,mtype,phase,batch,pre_data_x))\n",
    "\n",
    "#         if i == 200:\n",
    "#             continue\n",
    "#         print(stable_priority_x[i])\n",
    "#         print(stable_priority_y[i])\n",
    "\n",
    "        result_x[stable_priority_x[i]]= phase_prediction('x',i+625,pre_data_x)# the first batch\n",
    "        result_y[stable_priority_y[i]]= phase_prediction('y',i+625,pre_data_y)\n",
    "#         if i >=20:\n",
    "#             print(pre_data_x)\n",
    "#             pre_data_x[i+625]=result_x[stable_priority_x[i]]\n",
    "#             print(pre_data_x)\n",
    "#             pre_data_y[i+625]=result_y[stable_priority_y[i]]\n",
    "\n",
    "#         result_x[stable_priority_x[i]]= phase_prediction('x',i+625,pre_data_x.iloc[[100*(scope-1)+batch]])# the first batch\n",
    "#         result_y[stable_priority_y[i]]= phase_prediction('y',i+625,pre_data_y.iloc[[100*(scope-1)+batch]],next_phase,scope)\n",
    "#         elif predict_phase>phase:\n",
    "#             result_x[stable_priority_x[i]]= phase_prediction('x',i+625,pre_data_x.iloc[[batch]],next_phase,scope)# the first batch\n",
    "#             result_y[stable_priority_y[i]]= phase_prediction('y',i+625,pre_data_y.iloc[[batch]],next_phase,scope)\n",
    "#         else:\n",
    "#             result_x[stable_priority_x[i]]= phase_prediction('x',i+625,pre_data_x.iloc[[100*(phase-predict_phase)+batch]],next_phase,scope)# the first batch\n",
    "#             result_y[stable_priority_y[i]]= phase_prediction('y',i+625,pre_data_y.iloc[[100*(phase-predict_phase)+batch]],next_phase,scope)\n",
    "#         result_x[i]= phase_prediction('x',i+625,mtype,phase,batch,pre_data_x.head(1))\n",
    "#         result_y[i]= phase_prediction('y',i+625,mtype,phase,batch,pre_data_y.head(1))\n",
    "#         print(result_x[stable_priority_x[i]])\n",
    "#         print(result_y[stable_priority_y[i]])\n",
    "        # print(nxt_data_x[stable_priority_x[i]],result_x[stable_priority_x[i]])\n",
    "#     print(result_x,result_y)\n",
    "    return result_x,result_y\n",
    "        \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def vector_field_visualization(str1,ax1):\n",
    "    suf_1 = '.dat'\n",
    "    suf_2 = '.png'\n",
    "    data1 = pd.read_csv(str1+suf_1,skiprows = 3,header = None,delimiter = ' ')\n",
    "    value = data1.values.reshape(25,25,-1)\n",
    "    x=value[:,:,0]\n",
    "    y=value[:,:,1]\n",
    "    vx=value[:,:,2]\n",
    "    vy = value[:,:,3]\n",
    "    \n",
    "    ax1.quiver(x,y,vx,vy,color = '#000000')\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# result_x, result_y = batch_prediction(mtype='high',phase = 1,batch=1, cycle = 20 ,scope = 5, time_series = 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def continuous_prediction(x,y,mtype='high',phase = 1,batch=1, cycle = 10 ,scope = 5, time_series = 0):\n",
    "# def continuous_prediction(x,y,mtype,phase,batch,nxt_phase, time_series):\n",
    "    result_y = np.zeros(625)\n",
    "    result_x = np.zeros(625)\n",
    "    x=pd.DataFrame(x.reshape(1,-1),columns = range(625))\n",
    "    y=pd.DataFrame(y.reshape(1,-1),columns = range(625))\n",
    "    stable_priority_x = find_stable_point()\n",
    "    stable_priority_y = find_stable_point()\n",
    "    \n",
    "    \n",
    "    nxt_data_x = check_data('x',mtype,cycle,scope, time_series)\n",
    "    nxt_data_y = check_data('y',mtype,cycle,scope, time_series)\n",
    "\n",
    "    for i in range(625):\n",
    "        \n",
    "       \n",
    "        x.insert(len(x.columns),i+625,nxt_data_x[stable_priority_x[i]])\n",
    "        y.insert(len(y.columns),i+625,nxt_data_y[stable_priority_y[i]])\n",
    "#         print(pre_data_x.head(1))\n",
    "#         print(phase_prediction('x',i,mtype,phase,batch,pre_data_x))\n",
    "\n",
    "#         if i == 200:\n",
    "#             continue\n",
    "#         print(stable_priority_x[i])\n",
    "#         print(stable_priority_y[i])\n",
    "        \n",
    "\n",
    "        result_x[stable_priority_x[i]]= phase_prediction('x',i+625,x)# the first batch\n",
    "        result_y[stable_priority_y[i]]= phase_prediction('y',i+625,y)\n",
    "        x[i+625]=result_x[stable_priority_x[i]]\n",
    "        y[i+625]=result_y[stable_priority_y[i]]\n",
    "        \n",
    "#         result_x[i]= phase_prediction('x',i+625,mtype,phase,batch,pre_data_x.head(1))\n",
    "#         result_y[i]= phase_prediction('y',i+625,mtype,phase,batch,pre_data_y.head(1))\n",
    "#         print(result_x[stable_priority_x[i]])\n",
    "#         print(result_y[stable_priority_y[i]])\n",
    "        # print(nxt_data_x[stable_priority_x[i]],result_x[stable_priority_x[i]])\n",
    "    # print(result_x,result_y)\n",
    "    return result_x,result_y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def single_predictor(mtype = 'high',phase = 1, cycle = 10,  predict_phase = 1, nxt_phase = 6,scope = 1,elapse=5,first_rank = 0.8, second_rank = 0.7):\n",
    "#     batch_prediction(mtype='high',phase = 1,batch=1, cycle = 10 ,scope = 5, time_series = 1)\n",
    "    time_series = 0\n",
    "    batch = 1\n",
    "    for i in range(int((nxt_phase-phase)/elapse)):\n",
    "        \n",
    "        if i == 0:\n",
    "            x,y = batch_prediction(mtype, phase, batch, cycle ,elapse, time_series)\n",
    "        else:\n",
    "            \n",
    "            x,y = continuous_prediction(x,y,mtype, phase ,batch, cycle, elapse, time_series)\n",
    "        current_cad = time_series*elapse+1\n",
    "        target_cad = (time_series+1)*elapse+1\n",
    "        suf_1 = '.dat'\n",
    "        suf_2 = '.png'\n",
    "\n",
    "        str1 = get_path(mtype,cycle)+str(target_cad);\n",
    "        \n",
    "        cur_cad_val = -300+(current_cad-1)*2\n",
    "        \n",
    "        tg_cad_val = -300+(target_cad-1)*2\n",
    "        str2 = './result/'+get_res_path(mtype,cycle)+str(tg_cad_val)+'CAD_ATDC/'\n",
    "        \n",
    "        os.path.exists(str2)\n",
    "        if not os.path.exists(str2):\n",
    "            os.makedirs(str2)\n",
    "        if not os.path.exists(str2+'/x'):\n",
    "            os.makedirs(str2+'/x')\n",
    "        if not os.path.exists(str2+'/y'):\n",
    "            os.makedirs(str2+'/y')\n",
    "        if not os.path.exists(str2+'/SI/Data'):\n",
    "            os.makedirs(str2+'/SI/Data')\n",
    "        if not os.path.exists(str2+'/MI/Data'):\n",
    "            os.makedirs(str2+'/MI/Data')\n",
    "        if not os.path.exists(str2+'/Raw'):\n",
    "            os.makedirs(str2+'/Raw')\n",
    "        data1 = pd.read_csv(str1+suf_1,skiprows = 3,header = None,delimiter = ' ')\n",
    "        value = data1.values.reshape(25,25,-1)\n",
    "        xm=value[:,:,0]\n",
    "        ym=value[:,:,1]\n",
    "        x=x.reshape(25,25)\n",
    "        y=y.reshape(25,25)\n",
    "        x1=value[:,:,2]\n",
    "        y1=value[:,:,3]\n",
    "        pd.DataFrame(x).to_csv(str2+'/x/'+str(batch+1)+suf_1)\n",
    "        pd.DataFrame(x1).to_csv(str2+'/x/'+str(batch+1)+'-raw'+suf_1)\n",
    "        pd.DataFrame(y).to_csv(str2+'/y/'+str(batch+1)+suf_1)\n",
    "        pd.DataFrame(y1).to_csv(str2+'/y/'+str(batch+1)+'-raw'+suf_1)\n",
    "        plt.figure(2)\n",
    "        \n",
    "        ax1 = plt.subplot(121)\n",
    "        ax1.set(xlim = [-40,40],ylim = [-40,40],aspect = 'equal',xlabel = 'Original: -'+str(cur_cad_val)+' CAD')\n",
    "        path1 = get_path(mtype,cycle) + str(current_cad)\n",
    "       \n",
    "        vector_field_visualization(path1,ax1)\n",
    "\n",
    "\n",
    "\n",
    "        ax2 = plt.subplot(122)\n",
    "        ax2.set(xlim = [-40,40],ylim = [-40,40],aspect = 'equal',xlabel = 'Predicted: -'+str(tg_cad_val)+' CAD')\n",
    "        ax2.quiver(xm,ym,x,y, color = '#DC143C')\n",
    "        ax2.quiver(xm,ym,x1,y1,color = '#98FB98')\n",
    "\n",
    "        #     plt.xlabel('SI>'+str(first_rank)+': '+ str(100-round(first*100/310,1))+'%  SI>'+str(second_rank)+': '+str(100-round(second*100/310,1))+'%')\n",
    "        plt.savefig(str2+'/Raw/'+str(batch+1)+suf_2,dpi=600)\n",
    "        plt.show()\n",
    "        plt.close(2)\n",
    "\n",
    "\n",
    "        data_SI= np.ones((25,25))\n",
    "        first = 0\n",
    "        second = 0\n",
    "\n",
    "\n",
    "\n",
    "    #   SI Calculation\n",
    "        for i in range(25):\n",
    "            for j in range(25):\n",
    "                data_SI[i][j]=(x[i][j]*x1[i][j]+ y[i][j]*y1[i][j])/math.sqrt(x[i][j]*x[i][j]+ y[i][j]*y[i][j])/math.sqrt(x1[i][j]*x1[i][j]+y1[i][j]*y1[i][j])\n",
    "                if data_SI[i][j]<first_rank:\n",
    "                    first= first+1\n",
    "                if data_SI[i][j]<second_rank:\n",
    "                    second = second + 1\n",
    "        pd.DataFrame(data_SI).to_csv(str2+'/SI/Data/'+str(batch+1)+suf_1)\n",
    "\n",
    "        plt.figure(0)\n",
    "        plt.contourf(xm, ym, data_SI, [second_rank,first_rank],colors=['blue','lightsteelblue','white'],extend='both')\n",
    "    #     CS = plt.contour(xm, ym, data, [0.8,0.7],colors=['blue','lightsteelblue','white'],extend='both')\n",
    "    #     plt.clabel(CS,fontsize=10,colors=['red','red','white'])\n",
    "        plt.quiver(xm,ym,x,y, color = '#DC143C')\n",
    "        plt.quiver(xm,ym,x1,y1,color = '#98FB98')\n",
    "        plt.axis('square')\n",
    "        plt.xlim(-40,40)\n",
    "        plt.ylim(-40,40)\n",
    "        # plt.title('SI Prediction:-'+str(302-2*predict_phase)+' to -'+str(302-2*nxt_phase)+' Model: -'+str(302-2*phase)+' to -'+str(302-2*nxt_phase))\n",
    "        plt.title(str(tg_cad_val)+'CAD ATDC')\n",
    "        plt.xlabel('SI>'+str(first_rank)+': '+ str(100-round(first*100/310,1))+'%  SI>'+str(second_rank)+': '+str(100-round(second*100/310,1))+'%')\n",
    "        plt.savefig(str2+'/SI/'+str(batch+1)+suf_2,dpi=600)\n",
    "        plt.show()\n",
    "        plt.close(0)\n",
    "\n",
    "    # MI Calculation\n",
    "        plt.figure(1)\n",
    "        data_MI= np.ones((25,25))\n",
    "        first = 0\n",
    "        second = 0\n",
    "        for i in range(25):\n",
    "            for j in range(25):\n",
    "                if x1[i][j]==0:\n",
    "                    data_MI[i][j]=1\n",
    "                else:\n",
    "                    data_MI[i][j]=1-(math.sqrt(x[i][j]*x[i][j]+ y[i][j]*y[i][j])-math.sqrt(x1[i][j]*x1[i][j]+y1[i][j]*y1[i][j]))/(math.sqrt(x[i][j]*x[i][j]+ y[i][j]*y[i][j])+math.sqrt(x1[i][j]*x1[i][j]+y1[i][j]*y1[i][j]))\n",
    "                    if data_MI[i][j]<first_rank:\n",
    "                        first= first+1\n",
    "                    if data_MI[i][j]<second_rank:\n",
    "                        second = second + 1\n",
    "\n",
    "    #     print(data)\n",
    "    #     pd.DataFrame(data).to_csv(str2+'/'+str(batch+1)+suf_1)\n",
    "        pd.DataFrame(data_MI).to_csv(str2+'/MI/Data/'+str(batch+1)+suf_1)\n",
    "        plt.contourf(xm, ym, data_MI, [0.7,0.8],colors=['blue','lightsteelblue','white'],extend='both')\n",
    "\n",
    "    #     CS = plt.contour(xm, ym, data, [0.8,0.7],colors=['blue','lightsteelblue','white'],extend='both')\n",
    "    #     plt.clabel(CS,fontsize=10,colors=['red','red','white'])\n",
    "        plt.quiver(xm,ym,x,y, color = '#DC143C')\n",
    "        plt.quiver(xm,ym,x1,y1,color = '#98FB98')\n",
    "    #     plt.title('MI Prediction:'+predict_phase+' to '+nxt_phase+' Model: '+phase+' to '+nxt_phase)\n",
    "    #     plt.xlabel('MI>'+first_rank+': '+ str(1-round(first*100/310,1))+'%  MI>'+second_rank+': '+str(1-round(second*100/310,1))+'%')\n",
    "        plt.title(str(tg_cad_val)+'CAD ATDC')\n",
    "        plt.xlabel('MI>'+str(first_rank)+': '+ str(100-round(first*100/310,1))+'%  MI>'+str(second_rank)+': '+str(100-round(second*100/310,1))+'%')\n",
    "\n",
    "        plt.axis('square')\n",
    "        plt.xlim(-40,40)\n",
    "        plt.ylim(-40,40)\n",
    "\n",
    "        plt.savefig(str2+'/MI/'+str(batch+1)+suf_2,dpi=600)\n",
    "        plt.show()\n",
    "        plt.close(1)\n",
    "        \n",
    "        time_series = time_series+1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# single_predictor('high',1,10,1,121,1,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for sw in ['high','medium','low']:\n",
    "    for cycle in [70,80,90]:\n",
    "        single_predictor(sw,1,cycle,1,121,1,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}