From 68772ba4b43509407f025c5ae229875f73f67ea4 Mon Sep 17 00:00:00 2001 From: jajupmochi Date: Fri, 21 Sep 2018 18:31:12 +0200 Subject: [PATCH] 1. [IMPORTANT] correct an error in dataset split section in function cross_validation_pre_computed. DON NOT use previous versions. They are all wrong. 2. save gram matrices and relative data when using function cross_validation_pre_computed, before cross validation step, in case that something goes wrong with CV. Parameter read_gm_from_file can be used to choose whether to read gram matrices from file. 3. add some test code to check if a gram matrix is symmetric and positive semi-definite. --- README.md | 2 +- notebooks/get_dataset_attributes.ipynb | 275 ++++++------ notebooks/run_spkernel.ipynb | 65 +-- notebooks/run_spkernel.py | 150 ++++--- pygraph/kernels/spKernel.py | 11 +- pygraph/utils/model_selection_precomputed.py | 630 ++++++++++++++++++--------- 6 files changed, 652 insertions(+), 481 deletions(-) diff --git a/README.md b/README.md index 88eb744..41f90d7 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ A python package for graph kernels. ## Requirements -numpy==1.14.5 +numpy==1.15.1 scipy==1.1.0 matplotlib==2.2.2 networkx==2.1 diff --git a/notebooks/get_dataset_attributes.ipynb b/notebooks/get_dataset_attributes.ipynb index 337c3ec..ab50bc9 100644 --- a/notebooks/get_dataset_attributes.ipynb +++ b/notebooks/get_dataset_attributes.ipynb @@ -12,30 +12,52 @@ "output_type": "stream", "text": [ "\n", + "Letter-med:\n", + "substructures : {'linear', 'non linear'}\n", + "node_labeled : False\n", + "edge_labeled : False\n", + "is_directed : False\n", + "dataset_size : 2250\n", + "ave_graph_size : 4.674666666666667\n", + "min_graph_size : 1\n", + "max_graph_size : 9\n", + "ave_graph_edge_num : 3.2057777777777776\n", + "min_graph_edge_num : 0\n", + "max_graph_edge_num : 7\n", + "ave_graph_degree : 2.012888888888889\n", + "min_graph_degree : 0\n", + "max_graph_degree : 4\n", + "node_label_num : 0\n", + "edge_label_num : 0\n", + "node_attr_dim : 2\n", + "edge_attr_dim : 0\n", + "class_number : 15\n", + "\n", + "\n", "Mutagenicity:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : True\n", "is_directed : False\n", "dataset_size : 4337\n", - "ave_graph_size : 30.3177311506\n", + "ave_graph_size : 30.317731150564907\n", "min_graph_size : 4\n", "max_graph_size : 417\n", - "ave_graph_edge_num : 30.7694258704\n", + "ave_graph_edge_num : 30.76942587041734\n", "min_graph_edge_num : 3\n", "max_graph_edge_num : 112\n", - "ave_graph_degree : 3.75651371916\n", + "ave_graph_degree : 3.75651371916071\n", "min_graph_degree : 3\n", "max_graph_degree : 4\n", "node_label_num : 14\n", "edge_label_num : 3\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "AIDS:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : True\n", "is_directed : False\n", @@ -52,7 +74,7 @@ "node_label_num : 38\n", "edge_label_num : 3\n", "node_attr_dim : 4\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", @@ -62,13 +84,13 @@ "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 41\n", - "ave_graph_size : 1377.26829268\n", + "ave_graph_size : 1377.2682926829268\n", "min_graph_size : 134\n", "max_graph_size : 5037\n", - "ave_graph_edge_num : 3074.09756098\n", + "ave_graph_edge_num : 3074.0975609756097\n", "min_graph_edge_num : 320\n", "max_graph_edge_num : 10888\n", - "ave_graph_degree : 7.85365853659\n", + "ave_graph_degree : 7.853658536585366\n", "min_graph_degree : 6\n", "max_graph_degree : 10\n", "node_label_num : 5\n", @@ -79,51 +101,51 @@ "\n", "\n", "MSRC9:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 221\n", - "ave_graph_size : 40.5791855204\n", + "ave_graph_size : 40.57918552036199\n", "min_graph_size : 25\n", "max_graph_size : 55\n", - "ave_graph_edge_num : 97.9366515837\n", + "ave_graph_edge_num : 97.9366515837104\n", "min_graph_edge_num : 53\n", "max_graph_edge_num : 145\n", - "ave_graph_degree : 10.1583710407\n", + "ave_graph_degree : 10.158371040723981\n", "min_graph_degree : 8\n", "max_graph_degree : 16\n", "node_label_num : 10\n", "edge_label_num : 0\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 8\n", "\n", "\n", "MSRC21:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 563\n", - "ave_graph_size : 77.5204262877\n", + "ave_graph_size : 77.52042628774423\n", "min_graph_size : 51\n", "max_graph_size : 141\n", - "ave_graph_edge_num : 198.323268206\n", + "ave_graph_edge_num : 198.32326820603907\n", "min_graph_edge_num : 121\n", "max_graph_edge_num : 405\n", - "ave_graph_degree : 11.4156305506\n", + "ave_graph_degree : 11.41563055062167\n", "min_graph_degree : 8\n", "max_graph_degree : 23\n", "node_label_num : 22\n", "edge_label_num : 0\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 20\n", "\n", "\n", "SYNTHETIC:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", @@ -140,42 +162,42 @@ "node_label_num : 8\n", "edge_label_num : 0\n", "node_attr_dim : 1\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "BZR:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 405\n", - "ave_graph_size : 35.750617284\n", + "ave_graph_size : 35.75061728395062\n", "min_graph_size : 13\n", "max_graph_size : 57\n", - "ave_graph_edge_num : 38.3580246914\n", + "ave_graph_edge_num : 38.358024691358025\n", "min_graph_edge_num : 13\n", "max_graph_edge_num : 60\n", - "ave_graph_degree : 3.86419753086\n", + "ave_graph_degree : 3.8641975308641974\n", "min_graph_degree : 3\n", "max_graph_degree : 4\n", "node_label_num : 10\n", "edge_label_num : 0\n", "node_attr_dim : 3\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "COX2:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 467\n", - "ave_graph_size : 41.2248394004\n", + "ave_graph_size : 41.224839400428266\n", "min_graph_size : 32\n", "max_graph_size : 56\n", - "ave_graph_edge_num : 43.4453961456\n", + "ave_graph_edge_num : 43.44539614561028\n", "min_graph_edge_num : 34\n", "max_graph_edge_num : 59\n", "ave_graph_degree : 4.0\n", @@ -184,152 +206,152 @@ "node_label_num : 8\n", "edge_label_num : 0\n", "node_attr_dim : 3\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "DHFR:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 756\n", - "ave_graph_size : 42.4272486772\n", + "ave_graph_size : 42.42724867724868\n", "min_graph_size : 20\n", "max_graph_size : 71\n", - "ave_graph_edge_num : 44.544973545\n", + "ave_graph_edge_num : 44.544973544973544\n", "min_graph_edge_num : 21\n", "max_graph_edge_num : 73\n", - "ave_graph_degree : 3.95502645503\n", + "ave_graph_degree : 3.955026455026455\n", "min_graph_degree : 3\n", "max_graph_degree : 4\n", "node_label_num : 9\n", "edge_label_num : 0\n", "node_attr_dim : 3\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "ENZYMES:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 600\n", - "ave_graph_size : 32.6333333333\n", + "ave_graph_size : 32.63333333333333\n", "min_graph_size : 2\n", "max_graph_size : 126\n", - "ave_graph_edge_num : 62.1366666667\n", + "ave_graph_edge_num : 62.13666666666666\n", "min_graph_edge_num : 1\n", "max_graph_edge_num : 149\n", - "ave_graph_degree : 6.08666666667\n", + "ave_graph_degree : 6.086666666666667\n", "min_graph_degree : 1\n", "max_graph_degree : 9\n", "node_label_num : 3\n", "edge_label_num : 0\n", "node_attr_dim : 18\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 6\n", "\n", "\n", "PROTEINS:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 1113\n", - "ave_graph_size : 39.0575022462\n", + "ave_graph_size : 39.05750224618149\n", "min_graph_size : 4\n", "max_graph_size : 620\n", - "ave_graph_edge_num : 72.8158131177\n", + "ave_graph_edge_num : 72.8158131176999\n", "min_graph_edge_num : 5\n", "max_graph_edge_num : 1049\n", - "ave_graph_degree : 5.79424977538\n", + "ave_graph_degree : 5.794249775381851\n", "min_graph_degree : 3\n", "max_graph_degree : 25\n", "node_label_num : 3\n", "edge_label_num : 0\n", "node_attr_dim : 1\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "PROTEINS_full:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 1113\n", - "ave_graph_size : 39.0575022462\n", + "ave_graph_size : 39.05750224618149\n", "min_graph_size : 4\n", "max_graph_size : 620\n", - "ave_graph_edge_num : 72.8158131177\n", + "ave_graph_edge_num : 72.8158131176999\n", "min_graph_edge_num : 5\n", "max_graph_edge_num : 1049\n", - "ave_graph_degree : 5.79424977538\n", + "ave_graph_degree : 5.794249775381851\n", "min_graph_degree : 3\n", "max_graph_degree : 25\n", "node_label_num : 3\n", "edge_label_num : 0\n", "node_attr_dim : 29\n", - "edge_attr_dim : False\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "D&D:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 1178\n", - "ave_graph_size : 284.31663837\n", + "ave_graph_size : 284.3166383701188\n", "min_graph_size : 30\n", "max_graph_size : 5748\n", - "ave_graph_edge_num : 715.658743633\n", + "ave_graph_edge_num : 715.6587436332767\n", "min_graph_edge_num : 63\n", "max_graph_edge_num : 14267\n", - "ave_graph_degree : 9.50933786078\n", + "ave_graph_degree : 9.509337860780985\n", "min_graph_degree : 6\n", "max_graph_degree : 19\n", "node_label_num : 82\n", "edge_label_num : 0\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "MUTAG:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : True\n", "is_directed : False\n", "dataset_size : 188\n", - "ave_graph_size : 17.9308510638\n", + "ave_graph_size : 17.930851063829788\n", "min_graph_size : 10\n", "max_graph_size : 28\n", - "ave_graph_edge_num : 19.7925531915\n", + "ave_graph_edge_num : 19.79255319148936\n", "min_graph_edge_num : 10\n", "max_graph_edge_num : 33\n", - "ave_graph_degree : 3.00531914894\n", + "ave_graph_degree : 3.00531914893617\n", "min_graph_degree : 3\n", "max_graph_degree : 4\n", "node_label_num : 7\n", "edge_label_num : 11\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "Alkane:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 150\n", - "ave_graph_size : 8.87333333333\n", + "ave_graph_size : 8.873333333333333\n", "min_graph_size : 1\n", "max_graph_size : 10\n", - "ave_graph_edge_num : 7.87333333333\n", + "ave_graph_edge_num : 7.873333333333333\n", "min_graph_edge_num : 0\n", "max_graph_edge_num : 9\n", "ave_graph_degree : 3.36\n", @@ -337,43 +359,43 @@ "max_graph_degree : 4\n", "node_label_num : 2\n", "edge_label_num : 1\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 123\n", "\n", "\n", "Acyclic:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 183\n", - "ave_graph_size : 8.15300546448\n", + "ave_graph_size : 8.153005464480874\n", "min_graph_size : 3\n", "max_graph_size : 11\n", - "ave_graph_edge_num : 7.15300546448\n", + "ave_graph_edge_num : 7.1530054644808745\n", "min_graph_edge_num : 2\n", "max_graph_edge_num : 10\n", - "ave_graph_degree : 2.80327868852\n", + "ave_graph_degree : 2.80327868852459\n", "min_graph_degree : 2\n", "max_graph_degree : 4\n", "node_label_num : 3\n", "edge_label_num : 1\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 148\n", "\n", "\n", "MAO:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : True\n", "is_directed : False\n", "dataset_size : 68\n", - "ave_graph_size : 18.3823529412\n", + "ave_graph_size : 18.38235294117647\n", "min_graph_size : 11\n", "max_graph_size : 27\n", - "ave_graph_edge_num : 19.6323529412\n", + "ave_graph_edge_num : 19.63235294117647\n", "min_graph_edge_num : 12\n", "max_graph_edge_num : 29\n", "ave_graph_degree : 3.0\n", @@ -381,107 +403,95 @@ "max_graph_degree : 3\n", "node_label_num : 3\n", "edge_label_num : 4\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", - "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", "PAH:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : False\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 94\n", - "ave_graph_size : 20.7021276596\n", + "ave_graph_size : 20.70212765957447\n", "min_graph_size : 10\n", "max_graph_size : 28\n", - "ave_graph_edge_num : 24.4255319149\n", + "ave_graph_edge_num : 24.425531914893618\n", "min_graph_edge_num : 11\n", "max_graph_edge_num : 34\n", - "ave_graph_degree : 3.01063829787\n", + "ave_graph_degree : 3.0106382978723403\n", "min_graph_degree : 3\n", "max_graph_degree : 4\n", "node_label_num : 1\n", "edge_label_num : 1\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", "\n", "\n", "NCI1:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 4110\n", - "ave_graph_size : 29.8654501217\n", + "ave_graph_size : 29.8654501216545\n", "min_graph_size : 3\n", "max_graph_size : 111\n", "ave_graph_edge_num : 32.3\n", "min_graph_edge_num : 2\n", "max_graph_edge_num : 119\n", - "ave_graph_degree : 3.33600973236\n", + "ave_graph_degree : 3.3360097323600972\n", "min_graph_degree : 2\n", "max_graph_degree : 4\n", "node_label_num : 37\n", "edge_label_num : 0\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "\n", "\n", "NCI109:\n", - "substructures : {'non linear', 'linear'}\n", + "substructures : {'linear', 'non linear'}\n", "node_labeled : True\n", "edge_labeled : False\n", "is_directed : False\n", "dataset_size : 4127\n", - "ave_graph_size : 29.6811243034\n", + "ave_graph_size : 29.681124303368065\n", "min_graph_size : 4\n", "max_graph_size : 111\n", - "ave_graph_edge_num : 32.1308456506\n", + "ave_graph_edge_num : 32.13084565059365\n", "min_graph_edge_num : 3\n", "max_graph_edge_num : 119\n", - "ave_graph_degree : 3.34383329295\n", + "ave_graph_degree : 3.343833292948873\n", "min_graph_degree : 2\n", "max_graph_degree : 5\n", "node_label_num : 38\n", "edge_label_num : 0\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", + "node_attr_dim : 0\n", + "edge_attr_dim : 0\n", "class_number : 2\n", - "\n", - "load SDF: 100%|██████████| 4457424/4457424 [00:11<00:00, 397248.47it/s]\n", - "ajust data: 100%|██████████| 42687/42687 [00:10<00:00, 3939.72it/s] \n", - "\n", - "NCI-HIV:\n", - "substructures : {'non linear', 'linear'}\n", - "node_labeled : True\n", - "edge_labeled : True\n", - "is_directed : False\n", - "dataset_size : 42682\n", - "ave_graph_size : 45.7094559768\n", - "min_graph_size : 2\n", - "max_graph_size : 438\n", - "ave_graph_edge_num : 47.7137903566\n", - "min_graph_edge_num : 1\n", - "max_graph_edge_num : 441\n", - "ave_graph_degree : 3.97605548006\n", - "min_graph_degree : 1\n", - "max_graph_degree : 12\n", - "node_label_num : 63\n", - "edge_label_num : 3\n", - "node_attr_dim : False\n", - "edge_attr_dim : False\n", - "class_number : 3\n", "\n" ] + }, + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'tqdm'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 45\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'dataset'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 46\u001b[0m \u001b[0mfilename_y\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'dataset_y'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'dataset_y'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mds\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 47\u001b[0;31m extra_params=(ds['extra_params'] if 'extra_params' in ds else None))\n\u001b[0m\u001b[1;32m 48\u001b[0m attrs = get_dataset_attributes(\n\u001b[1;32m 49\u001b[0m dataset, target=y, node_label='atom', edge_label='bond_type')\n", + "\u001b[0;32m/media/ljia/DATA/research-repo/codes/Linlin/py-graph/pygraph/utils/graphfiles.py\u001b[0m in \u001b[0;36mloadDataset\u001b[0;34m(filename, filename_y, extra_params)\u001b[0m\n\u001b[1;32m 377\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mextension\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"sdf\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 378\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 379\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mtqdm\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 380\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 381\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'tqdm'" + ] } ], "source": [ @@ -491,6 +501,7 @@ "from pygraph.utils.graphdataset import get_dataset_attributes\n", "\n", "dslist = [\n", + " {'name': 'Letter-med', 'dataset': '../datasets/Letter-med/Letter-med_A.txt'},\n", " {'name': 'Mutagenicity', 'dataset': '../datasets/Mutagenicity/Mutagenicity_A.txt'},\n", " {'name': 'AIDS', 'dataset': '../datasets/AIDS/AIDS_A.txt'},\n", " {'name': 'FIRSTMM_DB', 'dataset': '../datasets/FIRSTMM_DB/FIRSTMM_DB_A.txt'},\n", @@ -557,7 +568,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.2" + "version": "3.6.5" } }, "nbformat": 4, diff --git a/notebooks/run_spkernel.ipynb b/notebooks/run_spkernel.ipynb index 5209609..180a8c8 100644 --- a/notebooks/run_spkernel.ipynb +++ b/notebooks/run_spkernel.ipynb @@ -6,64 +6,7 @@ "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Letter-med\n", - "\n", - "--- This is a classification problem ---\n", - "\n", - "\n", - "I. Loading dataset from file...\n", - "\n", - "2. Calculating gram matrices. This could take a while...\n", - "\n", - " None edge weight specified. Set all weight to 1.\n", - "\n", - "\n", - " 9 graphs are removed as they don't contain edges.\n", - "\n", - "getting sp graphs: 2241it [00:01, 2167.27it/s]\n", - "calculating kernels: 2512161it [35:21, 1183.88it/s]\n", - "\n", - " --- shortest path kernel matrix of size 2241 built in 2123.1229825019836 seconds ---\n", - "\n", - "the gram matrix with parameters {'n_jobs': 8, 'node_kernels': {'symb': , 'mix': functools.partial(, , ), 'nsymb': }} is: \n", - "[[1. 0.12737447 0.24414863 ... 0.08575717 0.24779506 0.13389497]\n", - " [0.12737447 1. 0.26175695 ... 0.45546182 0.49016833 0.67892735]\n", - " [0.24414863 0.26175695 1. ... 0.3161496 0.27686542 0.26213761]\n", - " ...\n", - " [0.08575717 0.45546182 0.3161496 ... 1. 0.47821266 0.36507203]\n", - " [0.24779506 0.49016833 0.27686542 ... 0.47821266 1. 0.58909 ]\n", - " [0.13389497 0.67892735 0.26213761 ... 0.36507203 0.58909 1. ]]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "1 gram matrices are calculated, 0 of which are ignored.\n", - "\n", - "3. Fitting and predicting using nested cross validation. This could really take a while...\n", - "\r", - "cross validation: 0%| | 0/30 [00:00 0: + print(', where %d graphs are ignored as their graph kernels with themselves are zeros.' % nb_g_ignore) + str_fw += ', where %d graphs are ignored as their graph kernels with themselves are zeros.' % nb_g_ignore + print() + print( + '{} gram matrices are calculated, {} of which are ignored.'.format( + len(param_list_precomputed), nb_gm_ignore)) + str_fw += '{} gram matrices are calculated, {} of which are ignored.\n\n'.format(len(param_list_precomputed), nb_gm_ignore) + str_fw += 'serial numbers of gram matrix figures and their corresponding parameters settings:\n\n' + str_fw += ''.join([ + '{}: {}\n'.format(idx, params_out) + for idx, params_out in enumerate(param_list_precomputed) + ]) + + print() + if len(gram_matrices) == 0: + print('all gram matrices are ignored, no results obtained.') + str_fw += '\nall gram matrices are ignored, no results obtained.\n\n' + else: + # save gram matrices to file. + np.savez(results_dir + '/' + ds_name + '.gm', + gms=gram_matrices, params=param_list_pre_revised, y=y, + gmtime=gram_matrix_time) + + print( + '3. Fitting and predicting using nested cross validation. This could really take a while...' + ) + + pool = Pool(n_jobs) + trial_do_partial = partial(trial_do, param_list_pre_revised, param_list, gram_matrices, y, model_type) + train_pref = [] + val_pref = [] + test_pref = [] + if NUM_TRIALS < 100: + chunksize, extra = divmod(NUM_TRIALS, n_jobs * 4) + if extra: + chunksize += 1 else: - print(Kmatrix) - str_fw += np.array2string( - Kmatrix, - separator=',', - threshold=np.inf, - floatmode='unique') + '\n\n' - plt.matshow(Kmatrix) - plt.colorbar() - fig_file_name = results_dir + '/GM[ds]' + ds_name - if params_out != {}: - fig_file_name += '[params]' + str(idx) - plt.savefig(fig_file_name + '.eps', format='eps', dpi=300) - plt.show() - gram_matrices.append(Kmatrix) - gram_matrix_time.append(current_run_time) - param_list_pre_revised.append(params_out) - if nb_g_ignore > 0: - print(', where %d graphs are ignored as their graph kernels with themselves are zeros.' % nb_g_ignore) - str_fw += ', where %d graphs are ignored as their graph kernels with themselves are zeros.' % nb_g_ignore - print() - print( - '{} gram matrices are calculated, {} of which are ignored.'.format( - len(param_list_precomputed), nb_gm_ignore)) - str_fw += '{} gram matrices are calculated, {} of which are ignored.\n\n'.format(len(param_list_precomputed), nb_gm_ignore) - str_fw += 'serial numbers of gram matrix figures and their corresponding parameters settings:\n\n' - str_fw += ''.join([ - '{}: {}\n'.format(idx, params_out) - for idx, params_out in enumerate(param_list_precomputed) - ]) - - print() - if len(gram_matrices) == 0: - print('all gram matrices are ignored, no results obtained.') - str_fw += '\nall gram matrices are ignored, no results obtained.\n\n' - else: + chunksize = 100 + for o1, o2, o3 in tqdm(pool.imap_unordered(trial_do_partial, range(NUM_TRIALS), chunksize), desc='cross validation', file=sys.stdout): + train_pref.append(o1) + val_pref.append(o2) + test_pref.append(o3) + pool.close() + pool.join() + + # # ---- use pool.map to parallel. ---- + # result_perf = pool.map(trial_do_partial, range(NUM_TRIALS)) + # train_pref = [item[0] for item in result_perf] + # val_pref = [item[1] for item in result_perf] + # test_pref = [item[2] for item in result_perf] + + # # ---- use joblib.Parallel to parallel and track progress. ---- + # trial_do_partial = partial(trial_do, param_list_pre_revised, param_list, gram_matrices, y, model_type) + # result_perf = Parallel(n_jobs=n_jobs, verbose=10)(delayed(trial_do_partial)(trial) for trial in range(NUM_TRIALS)) + # train_pref = [item[0] for item in result_perf] + # val_pref = [item[1] for item in result_perf] + # test_pref = [item[2] for item in result_perf] + + # # ---- direct running, normally use a single CPU core. ---- + # train_pref = [] + # val_pref = [] + # test_pref = [] + # for i in tqdm(range(NUM_TRIALS), desc='cross validation', file=sys.stdout): + # o1, o2, o3 = trial_do(param_list_pre_revised, param_list, gram_matrices, y, model_type, i) + # train_pref.append(o1) + # val_pref.append(o2) + # test_pref.append(o3) + + print() + print('4. Getting final performance...') + str_fw += '\nIII. Performance.\n\n' + # averages and confidences of performances on outer trials for each combination of parameters + average_train_scores = np.mean(train_pref, axis=0) + average_val_scores = np.mean(val_pref, axis=0) + average_perf_scores = np.mean(test_pref, axis=0) + # sample std is used here + std_train_scores = np.std(train_pref, axis=0, ddof=1) + std_val_scores = np.std(val_pref, axis=0, ddof=1) + std_perf_scores = np.std(test_pref, axis=0, ddof=1) + + if model_type == 'regression': + best_val_perf = np.amin(average_val_scores) + else: + best_val_perf = np.amax(average_val_scores) + best_params_index = np.where(average_val_scores == best_val_perf) + # find smallest val std with best val perf. + best_val_stds = [ + std_val_scores[value][best_params_index[1][idx]] + for idx, value in enumerate(best_params_index[0]) + ] + min_val_std = np.amin(best_val_stds) + best_params_index = np.where(std_val_scores == min_val_std) + best_params_out = [ + param_list_pre_revised[i] for i in best_params_index[0] + ] + best_params_in = [param_list[i] for i in best_params_index[1]] + print('best_params_out: ', best_params_out) + print('best_params_in: ', best_params_in) + print() + print('best_val_perf: ', best_val_perf) + print('best_val_std: ', min_val_std) + str_fw += 'best settings of hyper-params to build gram matrix: %s\n' % best_params_out + str_fw += 'best settings of other hyper-params: %s\n\n' % best_params_in + str_fw += 'best_val_perf: %s\n' % best_val_perf + str_fw += 'best_val_std: %s\n' % min_val_std + + final_performance = [ + average_perf_scores[value][best_params_index[1][idx]] + for idx, value in enumerate(best_params_index[0]) + ] + final_confidence = [ + std_perf_scores[value][best_params_index[1][idx]] + for idx, value in enumerate(best_params_index[0]) + ] + print('final_performance: ', final_performance) + print('final_confidence: ', final_confidence) + str_fw += 'final_performance: %s\n' % final_performance + str_fw += 'final_confidence: %s\n' % final_confidence + train_performance = [ + average_train_scores[value][best_params_index[1][idx]] + for idx, value in enumerate(best_params_index[0]) + ] + train_std = [ + std_train_scores[value][best_params_index[1][idx]] + for idx, value in enumerate(best_params_index[0]) + ] + print('train_performance: %s' % train_performance) + print('train_std: ', train_std) + str_fw += 'train_performance: %s\n' % train_performance + str_fw += 'train_std: %s\n\n' % train_std + + print() + tt_total = time.time() - tts # training time for all hyper-parameters + average_gram_matrix_time = np.mean(gram_matrix_time) + std_gram_matrix_time = np.std(gram_matrix_time, ddof=1) + best_gram_matrix_time = [ + gram_matrix_time[i] for i in best_params_index[0] + ] + ave_bgmt = np.mean(best_gram_matrix_time) + std_bgmt = np.std(best_gram_matrix_time, ddof=1) + print( + 'time to calculate gram matrix with different hyper-params: {:.2f}±{:.2f}s' + .format(average_gram_matrix_time, std_gram_matrix_time)) + print('time to calculate best gram matrix: {:.2f}±{:.2f}s'.format( + ave_bgmt, std_bgmt)) + print( + 'total training time with all hyper-param choices: {:.2f}s'.format( + tt_total)) + str_fw += 'time to calculate gram matrix with different hyper-params: {:.2f}±{:.2f}s\n'.format(average_gram_matrix_time, std_gram_matrix_time) + str_fw += 'time to calculate best gram matrix: {:.2f}±{:.2f}s\n'.format(ave_bgmt, std_bgmt) + str_fw += 'total training time with all hyper-param choices: {:.2f}s\n\n'.format(tt_total) + + # # save results to file + # np.savetxt(results_name_pre + 'average_train_scores.dt', + # average_train_scores) + # np.savetxt(results_name_pre + 'average_val_scores', average_val_scores) + # np.savetxt(results_name_pre + 'average_perf_scores.dt', + # average_perf_scores) + # np.savetxt(results_name_pre + 'std_train_scores.dt', std_train_scores) + # np.savetxt(results_name_pre + 'std_val_scores.dt', std_val_scores) + # np.savetxt(results_name_pre + 'std_perf_scores.dt', std_perf_scores) + + # np.save(results_name_pre + 'best_params_index', best_params_index) + # np.save(results_name_pre + 'best_params_pre.dt', best_params_out) + # np.save(results_name_pre + 'best_params_in.dt', best_params_in) + # np.save(results_name_pre + 'best_val_perf.dt', best_val_perf) + # np.save(results_name_pre + 'best_val_std.dt', best_val_std) + # np.save(results_name_pre + 'final_performance.dt', final_performance) + # np.save(results_name_pre + 'final_confidence.dt', final_confidence) + # np.save(results_name_pre + 'train_performance.dt', train_performance) + # np.save(results_name_pre + 'train_std.dt', train_std) + + # np.save(results_name_pre + 'gram_matrix_time.dt', gram_matrix_time) + # np.save(results_name_pre + 'average_gram_matrix_time.dt', + # average_gram_matrix_time) + # np.save(results_name_pre + 'std_gram_matrix_time.dt', + # std_gram_matrix_time) + # np.save(results_name_pre + 'best_gram_matrix_time.dt', + # best_gram_matrix_time) + + # print out as table. + from collections import OrderedDict + from tabulate import tabulate + table_dict = {} + if model_type == 'regression': + for param_in in param_list: + param_in['alpha'] = '{:.2e}'.format(param_in['alpha']) + else: + for param_in in param_list: + param_in['C'] = '{:.2e}'.format(param_in['C']) + table_dict['params'] = [{**param_out, **param_in} + for param_in in param_list for param_out in param_list_pre_revised] + table_dict['gram_matrix_time'] = [ + '{:.2f}'.format(gram_matrix_time[index_out]) + for param_in in param_list + for index_out, _ in enumerate(param_list_pre_revised) + ] + table_dict['valid_perf'] = [ + '{:.2f}±{:.2f}'.format(average_val_scores[index_out][index_in], + std_val_scores[index_out][index_in]) + for index_in, _ in enumerate(param_list) + for index_out, _ in enumerate(param_list_pre_revised) + ] + table_dict['test_perf'] = [ + '{:.2f}±{:.2f}'.format(average_perf_scores[index_out][index_in], + std_perf_scores[index_out][index_in]) + for index_in, _ in enumerate(param_list) + for index_out, _ in enumerate(param_list_pre_revised) + ] + table_dict['train_perf'] = [ + '{:.2f}±{:.2f}'.format(average_train_scores[index_out][index_in], + std_train_scores[index_out][index_in]) + for index_in, _ in enumerate(param_list) + for index_out, _ in enumerate(param_list_pre_revised) + ] + keyorder = [ + 'params', 'train_perf', 'valid_perf', 'test_perf', + 'gram_matrix_time' + ] + print() + tb_print = tabulate( + OrderedDict( + sorted(table_dict.items(), + key=lambda i: keyorder.index(i[0]))), + headers='keys') + print(tb_print) + str_fw += 'table of performance v.s. hyper-params:\n\n%s\n\n' % tb_print + + # read gram matrices from file. + else: + # Grid of parameters with a discrete number of values for each. +# param_list_precomputed = list(ParameterGrid(param_grid_precomputed)) + param_list = list(ParameterGrid(param_grid)) + + # read gram matrices from file. + print() + print('2. Reading gram matrices from file...') + str_fw += '\nII. Gram matrices.\n\nGram matrices are read from file, see last log for detail.\n' + gmfile = np.load(results_dir + '/' + ds_name + '.gm.npz') + gram_matrices = gmfile['gms'] # a list to store gram matrices for all param_grid_precomputed + param_list_pre_revised = gmfile['params'] # list to store param grids precomputed ignoring the useless ones + y = gmfile['y'].tolist() + + tts = time.time() # start training time +# nb_gm_ignore = 0 # the number of gram matrices those should not be considered, as they may contain elements that are not numbers (NaN) print( '3. Fitting and predicting using nested cross validation. This could really take a while...' ) + pool = Pool(n_jobs) trial_do_partial = partial(trial_do, param_list_pre_revised, param_list, gram_matrices, y, model_type) train_pref = [] @@ -205,7 +440,7 @@ def model_selection_for_precomputed_kernel(datafile, test_pref.append(o3) pool.close() pool.join() - + # # ---- use pool.map to parallel. ---- # result_perf = pool.map(trial_do_partial, range(NUM_TRIALS)) # train_pref = [item[0] for item in result_perf] @@ -219,19 +454,19 @@ def model_selection_for_precomputed_kernel(datafile, # val_pref = [item[1] for item in result_perf] # test_pref = [item[2] for item in result_perf] - # # ---- direct running, normally use single CPU core. ---- - # train_pref = [] - # val_pref = [] - # test_pref = [] - # for i in tqdm(range(NUM_TRIALS), desc='cross validation', file=sys.stdout): - # o1, o2, o3 = trial_do(param_list_pre_revised, param_list, gram_matrices, y, model_type, i) - # train_pref.append(o1) - # val_pref.append(o2) - # test_pref.append(o3) +# # ---- direct running, normally use a single CPU core. ---- +# train_pref = [] +# val_pref = [] +# test_pref = [] +# for i in tqdm(range(NUM_TRIALS), desc='cross validation', file=sys.stdout): +# o1, o2, o3 = trial_do(param_list_pre_revised, param_list, gram_matrices, y, model_type, i) +# train_pref.append(o1) +# val_pref.append(o2) +# test_pref.append(o3) print() print('4. Getting final performance...') - str_fw += '\nII. Performance.\n\n' + str_fw += '\nIII. Performance.\n\n' # averages and confidences of performances on outer trials for each combination of parameters average_train_scores = np.mean(train_pref, axis=0) average_val_scores = np.mean(val_pref, axis=0) @@ -293,53 +528,25 @@ def model_selection_for_precomputed_kernel(datafile, str_fw += 'train_std: %s\n\n' % train_std print() - tt_total = time.time() - tts # training time for all hyper-parameters - average_gram_matrix_time = np.mean(gram_matrix_time) - std_gram_matrix_time = np.std(gram_matrix_time, ddof=1) - best_gram_matrix_time = [ - gram_matrix_time[i] for i in best_params_index[0] - ] - ave_bgmt = np.mean(best_gram_matrix_time) - std_bgmt = np.std(best_gram_matrix_time, ddof=1) - print( - 'time to calculate gram matrix with different hyper-params: {:.2f}±{:.2f}s' - .format(average_gram_matrix_time, std_gram_matrix_time)) - print('time to calculate best gram matrix: {:.2f}±{:.2f}s'.format( - ave_bgmt, std_bgmt)) + tt_poster = time.time() - tts # training time with hyper-param choices who did not participate in calculation of gram matrices +# average_gram_matrix_time = np.mean(gram_matrix_time) +# std_gram_matrix_time = np.std(gram_matrix_time, ddof=1) +# best_gram_matrix_time = [ +# gram_matrix_time[i] for i in best_params_index[0] +# ] +# ave_bgmt = np.mean(best_gram_matrix_time) +# std_bgmt = np.std(best_gram_matrix_time, ddof=1) +# print( +# 'time to calculate gram matrix with different hyper-params: {:.2f}±{:.2f}s' +# .format(average_gram_matrix_time, std_gram_matrix_time)) +# print('time to calculate best gram matrix: {:.2f}±{:.2f}s'.format( +# ave_bgmt, std_bgmt)) print( - 'total training time with all hyper-param choices: {:.2f}s'.format( - tt_total)) - str_fw += 'time to calculate gram matrix with different hyper-params: {:.2f}±{:.2f}s\n'.format(average_gram_matrix_time, std_gram_matrix_time) - str_fw += 'time to calculate best gram matrix: {:.2f}±{:.2f}s\n'.format(ave_bgmt, std_bgmt) - str_fw += 'total training time with all hyper-param choices: {:.2f}s\n\n'.format(tt_total) - - # # save results to file - # np.savetxt(results_name_pre + 'average_train_scores.dt', - # average_train_scores) - # np.savetxt(results_name_pre + 'average_val_scores', average_val_scores) - # np.savetxt(results_name_pre + 'average_perf_scores.dt', - # average_perf_scores) - # np.savetxt(results_name_pre + 'std_train_scores.dt', std_train_scores) - # np.savetxt(results_name_pre + 'std_val_scores.dt', std_val_scores) - # np.savetxt(results_name_pre + 'std_perf_scores.dt', std_perf_scores) - - # np.save(results_name_pre + 'best_params_index', best_params_index) - # np.save(results_name_pre + 'best_params_pre.dt', best_params_out) - # np.save(results_name_pre + 'best_params_in.dt', best_params_in) - # np.save(results_name_pre + 'best_val_perf.dt', best_val_perf) - # np.save(results_name_pre + 'best_val_std.dt', best_val_std) - # np.save(results_name_pre + 'final_performance.dt', final_performance) - # np.save(results_name_pre + 'final_confidence.dt', final_confidence) - # np.save(results_name_pre + 'train_performance.dt', train_performance) - # np.save(results_name_pre + 'train_std.dt', train_std) - - # np.save(results_name_pre + 'gram_matrix_time.dt', gram_matrix_time) - # np.save(results_name_pre + 'average_gram_matrix_time.dt', - # average_gram_matrix_time) - # np.save(results_name_pre + 'std_gram_matrix_time.dt', - # std_gram_matrix_time) - # np.save(results_name_pre + 'best_gram_matrix_time.dt', - # best_gram_matrix_time) + 'training time with hyper-param choices who did not participate in calculation of gram matrices: {:.2f}s'.format( + tt_poster)) +# str_fw += 'time to calculate gram matrix with different hyper-params: {:.2f}±{:.2f}s\n'.format(average_gram_matrix_time, std_gram_matrix_time) +# str_fw += 'time to calculate best gram matrix: {:.2f}±{:.2f}s\n'.format(ave_bgmt, std_bgmt) + str_fw += 'training time with hyper-param choices who did not participate in calculation of gram matrices: {:.2f}s\n\n'.format(tt_poster) # print out as table. from collections import OrderedDict @@ -353,11 +560,11 @@ def model_selection_for_precomputed_kernel(datafile, param_in['C'] = '{:.2e}'.format(param_in['C']) table_dict['params'] = [{**param_out, **param_in} for param_in in param_list for param_out in param_list_pre_revised] - table_dict['gram_matrix_time'] = [ - '{:.2f}'.format(gram_matrix_time[index_out]) - for param_in in param_list - for index_out, _ in enumerate(param_list_pre_revised) - ] +# table_dict['gram_matrix_time'] = [ +# '{:.2f}'.format(gram_matrix_time[index_out]) +# for param_in in param_list +# for index_out, _ in enumerate(param_list_pre_revised) +# ] table_dict['valid_perf'] = [ '{:.2f}±{:.2f}'.format(average_val_scores[index_out][index_in], std_val_scores[index_out][index_in]) @@ -377,8 +584,7 @@ def model_selection_for_precomputed_kernel(datafile, for index_out, _ in enumerate(param_list_pre_revised) ] keyorder = [ - 'params', 'train_perf', 'valid_perf', 'test_perf', - 'gram_matrix_time' + 'params', 'train_perf', 'valid_perf', 'test_perf' ] print() tb_print = tabulate( @@ -392,59 +598,62 @@ def model_selection_for_precomputed_kernel(datafile, # open file to save all results for this dataset. if not os.path.exists(results_dir): os.makedirs(results_dir) - - with open(results_dir + '/' + ds_name + '.txt', 'w') as fresults: - fresults.write(str_fw) - fresults.close() + + # open file to save all results for this dataset. + if not os.path.exists(results_dir): + os.makedirs(results_dir) + if not os.path.exists(results_dir + '/' + ds_name + '.output.txt'): + with open(results_dir + '/' + ds_name + '.output.txt', 'w') as f: + f.write(str_fw) + else: + with open(results_dir + '/' + ds_name + '.output.txt', 'r+') as f: + content = f.read() + f.seek(0, 0) + f.write(str_fw + '\n\n\n' + content) def trial_do(param_list_pre_revised, param_list, gram_matrices, y, model_type, trial): # Test set level # Arrays to store scores - train_pref = np.zeros((len(param_list_pre_revised), - len(param_list))) - val_pref = np.zeros((len(param_list_pre_revised), - len(param_list))) - test_pref = np.zeros((len(param_list_pre_revised), - len(param_list))) + train_pref = np.zeros((len(param_list_pre_revised), len(param_list))) + val_pref = np.zeros((len(param_list_pre_revised), len(param_list))) + test_pref = np.zeros((len(param_list_pre_revised), len(param_list))) # loop for each outer param tuple for index_out, params_out in enumerate(param_list_pre_revised): # split gram matrix and y to app and test sets. - X_app, X_test, y_app, y_test = train_test_split( - gram_matrices[index_out], y, test_size=0.1) - split_index_app = [y.index(y_i) for y_i in y_app if y_i in y] - # split_index_test = [y.index(y_i) for y_i in y_test if y_i in y] - X_app = X_app[:, split_index_app] - X_test = X_test[:, split_index_app] + indices = range(len(y)) + X_app, X_test, y_app, y_test, idx_app, idx_test = train_test_split( + gram_matrices[index_out], y, indices, test_size=0.1, + random_state=None, shuffle=True) + X_app = X_app[:, idx_app] + X_test = X_test[:, idx_app] y_app = np.array(y_app) y_test = np.array(y_test) # loop for each inner param tuple for index_in, params_in in enumerate(param_list): - inner_cv = KFold( - n_splits=10, shuffle=True, random_state=trial) + inner_cv = KFold(n_splits=10, shuffle=True, random_state=trial) current_train_perf = [] current_valid_perf = [] - current_test_perf = [] + current_test_perf = [] # For regression use the Kernel Ridge method try: if model_type == 'regression': - KR = KernelRidge(kernel='precomputed', **params_in) + kr = KernelRidge(kernel='precomputed', **params_in) # loop for each split on validation set level # validation set level - for train_index, valid_index in inner_cv.split( - X_app): - KR.fit(X_app[train_index, :][:, train_index], + for train_index, valid_index in inner_cv.split(X_app): + kr.fit(X_app[train_index, :][:, train_index], y_app[train_index]) # predict on the train, validation and test set - y_pred_train = KR.predict( + y_pred_train = kr.predict( X_app[train_index, :][:, train_index]) - y_pred_valid = KR.predict( + y_pred_valid = kr.predict( X_app[valid_index, :][:, train_index]) - y_pred_test = KR.predict( + y_pred_test = kr.predict( X_test[:, train_index]) # root mean squared errors @@ -460,22 +669,23 @@ def trial_do(param_list_pre_revised, param_list, gram_matrices, y, model_type, t np.sqrt( mean_squared_error( y_test, y_pred_test))) - # For clcassification use SVM + # For clcassification use SVM else: - KR = SVC(kernel='precomputed', **params_in) + svc = SVC(kernel='precomputed', cache_size=200, + verbose=False, **params_in) # loop for each split on validation set level # validation set level - for train_index, valid_index in inner_cv.split( - X_app): - KR.fit(X_app[train_index, :][:, train_index], + for train_index, valid_index in inner_cv.split(X_app): +# np.savez("bug.npy",X_app[train_index, :][:, train_index],y_app[train_index]) + svc.fit(X_app[train_index, :][:, train_index], y_app[train_index]) - + # predict on the train, validation and test set - y_pred_train = KR.predict( + y_pred_train = svc.predict( X_app[train_index, :][:, train_index]) - y_pred_valid = KR.predict( + y_pred_valid = svc.predict( X_app[valid_index, :][:, train_index]) - y_pred_test = KR.predict( + y_pred_test = svc.predict( X_test[:, train_index]) # root mean squared errors