{"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":"import numpy as np \ntry:\n    import cupy as cp\n    wo_gpu=False\nexcept:\n    cp=np\n    wo_gpu=True\nimport pandas as pd \nimport matplotlib.pyplot as plt\nimport os\nimport random\nimport time\n\n%matplotlib inline\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torchvision\nfrom torch.utils.data import DataLoader,random_split,TensorDataset\n\nimport sklearn\nfrom sklearn import metrics\n\nimport gc","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Debug(Exception):\n    def __init__():\n        super().__init__()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!nvidia-smi","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Dataset:\n    def __init__(self,datatype,submission=False):\n        \n        self.datatype=datatype\n        \n        self.submission=submission\n        \n        rootdir=\"/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/\"\n        \n        self.meta=pd.read_csv(rootdir+datatype+\"_metadata.csv\")      \n        self.subjects=pd.read_csv(rootdir+\"subjects.csv\")\n        self.tasks=pd.read_csv(rootdir+\"tasks.csv\")\n        task_species=sorted(list(set(self.tasks.Task)))\n        \n        for i in range(len(task_species)):\n            self.tasks.loc[self.tasks[\"Task\"]==task_species[i],[\"Task\"]]=i\n        \n        self.tps=128 if datatype==\"tdcsfog\" else 100\n        \n        self.label_tensors=[]\n        self.input_tensors=[]\n        \n    def make_data(self,filenames,forward_length,backward_length,offset,aux,stddevs=None,means=None,tdcsfog_to_defog=False):\n        \n        gc.collect()\n        \n        print(\"----make data--------------------------------------\")\n        \n        #params\n        fl=int(forward_length*self.tps)\n        bl=int(backward_length*self.tps)\n        size=fl+bl\n        self.offset=int(offset*self.tps)\n        if aux<=0.5:raise RuntimeError(\"AUX should be over 0.5\")\n        \n        #empty data arrays\n        acc_data_list=[]\n        sub_data_list=[]\n        tsk_data_list=[]\n        lbl_data_list=[]\n        \n        #empty time array\n        if self.submission:\n            self.time=cp.array([])\n        \n        for filename in filenames:\n            \n            print(\"csv file :: {}\".format(filename))\n            \n            #read csv files\n            \n            #meta\n            meta=self.meta[self.meta.Id==os.path.basename(filename)[:-4]]\n\n            #tasks\n            if datatype==\"defog\":task=self.tasks[self.tasks.Id==os.path.basename(filename)[:-4]]\n\n            #subjects\n            subject=self.subjects[self.subjects.Subject==list(meta.Subject)[0]]\n            if self.datatype==\"defog\":subject=subject[subject.Visit==int(meta.Visit)]\n            \n            #acc/label\n            dataframe=pd.read_csv(filename)\n            \n            #iterators\n            if datatype==\"tdcsfog\":\n                indices=range(fl,len(dataframe)-bl,5000)\n                length=[5000]*len(indices)\n                tasks=[0]*len(indices)\n            else:\n                indices=(task.Begin*100).astype(\"uint\")\n                length=((task.End-task.Begin)*100).astype(\"uint\")\n                tasks=task.Task\n                \n            #iteration\n            \n            for i,l,t in zip(indices,length,tasks):\n                \n                df_i=dataframe[i-fl:i+l+bl]\n                \n                #time\n                if self.submission:\n                    self.time=cp.append(self.time,cp.asarray(df_i.Time)[fl:-bl:self.offset])\n                    df_i=df_i.T.reindex([\"Time\",\"AccV\",\"AccML\",\"AccAP\"]).T\n                    df_i[\"AccV\"]=df_i[\"AccV\"].astype(\"float64\")\n                    df_i[\"AccML\"]=df_i[\"AccML\"].astype(\"float64\")\n                    df_i[\"AccAP\"]=df_i[\"AccAP\"].astype(\"float64\")\n            \n                #auxiliary data\n                Aux_data1=(cp.ones(len(df_i)) if self.datatype==\"tdcsfog\" or self.submission else cp.asarray(df_i.Task)).astype(\"bool\")\n                Aux_data2=(cp.zeros(len(df_i)) if self.datatype==\"tdcsfog\" or self.submission else (1-aux)*(1-cp.asarray(df_i.Valid))).astype(\"float32\")\n                \n                #label data\n                if self.submission:Lbl_data=cp.zeros(len(df_i)).astype(\"float32\")\n                else:Lbl_data=cp.asarray(df_i.StartHesitation*1+df_i.Turn*2+df_i.Walking*3).astype(\"float32\")\n                \n                #subject data\n                AGE=subject.Age\n                YSD=(-1)**(subject.Sex==\"F\")*subject.YearsSinceDx\n                UPD=subject.UPDRSIII_On if not pd.isna(subject.UPDRSIII_On).any() else subject.UPDRSIII_Off\n                NFO=subject.NFOGQ\n                Sub_data=cp.asarray([AGE,YSD,UPD,NFO]).astype(\"float32\")\n                \n                #task data\n                Tsk_data=cp.asarray([t]).astype(\"uint\")\n                \n                #accelerometer data\n                Acc_data=cp.asarray([df_i.AccV,df_i.AccML,df_i.AccAP]).astype(\"float32\")\n\n                #make auto regression array\n                Aux_data1=Aux_data1[fl:-bl:self.offset]\n                Aux_data2=Aux_data2[fl:-bl:self.offset]\n                Acc_data=cp.tile(Acc_data,(1,size+1))[:,:size*(len(df_i)+1)].reshape(3,size,len(df_i)+1)[:,:,:-size-1:self.offset]\n                Lbl_data=(cp.tile(Lbl_data,(4,1)).T==cp.arange(4))[fl:-bl:self.offset].T\n                Sub_data=cp.tile(Sub_data,(1,len(Aux_data1)))\n                Tsk_data=cp.tile(Tsk_data,(1,len(Aux_data1)))\n\n                #concatenate\n                acc_data_list.append(Acc_data[:,:,Aux_data1].transpose(2,0,1))\n                lbl_data_list.append((Lbl_data+((-1)**(Lbl_data))*Aux_data2/(1+Lbl_data))[:,Aux_data1].T)\n                sub_data_list.append(Sub_data[:,Aux_data1].T)\n                tsk_data_list.append(Tsk_data[:,Aux_data1].T)\n            \n        self.acc_data=cp.concatenate(acc_data_list,axis=0)\n        self.lbl_data=cp.concatenate(lbl_data_list,axis=0)\n        self.sub_data=cp.concatenate(sub_data_list,axis=0)\n        self.tsk_data=cp.concatenate(tsk_data_list,axis=0)\n        \n        if stddevs is None:stddevs=self.stddevs=[self.acc_data.std(axis=0),self.sub_data.std(axis=0),self.tsk_data.std(axis=0)]\n        if means is None:means=self.means=[self.acc_data.mean(axis=0),self.sub_data.mean(axis=0),self.tsk_data.mean(axis=0)]\n            \n        self.acc_data=((self.acc_data-means[0])/(stddevs[0]+0.5*30)).astype(\"float32\")\n        self.sub_data=((self.sub_data-means[1])/(stddevs[1]+0.5*30)).astype(\"float32\")   \n        self.tsk_data=((self.tsk_data-means[2])/(stddevs[2]+0.5*30)).astype(\"float32\")  \n            \n        self.Nsamples=(self.lbl_data>(0.5)).sum(axis=0)\n        \n        if not wo_gpu and self.submission:self.time=self.time.get()\n        \n        print(\"num samples :: vanilla:{}, starthesitation:{}, turn:{}, walking:{}\".format(*[int(i) for i in self.Nsamples]))\n        \n        print(\"---------------------------------------------------\")\n        \n    def make_tensor(self,ratio=None,label=None,subject=True,task=False,model=\"multilabel\"):\n        \n        gc.collect()\n        \n        print(\"----make tensor------------------------------------\")\n        \n        #seriese that labeled true\n        if label is None:seriese_true,seriese_false=cp.arange(1,4),cp.asarray([0])\n        else:\n            seriese_true=cp.asarray([{\"S\":1,\"T\":2,\"W\":3}[i] for i in label])\n            seriese_false=cp.asarray([i for i in range(4) if i!=seriese_true])\n            \n        #number of samples for each seriese\n        if ratio is None:Nsamples=self.Nsamples\n        else:\n            Nsamples=cp.zeros(4)\n            ratio=cp.asarray(ratio)\n            N=min((self.Nsamples[seriese_true]/ratio).min(),self.Nsamples.sum())\n            Nsamples[seriese_true]=N*cp.asarray(ratio)\n            Nsamples[seriese_false]=self.Nsamples[seriese_false]*N/self.Nsamples.sum()\n            Nsamples=Nsamples.astype(\"uint\")\n        if (Nsamples>self.Nsamples).any():raise RuntimeError(\"number of samples exceeded the cap\")\n            \n        print(\"seriese :: true:{}, false:{}\".format(seriese_true,seriese_false))\n            \n        #choose indices randomly\n        indices=cp.concatenate([cp.random.permutation(cp.arange(self.Nsamples.sum())[l>0.5])[:n] for l,n in zip(self.lbl_data.T,Nsamples)]).astype(\"uint\")\n        if self.submission:indices=cp.arange(self.Nsamples.sum())\n        \n        #label and input\n        label_data=self.lbl_data[indices,seriese_true]\n        input_data=self.acc_data[indices]\n        \n        #concatenate vanilla label if multiclass\n        if model!=\"multilabel\":label_data=cp.append(1-label_data.sum(axis=1).reshape(-1,1),label_data,axis=1)\n        \n        #concatenate subject data\n        if subject:\n            sub_data=self.sub_data[indices]\n            input_data=cp.append(input_data.reshape(int(Nsamples.sum()),-1),sub_data,axis=1)\n        \n        #concatenate task data\n        if task and self.datatype==\"defog\":\n            tsk_data=self.tsk_data[indices]\n            input_data=cp.append(input_data.reshape(int(Nsamples.sum()),-1),tsk_data,axis=1)\n\n        print(\"input data shape :: {}, label data shape :: {}\".format(input_data.shape,label_data.shape))\n            \n        #cupy array to numpy array if necessary \n        if not wo_gpu:input_data,label_data=input_data.get(),label_data.get()\n            \n        #numpy array to torch tensor\n        self.input_tensors.append(torch.tensor(input_data,dtype=torch.float32))\n        self.label_tensors.append(torch.tensor(label_data,dtype=torch.float32))\n        \n        print(\"input tensor shape :: {}, label tensor shape :: {}\".format(self.input_tensors[-1].shape,self.label_tensors[-1].shape))\n        \n        print(\"---------------------------------------------------\")\n        \n    def make_dataloaders(self,batch_size=None):\n        \n        gc.collect()\n        \n        try:batch_sizes=[int(i) for i in batch_size]\n        except:batch_sizes=[batch_size]*len(self.label_tensors)\n            \n        dataloaders=[]\n            \n        for input_tensor,label_tensor,batch_size in zip(self.input_tensors,self.label_tensors,batch_sizes):\n        \n            if batch_size==None:batch_size=label_tensor.shape[0]\n\n            dataset=TensorDataset(input_tensor,label_tensor)\n            dataloaders.append(DataLoader(dataset=dataset,batch_size=batch_size,shuffle=True if not self.submission else False))\n                                 \n        return dataloaders\n                                 ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Trainer:\n    \n    def __init__(self,net):\n        self.net=net\n        \n        \n    def define_process(self,loss_func,learning_rate,optimizer):            \n\n        self.device=torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n        self.net=self.net.to(device=self.device)\n        \n        self.optimizer=optimizer(self.net.parameters(),lr=learning_rate)\n        self.criterion=loss_func\n        \n        print(\"network is defined\")\n        \n    def train(self,dataloader):\n        gc.collect()\n        self.net.train()\n        train_loss=0.0\n        train_eval=0.0\n        cnt=0\n        for inputs,labels in dataloader:\n            cnt+=1\n            \n            self.optimizer.zero_grad()\n            \n            inputs=inputs.to(self.device)\n            labels=labels.to(self.device)\n            labels=labels.float().to(self.device).squeeze()\n            \n            outputs=self.net(inputs)\n            outputs=outputs.squeeze()\n\n            y=outputs.detach().cpu().numpy().reshape(-1)\n            t=labels.detach().cpu().numpy().reshape(-1)>0\n\n            train_eval+=(metrics.average_precision_score(t,y)).mean()\n            \n            loss=self.criterion(outputs,labels)\n            loss.backward()\n            \n            train_loss+=loss.detach().cpu().numpy()\n            \n            del loss\n            \n            self.optimizer.step()\n\n        print(\n            \"train_loss:{},train_eval:{}\".format(train_loss/cnt,train_eval/cnt)\n        )\n        return train_loss/cnt,train_eval/cnt\n\n    def test(self,dataloader):\n        gc.collect()\n        \n        self.net.eval()\n        y=torch.tensor([],dtype=torch.float32)\n        t=torch.tensor([],dtype=torch.float32)\n        \n        with torch.no_grad():\n            \n            for inputs,labels in dataloader:\n                inputs=inputs.to(self.device)\n                labels=labels.to(self.device)\n                labels=labels.float().to(self.device).squeeze()\n                \n                outputs=self.net(inputs)\n                outputs=outputs.squeeze()\n\n                y=torch.concat([y,outputs.detach().cpu()])\n                t=torch.concat([t,labels.detach().cpu()])\n\n        test_eval=(metrics.average_precision_score((t.numpy()>0.5)*1.0,y.numpy())).mean()\n\n        loss=self.criterion(y,t)\n\n        test_loss=loss.detach().cpu().numpy()\n\n        del loss\n                \n        print(\n            \"---------------------------------------------\",\n            \"\\ntest_loss:{},test_eval:{}\".format(test_loss,test_eval)\n        )\n        \n        return test_loss,test_eval\n    \n    def learn(self,train_dataloader,test_dataloader,num_epochs,early_stopping):\n        gc.collect()\n        print(\"start training\")\n        train_loss_list=[]\n        test_loss_list=[]\n        train_eval_list=[]\n        test_eval_list=[]\n        \n        for epoch in range(num_epochs):\n            print(\n                \"=============================================\",\n                \"\\n epoch:{}/{}\".format(epoch,num_epochs),\n            )\n            \n            train_loss,train_eval=self.train(train_dataloader)\n            train_loss_list.append(train_loss)\n            train_eval_list.append(train_eval)\n            \n            test_loss,test_eval=self.test(test_dataloader)\n            test_loss_list.append(test_loss)\n            test_eval_list.append(test_eval)\n            \n            early_stopping(-test_eval,self.net)\n            if early_stopping.early_stop:\n                print(\"Early Stopping\")\n                break\n            print(\n                \"=============================================\",\n            )\n            \n            plt.plot(np.arange(epoch+1),train_loss_list,label=\"train BCE\")\n            plt.plot(np.arange(epoch+1),test_loss_list,label=\"test BCE\")\n            plt.grid()\n            plt.legend()\n            plt.show()\n            \n            plt.plot(np.arange(epoch+1),train_eval_list,label=\"train AP\")\n            plt.plot(np.arange(epoch+1),test_eval_list,label=\"test AP\")\n            plt.grid()\n            plt.legend()\n            plt.show()\n            \n        early_stopping.load_checkpoint(self.net)\n            \n        return train_loss_list,test_loss_list,train_eval_list,test_eval_list\n                \n            \n        ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Net_tdcsfog(nn.Module):\n    def __init__(self, block_size, subject):\n        self.block_size=block_size\n        self.subject=subject\n        super().__init__()\n        if subject:self.forward=self.forward1\n        self.conv1=nn.Conv1d(in_channels=3,out_channels=9,kernel_size=7,padding=3)\n        self.conv2=nn.Conv1d(in_channels=9,out_channels=9,kernel_size=7,padding=3)\n        self.pool1=nn.AvgPool1d(kernel_size=2)\n        self.conv3=nn.Conv1d(in_channels=9,out_channels=7,kernel_size=5,padding=2)\n        self.conv4=nn.Conv1d(in_channels=7,out_channels=7,kernel_size=5,padding=2)\n        self.pool2=nn.AvgPool1d(kernel_size=2)\n        self.fc1=nn.Linear(block_size//4*7+4*self.subject,4*7)\n        self.fc2=nn.Linear(4*7,1)\n        \n    def forward1(self,x):\n        x,x_=x[:,:-4].reshape(-1,3,self.block_size),x[:,-4:]\n        x=F.silu(self.conv1(x))\n        x=F.silu(self.conv2(x))\n        x=self.pool1(x)\n        x=F.silu(self.conv3(x))\n        x=F.silu(self.conv4(x))\n        x=self.pool2(x)\n        x=torch.cat((torch.flatten(x,1),x_),1)\n        x=F.silu(self.fc1(x))\n        x=torch.sigmoid(self.fc2(x))\n        return x\n        \n    def forward2(self,x):\n        x=x.reshape(-1,3,self.block_size)\n        x=F.silu(self.conv1(x))\n        x=F.silu(self.conv2(x))\n        x=self.pool1(x)\n        x=F.silu(self.conv3(x))\n        x=F.silu(self.conv4(x))\n        x=self.pool2(x)\n        x=torch.flatten(x,1)\n        x=F.silu(self.fc1(x))\n        x=torch.sigmoid(self.fc2(x))\n        return x\n\nclass Net_defog(nn.Module):\n    def __init__(self, block_size, subject, task):\n        self.block_size=block_size\n        self.subject=subject\n        self.task=task\n        if subject or task:self.forward=self.forward1\n        else:self.forward=self.forward2\n        super().__init__()\n        self.conv1=nn.Conv1d(in_channels=3,out_channels=12,kernel_size=7,padding=3)\n        self.conv2=nn.Conv1d(in_channels=12,out_channels=12,kernel_size=7,padding=3)\n        self.conv3=nn.Conv1d(in_channels=12,out_channels=12,kernel_size=7,padding=3)\n        self.pool1=nn.AvgPool1d(kernel_size=2)\n        self.conv4=nn.Conv1d(in_channels=12,out_channels=11,kernel_size=5,padding=2)\n        self.conv5=nn.Conv1d(in_channels=11,out_channels=10,kernel_size=5,padding=2)\n        self.conv6=nn.Conv1d(in_channels=10,out_channels=9,kernel_size=5,padding=2)\n        self.pool2=nn.AvgPool1d(kernel_size=2)\n        self.conv7=nn.Conv1d(in_channels=9,out_channels=7,kernel_size=3,padding=1)\n        self.conv8=nn.Conv1d(in_channels=7,out_channels=7,kernel_size=3,padding=1)\n        self.pool3=nn.AvgPool1d(kernel_size=2)\n        self.fc1=nn.Linear(block_size//8*7+4*subject+task,4*7)\n        self.fc2=nn.Linear(4*7,1)\n        \n    def forward1(self,x):\n        x,x_=x[:,:-(4*self.subject+self.task)].reshape(-1,3,self.block_size),x[:,-(4*self.subject+self.task):]\n        x=F.silu(self.conv1(x))\n        x=F.silu(self.conv2(x))\n        x=F.silu(self.conv3(x))\n        x=self.pool1(x)\n        x=F.silu(self.conv4(x))\n        x=F.silu(self.conv5(x))\n        x=F.silu(self.conv6(x))\n        x=self.pool2(x)\n        x=F.silu(self.conv7(x))\n        x=F.silu(self.conv8(x))\n        x=self.pool3(x)\n        x=torch.cat((torch.flatten(x,1),x_),1)\n        x=F.silu(self.fc1(x))\n        x=torch.sigmoid(self.fc2(x))\n        # x=F.softmax(self.fc2(x), dim=0) # 出力\n        return x\n        \n    def forward2(self,x):\n        x=x.reshape(-1,3,self.block_size)\n        x=F.silu(self.conv1(x))\n        x=F.silu(self.conv2(x))\n        x=F.silu(self.conv3(x))\n        x=self.pool1(x)\n        x=F.silu(self.conv4(x))\n        x=F.silu(self.conv5(x))\n        x=F.silu(self.conv6(x))\n        x=self.pool2(x)\n        x=F.silu(self.conv7(x))\n        x=F.silu(self.conv8(x))\n        x=self.pool3(x)\n        x=torch.flatten(x,1)\n        x=F.silu(self.fc2(x))\n        x=torch.sigmoid(self.fc2(x))\n        # x=F.softmax(self.fc2(x), dim=0) # 出力\n        return x","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nclass EarlyStopping:\n    def __init__(self,patience=7,verbose=False,delta=0,path='checkpoint.pt',trace_func=print,valid=True):\n        self.patience=patience\n        self.verbose=verbose\n        self.counter=0\n        self.best_score=None\n        self.early_stop=False\n        self.val_loss_min=np.inf\n        self.delta=delta\n        self.path=path\n        self.trace_func=trace_func\n        self.valid=valid\n        \n    def __call__(self,val_loss,model):\n\n        score=-val_loss\n\n        if self.best_score is None:\n            self.best_score=score\n            self.save_checkpoint(val_loss,model)\n        elif score<self.best_score+self.delta:\n            self.counter+=1\n            self.trace_func(f'EarlyStopping counter:{self.counter} out of {self.patience}')\n            if self.counter>=self.patience:\n                self.early_stop=True\n        else:\n            self.best_score=score\n            self.save_checkpoint(val_loss,model)\n            self.counter=0\n\n    def save_checkpoint(self,val_loss,model):\n        '''Saves model when validation loss decrease.'''\n        if self.verbose:\n            self.trace_func(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}).  Saving model ...')\n        torch.save(model.state_dict(),self.path)\n        self.val_loss_min = val_loss\n        \n    def load_checkpoint(self,model):\n        if self.valid:model.load_state_dict(torch.load(self.path))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def make_dataset(\n    datatype,subject,task,\n    forward_length,backward_length,offset,aux,\n    train_ratio,ratio\n):\n    gc.collect()\n        \n    print(\"----make dataloader--------------------------------\")\n    \n    #separate to train and test files\n                                 \n    homedir=\"/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/train/\"+datatype+\"/\"\n    filenames=np.array([homedir+filename for filename in os.listdir(homedir)])\n    np.random.shuffle(filenames)\n    train_filenames=filenames[:int(train_ratio*len(filenames))]\n    test_filenames=filenames[int(train_ratio*len(filenames)):]\n    \n    #make dataset object (train) \n                                 \n    dataset_train=Dataset(datatype)\n    dataset_train.make_data(train_filenames,forward_length,backward_length,offset,aux)\n    \n    #make dataset object (test)\n                                 \n    dataset_test=Dataset(datatype)\n    dataset_test.make_data(test_filenames,forward_length,backward_length,offset,aux,dataset_train.stddevs,dataset_train.means)\n    \n    #make dataloader (train)\n                                 \n    dataset_train.make_tensor([ratio[0]],[\"S\"],subject,task)\n                                 \n    dataset_train.make_tensor([ratio[1]],[\"T\"],subject,task)\n                                 \n    dataset_train.make_tensor([ratio[2]],[\"W\"],subject,task)\n    \n    #make dataloader (test)\n                                 \n    dataset_test.make_tensor(None,[\"S\"],subject,task)\n                                 \n    dataset_test.make_tensor(None,[\"T\"],subject,task)\n                                 \n    dataset_test.make_tensor(None,[\"W\"],subject,task)\n        \n    print(\"---------------------------------------------------\")\n    \n    return dataset_train,dataset_test\n\n\n\n\n\ndef learn(\n    dataset_train,dataset_test,\n    net,optimizer,loss_func,\n    num_epochs,batch_size,learning_rate,patience,delta,verbose,load\n):\n    gc.collect()\n        \n    print(\"----learn------------------------------------------\")\n    \n    #make dataloaders\n    \n    dataloader_train_S,dataloader_train_T,dataloader_train_W=dataset_train.make_dataloaders(batch_size)\n    dataloader_test_S,dataloader_test_T,dataloader_test_W=dataset_test.make_dataloaders(batch_size)\n    \n    #\n        \n    early_stopping_S=EarlyStopping(patience,verbose,delta,valid=load)\n    early_stopping_T=EarlyStopping(patience,verbose,delta,valid=load)\n    early_stopping_W=EarlyStopping(patience,verbose,delta,valid=load)\n\n    trainer_S=Trainer(net[0])\n    trainer_T=Trainer(net[1])\n    trainer_W=Trainer(net[2])\n\n    trainer_S.define_process(loss_func,learning_rate[0],optimizer)\n    trainer_T.define_process(loss_func,learning_rate[1],optimizer)\n    trainer_W.define_process(loss_func,learning_rate[2],optimizer)\n\n    trainer_S.learn(dataloader_train_S,dataloader_test_S,num_epochs,early_stopping_S)\n    trainer_T.learn(dataloader_train_T,dataloader_test_T,num_epochs,early_stopping_T)\n    trainer_W.learn(dataloader_train_W,dataloader_test_W,num_epochs,early_stopping_W)\n\n    score_S=-early_stopping_S.val_loss_min\n    score_T=-early_stopping_T.val_loss_min\n    score_W=-early_stopping_W.val_loss_min\n        \n    print(\"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\n\"*10,\n          \"\\n{}\\n{}\\n{}\\n{}\\n\".format(score_S,score_T,score_W,(score_S+score_T+score_W)/3),\n          \"\\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\"*10)\n        \n    print(\"---------------------------------------------------\")\n\n\n\n\n\n\n    \ndef apply(dataloader,net):\n    \n    gc.collect()\n\n    net.eval()\n\n    output_data=np.array([])\n\n    with torch.no_grad():\n\n        for inputs,_ in dataloader:\n\n            inputs=inputs.to(torch.device('cuda:0' if torch.cuda.is_available() else 'cpu'))\n\n            outputs=net(inputs)\n\n            output_data=np.append(output_data,outputs.detach().cpu().numpy().astype(\"float32\"))\n\n    return output_data\n\n\n\n\n\n\ndef make_submission(\n    submission,\n    datatype,subject,task,\n    forward_length,backward_length,offset,aux,stddevs,means,\n    ratio,batch_size,\n    net\n):\n    \n    gc.collect()\n        \n    print(\"----make submission csv----------------------------\")\n                                 \n    homedir=\"/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/test/\"+datatype+\"/\"\n    filenames=[homedir+filename for filename in os.listdir(homedir)]\n    \n    for i in range(len(filenames)):\n        \n        #make submission dataframe\n        \n        df=pd.read_csv(filenames[i])\n    \n        N=len(df)\n        fileId=os.path.basename(filenames[i])[:-4]\n        \n        submission_i=pd.DataFrame(\n            {\n                \"Id\":fileId+\"_\"+np.arange(N).astype(\"<U20\").astype(\"object\"),\n                \"StratHesitaiton\":np.zeros(N),\n                \"Turn\":np.zeros(N),\n                \"Walking\":np.zeros(N)\n            }\n        ).set_index(\"Id\")\n        \n        #make dataloader\n        \n        filenames_i=filenames[i:i+1]\n                                 \n        dataset=Dataset(datatype,True)\n        \n        dataset.make_data(filenames_i,forward_length,backward_length,offset,aux,stddevs,means)\n\n        dataset.make_tensor(None,[\"S\"],subject,task)\n\n        dataset.make_tensor(None,[\"T\"],subject,task)\n\n        dataset.make_tensor(None,[\"W\"],subject,task)\n        \n        dataloader_S,dataloader_T,dataloader_W=dataset.make_dataloaders(batch_size)\n        \n        #calc\n        \n        output_S=apply(dataloader_S,net[0])\n        \n        output_T=apply(dataloader_T,net[1])\n        \n        output_W=apply(dataloader_W,net[2])\n        \n        #assign output\n        \n        time=np.asarray([[int(i+j) for j in range(dataset.offset)] for i in dataset.time]).reshape(-1)\n        \n        Id=fileId+\"_\"+(time[time<N]).astype(\"<U20\").astype(\"object\")\n        \n        StartHesitation=np.tile(output_S,(dataset.offset,1)).T.reshape(-1)[:len(Id)]\n        \n        Turn=np.tile(output_T,(dataset.offset,1)).T.reshape(-1)[:len(Id)]\n        \n        Walking=np.tile(output_W,(dataset.offset,1)).T.reshape(-1)[:len(Id)]\n        \n        df_output=pd.DataFrame({\"Id\":Id,\"StartHesitation\":StartHesitation,\"Turn\":Turn,\"Walking\":Walking}).set_index(\"Id\")\n        \n        submission_i.update(df_output)\n        \n        del dataset\n        \n        #append to list\n            \n        submission.append(submission_i.reset_index())\n        \n    print(\"---------------------------------------------------\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission=[]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"datatype=\"tdcsfog\"\nsubject=True\ntask=False\n\nforward_length=0.75\nbackward_length=0.25\noffset=0.125\naux=0.8\n\ntrain_ratio=0.7\nratio=[0.1,0.3,0.1]\n\nnet_args=(int(128*(forward_length+backward_length)),subject)\nnet=[Net_tdcsfog(*net_args),Net_tdcsfog(*net_args),Net_tdcsfog(*net_args)]\noptimizer=torch.optim.Adam\nloss_func=nn.BCELoss()\n\nnum_epochs=75\nbatch_size=2000\nlearning_rate=[0.001,0.001,0.001]\npatience=50\ndelta=0\nverbose=True\nload=True\n\nscores=[]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dataset_train,dataset_test=make_dataset(\n    datatype,subject,task,\n    forward_length,backward_length,offset,aux,\n    train_ratio,ratio\n)\n\nstddevs,means=dataset_train.stddevs,dataset_train.means\n\nlearn(\n    dataset_train,dataset_test,\n    net,optimizer,loss_func,\n    num_epochs,batch_size,learning_rate,patience,delta,verbose,load\n)\n\ndel dataset_train,dataset_test\n\nmake_submission(\n    submission,\n    datatype,subject,task,\n    forward_length,backward_length,offset,aux,stddevs,means,\n    ratio,batch_size,\n    net\n)\n\ndel net","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"datatype=\"defog\"\nsubject=True\ntask=True\n\nforward_length=0.75\nbackward_length=0.25\noffset=0.1\naux=0.8\n\ntrain_ratio=0.7\nratio=[0.02,0.3,0.1]\n\nnet_args=(int(100*(forward_length+backward_length)),subject,task)\nnet=[Net_defog(*net_args),Net_defog(*net_args),Net_defog(*net_args)]\noptimizer=torch.optim.Adam\nloss_func=nn.BCELoss()\n\nnum_epochs=75\nbatch_size=2000\nlearning_rate=[0.002,0.002,0.002]\npatience=50\ndelta=0\nverbose=True\nload=True\n\nscores=[]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dataset_train,dataset_test=make_dataset(\n    datatype,subject,task,\n    forward_length,backward_length,offset,aux,\n    train_ratio,ratio\n)\n\nstddevs,means=dataset_train.stddevs,dataset_train.means\n\nlearn(\n    dataset_train,dataset_test,\n    net,optimizer,loss_func,\n    num_epochs,batch_size,learning_rate,patience,delta,verbose,load\n)\n\ndel dataset_train,dataset_test\n\nmake_submission(\n    submission,\n    datatype,subject,task,\n    forward_length,backward_length,offset,aux,stddevs,means,\n    ratio,batch_size,\n    net\n)\n\ndel net","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(submission)\nif submission:\n    submission=pd.concat(submission)\n    print(submission.tail())\n    print(submission.describe())\n    submission.to_csv(\"submission.csv\",index=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"pd.read_csv(\"/kaggle/input/tlvmc-parkinsons-freezing-gait-prediction/sample_submission.csv\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}