diff --git a/workspace/2-data_csv.ipynb b/workspace/2-data_csv.ipynb
index a8c36f9066a1096bc0c289cfd4f20eceb385dd51..62ecf3ae6c05097cc7ac0143de6eafc3000cc9b1 100644
--- a/workspace/2-data_csv.ipynb
+++ b/workspace/2-data_csv.ipynb
@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
@@ -10,41 +10,43 @@
"import numpy as np\n",
"import pandas as pd\n",
"from tqdm import tqdm\n",
- "import utils.samplefiles"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {},
- "outputs": [],
- "source": [
- "train_wnum = 50\n",
- "train_nnum = 50\n",
- "test_wnum = 50\n",
- "test_nnum = 50"
+ "import utils.samplefiles\n",
+ "import h5py"
]
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"data = utils.samplefiles.SampleFile()\n",
- "data.read_hdf('./output/train.hdf')"
+ "data.read_hdf('./output/train.hdf')\n",
+ "\n",
+ "wave, noise = data.as_dataframe(injection_parameters=True, \n",
+ " static_arguments=False, \n",
+ " command_line_arguments=False, \n",
+ " split_injections_noise=True)"
]
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 23,
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4096"
+ ]
+ },
+ "execution_count": 23,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "wave, noise = data.as_dataframe(injection_parameters=True, \n",
- " static_arguments=False, \n",
- " command_line_arguments=False, \n",
- " split_injections_noise=True)"
+ "wave['h1_strain'][0].size"
]
},
{
@@ -56,7 +58,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
@@ -66,6 +68,26 @@
"nary = np.array(h1n)"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4096"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "h1w[0].size"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -75,16 +97,41 @@
},
{
"cell_type": "code",
- "execution_count": 16,
+ "execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
+ "train_wnum = 50\n",
+ "train_nnum = 50\n",
+ "test_wnum = 50\n",
+ "test_nnum = 50\n",
+ "\n",
"wtrain = wary[:train_wnum,:]\n",
"ntrain = nary[:train_nnum,:]\n",
"wtest = wary[train_wnum:,:]\n",
"ntest = nary[train_nnum:,:]"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(50, 4096)"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "wtrain.shape"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -94,7 +141,7 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
@@ -108,25 +155,25 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Training set name"
+ "# Training set"
]
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "100%|██████████| 50/50 [00:00<00:00, 299593.14it/s]\n"
+ "100%|██████████| 4096/4096 [00:00<00:00, 774600.71it/s]\n"
]
}
],
"source": [
"train_name = []\n",
- "num = 50\n",
+ "num = wtrain.shape[1]-1 # 4096\n",
"train_name.append('label')\n",
"for i in tqdm(range(0,num)):\n",
" train_name.append('point{s1}'.format(s1=i))"
@@ -134,14 +181,14 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "100%|██████████| 50/50 [00:00<00:00, 63.12it/s]\n"
+ "100%|██████████| 50/50 [00:00<00:00, 120.83it/s]\n"
]
}
],
@@ -156,29 +203,58 @@
" writer.writerow(ntrain[i])"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "train_set = pd.read_csv(\"./output/train.csv\", dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(100, 4097)"
+ ]
+ },
+ "execution_count": 33,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "train_set.shape"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "testing set name"
+ "# Testing set"
]
},
{
"cell_type": "code",
- "execution_count": 20,
+ "execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "100%|██████████| 50/50 [00:00<00:00, 394201.50it/s]\n"
+ "100%|██████████| 4096/4096 [00:00<00:00, 457568.56it/s]\n"
]
}
],
"source": [
"test_name = []\n",
- "num = 50\n",
+ "num = wtrain.shape[1]-1 # 4096\n",
"test_name.append('label')\n",
"for i in tqdm(range(0,num)):\n",
" test_name.append('point{s1}'.format(s1=i))"
@@ -186,14 +262,14 @@
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "100%|██████████| 50/50 [00:00<00:00, 60.24it/s]\n"
+ "100%|██████████| 50/50 [00:00<00:00, 120.86it/s]\n"
]
}
],
@@ -208,6 +284,35 @@
" writer.writerow(ntest[i])"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "test_set = pd.read_csv(\"./output/test.csv\", dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(100, 4097)"
+ ]
+ },
+ "execution_count": 38,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "test_set.shape"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -232,7 +337,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.1"
+ "version": "3.8.10"
}
},
"nbformat": 4,
diff --git a/workspace/3-training.ipynb b/workspace/3-training.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..7dc66d71009928f350f9aac3eb4d0365d325dd3b
--- /dev/null
+++ b/workspace/3-training.ipynb
@@ -0,0 +1,440 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import torch.nn as nn\n",
+ "import torch.optim as optim\n",
+ "import matplotlib.pyplot as plt\n",
+ "import torch.nn.functional as F\n",
+ "from torchsummary import summary\n",
+ "from torch.optim import lr_scheduler\n",
+ "from torch.utils.data import DataLoader\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from models import *\n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# hyper-parameters\n",
+ "# how many samples per batch to load\n",
+ "batch_size = 10\n",
+ "# percentage of training set to use as validation\n",
+ "valid_size = 0.1\n",
+ "# number of epochs to train the model\n",
+ "n_epochs = 30\n",
+ "# track change in validation loss\n",
+ "valid_loss_min = np.Inf\n",
+ "# specify the image classes\n",
+ "classes = ['noise', 'wave']\n",
+ "# gpu\n",
+ "DEVICE = torch.device('cuda: 3' if torch.cuda.is_available() else 'cpu')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# choose the training and test datasets\n",
+ "train_set = pd.read_csv(\"./output/train.csv\", dtype=np.float32)\n",
+ "\n",
+ "# Seperate the features and labels\n",
+ "total_train_label = train_set.label.values\n",
+ "total_train_data = train_set.loc[:, train_set.columns != 'label'].values\n",
+ "total_train_data = total_train_data.reshape(-1, 1, 4096)\n",
+ "\n",
+ "# Split into training and test set\n",
+ "data_train, data_valid, label_train, label_valid = train_test_split(total_train_data, total_train_label, test_size=0.1, random_state=2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# create feature and targets tensor for train set. As you remember we need variable to accumulate gradients. Therefore first we create tensor, then we will create variable\n",
+ "dataTrain = torch.from_numpy(data_train)\n",
+ "labelTrain = torch.from_numpy(label_train).type(torch.LongTensor) # data type is long\n",
+ "\n",
+ "# create feature and targets tensor for valid set.\n",
+ "dataValid = torch.from_numpy(data_valid)\n",
+ "labelValid = torch.from_numpy(label_valid).type(torch.LongTensor) # data type is long"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Pytorch train and valid sets\n",
+ "train = torch.utils.data.TensorDataset(dataTrain,labelTrain)\n",
+ "valid = torch.utils.data.TensorDataset(dataValid,labelValid)\n",
+ "\n",
+ "# data loader\n",
+ "train_loader = torch.utils.data.DataLoader(train, batch_size = batch_size, shuffle = True)\n",
+ "valid_loader = torch.utils.data.DataLoader(valid, batch_size = batch_size, shuffle = True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# instantiate model\n",
+ "model = ConvNet4().to(DEVICE)\n",
+ "# specify optimizer\n",
+ "optimizer = optim.Adam(model.parameters(), lr=5e-5)\n",
+ "#learning rate\n",
+ "lr_sched = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1)\n",
+ "# summary\n",
+ "#summary(model, input_size=(1,4096))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#curve list\n",
+ "train_Loss_list = []\n",
+ "valid_Loss_list = []\n",
+ "accracy_list = []\n",
+ "valid_len = 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Validation loss decreased (0.638117 --> 0.638116). Saving model ...\n",
+ "Validation loss decreased (0.638116 --> 0.638115). Saving model ...\n",
+ "Validation loss decreased (0.638115 --> 0.638113). Saving model ...\n",
+ "Validation loss decreased (0.638113 --> 0.638113). Saving model ...\n",
+ "iteration: 5.0 \tTraining Loss: 0.241428 \tValidation Loss: 0.638112\n",
+ "Validation loss decreased (0.638113 --> 0.638112). Saving model ...\n",
+ "Validation loss decreased (0.638112 --> 0.638110). Saving model ...\n",
+ "Validation loss decreased (0.638110 --> 0.638110). Saving model ...\n",
+ "iteration: 15.0 \tTraining Loss: 0.278747 \tValidation Loss: 0.638117\n",
+ "iteration: 25.0 \tTraining Loss: 0.217533 \tValidation Loss: 0.638129\n",
+ "iteration: 35.0 \tTraining Loss: 0.268120 \tValidation Loss: 0.638133\n",
+ "iteration: 45.0 \tTraining Loss: 0.242722 \tValidation Loss: 0.638136\n",
+ "iteration: 55.0 \tTraining Loss: 0.210212 \tValidation Loss: 0.638121\n",
+ "iteration: 65.0 \tTraining Loss: 0.222743 \tValidation Loss: 0.638116\n",
+ "iteration: 75.0 \tTraining Loss: 0.180599 \tValidation Loss: 0.638120\n",
+ "iteration: 85.0 \tTraining Loss: 0.219321 \tValidation Loss: 0.638117\n",
+ "iteration: 95.0 \tTraining Loss: 0.218023 \tValidation Loss: 0.638128\n",
+ "iteration: 105.0 \tTraining Loss: 0.212116 \tValidation Loss: 0.638129\n",
+ "iteration: 115.0 \tTraining Loss: 0.226289 \tValidation Loss: 0.638129\n",
+ "iteration: 125.0 \tTraining Loss: 0.266237 \tValidation Loss: 0.638129\n",
+ "iteration: 135.0 \tTraining Loss: 0.228767 \tValidation Loss: 0.638129\n",
+ "iteration: 145.0 \tTraining Loss: 0.249504 \tValidation Loss: 0.638129\n",
+ "iteration: 155.0 \tTraining Loss: 0.242986 \tValidation Loss: 0.638129\n",
+ "iteration: 165.0 \tTraining Loss: 0.222421 \tValidation Loss: 0.638129\n",
+ "iteration: 175.0 \tTraining Loss: 0.195560 \tValidation Loss: 0.638129\n",
+ "iteration: 185.0 \tTraining Loss: 0.228540 \tValidation Loss: 0.638129\n",
+ "iteration: 195.0 \tTraining Loss: 0.217326 \tValidation Loss: 0.638129\n",
+ "iteration: 205.0 \tTraining Loss: 0.258029 \tValidation Loss: 0.638129\n",
+ "iteration: 215.0 \tTraining Loss: 0.254950 \tValidation Loss: 0.638129\n",
+ "iteration: 225.0 \tTraining Loss: 0.185815 \tValidation Loss: 0.638129\n",
+ "iteration: 235.0 \tTraining Loss: 0.224218 \tValidation Loss: 0.638129\n",
+ "iteration: 245.0 \tTraining Loss: 0.215922 \tValidation Loss: 0.638129\n",
+ "iteration: 255.0 \tTraining Loss: 0.245718 \tValidation Loss: 0.638129\n",
+ "iteration: 265.0 \tTraining Loss: 0.268707 \tValidation Loss: 0.638129\n",
+ "iteration: 275.0 \tTraining Loss: 0.195637 \tValidation Loss: 0.638129\n",
+ "iteration: 285.0 \tTraining Loss: 0.205642 \tValidation Loss: 0.638129\n",
+ "iteration: 295.0 \tTraining Loss: 0.205471 \tValidation Loss: 0.638129\n"
+ ]
+ }
+ ],
+ "source": [
+ "# train\n",
+ "for epoch in range(0, n_epochs):\n",
+ "\n",
+ " # keep track of training, validation loss and correct\n",
+ " train_loss = 0.0\n",
+ " valid_loss = 0.0\n",
+ " correct = 0.0\n",
+ " # train the model \n",
+ " model.train()\n",
+ " for batch_idx, (data, target) in enumerate(train_loader):\n",
+ " data, target = data.to(DEVICE), target.to(DEVICE).float().reshape(batch_size, 1)\n",
+ " optimizer.zero_grad()\n",
+ " output = model(data)\n",
+ " loss = F.binary_cross_entropy(output, target)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " train_loss += loss.item()*data.size(0)\n",
+ " #valid more\n",
+ " if (batch_idx + 1) % valid_len == 0:\n",
+ " class_correct = list(0. for i in range(2))\n",
+ " class_total = list(0. for i in range(2))\n",
+ " # validate the model \n",
+ " model.eval()\n",
+ " for data, target in valid_loader:\n",
+ " data, target = data.to(DEVICE), target.to(DEVICE).float().reshape(batch_size, 1)\n",
+ " output = model(data)\n",
+ " loss = F.binary_cross_entropy(output, target)\n",
+ " valid_loss += loss.item()*data.size(0)\n",
+ " # less the limit 0.5->0.1, higher the recall rate\n",
+ " pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in output]).to(DEVICE) \n",
+ " # compare predictions to true label\n",
+ " correct_tensor = pred.eq(target.data.view_as(pred).long())\n",
+ " correct = np.squeeze(correct_tensor.cpu().numpy())\n",
+ " # calculate test accuracy for each object class\n",
+ " for i in range(batch_size):\n",
+ " label = target.data[i].int()\n",
+ " class_correct[label] += correct[i].item()\n",
+ " class_total[label] += 1\n",
+ "\n",
+ " # calculate accuracy\n",
+ " accuracy = 100. * np.sum(class_correct) / np.sum(class_total)\n",
+ " # calculate average losses\n",
+ " train_loss = train_loss / (valid_len * batch_size)\n",
+ " valid_loss = valid_loss / len(valid_loader.dataset)\n",
+ " #curve data\n",
+ " train_Loss_list.append(train_loss)\n",
+ " valid_Loss_list.append(valid_loss)\n",
+ " accracy_list.append(accuracy)\n",
+ " \n",
+ " # print training/validation statistics \n",
+ " if((epoch * 10 + (batch_idx + 1) / valid_len) % 5 == 0):\n",
+ " print('iteration: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}'.format(\n",
+ " epoch * 10 + (batch_idx + 1) / valid_len, train_loss, valid_loss))\n",
+ "\n",
+ " # save model if validation loss has decreased\n",
+ " if valid_loss <= valid_loss_min:\n",
+ " print('Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...'.format(\n",
+ " valid_loss_min,\n",
+ " valid_loss))\n",
+ " torch.save(model.state_dict(), './param/exp1_data1.2_convnet4.pt')\n",
+ " valid_loss_min = valid_loss\n",
+ " train_loss = 0.0\n",
+ " valid_loss = 0.0\n",
+ " # learning rate\n",
+ " lr_sched.step()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "length = len(train_Loss_list)\n",
+ "x = range(0, length)\n",
+ "plt.plot(x, train_Loss_list, label='train loss')\n",
+ "plt.plot(x, valid_Loss_list, label='valid loss')\n",
+ "plt.title('Convolutional Neural Network')\n",
+ "plt.xlabel('iteration')\n",
+ "plt.ylabel('Loss')\n",
+ "plt.legend()\n",
+ "#plt.savefig(\"cnn_loss.jpg\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "length = len(accracy_list)\n",
+ "x = range(0, length)\n",
+ "plt.plot(x, accracy_list)\n",
+ "plt.title('Convolutional Neural Network')\n",
+ "plt.xlabel('iteration')\n",
+ "plt.ylabel('accracy')\n",
+ "#plt.savefig(\"cnn_loss.jpg\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#np.savetxt('./cache/new/data_1.2_convnet1/accracy.txt',accracy_list,fmt=\"%.6f\",delimiter=\"\\n\")\n",
+ "#np.savetxt('./cache/new/data_1.2_convnet1/train_Loss_list.txt',train_Loss_list,fmt=\"%.6f\",delimiter=\"\\n\")\n",
+ "#np.savetxt('./cache/new/data_1.2_convnet1/valid_Loss_list.txt',valid_Loss_list,fmt=\"%.6f\",delimiter=\"\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "<All keys matched successfully>"
+ ]
+ },
+ "execution_count": 35,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model.load_state_dict(torch.load('./param/exp1_data1.2_convnet4.pt'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "test_set = pd.read_csv(\"./output/train.csv\", dtype=np.float32)\n",
+ "\n",
+ "# Seperate the features and labels\n",
+ "label_test = test_set.label.values\n",
+ "data_test = test_set.loc[:, test_set.columns != 'label'].values\n",
+ "data_test = data_test.reshape(-1, 1, 4096)\n",
+ "\n",
+ "# create feature and targets tensor for test set.\n",
+ "dataTest = torch.from_numpy(data_test)\n",
+ "labelTest = torch.from_numpy(label_test).type(torch.LongTensor) # data type is long\n",
+ "\n",
+ "test = torch.utils.data.TensorDataset(dataTest,labelTest)\n",
+ "test_loader = torch.utils.data.DataLoader(test, batch_size = batch_size, shuffle = True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 0.268362\n",
+ "\n",
+ "Test Accuracy of noise: 98% (49/50)\n",
+ "Test Accuracy of wave: 96% (48/50)\n",
+ "\n",
+ "Test Accuracy (Overall): 97% (97/100)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# track test loss\n",
+ "test_loss = 0.0\n",
+ "class_correct = list(0. for i in range(2))\n",
+ "class_total = list(0. for i in range(2))\n",
+ "\n",
+ "model.eval()\n",
+ "# iterate over test data\n",
+ "for data, target in test_loader:\n",
+ " data, target = data.to(DEVICE), target.to(DEVICE).float().reshape(batch_size, 1)\n",
+ " output = model(data)\n",
+ " loss = F.binary_cross_entropy(output, target)\n",
+ " test_loss += loss.item()*data.size(0)\n",
+ " # less the limit 0.5->0.1, higher the recall rate\n",
+ " pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in output]).to(DEVICE) \n",
+ " # compare predictions to true label\n",
+ " correct_tensor = pred.eq(target.data.view_as(pred).long())\n",
+ " correct = np.squeeze(correct_tensor.cpu().numpy())\n",
+ " # calculate test accuracy for each object class\n",
+ " for i in range(batch_size):\n",
+ " label = target.data[i].int()\n",
+ " class_correct[label] += correct[i].item()\n",
+ " class_total[label] += 1\n",
+ "\n",
+ "# average test loss\n",
+ "test_loss = test_loss/len(test_loader.dataset)\n",
+ "print('Test Loss: {:.6f}\\n'.format(test_loss))\n",
+ "\n",
+ "for i in range(2):\n",
+ " if class_total[i] > 0:\n",
+ " print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (\n",
+ " classes[i], 100 * class_correct[i] / class_total[i],\n",
+ " np.sum(class_correct[i]), np.sum(class_total[i])))\n",
+ " else:\n",
+ " print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))\n",
+ "\n",
+ "print('\\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (\n",
+ " 100. * np.sum(class_correct) / np.sum(class_total),\n",
+ " np.sum(class_correct), np.sum(class_total)))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "anaconda-cloud": {},
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/workspace/3-machine_learning.ipynb b/workspace/backup-mymodifiedversion-3-machine_learning.ipynb
similarity index 83%
rename from workspace/3-machine_learning.ipynb
rename to workspace/backup-mymodifiedversion-3-machine_learning.ipynb
index 8c240b78933238cdfff7a1d07e976c84174cdd93..443fa5fadd072d4ddfb52a7d9dd38d63627f98dc 100644
--- a/workspace/3-machine_learning.ipynb
+++ b/workspace/backup-mymodifiedversion-3-machine_learning.ipynb
@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
@@ -23,7 +23,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
@@ -33,7 +33,7 @@
"# percentage of training set to use as validation\n",
"valid_size = 0.1\n",
"# number of epochs to train the model\n",
- "n_epochs = 30\n",
+ "n_epochs = 1\n",
"# track change in validation loss\n",
"valid_loss_min = np.Inf\n",
"# specify the image classes\n",
@@ -44,7 +44,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
@@ -54,86 +54,120 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"# Seperate the features and labels\n",
"total_train_label = train_set.label.values\n",
- "total_train_data = train_set.loc[:, train_set.columns != 'label'].values"
+ "total_train_data = train_set.loc[:, train_set.columns != 'label'].values\n",
+ "total_train_data = total_train_data.reshape(-1, 1, 4096)"
]
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "(array([[-62.03712 , -7.5803556, 15.291977 , ..., 7.230299 ,\n",
- " -69.84998 , 18.02432 ],\n",
- " [-32.492123 , 4.4595265, -0.5901758, ..., 14.5061865,\n",
- " -23.653366 , 37.64089 ],\n",
- " [-26.649189 , 31.127876 , 56.877144 , ..., 51.428246 ,\n",
- " 49.74805 , -14.098241 ],\n",
- " ...,\n",
- " [-22.56183 , 33.652225 , 15.230522 , ..., -56.98435 ,\n",
- " 19.305769 , 18.769468 ],\n",
- " [-15.172637 , -36.630943 , 43.394974 , ..., -5.847082 ,\n",
- " -59.176975 , 19.188839 ],\n",
- " [-22.888329 , 41.428745 , 5.050339 , ..., 2.9315968,\n",
- " -15.47938 , -23.167208 ]], dtype=float32),\n",
- " (100, 50))"
+ "(100,)"
]
},
- "execution_count": 5,
+ "execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
- "total_train_data,total_train_data.shape"
+ "total_train_label.shape"
]
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(100, 1, 4096)"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "total_train_data.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
- "total_train_data = total_train_data.reshape(-1, 1, 100)"
+ "#total_train_data = total_train_data.reshape(-1, 1, 16384)\n",
+ "#total_train_label = total_train_label.reshape(-1, 1, 1)"
]
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 26,
"metadata": {},
"outputs": [
{
- "ename": "ValueError",
- "evalue": "Found input variables with inconsistent numbers of samples: [50, 100]",
- "output_type": "error",
- "traceback": [
- "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
- "\u001b[0;32m<ipython-input-7-98b7e345d0c3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Split into training and test set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mdata_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_valid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel_valid\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtrain_test_split\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtotal_train_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal_train_label\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
- "\u001b[0;32m~/opt/miniconda3/lib/python3.9/site-packages/sklearn/model_selection/_split.py\u001b[0m in \u001b[0;36mtrain_test_split\u001b[0;34m(test_size, train_size, random_state, shuffle, stratify, *arrays)\u001b[0m\n\u001b[1;32m 2170\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"At least one array required as input\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2172\u001b[0;31m \u001b[0marrays\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mindexable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2174\u001b[0m \u001b[0mn_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_num_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrays\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/opt/miniconda3/lib/python3.9/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mindexable\u001b[0;34m(*iterables)\u001b[0m\n\u001b[1;32m 354\u001b[0m \"\"\"\n\u001b[1;32m 355\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0m_make_indexable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mX\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterables\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 356\u001b[0;31m \u001b[0mcheck_consistent_length\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 357\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 358\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;32m~/opt/miniconda3/lib/python3.9/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_consistent_length\u001b[0;34m(*arrays)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[0muniques\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munique\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlengths\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muniques\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 319\u001b[0;31m raise ValueError(\"Found input variables with inconsistent numbers of\"\n\u001b[0m\u001b[1;32m 320\u001b[0m \" samples: %r\" % [int(l) for l in lengths])\n\u001b[1;32m 321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
- "\u001b[0;31mValueError\u001b[0m: Found input variables with inconsistent numbers of samples: [50, 100]"
- ]
+ "data": {
+ "text/plain": [
+ "(100, 1, 4096)"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
}
],
+ "source": [
+ "total_train_data.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(100,)"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "total_train_label.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
"source": [
"# Split into training and test set\n",
"data_train, data_valid, label_train, label_valid = \\\n",
- "train_test_split(total_train_data, total_train_label, test_size=0.1, random_state=2)"
+ "train_test_split(total_train_data, total_train_label, test_size=valid_size, random_state=2)"
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
@@ -150,7 +184,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
@@ -165,12 +199,104 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0 (tensor([[[ -3.6588, -8.7501, -13.2873, ..., 50.3284, 73.6249, -7.4861]],\n",
+ "\n",
+ " [[ 58.8892, -34.4240, -7.0151, ..., 19.6284, 5.8056, -10.1896]],\n",
+ "\n",
+ " [[-25.7599, 38.4685, -5.8641, ..., -1.0486, -15.9929, -13.8097]],\n",
+ "\n",
+ " ...,\n",
+ "\n",
+ " [[ -8.6096, 11.9229, -7.7777, ..., -33.6976, 31.7323, 22.5505]],\n",
+ "\n",
+ " [[ 4.9527, -4.7260, -51.1175, ..., -23.3081, -23.6608, 9.2065]],\n",
+ "\n",
+ " [[ 41.5923, 16.7344, -9.3329, ..., -4.5990, 40.6475, 17.2668]]]), tensor([1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1,\n",
+ " 0]))\n",
+ "1 (tensor([[[ 31.8002, -35.3708, -3.3680, ..., -37.3070, -20.4746, -25.6443]],\n",
+ "\n",
+ " [[ -8.9197, -14.1783, -7.0737, ..., -6.1846, -9.7816, 34.2528]],\n",
+ "\n",
+ " [[-20.0077, 76.9484, 6.7912, ..., 30.4908, 10.9669, 18.0433]],\n",
+ "\n",
+ " ...,\n",
+ "\n",
+ " [[ 61.0710, -1.1720, -5.4269, ..., -15.4596, -49.9105, 7.8992]],\n",
+ "\n",
+ " [[ -2.5201, -16.3237, 30.1252, ..., -0.4326, 36.2127, 19.0306]],\n",
+ "\n",
+ " [[-47.8746, 14.1169, 28.6327, ..., -34.9201, -8.5922, 19.4526]]]), tensor([0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1,\n",
+ " 0]))\n",
+ "2 (tensor([[[ 24.0152, 46.1441, 10.9930, ..., -3.9326, 12.6095, -33.1261]],\n",
+ "\n",
+ " [[ 5.0609, -19.4981, -45.3404, ..., 28.1799, -84.9188, -9.8493]],\n",
+ "\n",
+ " [[ 31.7707, -8.6773, -11.7029, ..., -28.5239, 47.4721, -6.9119]],\n",
+ "\n",
+ " ...,\n",
+ "\n",
+ " [[ 33.2307, 11.9690, 48.2033, ..., 3.5819, 5.1547, 3.5468]],\n",
+ "\n",
+ " [[ 55.1532, -6.3257, 12.0293, ..., -58.0621, -10.6701, -30.3893]],\n",
+ "\n",
+ " [[-39.4150, 25.1565, -14.5661, ..., 43.6791, -66.4943, 74.3911]]]), tensor([1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1,\n",
+ " 0]))\n",
+ "3 (tensor([[[ 21.6147, -20.1361, -72.1704, ..., -26.1830, 3.1268, -2.8540]],\n",
+ "\n",
+ " [[-15.4415, 32.3177, -19.1063, ..., -61.5150, 18.5274, -44.2418]],\n",
+ "\n",
+ " [[ -2.6239, 20.6541, 29.9448, ..., 5.2102, 0.8877, 30.8585]],\n",
+ "\n",
+ " ...,\n",
+ "\n",
+ " [[ 10.4988, 16.8289, -18.8190, ..., -90.1444, 29.9813, 53.8949]],\n",
+ "\n",
+ " [[ 31.0470, 18.0455, -4.1932, ..., -11.7091, -41.2828, 17.5074]],\n",
+ "\n",
+ " [[ 17.8683, -21.5610, -1.2673, ..., 1.7552, 25.0248, 14.9674]]]), tensor([1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0]))\n"
+ ]
+ }
+ ],
+ "source": [
+ "for batch_idx, (data, target) in enumerate(train_loader):\n",
+ " print(batch_idx,(data,target))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "torch.Size([90, 1, 4096])"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "train.tensors[0].shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"# instantiate model\n",
- "model = ConvNet4().to(DEVICE)\n",
+ "model = ConvNet1().to(DEVICE)\n",
"# specify optimizer\n",
"optimizer = optim.Adam(model.parameters(), lr=5e-5)\n",
"#learning rate\n",
@@ -181,7 +307,36 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 37,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "ConvNet1(\n",
+ " (conv1): Conv1d(1, 16, kernel_size=(16,), stride=(1,))\n",
+ " (max_pool1): MaxPool1d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
+ " (conv2): Conv1d(16, 32, kernel_size=(8,), stride=(1,))\n",
+ " (max_pool2): MaxPool1d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
+ " (conv3): Conv1d(32, 64, kernel_size=(8,), stride=(1,))\n",
+ " (max_pool3): MaxPool1d(kernel_size=4, stride=4, padding=0, dilation=1, ceil_mode=False)\n",
+ " (fc1): Linear(in_features=3904, out_features=64, bias=True)\n",
+ " (fc2): Linear(in_features=64, out_features=1, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 37,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
"metadata": {},
"outputs": [],
"source": [
@@ -194,88 +349,18 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 39,
"metadata": {},
"outputs": [
{
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Validation loss decreased (inf --> 0.687406). Saving model ...\n",
- "Validation loss decreased (0.687406 --> 0.681616). Saving model ...\n",
- "Validation loss decreased (0.681616 --> 0.676216). Saving model ...\n",
- "iteration: 5.0 \tTraining Loss: 0.670587 \tValidation Loss: 0.667222\n",
- "Validation loss decreased (0.676216 --> 0.667222). Saving model ...\n",
- "Validation loss decreased (0.667222 --> 0.648601). Saving model ...\n",
- "Validation loss decreased (0.648601 --> 0.642810). Saving model ...\n",
- "Validation loss decreased (0.642810 --> 0.621476). Saving model ...\n",
- "Validation loss decreased (0.621476 --> 0.600710). Saving model ...\n",
- "Validation loss decreased (0.600710 --> 0.559009). Saving model ...\n",
- "Validation loss decreased (0.559009 --> 0.469705). Saving model ...\n",
- "Validation loss decreased (0.469705 --> 0.414217). Saving model ...\n",
- "iteration: 15.0 \tTraining Loss: 0.427971 \tValidation Loss: 0.370859\n",
- "Validation loss decreased (0.414217 --> 0.370859). Saving model ...\n",
- "Validation loss decreased (0.370859 --> 0.369948). Saving model ...\n",
- "Validation loss decreased (0.369948 --> 0.327391). Saving model ...\n",
- "Validation loss decreased (0.327391 --> 0.312415). Saving model ...\n",
- "Validation loss decreased (0.312415 --> 0.271771). Saving model ...\n",
- "Validation loss decreased (0.271771 --> 0.265176). Saving model ...\n",
- "Validation loss decreased (0.265176 --> 0.261692). Saving model ...\n",
- "Validation loss decreased (0.261692 --> 0.244539). Saving model ...\n",
- "iteration: 25.0 \tTraining Loss: 0.241963 \tValidation Loss: 0.246531\n",
- "Validation loss decreased (0.244539 --> 0.233539). Saving model ...\n",
- "Validation loss decreased (0.233539 --> 0.230913). Saving model ...\n",
- "Validation loss decreased (0.230913 --> 0.227057). Saving model ...\n",
- "Validation loss decreased (0.227057 --> 0.225386). Saving model ...\n",
- "Validation loss decreased (0.225386 --> 0.219995). Saving model ...\n",
- "iteration: 35.0 \tTraining Loss: 0.266930 \tValidation Loss: 0.240498\n",
- "Validation loss decreased (0.219995 --> 0.216780). Saving model ...\n",
- "Validation loss decreased (0.216780 --> 0.214125). Saving model ...\n",
- "Validation loss decreased (0.214125 --> 0.212111). Saving model ...\n",
- "Validation loss decreased (0.212111 --> 0.211900). Saving model ...\n",
- "iteration: 45.0 \tTraining Loss: 0.179977 \tValidation Loss: 0.259835\n",
- "Validation loss decreased (0.211900 --> 0.204226). Saving model ...\n",
- "Validation loss decreased (0.204226 --> 0.199974). Saving model ...\n",
- "iteration: 55.0 \tTraining Loss: 0.147942 \tValidation Loss: 0.205356\n",
- "Validation loss decreased (0.199974 --> 0.195755). Saving model ...\n",
- "Validation loss decreased (0.195755 --> 0.194970). Saving model ...\n",
- "Validation loss decreased (0.194970 --> 0.194251). Saving model ...\n",
- "Validation loss decreased (0.194251 --> 0.194100). Saving model ...\n",
- "Validation loss decreased (0.194100 --> 0.192323). Saving model ...\n",
- "iteration: 65.0 \tTraining Loss: 0.170526 \tValidation Loss: 0.192809\n",
- "Validation loss decreased (0.192323 --> 0.188182). Saving model ...\n",
- "Validation loss decreased (0.188182 --> 0.187559). Saving model ...\n",
- "Validation loss decreased (0.187559 --> 0.186908). Saving model ...\n",
- "Validation loss decreased (0.186908 --> 0.185635). Saving model ...\n",
- "iteration: 75.0 \tTraining Loss: 0.112142 \tValidation Loss: 0.187386\n",
- "Validation loss decreased (0.185635 --> 0.181862). Saving model ...\n",
- "iteration: 85.0 \tTraining Loss: 0.119231 \tValidation Loss: 0.182259\n",
- "Validation loss decreased (0.181862 --> 0.181267). Saving model ...\n",
- "Validation loss decreased (0.181267 --> 0.180979). Saving model ...\n",
- "Validation loss decreased (0.180979 --> 0.180108). Saving model ...\n",
- "Validation loss decreased (0.180108 --> 0.178496). Saving model ...\n",
- "iteration: 95.0 \tTraining Loss: 0.149047 \tValidation Loss: 0.179502\n",
- "iteration: 105.0 \tTraining Loss: 0.085169 \tValidation Loss: 0.179523\n",
- "Validation loss decreased (0.178496 --> 0.178160). Saving model ...\n",
- "iteration: 115.0 \tTraining Loss: 0.084234 \tValidation Loss: 0.195391\n",
- "iteration: 125.0 \tTraining Loss: 0.092414 \tValidation Loss: 0.181713\n",
- "iteration: 135.0 \tTraining Loss: 0.062861 \tValidation Loss: 0.188943\n",
- "iteration: 145.0 \tTraining Loss: 0.055033 \tValidation Loss: 0.187805\n",
- "iteration: 155.0 \tTraining Loss: 0.047300 \tValidation Loss: 0.191877\n",
- "iteration: 165.0 \tTraining Loss: 0.035127 \tValidation Loss: 0.205924\n",
- "iteration: 175.0 \tTraining Loss: 0.045897 \tValidation Loss: 0.199864\n",
- "iteration: 185.0 \tTraining Loss: 0.026902 \tValidation Loss: 0.222597\n",
- "iteration: 195.0 \tTraining Loss: 0.025435 \tValidation Loss: 0.218615\n",
- "iteration: 205.0 \tTraining Loss: 0.018787 \tValidation Loss: 0.221879\n",
- "iteration: 215.0 \tTraining Loss: 0.016591 \tValidation Loss: 0.223594\n",
- "iteration: 225.0 \tTraining Loss: 0.017554 \tValidation Loss: 0.224143\n",
- "iteration: 235.0 \tTraining Loss: 0.013084 \tValidation Loss: 0.225407\n",
- "iteration: 245.0 \tTraining Loss: 0.015281 \tValidation Loss: 0.223412\n",
- "iteration: 255.0 \tTraining Loss: 0.011665 \tValidation Loss: 0.227159\n",
- "iteration: 265.0 \tTraining Loss: 0.010941 \tValidation Loss: 0.227533\n",
- "iteration: 275.0 \tTraining Loss: 0.012160 \tValidation Loss: 0.234278\n",
- "iteration: 285.0 \tTraining Loss: 0.009149 \tValidation Loss: 0.232661\n",
- "iteration: 295.0 \tTraining Loss: 0.013521 \tValidation Loss: 0.231244\n"
+ "ename": "RuntimeError",
+ "evalue": "shape '[25, 1]' is invalid for input of size 15",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-39-747daa443a1d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDEVICE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDEVICE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mRuntimeError\u001b[0m: shape '[25, 1]' is invalid for input of size 15"
]
}
],
@@ -543,7 +628,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.9.1"
+ "version": "3.8.10"
}
},
"nbformat": 4,
diff --git a/workspace/config_files/default.json b/workspace/config_files/default.json
old mode 100755
new mode 100644
index b830806fe5f8385aff498f36f092f09480cf703e..e8fd7471e48b349c6e7dee1333b67de6d90c8de3
--- a/workspace/config_files/default.json
+++ b/workspace/config_files/default.json
@@ -8,5 +8,5 @@
"n_injection_samples": 100,
"n_noise_samples": 100,
"n_processes": 4,
- "output_file_name": "train.hdf"
+ "output_file_name": "test.hdf"
}
diff --git a/workspace/config_files/waveform_params.ini b/workspace/config_files/waveform_params.ini
old mode 100755
new mode 100644
index 3dadf30be35681ef5a3c998df9de306039d9a75f..90732345adf99700173c7c2bfe7aea2eecbbb7db
--- a/workspace/config_files/waveform_params.ini
+++ b/workspace/config_files/waveform_params.ini
@@ -13,7 +13,7 @@ injection_snr =
[static_args]
approximant = SEOBNRv4
domain = time
-f_lower = 18
+f_lower = 10
distance = 100
waveform_length = 128
@@ -31,8 +31,8 @@ target_sampling_rate = 2048
; Define parameters for the whitening procedure. See documentation of the
; pycbc.types.TimeSeries.whiten() method for an explanation of what these
; values exactly mean.
-whitening_segment_duration = 4
-whitening_max_filter_duration = 4
+whitening_segment_duration = 1
+whitening_max_filter_duration = 1
; Define the lower and upper bound for the bandpass filter (in Hertz)
bandpass_lower = 20
@@ -41,8 +41,8 @@ bandpass_upper = 2048
; Define how to align the sample around the event time. By convention, the
; event time is the H1 time!
; The sum of these values will be the the sample_length!
-seconds_before_event = 5.5
-seconds_after_event = 2.5
+seconds_before_event = 1.5
+seconds_after_event = 0.5
; alpha for the Tukey window that is used to "fade on" the waveforms
; It represents the fraction of the window inside the cosine tapered region.
diff --git a/workspace/param/exp1_data1.2_convnet4.pt b/workspace/param/exp1_data1.2_convnet4.pt
new file mode 100644
index 0000000000000000000000000000000000000000..14fb86222045f8d06be7bb374a9e45e94e4f51f9
Binary files /dev/null and b/workspace/param/exp1_data1.2_convnet4.pt differ
diff --git a/workspace/plot_sample.py b/workspace/plot_sample.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/__init__.py b/workspace/utils/__init__.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/configfiles.py b/workspace/utils/configfiles.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/hdffiles.py b/workspace/utils/hdffiles.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/progressbar.py b/workspace/utils/progressbar.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/samplefiles.py b/workspace/utils/samplefiles.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/samplegeneration.py b/workspace/utils/samplegeneration.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/staticargs.py b/workspace/utils/staticargs.py
old mode 100755
new mode 100644
diff --git a/workspace/utils/waveforms.py b/workspace/utils/waveforms.py
old mode 100755
new mode 100644