diff --git a/DNN.ipynb b/DNN.ipynb index 84927a7..e4ffe7c 100644 --- a/DNN.ipynb +++ b/DNN.ipynb @@ -34,7 +34,9 @@ "metadata": {}, "outputs": [], "source": [ - "l_index=1" + "l_index=1\n", + "mag_index=1\n", + "Ds_mass= 1968" ] }, { @@ -70,24 +72,22 @@ "MC_sig_dict[\"Ds_OWNPV_CHI2\"]=MC_sig_dict[\"Ds_OWNPV_CHI2\"]/MC_sig_dict[\"Ds_OWNPV_NDOF\"]\n", "MC_sig_dict[\"Ds_IPCHI2_OWNPV\"]=MC_sig_dict[\"Ds_IPCHI2_OWNPV\"]/MC_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", "\n", - "del MC_sig_dict[\"Ds_OWNPV_NDOF\"]\n", "del MC_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", - "\n", + "del MC_sig_dict[\"Ds_OWNPV_NDOF\"]\n", "\n", "data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]=data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", "data_bkg_dict[\"Ds_OWNPV_CHI2\"]=data_bkg_dict[\"Ds_OWNPV_CHI2\"]/data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", "data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]=data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", "\n", - "del data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", "del data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", - "\n", + "del data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", "\n", "data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]=data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", "data_bkg_dict[\"phi_OWNPV_CHI2\"]=data_bkg_dict[\"phi_OWNPV_CHI2\"]/data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", "data_bkg_dict[\"phi_IPCHI2_OWNPV\"]=data_bkg_dict[\"phi_IPCHI2_OWNPV\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", "\n", - "del data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", - "del data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n" + "del data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "del data_bkg_dict[\"phi_OWNPV_NDOF\"]" ] }, { @@ -138,8 +138,8 @@ "source": [ "#Convert data dictionaries to arrays for NN\n", "\n", - "MC_sig = extract_array(MC_sig_dict, branches_needed, dim, m//2)\n", - "data_bkg = extract_array(data_bkg_dict, branches_needed, dim, m)" + "MC_sig = extract_array(MC_sig_dict, branches_needed, dim, m)\n", + "data_bkg = extract_array(data_bkg_dict, branches_needed, dim, n)" ] }, { @@ -161,6 +161,7 @@ "outputs": [], "source": [ "#SOME CROSS CHECKS\n", + "#MC_sig.shape==data_bkg.shape\n", "#MC_sig_labelled.shape[1]==dim+1==data_bkg_labelled.shape[1]\n", "#data_bkg_labelled[:,dim].sum()==0\n", "#(MC_sig_labelled[:,dim].sum()/m)==1" @@ -168,59 +169,56 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "#Merge MC sig and data bkg, shuffle it\n", - "\n", - "data=np.concatenate((MC_sig_labelled,data_bkg_labelled), axis =0)\n", - "np.random.seed(1)\n", - "np.random.shuffle(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "#Establish train/val/test sizes\n", - "train_size=m+m//2" - ] - }, - { - "cell_type": "code", "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(135665, 1000, 100000)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#Strip away the label column and convert it to a one-hot encoding\n", + "#Establish train/val/test sizes\n", "\n", - "X=data[:,0:dim]\n", - "Y_labels=data[:,dim].astype(int)\n", - "Y_labels=Y_labels.reshape(train_size,1)\n", - "Y_labels_hot = to_one_hot(Y_labels)\n", - "Y_labels=Y_labels_hot\n" + "val_size=1000\n", + "test_size=100000\n", + "\n", + "train_size=MC_sig.shape[0]+data_bkg.shape[0]-val_size-test_size\n", + "(train_size, val_size, test_size)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "#Divide the dataset k \"equi populated\" sets\n", - "k=2\n", - "k_batch_size=train_size//k\n", + "#Merge MC sig and data bkg, shuffle it\n", "\n", - "X_dict={}\n", - "Y_dict={}\n", + "data=np.concatenate((MC_sig_labelled,data_bkg_labelled), axis =0)\n", + "np.random.seed(1)\n", + "np.random.shuffle(data)\n", "\n", - "for i in range(k):\n", - " X_dict[i]=X[k_batch_size*i:k_batch_size*(i+1)]\n", - " Y_dict[i]=Y_labels[k_batch_size*i:k_batch_size*(i+1)]\n", - "\n" + "#Check that nothing is missing\n", + "\n", + "data.shape[0]==train_size+val_size+test_size" ] }, { @@ -229,7 +227,13 @@ "metadata": {}, "outputs": [], "source": [ - "k=range(k)" + "#Strip away the label column and convert it to a one-hot encoding\n", + "\n", + "X=data[:,0:dim]\n", + "Y_labels=data[:,dim].astype(int)\n", + "Y_labels=Y_labels.reshape(train_size+val_size+test_size,1)\n", + "Y_labels_hot = to_one_hot(Y_labels)\n", + "Y_labels=Y_labels_hot\n" ] }, { @@ -238,16 +242,16 @@ "metadata": {}, "outputs": [], "source": [ - "#Strip out the reconstructed Ds mass and build train and test sets\n", - "i=0\n", + "#Divide the dataset in train/val/test sets \n", "\n", - "X_test = X_dict[k[i]][:,0:dim-1]\n", - "Y_test = Y_dict[k[i]][:,0:dim-1]\n", + "X_train_0 = X[0:train_size]\n", + "Y_train = Y_labels[0:train_size]\n", "\n", - "k=np.delete(k, i)\n", + "X_val_0 = X[train_size:train_size+val_size]\n", + "Y_val = Y_labels[train_size:train_size+val_size]\n", "\n", - "X_train = np.concatenate([X_dict[j][:,0:dim-1] for j in k],axis=0)\n", - "Y_train = np.concatenate([Y_dict[j][:,0:dim-1] for j in k],axis=0)\n" + "X_test_0 = X[train_size+val_size:train_size+val_size+test_size]\n", + "Y_test = Y_labels[train_size+val_size:train_size+val_size+test_size]" ] }, { @@ -258,7 +262,17 @@ { "data": { "text/plain": [ - "(35962, 10)" + "['Ds_ENDVERTEX_CHI2',\n", + " 'Ds_OWNPV_CHI2',\n", + " 'Ds_IPCHI2_OWNPV',\n", + " 'Ds_IP_OWNPV',\n", + " 'Ds_DIRA_OWNPV',\n", + " 'phi_ENDVERTEX_CHI2',\n", + " 'phi_OWNPV_CHI2',\n", + " 'phi_IPCHI2_OWNPV',\n", + " 'phi_IP_OWNPV',\n", + " 'phi_DIRA_OWNPV',\n", + " 'Ds_ConsD_M']" ] }, "execution_count": 16, @@ -267,8 +281,21 @@ } ], "source": [ - "dim=X_train.shape[1]\n", - "X_train.shape" + "branches_needed" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#Strip out the reconstructed Ds mass\n", + "\n", + "X_train = X_train_0[:,0:dim-1]\n", + "X_val = X_val_0[:,0:dim-1]\n", + "X_test = X_test_0[:,0:dim-1]\n", + "dim=X_train.shape[1]" ] }, { @@ -280,19 +307,19 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "#task='TRAIN'\n", "task='TEST'\n", "\n", - "PATH=l_flv[l_index]+'_test_'+str(i)" + "PATH=l_flv[l_index]+'_Mag'+mag_status[mag_index]+'_test_4'" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -300,7 +327,9 @@ " with open(PATH+'/hyper_parameters.pkl', 'rb') as f: \n", " hyper_dict = pickle.load(f)\n", " \n", - " k=hyper_dict[\"k\"]\n", + " m=hyper_dict[\"m\"]\n", + " test_size=hyper_dict[\"test_size\"]\n", + " val_size=hyper_dict[\"val_size\"]\n", " LEARNING_RATE=hyper_dict[\"LEARNING_RATE\"]\n", " BETA1=hyper_dict[\"BETA1\"]\n", " BATCH_SIZE=hyper_dict[\"BATCH_SIZE\"]\n", @@ -314,7 +343,7 @@ "elif task=='TRAIN' and not os.path.exists(PATH+'/hyper_parameters.pkl'):\n", " \n", " \n", - " LEARNING_RATE = 0.0001\n", + " LEARNING_RATE = 0.001\n", " BETA1 = 0.5\n", " BATCH_SIZE = 64\n", " EPOCHS = 20\n", @@ -326,10 +355,10 @@ " 'dense_layers': [\n", " #(16, 'bn', 0.8, lrelu, tf.glorot_uniform_initializer()),\n", " #(8, 'bn', 0.5, lrelu, tf.glorot_uniform_initializer()),\n", - " (16, 'bn',0.5, lrelu, tf.glorot_uniform_initializer()),\n", - " (32, 'bn', 0.5, lrelu, tf.glorot_uniform_initializer()),\n", - " (16, 'bn', 0.5, lrelu, tf.glorot_uniform_initializer()),\n", - " (8, 'bn', 0.5, lrelu, tf.glorot_uniform_initializer()),\n", + " #(16, 'bn',0.8, lrelu, tf.glorot_uniform_initializer()),\n", + " (32, 'bn', 0.8, lrelu, tf.glorot_uniform_initializer()),\n", + " (16, 'bn', 0.8, lrelu, tf.glorot_uniform_initializer()),\n", + " (8, 'bn', 0.8, lrelu, tf.glorot_uniform_initializer()),\n", " ],\n", " 'n_classes':2,\n", " }" @@ -337,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -347,7 +376,9 @@ " #for key, item in hyper_dict.items():\n", " # print(key+':'+str(item))\n", " \n", - " k=hyper_dict[\"k\"]\n", + " m=hyper_dict[\"m\"]\n", + " test_size=hyper_dict[\"test_size\"]\n", + " val_size=hyper_dict[\"val_size\"]\n", " LEARNING_RATE=hyper_dict[\"LEARNING_RATE\"]\n", " BETA1=hyper_dict[\"BETA1\"]\n", " BATCH_SIZE=hyper_dict[\"BATCH_SIZE\"]\n", @@ -361,16 +392,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ "def bkg():\n", " \n", - " batch_size_output=128\n", - " test_size=k_batch_size\n", - " n_batches_output = test_size//batch_size_output\n", - " \n", " tf.reset_default_graph()\n", " nn = DNN(dim, sizes,\n", " lr=LEARNING_RATE, beta1=BETA1, lambd=LAMBD,\n", @@ -403,7 +430,7 @@ " print('Model restored.')\n", " \n", " nn.set_session(sess)\n", - " nn.fit(X_train, Y_train, X_test, Y_test)\n", + " nn.fit(X_train, Y_train, X_val, Y_val)\n", " \n", " save_path = saver.save(sess, PATH+'/CNN_model.ckpt')\n", " print(\"Model saved in path: %s\" % save_path)\n", @@ -414,24 +441,25 @@ " print('Model restored.')\n", " \n", " nn.set_session(sess)\n", - " nn.test(X_test, Y_test)\n", - " \n", - " \n", + " #nn.test(X_test, Y_test)\n", " output_dict={}\n", " \n", + " batch_size_output=100\n", + " n_batches_output = X_test.shape[0]//batch_size_output\n", + " \n", " for i in range(n_batches_output):\n", " small_dataset = X_test[i*batch_size_output:(i+1)*batch_size_output]\n", " output_dict[i] = nn.predict(small_dataset)\n", - " \n", " output=np.concatenate([output_dict[i] for i in range(n_batches_output)])\n", + " \n", " return output\n" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 39, "metadata": { - "scrolled": false + "scrolled": true }, "outputs": [ { @@ -444,9 +472,8 @@ "Logits shape (?, 2)\n", "\n", " Evaluate model on test set...\n", - "INFO:tensorflow:Restoring parameters from mu_test_0/CNN_model.ckpt\n", - "Model restored.\n", - "Test accuracy: 0.9935\n" + "INFO:tensorflow:Restoring parameters from mu_MagDown_test_4/CNN_model.ckpt\n", + "Model restored.\n" ] } ], @@ -486,12 +513,32 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "text/plain": [ + "(100000, 2)" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -504,9 +551,9 @@ "if task=='TEST':\n", "\n", " Ds_mass_MC =[MC_sig_dict[\"Ds_ConsD_M\"][i][0] for i in range(m)]\n", - " NN_selected = X_dict[k[i]][0:output.shape[0]][np.argmax(output, axis=1).astype(np.bool)]\n", + " NN_selected = X_test_0[np.argmax(output, axis=1).astype(np.bool)]\n", " Ds_mass_sel_NN = [NN_selected[i][dim] for i in range(NN_selected.shape[0])]\n", - " Ds_mass_train_NN =X_dict[k[i]][:,dim]\n", + " Ds_mass_train_NN =[X_train_0[i][dim] for i in range(X_train_0.shape[0])]\n", "\n", " plt.subplot(1,2,1)\n", " plt.hist(Ds_mass_MC,bins=70);\n", @@ -520,13 +567,15 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "if task=='TRAIN':\n", " hyper_dict={\n", - " 'k':k,\n", + " 'm':m,\n", + " 'test_size':test_size,\n", + " 'val_size':val_size,\n", " 'LEARNING_RATE':LEARNING_RATE,\n", " 'BETA1':BETA1,\n", " 'BATCH_SIZE':BATCH_SIZE,\n", diff --git a/dataMC_visualization.ipynb b/dataMC_visualization.ipynb index 196209f..e428ebb 100644 --- a/dataMC_visualization.ipynb +++ b/dataMC_visualization.ipynb @@ -73,7 +73,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -94,7 +94,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -175,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -212,7 +212,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -243,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -287,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -296,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -310,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -320,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -352,7 +352,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +370,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -379,7 +379,7 @@ "(47950,)" ] }, - "execution_count": 40, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -390,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -454,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -484,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -514,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -543,7 +543,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -572,7 +572,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -600,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -628,7 +628,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -656,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -684,7 +684,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -711,7 +711,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -734,7 +734,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [