upload processed fMRI (CC2017)

CC2017-processed/all-test-allsub-fmri.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c45a6f47b768a28463429be1d91bb9c5f5b1eaa1154727a0f2c585d519bfbf6
+size 947650688

CC2017-processed/all-train-allsub-fmri.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a9241586ef305228bbace0f145b3180f142c1ef2c9a1c940e4c850a135f6314
+size 3411542144

CC2017-processed/dataset_cc2017.py

@@ -0,0 +1,158 @@
+import os
+import torch
+import random
+import decord
+decord.bridge.set_bridge('torch')
+
+import numpy as np
+
+from einops import rearrange
+
+class CC2017_fmri_video_dataset(torch.utils.data.Dataset):
+
+    def __init__(self,
+                 path,
+                 image_size=(256, 256),
+                 time_sbj=240,
+                 lag=3,
+                 window_size=2,
+                 phase='train',
+
+                 width: int = 256,
+                 height: int = 256,
+                 n_sample_frames: int = 6,
+                 sample_frame_rate: int = 10,
+
+                #  data_aug: bool = False,
+
+                 stage: str = 'fmri-video',
+
+                 load_to_memory = False,
+                 subjects = [0,1,2],
+        ):
+
+        super().__init__()
+        assert phase in ['train', 'test']
+        # if data_aug:
+        #     assert phase == 'train'
+        
+        self.fmri_frames = 246
+        self.subjects = subjects
+        if phase == 'train':
+            self.segments = 18
+            self.records = 2
+            self.str = 'seg'
+        else:
+            self.segments = 5
+            self.records = 10
+            self.str = 'test'
+        self.time_per_sbj = time_sbj
+        self.len = 1 * self.segments * self.time_per_sbj # * self.records
+        self.phase = phase
+        self.stage = stage
+        # self.data_aug = data_aug
+        # if self.data_aug:
+        #     print('using data augmentation.')
+        #     self.image_transform = transforms.Compose([
+        #         random_crop(round(image_size[0] * 0.8), p=0.5),
+        #         transforms.Resize(image_size),
+        #     ])
+        
+        print('start load ' + phase + ' dataset\nstage : ' + self.stage)
+
+        #################### prompt #####################
+
+        self.frame_level_prompt = np.load(os.path.join(path, 'stimuli/text_%s_256_3hz.npy' % phase))
+        print('prompt load finished.')
+
+        #################### video #####################
+
+        self.width = width
+        self.height = height
+        self.n_sample_frames = n_sample_frames
+        self.sample_frame_rate = sample_frame_rate
+        self.video_data = []
+        self.load_to_memory = load_to_memory
+        if self.load_to_memory:
+            for segid in range(1, self.segments+1):
+                print(f'video loading ... {segid}/{self.segments}')
+                self.video_data.append([])
+                video = decord.VideoReader(os.path.join(path, 'stimuli/%s%d.mp4' % (self.str, segid)), width=self.width, height=self.height)
+                for sampleid in range(self.time_per_sbj):
+                    sample_index = [int((sampleid * n_sample_frames + i) * sample_frame_rate) for i in range(n_sample_frames)]
+                    sample = video.get_batch(sample_index)
+                    sample = rearrange(sample, "f h w c -> f c h w")
+                    self.video_data[-1].append(sample.numpy())
+                del video
+            self.video_data = (np.array(self.video_data) / 127.5 - 1.0).astype(np.float16)
+        else:
+            for segid in range(1, self.segments+1):
+                video = decord.VideoReader(os.path.join(path, 'stimuli/%s%d.mp4' % (self.str, segid)), width=self.width, height=self.height)
+                self.video_data.append(video)
+
+        print('video load finished.')
+
+        #################### fmri #####################
+
+        self.image_size = image_size # (H, W)
+        self.lag = lag
+        self.window_size = window_size
+
+        self.path = path
+
+        self.fmri_data = np.load(os.path.join(path, f'./all-{phase}-allsub-fmri.npy'))
+        print('fmri load finished.')
+    
+        self.records = 1
+
+        self.aver_fmri = 0.0 * self.__getitem__(0)['image'][0]
+
+    def __len__(self):
+        return self.len
+
+    def getIndex(self, index):
+        subid = index // (self.segments * self.records * self.time_per_sbj)
+        index %= (self.segments * self.records * self.time_per_sbj)
+        segid = index // (self.records * self.time_per_sbj)
+        index %= (self.records * self.time_per_sbj)
+        recid = index // self.time_per_sbj
+        index %= self.time_per_sbj
+        timid = index
+        promptid = segid * self.time_per_sbj + timid
+        return subid, segid, recid, timid, promptid
+
+    def __getitem__(self, index):
+        subid, segid, recid, timid, promptid = self.getIndex(index)
+
+        frame_id = random.randint(0, self.n_sample_frames-1)
+        text_prompt = self.frame_level_prompt[segid, timid, frame_id]
+
+        sample_index = [int((timid * self.n_sample_frames + i) * self.sample_frame_rate) for i in range(self.n_sample_frames)]
+        if self.stage == 'fmri-text':
+            sample_index = [sample_index[frame_id]]
+
+        if self.load_to_memory:
+            video = self.video_data[segid, timid]
+            video = torch.from_numpy(video)
+        else:
+            video = self.video_data[segid].get_batch(sample_index)
+            video = rearrange(video, "f h w c -> f c h w")
+            video = video / 127.5 - 1.0
+
+        if self.stage == 'fmri-text':
+            if self.load_to_memory:
+                video = video[frame_id]
+            else:
+                video = video[0]
+            # rescale [-1, 1] to [0, 1]
+            video = (video + 1) / 2
+        
+        fmri = self.fmri_data[self.subjects][:,segid, recid, timid : timid + self.window_size]
+        fmri = torch.from_numpy(fmri)[:, :, None]
+
+        # if self.data_aug:
+        #     video = self.image_transform(video)
+        #     text_prompt = self.text_transform(text_prompt)
+        
+        item = {'text_prompt': text_prompt, 'pixel_values': video, 'image': fmri}
+        return item

CC2017-processed/stimuli/text_test_256_3hz.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aeb8af4eb85e7d2c8f75bb957335d7bb370c1542dff8e5b338dd8fc44b1d1ee3
+size 2505728

CC2017-processed/stimuli/text_train_256_3hz.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d932466ac9251013def65d029a0443b55c9a114a6d9e4866fd1de38a7cf8ee3
+size 13789568

CC2017-processed/vc_roi.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc5a6ff1889ccd128ee3a703cb49c64a805d6719cc8f0cef303334d1df3323ad
+size 30589