{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-05-03T10:10:10.972376Z","iopub.execute_input":"2023-05-03T10:10:10.973116Z","iopub.status.idle":"2023-05-03T10:10:11.122174Z","shell.execute_reply.started":"2023-05-03T10:10:10.973077Z","shell.execute_reply":"2023-05-03T10:10:11.121074Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# import os\n# import pandas as pd\n# import matplotlib.pyplot as plt\n# import seaborn as sns","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.123853Z","iopub.execute_input":"2023-05-03T10:10:11.124852Z","iopub.status.idle":"2023-05-03T10:10:11.12981Z","shell.execute_reply.started":"2023-05-03T10:10:11.124805Z","shell.execute_reply":"2023-05-03T10:10:11.128565Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# train_dir='/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train'\n# path =f'{train_dir}/tdcsfog'\n# tdcsfog_train_csv = [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.csv')]\n# tdcsfog_train = pd.concat([pd.read_csv(f) for f in tdcsfog_train_csv])\n# tdcsfog_train.describe()","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.170991Z","iopub.execute_input":"2023-05-03T10:10:11.171712Z","iopub.status.idle":"2023-05-03T10:10:11.176386Z","shell.execute_reply.started":"2023-05-03T10:10:11.171661Z","shell.execute_reply":"2023-05-03T10:10:11.175389Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# path =f'{train_dir}/defog'\n# defog_train_csv = [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.csv')]\n# defog_train = pd.concat([pd.read_csv(f) for f in defog_train_csv])\n# defog_train.describe()","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.37475Z","iopub.execute_input":"2023-05-03T10:10:11.375314Z","iopub.status.idle":"2023-05-03T10:10:11.38002Z","shell.execute_reply.started":"2023-05-03T10:10:11.375283Z","shell.execute_reply":"2023-05-03T10:10:11.378775Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# path =f'{train_dir}/notype'\n# notype_train_csv = [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.csv')]\n# notype_train = pd.concat([pd.read_csv(f) for f in defog_train_csv])\n# notype_train.describe()","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.478719Z","iopub.execute_input":"2023-05-03T10:10:11.478991Z","iopub.status.idle":"2023-05-03T10:10:11.48332Z","shell.execute_reply.started":"2023-05-03T10:10:11.478965Z","shell.execute_reply":"2023-05-03T10:10:11.482162Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# def plot_target_bar(df):\n#     counts = df[['StartHesitation', 'Turn', 'Walking']].sum()\n#     print(counts)\n#     plt.bar(counts.index, counts.values)\n#     plt.show()\n","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.578685Z","iopub.execute_input":"2023-05-03T10:10:11.579215Z","iopub.status.idle":"2023-05-03T10:10:11.583374Z","shell.execute_reply.started":"2023-05-03T10:10:11.579178Z","shell.execute_reply":"2023-05-03T10:10:11.582224Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# print('==notype==')\n# plot_target_bar(notype_train)\n# print('==defog==')\n# plot_target_bar(defog_train)\n# print('==tdcsfog==')\n# plot_target_bar(tdcsfog_train)","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.666202Z","iopub.execute_input":"2023-05-03T10:10:11.666801Z","iopub.status.idle":"2023-05-03T10:10:11.671286Z","shell.execute_reply.started":"2023-05-03T10:10:11.666762Z","shell.execute_reply":"2023-05-03T10:10:11.670129Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## D\n","metadata":{}},{"cell_type":"code","source":"!pip install neptune \n!pip install lightning","metadata":{"execution":{"iopub.status.busy":"2023-05-03T10:10:11.74722Z","iopub.execute_input":"2023-05-03T10:10:11.747519Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport torch\nimport torchvision\nfrom torch import nn\nfrom torch.nn import functional as F\nfrom torch.utils.data import Dataset\nfrom torch.utils.data import DataLoader, random_split\nimport lightning as L\nimport neptune.new as neptune\nfrom torchmetrics import Accuracy\nimport os\nimport pandas as pd","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class DS(Dataset):\n    def __init__(self, dataset, labels, seq_len=50):\n        train_dir = '/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train'\n        path = f'{train_dir}/{dataset}'\n        files = [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.csv')]\n        self.df = pd.concat([pd.read_csv(f) for f in files])\n        self.labels = labels\n        self.seq_len = seq_len\n\n    def __len__(self):\n        return len(self.df) // self.seq_len\n\n    def __getitem__(self, idx):\n        start_idx = idx * self.seq_len\n        end_idx = (idx + 1) * self.seq_len\n        records = self.df.iloc[start_idx:end_idx]\n        x = torch.stack([torch.Tensor(r[['AccV', 'AccML', 'AccAP']]) for _, r in records.iterrows()])\n        x = torch.transpose(x, 0, 1)\n        y = torch.stack([torch.Tensor(r[self.labels]) for _, r in records.iterrows()])\n        y =torch.transpose(y, 0, 1)\n        y=torch.any(y != 0, dim=1).float()\n        return x, y\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tdcsfog_ds = DS('tdcsfog',['StartHesitation','Turn','Walking'],128)\ndefog_ds = DS('defog',['StartHesitation','Turn','Walking'],100)\nnotype_ds = DS('notype',['Event'],100)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\nfrom torch.utils.data import Subset\n\ntrain_idx, val_idx = train_test_split(list(range(len(tdcsfog_ds))), test_size=0.2)\ntdcsfog_train,tdcsfog_val =Subset(tdcsfog_ds, train_idx),Subset(tdcsfog_ds, train_idx)\n\ntrain_idx, val_idx = train_test_split(list(range(len(defog_ds))), test_size=0.2)\ndefog_train,defog_val =Subset(defog_ds, train_idx),Subset(defog_ds, train_idx)\n\n# train_idx, val_idx = train_test_split(list(range(len(notype_ds))), test_size=0.2)\n# notype_train,notype_val =Subset(notype_ds, train_idx),Subset(notype_ds, train_idx)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def train_model(model,tags,epochs,batch_size):\n    trainer = L.Trainer(\n        accelerator='auto',\n        max_epochs=epochs,\n        devices=2\n    )\n    run = neptune.init_run(\n        project=\"harelmx/deep-hw2\",\n        api_token=\"eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI5ZDUzNTU3NC0xMzczLTQ4NGQtYTVhOS1jZGJmNzQ3MTA3ZjIifQ==\",\n    )  \n    run[\"sys/tags\"].add(tags)\n    run[\"config/lr\"]=lr\n    run[\"config/epochs\"]=trainer.max_epochs\n    run[\"config/batch_size\"]=batch_size\n    model.run=run\n    trainer.fit(model,model.train_loader,model.val_loader)\n    print('===vaidate===')\n    trainer.validate(model,model.val_loader)\n    print(trainer.callback_metrics['val_loss'])\n    val_loss=trainer.callback_metrics['val_loss']\n#     val_acc=trainer.callback_metrics['val_acc']\n#     print('===test===')\n#     trainer.test(model,test_loader)\n#     test_loss=trainer.callback_metrics['test_loss']\n#     test_acc=trainer.callback_metrics['test_acc']\n    run.stop()\n#     return val_loss, val_acc, test_loss, test_acc, model","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nclass OneDimConvModel(L.LightningModule):\n    def __init__(self, train_loader,val_loader,seq_len,neptun_run=None) -> None:\n        super().__init__()\n        # self.save_hyperparameters()\n        self.train_loader=train_loader\n        self.val_loader=val_loader\n        self.run=neptun_run\n        \n        self.val_accuracy = Accuracy(task=\"multiclass\", num_classes=515)\n        self.test_accuracy = Accuracy(task=\"multiclass\", num_classes=515)\n        kernel_size=3\n        self.conv1 = nn.Conv1d(3,3,kernel_size,stride=1)\n        self.fc = torch.nn.Linear(3*seq_len-kernel_size*2, 3)\n\n    def forward(self, x):\n        x = self.conv1(x)\n        x = F.relu(x)\n        x = torch.flatten(x,start_dim=1)\n        x = self.fc(x)\n        x = F.relu(x)\n        y_hat = F.log_softmax(x, dim=1)\n        return y_hat\n\n    \n    def training_step(self, batch, batch_idx):\n        X, y = batch\n        loss = F.cross_entropy(self(X),y)\n        if self.run:\n            self.run['train/loss'].append(loss.item())\n        return loss\n    \n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters(),lr=lr)\n\n\n    def validation_step(self, batch, batch_idx):\n        X, y = batch\n        y_hat = self(X)\n        loss = F.cross_entropy(y_hat,y.float()).item()\n        if self.run:\n          self.run['validation/loss'].append(loss)\n        self.log(\"val_loss\", loss , prog_bar=True,on_step=True)\n\n\n\n#     def test_step(self, batch, batch_idx):\n#         X, y = batch\n#         logits = self(X)\n#         preds = torch.argmax(logits, dim=1)\n# #         accuracy=self.val_accuracy(preds, y).item()\n#         loss = F.cross_entropy(logits,y).item()\n#         if self.run:\n#           self.run['test/loss'].append(loss)\n# #           self.run['test/accuracy'].append(accuracy)\n# #         self.log(\"test_acc\", accuracy, prog_bar=True,on_step=True)\n#         self.log(\"test_loss\", loss , prog_bar=True,on_step=True)\n    \n    def train_dataloader(self):\n        return self.train_loader\n\n    def val_dataloader(self):\n        return self.val_loader\n\n#     def test_dataloader(self):\n#         return test_loader\n\n\n\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"BATCH_SIZE = 64\ndevice='cuda'\nlr=1e-4\nepochs=10\ntdcsfog_train_loader = torch.utils.data.DataLoader(tdcsfog_train, batch_size=BATCH_SIZE,shuffle=True)\ntdcsfog_val_loader = torch.utils.data.DataLoader(tdcsfog_val, batch_size=BATCH_SIZE,shuffle=False)\nmodel=OneDimConvModel(tdcsfog_train_loader,tdcsfog_val_loader,128)\ntrain_model(model,['try'],epochs,BATCH_SIZE)","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}