{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Introduction\n\nThis notebook is forked from https://www.kaggle.com/andypenrose/osic-multiple-quantile-regression-starter \n","execution_count":null},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport pydicom\nimport os\nimport random\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\nfrom PIL import Image\nfrom sklearn.metrics import mean_absolute_error, mean_squared_error\nfrom sklearn.model_selection import KFold,GroupKFold,TimeSeriesSplit,train_test_split\nfrom time import time","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import tensorflow as tf\nimport tensorflow.keras.backend as K\nimport tensorflow.keras.layers as L\nimport tensorflow.keras.models as M\n\nfrom keras.layers import LSTM, Dropout","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"try:\n    del z_test\n    del y_test\n    del pred_test\n    print('deleted')\nexcept:\n    print('go')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def seed_everything(seed=2020):\n    random.seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    np.random.seed(seed)\n    tf.random.set_seed(seed)\n    \nseed_everything(24)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"ROOT = \"../input/osic-pulmonary-fibrosis-progression\"","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"## evaluation metric function\ndef laplace_log_likelihood(actual_fvc, predicted_fvc, confidence, return_values = False):\n    \"\"\"\n    Calculates the modified Laplace Log Likelihood score for this competition.\n    \"\"\"\n    sd_clipped = np.maximum(confidence, 70)\n    delta = np.minimum(np.abs(actual_fvc - predicted_fvc), 1000)\n    metric = - np.sqrt(2) * delta / sd_clipped - np.log(np.sqrt(2) * sd_clipped)\n\n    if return_values:\n        return metric\n    else:\n        return np.mean(metric)\n\n\n## default benchmark\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tra = pd.read_csv(f\"{ROOT}/train.csv\")\ntra.drop_duplicates(keep=False, inplace=True, subset=['Patient','Weeks'])\nchunk = pd.read_csv(f\"{ROOT}/test.csv\")\n\nsub = pd.read_csv(f\"{ROOT}/sample_submission.csv\")\nsub['Patient'] = sub['Patient_Week'].apply(lambda x:x.split('_')[0])\nsub['Weeks'] = sub['Patient_Week'].apply(lambda x: int(x.split('_')[-1]))\nsub =  sub[['Patient','Weeks','Confidence','Patient_Week']]\nsub = sub.merge(chunk.drop('Weeks', axis=1), on=\"Patient\") # appiccica a sub le colonne di Chunk a parte week\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tra.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\ntr['Dist'] = 0\ntr = tr.sort_values(by=['Patient', 'Weeks'])\nfor p in range(1,tr.shape[0]):\n    if tr.iloc[p, 0] == tr.iloc[p-1, 0]:\n        tr.iloc[p, -1] = tr.iloc[p, 2] - tr.iloc[p-1, 2]   \nprint(tr.iloc[:,-1].describe())\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sub.columns","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\nsub['Dist'] = 0\nsub = sub.sort_values(by=['Patient', 'Weeks'])\nfor p in range(1,sub.shape[0]):\n    if sub.iloc[p, 0] == sub.iloc[p-1, 0]:\n        sub.iloc[p, -1] = sub.iloc[p, 4] - sub.iloc[p-1, 4]   \nprint(sub.iloc[:,-1].describe())\n'''\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\nchunk['Dist'] = 0\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"trr = pd.DataFrame(tr).copy()\nppp=trr[trr.Patient == 'ID00007637202177411956430'].copy()\nppp['Old'] = True\naaa = ppp.loc[0]\naaa\nr = pd.DataFrame([aaa], columns = ppp.columns)\nr['Weeks']=0\nr['FVC']=0\nr['Percent']=0\nppp = pd.concat([ppp, r], ignore_index=True)","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"tr = pd.DataFrame(tra).copy()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\n# devo creare le righe mancanti\n\npat = tr['Patient'][0]\nfor pat in tr['Patient'].unique():\n    k=0\n    base = tr.loc[tr.Patient == pat]\n    baseB = base.values[0]\n    baseDf = pd.DataFrame([baseB], columns = base.columns)\n    for we in sorted(sub['Weeks'].unique()):\n        a = tr.loc[tr['Patient'] == pat] #tutte le week di pat\n        b= a.loc[a['Weeks'] == we,'FVC'] #FVC di week we\n        if b.unique().size == 0:\n            if we == sub['Weeks'].max():\n                appoggio = baseDf.copy()\n                bb= a.loc[a['Weeks'] == (we-k-1),'FVC']\n                bb = bb.values[0]\n                delta = 0\n                #print('we:',we,' b:',b,' bb',bb,'k:',k,' delta:',delta)\n      \n                for j in range(1, k+1):\n                    appoggio.Weeks = (we-k+j)\n                    appoggio.FVC = bb\n                    appoggio.Percent = appoggio.FVC / (baseDf.FVC / baseDf.Percent)\n                    tr = pd.concat([tr, appoggio], ignore_index=True)\n    \n                del appoggio\n                k=0\n            elif we == sub['Weeks'].min():\n                appoggio = baseDf.copy()\n                appoggio.Weeks = we\n                tr = pd.concat([tr, appoggio], ignore_index=True)\n                del appoggio\n                k=0\n            else:\n                k = k+1\n        elif k > 0:\n            appoggio = baseDf.copy()\n            bb= a.loc[a['Weeks'] == (we-k-1),'FVC'] \n            if bb.unique().size == 0:\n                appoggio.Weeks = (we-k-1)\n                appoggio.FVC = b.values[0]\n                appoggio.Percent = appoggio.FVC / (baseDf.FVC / baseDf.Percent)\n                del bb\n                bb = a.loc[a['Weeks'] == we,'FVC']\n            \n            bb = bb.values[0]\n            b = b.values[0]\n            delta = b - bb\n            #print('we:',we,' b:',b,' bb',bb,'k:',k,' delta:',delta)\n  \n            for j in range(0, k):\n                bbb = bb + delta/(k+1)*(j+1) #ho calcolato FVC nuova riga\n                \n                appoggio.Weeks = (we-k+j)\n                appoggio.FVC = bbb\n                appoggio.Percent = appoggio.FVC / (baseDf.FVC / baseDf.Percent)\n                \n                tr = pd.concat([tr, appoggio], ignore_index=True)\n    \n            del appoggio\n            k=0\n    del baseDf,baseB, base, a, b, bb, bbb,\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tr['WHERE'] = 'train'\nchunk['WHERE'] = 'val'\nsub['WHERE'] = 'test'\ndata = tr.append([chunk, sub])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(tr.shape, chunk.shape, sub.shape, data.shape)\nprint(tr.Patient.nunique(), chunk.Patient.nunique(), sub.Patient.nunique(), \n      data.Patient.nunique())\n#","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\nvoglio associare ad ogni riga:\n- aggregando per età/smoking status e sesso\n    - i tre percentili del valore massimo\n    - i tre percentili del valore minimo\n    - i tre percentili del rapporto tra max e min\n    f=pd.DataFrame(d.groupby(['a','b']))\n'''\ndata['min_perc'] = data.Percent\ndata.loc[data.WHERE=='test','min_perc'] = np.nan\ndata['max_perc'] = data.Percent\ndata.loc[data.WHERE=='test','max_perc'] = np.nan\n\ndata['min_perc'] = data.groupby(['Age','SmokingStatus','Sex'])['Percent'].transform('min')\ndata['max_perc'] = data.groupby(['Age','SmokingStatus','Sex'])['Percent'].transform('max')\n\ndata['rif_perc'] = data.max_perc - data.min_perc\ndata.loc[data.rif_perc > 0, 'rif_perc']= (data.loc[data.rif_perc > 0, 'Percent']- data.loc[data.rif_perc > 0, 'min_perc'])/\\\n    (data.loc[data.rif_perc > 0, 'max_perc'] - data.loc[data.rif_perc > 0, 'min_perc'])\n\ndata = data.drop(['max_perc','min_perc'], axis=1)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data.info()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# identifica la prima settimana per paziente\n\ndata['min_week'] = data['Weeks']\ndata.loc[data.WHERE=='test','min_week'] = np.nan\ndata['min_week'] = data.groupby('Patient')['min_week'].transform('min')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# identifica la FVC della min_week ed elimina eventuali duplicati\n\nbase = data.loc[data.Weeks == data.min_week]\nbase = base[['Patient','FVC']]\nbase = base[['Patient','FVC']].copy()\nbase.columns = ['Patient','min_FVC']\nbase['nb'] = 1\nbase['nb'] = base.groupby('Patient')['nb'].transform('cumsum')\nbase = base[base.nb==1]\nbase.drop('nb', axis=1, inplace=True)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# aggiunge le colonne (identiche per paziente) min_FVC e base_week (indice della settimana dove la min_week = 0)\n\ndata = data.merge(base, on='Patient', how='left')\ndata['base_week'] = data['Weeks'] - data['min_week']\ndel base","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"FE = []\n\n# aggiunge le colonne categoriche per sex e smokingStatus utilizzando il bool sul valore assunto\n\nCOLS = ['Sex','SmokingStatus']\nfor col in COLS:\n    for mod in data[col].unique():\n        FE.append(mod)\n        data[mod] = (data[col] == mod).astype(int)\n#=================\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"'''\ndata.loc[data['SmokingStatus'] == 'Never smoked','SmokingStatus'] = 0\ndata.loc[data['SmokingStatus'] == 'Ex-smoker','SmokingStatus'] = 0.5\ndata.loc[data['SmokingStatus'] == 'Currently smokes','SmokingStatus'] = 1\n\ndata.loc[data['Sex'] == 'Male','Sex'] = 1\ndata.loc[data['Sex'] == 'Female','Sex'] = 0\n\ndata['Sex'] = data['Sex'].astype(float)\ndata['SmokingStatus'] = data['SmokingStatus'].astype(float)\n\nFE += ['Sex', 'SmokingStatus']\n'''","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# normalizza age\ndata['age'] = (data['Age'] - data['Age'].min() ) / ( data['Age'].max() - data['Age'].min() )\n\n# crea per ogni patient il normalizzato del valore di FVC alla settimana base, cioè del punto di partenza\ndata['FVC_BASE'] = (data['min_FVC'] - data['min_FVC'].min() ) / ( data['min_FVC'].max() - data['min_FVC'].min() )\n\n# crea per ogni week il normalizzato di base_week, che è la correzione per portare a zero la min_week\ndata['week'] = (data['base_week'] - data['base_week'].min() ) / ( data['base_week'].max() - data['base_week'].min() )\n\n# normalizza la percent\ndata['percent'] = (data['Percent'] - data['Percent'].min() ) / ( data['Percent'].max() - data['Percent'].min() )\n\n'''\n# normalizza la Dist\ndata['dist'] = (data['Dist'] - data['Dist'].min() ) / ( data['Dist'].max() - data['Dist'].min() )\n'''\n# all'elenco delle colonne aggiunge quelle normalizzate\n'''\nFE += ['age','percent','week','FVC_BASE', 'dist','rif_perc']\n'''\nFE += ['age','percent','week','FVC_BASE']\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data.info()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tr = data.loc[data.WHERE=='train']\nchunk = data.loc[data.WHERE=='val']\nsub = data.loc[data.WHERE=='test']\ndel data","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tr.info()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"tr.shape, chunk.shape, sub.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"\nk=0\ntr['KGroup'] = 0\n\nfor pat in tr.Patient.unique():\n    k=k+1\n    tr.loc[tr.Patient == pat, 'KGroup'] = k\n        \nk=0\nchunk['KGroup'] = 0\nfor pat in chunk.Patient.unique():\n    k=k+1\n    chunk.loc[chunk.Patient == pat, 'KGroup'] = k\n        \nk=0\nsub['KGroup'] = 0\nfor pat in sub.Patient.unique():\n    k=k+1\n    sub.loc[sub.Patient == pat, 'KGroup'] = k\n\ndel k, pat","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from tensorflow.keras import datasets, layers, models, regularizers, optimizers, callbacks\nfrom tensorflow.keras.layers import Flatten, BatchNormalization\nfrom keras.regularizers import l1_l2,l2,l1\nfrom tensorflow.keras.optimizers import SGD\nfrom tensorflow.keras import activations\nfrom keras.layers import LeakyReLU\nfrom tensorflow.keras.callbacks import History, EarlyStopping","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#, kernel_regularizer=l1_l2(l1=0.0001,l2=0.001)\n#, kernel_regularizer=l2(0.01)\n\nALPHA= 0.01\nL2 = 0.001\nMOMENTUM = 0.9 #ex 0,99\nDPO = 0.3\n\nuse_metric = 1.0 #0.8\nBATCH_SIZE = 16\nHDO = 144\nEPOCHS = 2000\nOPTIMIZER= \"adamax\"\n\nqmin = 0.2 #0.25\nqmed = 0.5\nqmax = 0.8 #0.75\n\nCORRECTION = tf.constant(1, dtype='float32') # per correggere la Confidence\nGROUPS = True\nNFOLD = 5\nTESTSIZE = 0.0 #0.2\nVAL_SPLIT = 0.1 # utilizzato solo se GROUPS = False\nERR = 0.0","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#tf.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False,name='Adam')\n\ntf.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False,name='Adam')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#tf.keras.optimizers.Adamax(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, name='Adamax')\n\ntf.keras.optimizers.Adamax(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07, name='Adamax')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def myLoss(y_true,y_pred):\n    sigma = (y_pred[:, 2] - y_pred[:, 0])\n    delta = tf.abs(y_true[:, 0] - y_pred[:, 1])\n    errore = tf.abs(sigma) - tf.abs(delta)\n    return errore","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"C1, C2 = tf.constant(70, dtype='float32'), tf.constant(1000, dtype=\"float32\")\nBEST = 0\n#=============================#\ndef score(y_true, y_pred):\n    tf.dtypes.cast(y_true, tf.float32)\n    tf.dtypes.cast(y_pred, tf.float32)\n    sigma = (y_pred[:, 2] - y_pred[:, 0])\n    #sigmaSTD = tf.math.reduce_std(sigma)\n    fvc_pred = y_pred[:, 1]\n    \n    #sigma_clip = sigma + C1\n    #sigma_clip = tf.maximum(sigmaSTD, C1)\n    sigma_clip = tf.maximum(sigma, C1)\n    delta = tf.abs(y_true[:, 0] - fvc_pred)\n    delta = tf.minimum(delta, C2)\n    sq2 = tf.sqrt( tf.dtypes.cast(2, dtype=tf.float32) )\n    metric = -((delta / sigma_clip) * sq2 + tf.math.log(sigma_clip * sq2))/BEST\n    return K.mean(metric)\n#============================#\ndef qloss(y_true, y_pred):\n    # Pinball loss for multiple quantiles\n    qs = [qmin,qmed,qmax]\n    q = tf.constant(np.array([qs]), dtype=tf.float32)\n    e = y_true - y_pred\n    '''\n    a[[a1],...[an]],b[[b11,b12,b13],...[bn1,bn2.bn3]]\n    c = a - b = [[a1-b11,a1-b12,a1-b13],...,[an-bn1,an-bn2,an-bn3] cioè a(1,) x b(3,) = c(3,)\n    c = q(3)*c(3,) = (3,) = [[q1*c11,q2*c12,q3*c13],...[q1*cn1,q2*cn2,q3*cn3]]\n    \n    in sostanza crea tre versioni di delta vs y_true le moltiplica per q e (1-q) e prende il max\n    '''\n\n    v = tf.maximum(q*e, (q-1)*e) \n    return K.mean(v)\n#=============================#\ndef mloss(_lambda, err):\n    def loss(y_true, y_pred):\n        return _lambda * qloss(y_true, y_pred) + (1 - _lambda)*score(y_true, y_pred) + err * myLoss(y_true, y_pred)\n    return loss\n#=================\n\ndef make_model():\n    z = L.Input((len(FE),), name=\"Patient\")\n    \n    x = L.LeakyReLU(alpha=ALPHA)(z)\n    x = L.Dense(HDO, kernel_regularizer=l2(L2))(x)\n    \n    x = L.LeakyReLU(alpha=ALPHA)(x)\n    x = L.Dense(HDO, kernel_regularizer=l2(L2))(x)\n    \n    p1 = L.Dense(3, activation=\"swish\", name=\"p1\")(x)\n    \n    model = M.Model(z, p1, name=\"CNN\")\n    model.compile(loss=mloss(use_metric, ERR), optimizer= OPTIMIZER, metrics=[score]) # , metrics=[score]\n    return model\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"net = make_model()\nprint(net.summary())\nprint(net.count_params())","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"X=np.reshape(X,(X.shape[0],X.shape[1],1))","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"print(len(tr['KGroup'].unique()))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"a=tr['KGroup'].unique()\nb=int(len(tr['KGroup'].unique())*(1-TESTSIZE))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_group = np.random.choice(a, b, replace=False)\ntrain_group = list(train_group)\ntest_group = []\nfor k in range(1,len(tr['KGroup'].unique())+1):\n    if k not in train_group:\n        test_group.append(int(k))\n\nprint(len(train_group),len(test_group))\ndel a,b,k","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train = pd.DataFrame()\nY_train = pd.DataFrame()\nfor k in train_group:\n    X_train = X_train.append(tr.loc[tr.KGroup == k])\nY_train = X_train['FVC']\ndel k","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_test = pd.DataFrame()\nY_test = pd.DataFrame()\nif TESTSIZE > 0:\n    for k in test_group:\n        X_test = X_test.append(tr.loc[tr.KGroup == k])\n    Y_test = X_test['FVC']\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(X_train.shape,Y_train.shape,X_test.shape,Y_test.shape)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"FE","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"z = X_train[FE].values\nz = np.reshape(z,(z.shape[0],z.shape[1],1))\n\ny = Y_train.values\n\nze = sub[FE].values\nze = np.reshape(ze,(ze.shape[0],z.shape[1],1))\n\npe = np.zeros((ze.shape[0], 3))\npred = np.zeros((z.shape[0], 3))\npred_act = np.zeros((z.shape[0], 3))\n\nif TESTSIZE > 0:\n    z_test = X_test[FE].values\n    z_test = np.reshape(z_test,(z_test.shape[0],z_test.shape[1],1))\n    \n    y_test = Y_test.values\n    \n    pred_test = np.zeros((z_test.shape[0], 3))\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(z.shape,'\\n',FE)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_model(model_history, epochs, metric):\n    fraz = 1.2\n    starting_point = int(epochs/fraz)\n    if GROUPS:\n        epochs = epochs * NFOLD\n    plt.figure(figsize=(14,10))\n    plt.title(\"Metric\")\n    plt.xlabel(\"Epoch\")\n    plt.ylabel(\"Metric\")\n    plt.plot(model_history[metric][epochs - starting_point:],color='green')\n    try: plt.plot(model_history['val_' + metric][epochs - starting_point:],color='red')\n    except: no=1\n\n    plt.figure(figsize=(14,10))\n    plt.title(\"Loss\")\n    plt.xlabel(\"Epoch\")\n    plt.ylabel(\"Loss\")\n    plt.plot(model_history['loss'][epochs - starting_point:],color='green')\n    try: plt.plot(model_history['val_loss'][epochs - starting_point:],color='red')\n    except: no=1","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def analyze_model(trax, tray, testx, testy):\n    a = net.evaluate(trax,tray, verbose=0, batch_size=BATCH_SIZE)\n    b = net.evaluate(testx,testy, verbose=0, batch_size=BATCH_SIZE)\n\n    c = tf.constant(BEST, dtype='float32')\n    \n    print(\"train:\", a*c,'\\n')\n    print(\"test:\", b*c,'\\n')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def analyze_GROUP_model(a,b,c):\n    #best = tf.constant(BEST, dtype='float32')\n    #fold =tf.constant(NFOLD, dtype='float32')\n    \n    print(\"train:\", a[0] / NFOLD ,a[1] * BEST / NFOLD,'\\n')\n    print(\"val:\", b[0] / NFOLD ,b[1] * BEST / NFOLD,'\\n')\n    print(\"test:\", c[0] / NFOLD ,c[1] * BEST / NFOLD,'\\n')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def laplace_Group_model(scope,base_x,base_y, predicted, bias):\n    actualFVC = base_y\n    predictedFVC = predicted\n    sigma_opt_actual = mean_absolute_error(actualFVC, predictedFVC[:, 1])\n    sigmaSTD = mean_squared_error(actualFVC, predictedFVC[:, 1])\n    unc_actual = (predictedFVC[:,2] - predictedFVC[:, 0]) * bias\n    sigma_mean_actual = np.mean(unc_actual)\n    best = laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = actualFVC,\\\n                                            confidence= 0)\n    print('laplace_log_likelihood su '+ scope +':\\n')\n    print(\"opt_actual\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                           confidence= sigma_opt_actual))\n    print(\"mean_squared\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                             confidence= sigmaSTD))\n    print(\"unc_actual\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                           confidence= unc_actual))\n    print(\"mean_actual\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                            confidence= sigma_mean_actual))\n    return(best)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def laplace_model(scope,base_x,base_y,base_pred):\n    actualFVC = base_y\n    #predictedFVC = net.predict(base_x, batch_size=BATCH_SIZE, verbose=0) #calcolato sull'ultimo fold\n    predictedFVC = base_pred\n    sigma_opt_actual = mean_absolute_error(actualFVC, predictedFVC[:, 1])\n    sigmaSTD = mean_squared_error(actualFVC, predictedFVC[:, 1])\n    unc_actual = predictedFVC[:,2] - predictedFVC[:, 0]\n    sigma_mean_actual = np.mean(unc_actual)\n    best = laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = actualFVC,\\\n                                            confidence= 0)\n    print('laplace_log_likelihood su '+ scope +':\\n')\n    print(\"opt_actual\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                           confidence= sigma_opt_actual))\n    print(\"mean_squared\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                             confidence= sigmaSTD))\n    print(\"unc_actual\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                           confidence= unc_actual))\n    print(\"mean_actual\", laplace_log_likelihood(actual_fvc = actualFVC, predicted_fvc = predictedFVC[:,1],\\\n                                            confidence= sigma_mean_actual))\n    return(best)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"BEST = laplace_model('BEST',z,y,pred)\nstart_at = time()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\nif GROUPS:\n    history=History()\n    groups = X_train.KGroup \n\n    gkf = GroupKFold(n_splits= NFOLD)\n\n    cnt=0\n    net_train = np.zeros(2,)\n    net_val = np.zeros(2,)\n    net_test = np.zeros(2,)\n\n    start_at = time()\n    for tr_idx, val_idx in gkf.split(z, y, groups=groups): \n        cnt += 1 \n        print(f\"GROUP {cnt}\") \n        net = make_model()\n\n        start_Fold = time()\n        # addestra il modello\n        net.fit(z[tr_idx], y[tr_idx], batch_size=BATCH_SIZE, epochs=EPOCHS, \n            validation_data=(z[val_idx], y[val_idx]), verbose=0, callbacks=[history])\n\n        # valutazione su train e su val\n        exec_time = time() - start_Fold\n        a = net.evaluate(z[tr_idx], y[tr_idx], verbose=0, batch_size=BATCH_SIZE)\n        b = net.evaluate(z[val_idx], y[val_idx], verbose=0, batch_size=BATCH_SIZE)\n        print(\"train su fold:\", a[0],a[1]*BEST)\n        print(\"val su fold:\", b[0],b[1]*BEST)\n        net_train += a\n        net_val += b\n        \n        if TESTSIZE > 0:\n            c = net.evaluate(z_test, y_test, verbose=0, batch_size=BATCH_SIZE)\n            print(\"test su fold:\", c[0],c[1]*BEST,)\n            net_test += c\n            # previsione su test\n            pred_test += net.predict(z_test, batch_size=BATCH_SIZE, verbose=0) / NFOLD #calcolato sul fold corrente\n        \n        # previsione su val\n        pred[val_idx] += net.predict(z[val_idx], batch_size=BATCH_SIZE, verbose=0) #calcolato sul fold corrente\n\n        # previsione su sub\n        pe += net.predict(ze, batch_size=BATCH_SIZE, verbose=0) / NFOLD #calcolato sul fold corrente\n        \n        print(\"Tempo di addestramento: %d minuti e %d secondi\" % (exec_time/60, exec_time%60),'\\n')\n    \n    exec_time = time() - start_at\n    print(\"\\nTempo totale di addestramento: %d minuti e %d secondi\" % (exec_time/60, exec_time%60),'\\n')\n    del a,b","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"if GROUPS == False:\n    print(\"Inizio addestramento: ...\\n\")\n    history = History()\n    net = make_model()\n    net.fit(z, y, batch_size=BATCH_SIZE, epochs=EPOCHS, \n            validation_split=VAL_SPLIT, verbose=0, callbacks=[history])\n    exec_time = time() - start_at\n    print(\"Tempo totale di addestramento: %d minuti e %d secondi\" % (exec_time/60, exec_time%60),'\\n')\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"if GROUPS:\n    analyze_GROUP_model(net_train, net_val, net_test)\nelse:\n    #def analyze_model(trax, tray, testx, testy):\n    if TESTSIZE > 0:\n        analyze_model(z,y,z_test, y_test)\n    else: \n        analyze_model(z,y,z, y)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}},"execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"# def plot_model(model_history, starting_point, metric):\nplot_model(history.history, EPOCHS, 'score' )","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(14,10))\nplt.title(\"Metric\")\nplt.xlabel(\"Epoch\")\nplt.ylabel(\"Metric\")\nplt.plot(abs(y-pred[:,1]),color='red')\nplt.plot(abs(pred[:,0]-pred[:,2]),color='blue')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"if TESTSIZE > 0:\n    plt.figure(figsize=(14,10))\n    plt.title(\"Metric\")\n    plt.xlabel(\"Epoch\")\n    plt.ylabel(\"Metric\")\n    plt.plot(abs(y_test-pred_test[:,1]),color='red')\n    plt.plot(abs(pred_test[:,0]-pred_test[:,2]),color='blue')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"z.shape, y.shape, pred.shape\ntry:\n    print(z.shape, y.shape, pred.shape, pred_test.shape)\nexcept:\n    print(z.shape, y.shape, pred.shape)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#pred_test","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"\nif GROUPS:\n    for BIAS in (1,0,0.2,0.4,0.6,0.8,1.0,1.2,1.4,1.6,1.8,2):\n        print('\\nBIAS:',BIAS,'\\n')\n        laplace_Group_model('training',z,y,pred, BIAS)\n        print('\\nx--------x\\n')\n        if TESTSIZE > 0: laplace_Group_model('test',z_test,y_test,pred_test, BIAS)\nelse:\n    laplace_model('training',z,y,pred)\n    print('\\nx--------x\\n')\n    if TESTSIZE > 0: laplace_model('test',z_test,y_test,pred_test)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#predxs = net.predict(z, batch_size=BATCH_SIZE, verbose=0) #calcolato sull'ultimo fold\npredxs = pred\nidxs = np.random.randint(0, y.shape[0], 100)\nidxs = np.sort(idxs)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"LOW_CORRECTION = tf.constant(1.0, dtype='float32') # per correggere la Confidenc\nHIGH_CORRECTION = tf.constant(1.0, dtype='float32') \n\nplt.figure(figsize=(14,6))\nplt.plot(y[idxs], label=\"ground truth\")\nplt.plot(predxs[idxs, 0] * LOW_CORRECTION, label=\"q20\")\nplt.plot(predxs[idxs, 1], label=\"q50\")\nplt.plot(predxs[idxs, 2] * HIGH_CORRECTION, label=\"q80\")\nplt.legend(loc=\"best\")\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"if TESTSIZE > 0:\n    #predxs = net.predict(z_test, batch_size=BATCH_SIZE, verbose=0) #calcolato sull'ultimo fold\n    predxs = pred_test\n    idxs = np.random.randint(0, y_test.shape[0], 100)\n    idxs = np.sort(idxs)\n    plt.figure(figsize=(14,6))\n    plt.plot(y_test[idxs], label=\"ground truth\")\n    plt.plot(predxs[idxs, 0] * LOW_CORRECTION, label=\"q20\")\n    plt.plot(predxs[idxs, 1], label=\"q50\")\n    plt.plot(predxs[idxs, 2] * HIGH_CORRECTION, label=\"q80\")\n    plt.legend(loc=\"best\")\n    plt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sigma_opt = mean_absolute_error(y, pred[:, 1])\nunc = pred[:,2] - pred[:, 0]\nsigma_mean = np.mean(unc)\nprint('sigma_opt mean_absolute_error(y, pred[:, 1]):',sigma_opt, \n      '\\nsigma_mean np.mean(unc) unc = pred[:,2] - pred[:, 0]:',sigma_mean)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.hist(unc)\nplt.title(\"uncertainty in prediction\")\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"CORRECTION = tf.constant(1.0, dtype='float32') ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sab = sub.copy()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"\n#pe = net.predict(ze, batch_size=BATCH_SIZE, verbose=0) #calcolato sull'ultimo fold\n\nsab['FVC1'] = pe[:, 1]\nsab['Confidence1'] = (pe[:, 2] - pe[:, 0]) #* CORRECTION #devo capire perché utilizzare questa","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"CORRECTION","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"d21 = pe[:,2]-pe[:,1]\nd10 = pe[:,1]-pe[:,0]\nd20 = pe[:,2]-pe[:,0]\ndcorrect = (pe[:,2] - pe[:,0]) * CORRECTION\ng = {'2-1':d21,'1-0':d10,'2-0':d20,'2-0 corr':dcorrect}\ng = pd.DataFrame(data=g)\ng.describe().T","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"subm = sab[['Patient_Week','FVC','Confidence','FVC1','Confidence1']].copy()\nsubm.loc[~subm.FVC1.isnull(),'FVC'] = subm.loc[~subm.FVC1.isnull(),'FVC1']\nsubm.loc[~subm.FVC1.isnull(),'Confidence'] = abs(subm.loc[~subm.FVC1.isnull(),'Confidence1'])\n\nsubm.describe().T","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"if sigma_mean<70:\n    subm['Confidence'] = sigma_opt\nelse:\n    subm.loc[~subm.FVC1.isnull(),'Confidence'] = subm.loc[~subm.FVC1.isnull(),'Confidence1']\n\nsubm.describe().T","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"otest = pd.read_csv('../input/osic-pulmonary-fibrosis-progression/test.csv')\nfor i in range(len(otest)):\n    subm.loc[subm['Patient_Week']==otest.Patient[i]+'_'+str(otest.Weeks[i]), 'FVC'] = otest.FVC[i]\n    subm.loc[subm['Patient_Week']==otest.Patient[i]+'_'+str(otest.Weeks[i]), 'Confidence'] = 0.1\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"subm[[\"Patient_Week\",\"FVC\",\"Confidence\"]].to_csv(\"submission.csv\", index=False)\nprint('Saved',GROUPS)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#import sys \n#sys.exit()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}