diff --git a/dataset/MetaPhysDataset.py b/dataset/MetaPhysDataset.py
index eb56c4c..28513a5 100644
--- a/dataset/MetaPhysDataset.py
+++ b/dataset/MetaPhysDataset.py
@@ -6,10 +6,13 @@
 import torchvision.transforms as transforms
 from torchmeta.transforms import ClassSplitter
 
+import scipy.io
+from scipy.signal import butter
+
 class MetaPhysDataset(MetaDataset):
-    def __init__(self, num_shots_tr, num_shots_ts, option='train',
-                 unsupervised=0,frame_depth=10,
-                 appearance_data=None, motion_data=None, target=None):
+    def __init__(self, num_shots_tr, num_shots_ts, video_data, label_data,
+                 option='train', unsupervised=0,frame_depth=10,
+                 ):
 
         self.transform = transforms.Compose([transforms.ToTensor()])
         self.num_samples_per_task = num_shots_tr + num_shots_ts
@@ -18,70 +21,30 @@ def __init__(self, num_shots_tr, num_shots_ts, option='train',
         self.num_shots_tr = num_shots_tr
         self.num_shots_ts = num_shots_ts
         self.unsupervised = unsupervised
-        self.a = appearance_data
-        self.m = motion_data
-        self.label = target
         self.dataset_transform = ClassSplitter(shuffle=False, num_train_per_class=num_shots_tr,
                                                    num_test_per_class=num_shots_ts)
 
-    def __getitem__(self, index):
-        if torch.is_tensor(index):
-            index = index.tolist()
-        ap = []
-        mo = []
-        la = []
-        data_len = len(self.label[index]) // self.num_samples_per_task  # 1개의 데이터를 8개로
-        for i in range(self.num_samples_per_task):
-            ap.append(self.a[index][data_len * i:data_len * (i + 1)])
-            mo.append(self.m[index][data_len * i:data_len * (i + 1)])
-            la.append(self.label[index][data_len * i:data_len * (i + 1)])
+        self.video_data = video_data
+        self.label = label_data
 
-        task = PersonTask(ap, mo, la)
-
-        self.dataset_transform = ClassSplitter(shuffle=False, num_train_per_class=self.num_shots_tr,
-                                               num_test_per_class=self.num_shots_ts)
-        if self.dataset_transform is not None:
-            task = self.dataset_transform(task)
-
-        return task
-
-    def __len__(self):
-        return len(self.label)
-
-class MetaPhys_task_Dataset(MetaDataset):
-    def __init__(self, num_shots_tr, num_shots_ts, option='train',
-                 unsupervised=0,frame_depth=10,
-                 appearance_data=None, motion_data=None, target=None):
-
-        self.transform = transforms.Compose([transforms.ToTensor()])
-        self.num_samples_per_task = num_shots_tr + num_shots_ts
-        self.frame_depth = frame_depth
-        self.option = option
-        self.num_shots_tr = num_shots_tr
-        self.num_shots_ts = num_shots_ts
-        self.unsupervised = unsupervised
-        self.a = appearance_data
-        self.m = motion_data
-        self.label = target
-        self.dataset_transform = ClassSplitter(shuffle=False, num_train_per_class=num_shots_tr,
-                                                   num_test_per_class=num_shots_ts)
 
     def __getitem__(self, index):
         if torch.is_tensor(index):
             index = index.tolist()
-        ap = []
-        mo = []
+
+        vi = []
         la = []
 
-        for i in range(4):
-            ap.append(self.a[index][i])
-            mo.append(self.m[index][i])
-            la.append(self.label[index][i])
+        data_len = len(self.label[index]) // 2  # 1개의 데이터를 self.num_samples_per_task 로
+        for i in range(2):
+            vi.append(self.video_data[index][data_len * i:data_len * (i + 1)])
+            la.append(self.label[index][data_len * i:data_len * (i + 1)])
 
-        task = PersonTask(ap, mo, la)
 
         self.dataset_transform = ClassSplitter(shuffle=False, num_train_per_class=self.num_shots_tr,
                                                num_test_per_class=self.num_shots_ts)
+
+        task = PersonTask(vi, la, len(vi))
         if self.dataset_transform is not None:
             task = self.dataset_transform(task)
 
@@ -90,28 +53,43 @@ def __getitem__(self, index):
     def __len__(self):
         return len(self.label)
 
+
 class PersonTask(Task):
-    def __init__(self, a, m ,label):
+    def __init__(self, video ,label, num_samples):
         super(PersonTask, self).__init__(None, None) # Regression task
         self.transform = transforms.Compose([transforms.ToTensor()])
-        self.a = a
-        self.m = m
+        self.video = video
         self.label = label
-        self.len_data = 0
+        self.num_samples = num_samples
 
     def __len__(self):
         return len(self.label)
 
     def __getitem__(self, index):
-        self.len_data = len(self.label[index]) // 10
-        appearance_data = torch.tensor(np.transpose(self.a[index], (0, 3, 2, 1)), dtype=torch.float32)[:self.len_data*10]
-        motion_data = torch.tensor(np.transpose(self.m[index], (0, 3, 2, 1)), dtype=torch.float32)[:self.len_data*10]
 
-        target = torch.tensor(self.label[index], dtype=torch.float32)[:self.len_data*10]
-        input = torch.cat([appearance_data, motion_data], dim=1)
+        '''
+        if index<self.num_samples:
+            video_data = np.concatenate((self.video[index], self.video[index + 1]), axis=0)
+            label_data = np.concatenate((self.label[index], self.label[index + 1]), axis=0)
+
+            video_data = torch.tensor(np.transpose(video_data, (0, 4, 1, 2, 3)), dtype=torch.float32)
+            label_data = torch.tensor(label_data, dtype=torch.float32)
+
+            if torch.cuda.is_available():
+                video_data = video_data.to('cuda:9')
+                label_data = label_data.to('cuda:9')
+
+            return video_data, label_data
+
+
+        '''
+        video_data = torch.tensor(np.transpose(self.video[index], (0, 4, 1, 2, 3)), dtype=torch.float32)
+        #video_data = torch.tensor(np.transpose(self.video[index], (3, 0, 1, 2)), dtype=torch.float32)
+        label_data = torch.tensor(self.label[index], dtype=torch.float32)
 
         if torch.cuda.is_available():
-            input = input.to('cuda:9')
-            target = target.to('cuda:9')
+            video_data = video_data.to('cuda:9')
+            label_data = label_data.to('cuda:9')
+
+        return video_data, label_data
 
-        return input, target
\ No newline at end of file
diff --git a/dataset/dataset_loader.py b/dataset/dataset_loader.py
index 8442b6b..6b7fb3c 100755
--- a/dataset/dataset_loader.py
+++ b/dataset/dataset_loader.py
@@ -5,7 +5,8 @@
 from dataset.DeepPhysDataset import DeepPhysDataset
 from dataset.PPNetDataset import PPNetDataset
 from dataset.PhysNetDataset import PhysNetDataset
-from dataset.MetaPhysDataset import MetaPhysDataset, MetaPhys_task_Dataset
+from dataset.MetaPhysDataset import MetaPhysDataset
+import random
 
 def dataset_loader(save_root_path: str = "/media/hdd1/dy_dataset/",
                    model_name: str = "DeepPhys",
@@ -103,33 +104,24 @@ def dataset_loader(save_root_path: str = "/media/hdd1/dy_dataset/",
                                   target=np.asarray(target_data)
                                   )
 
-    elif model_name == "MetaPhys_task":
-        appearance_data_all = []
-        motion_data_all = []
-        target_data_all = []
-
-        for key in hpy_file.keys(): #1, 2, ...
-            appearance_data = []
-            motion_data = []
-            target_data = []
-            for data in hpy_file[key]: #1/1, 1/2, ...
-                appearance_data.append(hpy_file[key][data]['preprocessed_video'][:, :, :, -3:])
-                motion_data.append(hpy_file[key][data]['preprocessed_video'][:, :, :, :3])
-                target_data.append(hpy_file[key][data]['preprocessed_label'][:])
-            appearance_data_all.append(appearance_data) #np.asarray(
-            motion_data_all.append(motion_data)
-            target_data_all.append(target_data)
-        hpy_file.close()
+    elif model_name == "MetaPhysNet":
+        hpy_file = h5py.File(save_root_path + model_name + "_" + dataset_name + "_" + option + ".hdf5", "r")
+        video_data = []
+        label_data = []
 
-        dataset = MetaPhys_task_Dataset(num_shots,
+        keys = list(hpy_file.keys())
+        random_keys = random.sample(keys, len(keys))
+        for key in random_keys: #subject1, subject10, ...
+            video_data.append(hpy_file[key]['preprocessed_video'])
+            label_data.append(hpy_file[key]['preprocessed_label'])
+
+        dataset = MetaPhysDataset(num_shots,
                                   num_test_shots,
-                                  option,
-                                  unsupervised,
-                                  frame_depth=10,
+                                  video_data=np.asarray(video_data[:]), # 너무 많을 때  개수 제한
+                                  label_data=np.asarray(label_data[:]),
 
-                                  appearance_data=np.asarray(appearance_data_all),
-                                  motion_data=np.asarray(motion_data_all),
-                                  target=np.asarray(target_data_all)
+                                  option=option,
+                                  unsupervised= unsupervised,
+                                  frame_depth=10
                                   )
-
     return dataset
diff --git a/main.py b/main.py
index 02f60b1..0ef4060 100755
--- a/main.py
+++ b/main.py
@@ -6,6 +6,7 @@
 
 import numpy as np
 import torch
+import torch.nn as nn
 from torch.utils.data import DataLoader, random_split
 from torchmeta.utils.data import BatchMetaDataLoader
 from tqdm import tqdm
@@ -19,7 +20,7 @@
 from utils.dataset_preprocess import preprocessing
 from utils.funcs import normalize, plot_graph, detrend
 
-from nets.models.MetaPhys import maml_train, maml_val, maml_test
+from nets.models.Meta import Meta
 
 with open('meta_params.json') as f:
     jsonObject = json.load(f)
@@ -95,13 +96,11 @@
 '''
 if __TIME__:
     start_time = time.time()
-if model_params["name"] == 'MetaPhys':
+if model_params["name"] == 'MetaPhys' or 'MetaPhysNet':
     train_loader = BatchMetaDataLoader(train_dataset, batch_size=params["train_batch_size"],
                                        shuffle=params["train_shuffle"])
     validation_loader = BatchMetaDataLoader(validation_dataset, batch_size=params["train_batch_size"],
                                             shuffle=params["train_shuffle"])
-    test_loader = BatchMetaDataLoader(test_dataset, batch_size=params["test_batch_size"],
-                                      shuffle=params["test_shuffle"])
 else:
     train_loader = DataLoader(train_dataset, batch_size=params["train_batch_size"],
                               shuffle=params["train_shuffle"])
@@ -132,8 +131,8 @@
     #     model = DataParallelModel(model, device_ids=[0, 1, 2])
     # else:
     #     model = DataParallel(model, output_device=0)
-    torch.cuda.set_device(int(options["set_gpu_device"]))
-    model.cuda()
+    device = torch.device('cuda:9')
+    model.to(device=device)
 else:
     model = model.to('cpu')
 
@@ -165,7 +164,6 @@
 if __TIME__:
     start_time = time.time()
 optimizer = optimizers(model.parameters(), hyper_params["learning_rate"], hyper_params["optimizer"])
-inner_optimizer = optimizers(model.parameters(), hyper_params["inner_learning_rate"], hyper_params["inner_optimizer"])
 scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.99)
 if __TIME__:
     log_info_time("setting optimizer time \t: ", datetime.timedelta(seconds=time.time() - start_time))
@@ -179,10 +177,10 @@
 for epoch in range(hyper_params["epochs"]):
     if __TIME__ and epoch == 0:
         start_time = time.time()
-    with tqdm(train_loader, desc="Train ", total=len(train_loader)) as tepoch:
-        if model_params["name"] == 'MetaPhys':
-            maml_train(tepoch, model, inner_criterion, outer_criterion, inner_optimizer, optimizer, meta_params["num_adapt_steps"])
-        else:
+    if model_params["name"] == 'MetaPhys' or 'MetaPhysNet':
+        Meta(model, train_loader, validation_loader, inner_criterion)
+    else:
+        with tqdm(train_loader, desc="Train ", total=len(train_loader)) as tepoch:
             model.train()
             running_loss = 0.0
             i = 0
@@ -206,13 +204,10 @@
                 running_loss += loss.item()
                 optimizer.step()
                 tepoch.set_postfix(loss=running_loss / params["train_batch_size"])
-    if __TIME__ and epoch == 0:
-        log_info_time("1 epoch training time \t: ", datetime.timedelta(seconds=time.time() - start_time))
+        if __TIME__ and epoch == 0:
+            log_info_time("1 epoch training time \t: ", datetime.timedelta(seconds=time.time() - start_time))
 
-    with tqdm(validation_loader, desc="Validation ", total=len(validation_loader)) as tepoch:
-        if model_params["name"] == 'MetaPhys':
-            maml_val(tepoch, model, inner_criterion, outer_criterion, inner_optimizer, meta_params["num_adapt_steps"])
-        else:
+        with tqdm(validation_loader, desc="Validation ", total=len(validation_loader)) as tepoch:
             model.eval()
             running_loss = 0.0
             with torch.no_grad():
@@ -241,15 +236,12 @@
                                + str(min_val_loss) + '.pth')
                     min_val_loss_model = copy.deepcopy(model)
 
-    if epoch + 1 == hyper_params["epochs"] or epoch % 10 == 0:
-        if __TIME__ and epoch == 0:
-            start_time = time.time()
-        if epoch + 1 == hyper_params["epochs"]:
-            model = min_val_loss_model
-        with tqdm(test_loader, desc="test ", total=len(test_loader)) as tepoch:
-            if model_params["name"] == 'MetaPhys':
-                maml_test(tepoch, model, inner_criterion, outer_criterion, inner_optimizer, meta_params["num_adapt_steps"])
-            else:
+        if epoch + 1 == hyper_params["epochs"] or epoch % 10 == 0:
+            if __TIME__ and epoch == 0:
+                start_time = time.time()
+            if epoch + 1 == hyper_params["epochs"]:
+                model = min_val_loss_model
+            with tqdm(test_loader, desc="test ", total=len(test_loader)) as tepoch:
                 model.eval()
                 inference_array = []
                 target_array = []
diff --git a/meta_params.json b/meta_params.json
index 8f1d3c4..a9023b1 100644
--- a/meta_params.json
+++ b/meta_params.json
@@ -4,20 +4,21 @@
     "__MODEL_SUMMARY__" : 0,
     "options":{
         "parallel_criterion" : 1,
-        "parallel_criterion_comment" : "TODO need to verification"
+        "parallel_criterion_comment" : "TODO need to verification",
+        "set_gpu_device" : "9"
     },
     "params":
     {
-        "save_root_path": "/media/hdd1/yj/dataset/",
+        "save_root_path": "/media/hdd1/yj/dataset2/",
         "data_root_path": "/media/hdd1/",
-        "dataset_name": "cohface",
+        "dataset_name": "LGGI",
         "checkpoint_path" : "/media/hdd1/yj/checkpoint/",
         "train_ratio": 0.9,
         "train_ratio_comment" : "generate train dataset using train_ratio",
-        "validation_ratio": 0.5,
+        "validation_ratio": 0.6,
         "validation_ratio_comment" : "split train dataset using validation_ratio",
         "train_batch_size" : 1,
-        "train_shuffle" : 1,
+        "train_shuffle" : 0,
         "test_batch_size" : 1,
         "test_shuffle" : 0
     },
@@ -39,8 +40,8 @@
                     "adam","sgd","rms_prop","ada_delta","ada_grad","ada_max",
                     "ada_mw","a_sgd","lbfgs","n_adam","r_adam","rprop","sparse_adam"
                 ],
-        "learning_rate": 0.001,
-        "inner_learning_rate" : 0.01,
+        "learning_rate": 0.003,
+        "inner_learning_rate" : 0.05,
         "learning_rate_comment": [
             "DeepPhys : lr = 1",
             "PhysNet : lr = 0.001",
@@ -50,26 +51,26 @@
     },
     "meta_params":
     {
-        "num_shots" : 2,
-        "num_test_shots" : 2,
+        "num_shots" : 1,
+        "num_test_shots" : 1,
         "fs" : 30,
         "fs_comment" : "sampling rate of dataset",
         "unsupervised" : 0,
         "pre_trained" : 0,
         "pre_trained_comment" : "pretrained or not",
-        "inner_loss" : "mse",
-        "outer_loss" : "mse",
+        "inner_loss" : "neg_pearson",
+        "outer_loss" : "neg_pearson",
         "num_adapt_steps" : 1
     },
     "model_params":
     {
-        "name": "MetaPhys_task",
+        "name": "MetaPhysNet",
         "name_comment":
                 [
                     "DeepPhys",
                     "PhysNet",
                     "MetaPhys",
-                    "MetaPhys_task"
+                    "MetaPhysNet"
                 ]
     }
 }
\ No newline at end of file
diff --git a/nets/models/Meta.py b/nets/models/Meta.py
new file mode 100644
index 0000000..23ec991
--- /dev/null
+++ b/nets/models/Meta.py
@@ -0,0 +1,144 @@
+"""
+Demonstrates how to:
+    * use the MAML wrapper for fast-adaptation,
+    * use the benchmark interface to load Omniglot, and
+    * sample tasks and split them in adaptation and evaluation sets.
+"""
+
+import random
+import numpy as np
+import torch
+import learn2learn as l2l
+
+from torch import nn, optim
+from tqdm import tqdm
+
+import matplotlib.pyplot as plt
+from utils.funcs import normalize,plot_graph
+
+def accuracy(predictions, targets):
+    predictions = predictions.argmax(dim=1).view(targets.shape)
+    return (predictions == targets).sum().float() / targets.size(0)
+
+
+def fast_adapt(batch, learner, loss, adaptation_steps, i , mode):
+
+    batch['train'][0] = batch['train'][0].squeeze()
+    batch['test'][0] = batch['test'][0].squeeze()
+    batch['train'][1] = batch['train'][1].squeeze()
+    batch['test'][1] = batch['test'][1].squeeze()
+
+    inference_array = []
+    target_array = []
+
+    #data, labels = batch
+    #data, labels = data.to(device), labels.to(device)
+
+    # Separate data into adaptation/evalutation sets
+    #adaptation_indices = np.zeros(data.size(0), dtype=bool)
+    #adaptation_indices[np.arange(shots*ways) * 2] = True
+    #evaluation_indices = torch.from_numpy(~adaptation_indices)
+    #adaptation_indices = torch.from_numpy(adaptation_indices)
+    #adaptation_data, adaptation_labels = data[adaptation_indices], labels[adaptation_indices]
+    #evaluation_data, evaluation_labels = data[evaluation_indices], labels[evaluation_indices]
+    adaptation_data, adaptation_labels = batch['train']
+    evaluation_data, evaluation_labels = batch['test']
+
+    # Adapt the model
+    for step in range(adaptation_steps):
+        train_error = loss(learner(adaptation_data), adaptation_labels)
+        learner.adapt(train_error)
+
+    # Evaluate the adapted model
+    predictions = learner(evaluation_data)
+    valid_error = loss(predictions, evaluation_labels)
+    #valid_accuracy = accuracy(predictions, evaluation_labels)
+
+
+
+    if mode =='test'and i % 30 == 1:
+        plt.rcParams["figure.figsize"] = (14, 5)
+        #plt.plot(peaks, np.array(inference_array)[peaks], 'xr');
+        plt.plot(normalize(predictions.cpu().detach().numpy()[0]))
+        #plt.plot(peaks2, np.array(target_array)[peaks2], 'xb');
+        plt.plot(normalize(evaluation_labels.cpu().detach().numpy()[0]))
+        plt.show()
+        #print(len(peaks), len(peaks2))
+
+    return valid_error
+
+
+def Meta(
+        model,
+        train_loader,
+        test_loader,
+        inner_criterion,
+        ways=5,
+        shots=1,
+        meta_lr=0.003,
+        fast_lr=0.5,
+        meta_batch_size=32,
+        adaptation_steps=1,
+        num_iterations=60000,
+        cuda=True,
+        seed=42,
+):
+    #random.seed(seed)
+    #np.random.seed(seed)
+    #torch.manual_seed(seed)
+
+    # Create model
+    maml = l2l.algorithms.MAML(model, lr=fast_lr, first_order=False)
+    opt = optim.Adam(maml.parameters(), meta_lr)
+    loss = inner_criterion #nn.CrossEntropyLoss(reduction='mean')
+
+    i = 0
+    with tqdm(train_loader, desc="Train ", total=len(train_loader)) as tepoch:
+    #for iteration in range(num_iterations):
+        opt.zero_grad()
+        meta_train_error = 0.0
+
+        #for task in range(meta_batch_size):
+        for batch in tepoch:
+
+            # Compute meta-training loss
+            learner = maml.clone()
+            i = 0 #i += 1
+            evaluation_error = fast_adapt(batch,
+                                                               learner,
+                                                               loss,
+                                                               adaptation_steps,
+                                                               i,'train')
+            evaluation_error.backward()
+            meta_train_error += evaluation_error.item()
+            #meta_train_accuracy += evaluation_accuracy.item()
+            tepoch.set_postfix(loss=meta_train_error)
+
+        #print('Iteration', iteration)
+        print('Meta Train Error', meta_train_error / len(tepoch))
+        #print('Meta Train Accuracy', meta_train_accuracy / len(tepoch))
+        #print('Meta Valid Error', meta_valid_error / meta_batch_size)
+        #rint('Meta Valid Accuracy', meta_valid_accuracy / meta_batch_size)
+
+        # Average the accumulated gradients and optimize
+        for p in maml.parameters():
+            p.grad.data.mul_(1.0 / len(tepoch))
+        opt.step()
+
+    meta_test_error = 0.0
+
+
+    with tqdm(test_loader, desc="Test ", total=len(test_loader)) as tepoch:
+        for batch in tepoch:
+        #for task in range(meta_batch_size):
+            # Compute meta-testing loss
+            learner = maml.clone()
+            evaluation_error = fast_adapt(batch,
+                                           learner,
+                                           loss,
+                                           adaptation_steps,
+                                           i,'test')
+            meta_test_error += evaluation_error.item()
+            i += 1
+        print('Meta Test Error', meta_test_error / len(tepoch))
+        print('\n')
diff --git a/utils/dataset_preprocess.py b/utils/dataset_preprocess.py
index aa1abcd..18ce122 100755
--- a/utils/dataset_preprocess.py
+++ b/utils/dataset_preprocess.py
@@ -111,7 +111,7 @@ def preprocess_Dataset(path, flag, model_name, dataset_name, return_dict):
         elif model_name == "PPNet":    # Sequence data based
             ppg, sbp, dbp, hr  = PPNet_preprocess_Mat(path)
 
-        if model_name in ["DeepPhys","MTTS","PhysNet","PhysNet_LSTM","MetaPhys","MetaPhysNet"]:  # can't detect face
+        if model_name in ["DeepPhys","MTTS","PhysNet","PhysNet_LSTM"]:  # can't detect face
             if not rst:
                 return
 
diff --git a/utils/image_preprocess.py b/utils/image_preprocess.py
index 31a7cad..75333e3 100755
--- a/utils/image_preprocess.py
+++ b/utils/image_preprocess.py
@@ -3,7 +3,7 @@
 from tqdm import tqdm
 from face_recognition import face_locations, face_landmarks
 from skimage.util import img_as_float
-import mediapipe as mp
+#import mediapipe as mp
 
 
 def Deepphys_preprocess_Video(path, flag):
@@ -73,8 +73,7 @@ def PhysNet_preprocess_Video(path, flag):
                 rst, crop_frame = faceDetection(frame)
                 if not rst:  # can't detect face
                     return False, None
-            if flag == 2:
-
+            elif flag == 2:
                 f, dot = crop_mediapipe(detector,frame)
                 view,remove = make_mask(dot)
                 crop_frame = generate_maks(f,view,remove)
@@ -196,7 +195,7 @@ def faceDetection(frame):
 
     if len(face_location) == 0:  # cant detect face
         print('cant detect face')
-        if locat == ():
+        if locat == (): # 기존 frame
             dst = resized_frame[resized_frame.shape[0] // 4: resized_frame.shape[0] // 4 * 3,
                   resized_frame.shape[1] // 4:resized_frame.shape[1] // 4 * 3]
         else:
@@ -403,4 +402,4 @@ def generate_maks(src, view,remove):
     return rst
 
 if __name__ == '__main__':
-    PhysNet_preprocess_Video('/media/hdd1/LGGI/alex/alex_gym/cv_camera_sensor_stream_handler.avi',1)
\ No newline at end of file
+    PhysNet_preprocess_Video('/media/hdd1/UBFC/subject20/vid.avi',1)
\ No newline at end of file