Upload folder using huggingface_hub

README.md

@@ -0,0 +1,98 @@
+This repository contains **ViSpeR**, a large-scale dataset for Visual Speech Recognition for Arabic, Chinese, French and Spanish.
+
+## Dataset Summary:
+
+Given the scarcity of publicly available VSR data for non-English languages, we collected VSR data for the most four spoken languages at scale.
+
+
+Comparison of VSR datasets. Our proposed ViSpeR dataset is larger in size compared to other datasets that cover non-English languages for the VSR task. For our dataset, the numbers in parenthesis denote the number of clips. We also give the clip coverage under TedX and Wild subsets of our ViSpeR dataset.
+![Lip2Vec Illustration](visper_stats.png)
+
+
+## Downloading the data:
+
+First, use the langauge.json to download the videos and put them in seperate folders. The raw data should be structured as follows:
+```bash
+Data/
+├── Chinese/
+│ ├── video_id.mp4
+│ └── ...
+├── Arabic/
+│ ├── video_id.mp4
+│ └── ...
+├── French/
+│ ├── video_id.mp4
+│ └── ...
+├── Spanish/
+│ ├── video_id.mp4
+│ └── ...
+
+```
+
+## Setup:
+
+1- Setup the environement:
+ ```bash
+conda create --name visper python=3.10
+conda activate visper
+pip install -r requirements.txt
+```
+
+2- Install ffmpeg:
+ ```bash
+conda install "ffmpeg<5" -c conda-forge
+```
+
+## Processing the data:
+
+Then, use the provided metadata to process the raw data for creating the ViSpeR dataset. You can use the ```crop_videos.py``` to process the data, note that all clips are cropped and transformed
+
+python crop_videos.py --video_dir [path_to_data_language] --save_path [save_path_language] --json [language_metadata.json] --use_ffmpeg True
+```
+
+```bash
+ViSpeR/
+├── Chinese/
+│ ├── video_id/
+│ │  │── 00001.mp4
+│ │  │── 00001.json
+│ └── ...
+├── Arabic/
+│ ├── video_id/
+│ │  │── 00001.mp4
+│ │  │── 00001.json
+│ └── ...
+├── French/
+│ ├── video_id/
+│ │  │── 00001.mp4
+│ │  │── 00001.json
+│ └── ...
+├── Spanish/
+│ ├── video_id/
+│ │  │── 00001.mp4
+│ │  │── 00001.json
+│ └── ...
+
+```
+
+The ```video_id/xxxx.json``` has the 'label' of the corresponding video ```video_id/xxxx.mp4```.
+
+
+
+## Intended Use
+
+This dataset can be used to train models for visual speech recognition. It's particularly useful for research and development purposes in the field of audio-visual content processing. The data can be used to assess the performance of current and future models.
+
+## Limitations and Biases
+Due to the data collection process focusing on YouTube, biases inherent to the platform may be present in the dataset. Also, while measures are taken to ensure diversity in content, the dataset might still be skewed towards certain types of content due to the filtering process.
+
+
+## Citation
+```bash
+@article{djilali2023vsr,
+  title={Do VSR Models Generalize Beyond LRS3?},
+  author={Djilali, Yasser Abdelaziz Dahou and Narayan, Sanath and Bihan, Eustache Le and Boussaid, Haithem and Almazrouei, Ebtessam and Debbah, Merouane},
+  journal={arXiv preprint arXiv:2311.14063},
+  year={2023}
+}
+```

crop_videos.py

@@ -0,0 +1,105 @@
+import json
+import numpy as np
+import os
+from tqdm import tqdm
+import subprocess
+from glob import glob
+import argparse
+import time
+from utils import crop_video, crop_face, write_video, crop_and_save_audio
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+import sys
+
+
+'''
+Crop the untrimmed videos into multiple clips using corresponding start and end times, bounding boxes and face landmarks.
+
+Usage: 
+python crop_videos.py --video_dir /path/to/25-fps-videos --save_path /path/to/save/the/clips --json /path/to/json/file
+
+To save videos using ffmpeg, add "--use_ffmpeg True". This takes additional time but saves disk space.
+
+To additionally save audio as separate wav files, add "--save_audio True"
+
+To merge audio with video and save as a single mp4, add "--merge_audio True"
+'''
+
+
+def write_clip(metadata, vid_p, args):
+    '''
+    param metadata: dict containing start, end, bounding boxes, landmarks
+    param vid_p: path to original untrimmed video at 25fps
+    param args: main args 
+    '''
+    for k, clip in enumerate(metadata):
+        # get the clip frames and corresponding landmarks
+        video, landmarks = crop_video(vid_p, clip)
+        # get the cropped sequence around the mouth using the landmarks
+        crop_seq = crop_face(video, landmarks)
+        save_video_path = os.path.join(args.save_path, 'videos', vid_p.split('/')[-1][:-4], f'{str(k).zfill(5)}.mp4')
+        save_audio_path = save_video_path.replace('.mp4','.wav')
+        # get the audio part of the clip
+        if args.save_audio or args.merge_audio:
+            crop_and_save_audio(vid_p, save_audio_path, clip['start'], clip['end'])
+        # write clip to disk
+        write_video(save_video_path, crop_seq, save_audio_path, merge_audio=args.merge_audio, use_ffmpeg=args.use_ffmpeg)
+    return 
+
+
+def main(args):
+    savepath = args.save_path
+    json_path = args.json
+    vid_dir = args.video_dir
+
+    video_list = glob(os.path.join(vid_dir, '25_fps_videos*', '*.mp4'))
+    print(f'Loading json file {json_path}')
+    data = json.load(open(json_path,'r'))
+    print(f'Total number of videos {len(video_list)}. Json length {len(data)}')
+    video_ids = list(data.keys())
+    count_clips = 0
+
+    futures = []
+    writer_str = 'Ffmpeg' if args.use_ffmpeg else 'cv2.VideoWriter'
+    print(f'Using {writer_str} to save the cropped clips.')
+    
+    with tqdm(total=len(video_ids), file=sys.stdout) as progress:
+        with ProcessPoolExecutor() as executor:
+            for z in video_ids:
+                idx = [k for k, i in enumerate(video_list) if z in i]        
+                metadata = data[z]
+                vid_p = video_list[idx[0]]
+                os.makedirs(os.path.join(savepath, 'videos', vid_p.split('/')[-1][:-4]), exist_ok=True)
+                future = executor.submit(write_clip, metadata, vid_p, args)
+                futures.append(future)
+
+            for _ in as_completed(futures):
+                progress.update()
+                    
+    print(f'Cropping videos completed.')
+    print(f'Getting the labels.')
+    labels = {}
+    for z in tqdm(video_ids):
+        metadata = data[z]
+        for k, clip in enumerate(metadata):
+            labk = clip['label']
+            fi = os.path.join('videos', vid_p.split('/')[-1][:-4], f'{str(k).zfill(5)}.mp4')
+            labels[fi] = labk
+    label_file = f'{args.save_path}/labels.json'
+    with open(label_file, 'w', encoding='utf-8') as f:
+        json.dump(labels, f)
+    
+        
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Vhisper crop videos')
+    parser.add_argument('--save_path', type=str, default='', help='Path for saving.')
+    parser.add_argument('--json', type=str, default='', help='Json path')
+    parser.add_argument('--video_dir', type=str, default='', help='Path to directory where original videos are stored.')
+    parser.add_argument('--save_audio', type=bool, default=False, help='Whether to save audio info.')
+    parser.add_argument('--merge_audio', type=bool, default=False, help='Whether to merge audio with the video when saving.')
+    parser.add_argument('--use_ffmpeg', type=bool, default=False, help='Whether to use ffmpeg instead of cv2 for saving the video.')
+    
+    args = parser.parse_args()
+    tic = time.time()
+    main(args)
+    print(f'Elpased total time for processing: {time.time()-tic} seconds')

requirements.txt

@@ -0,0 +1,6 @@
+python-speech-features==0.6
+scipy==1.10.0
+opencv-python==4.5.4.60
+sentencepiece==0.1.96
+editdistance==0.6.0
+numpy

train.tar.gz

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

utils.py

@@ -0,0 +1,262 @@
+import cv2
+import numpy as np
+from scipy import signal
+import os
+import subprocess 
+import tempfile
+
+CROP_SCALE = 0.4
+WINDOW_MARGIN = 12
+START_IDX, STOP_IDX = 3, 5
+STABLE_POINTS = (36, 45, 33, 48, 54)
+CROP_HEIGHT, CROP_WIDTH = 96, 96
+
+# PATH='/home/users/u100438/home200093/dataset_release/'
+REFERENCE = np.load(os.path.join( os.path.dirname(__file__), '20words_mean_face.npy'))
+
+
+def crop_and_save_audio(mp4_path: str, saving_path:str, start_audio: float, end_audio: float) -> None:
+    """
+    Crops original audio corresponding to the start and end time.
+    Saves it as wav file with single channel and 16kHz sampling rate.
+    
+    :param mp4_path: str, path to original video.
+    :param saving_path: str, path where audio will be saved. SHOULD END WITH .wav
+    :param start_audio: float, start time of clip in seconds
+    :param end_audio: float, end time of clip in seconds
+    :return: None.
+    """
+
+    # write audio.
+    command = f"ffmpeg -loglevel error -y -i {mp4_path} -ss {start_audio} -to {end_audio} -vn -acodec pcm_s16le -ar 16000 -ac 1 {saving_path}"
+    subprocess.call(command, shell=True)
+
+
+
+def crop_video(vid_path: str, clip_data: dict):
+    '''
+    Reads the video frames of video (in vid_path) between clip_data['start'] and clip_data['end'] times.
+    Crops the faces in these frames using bounding boxes given by clip_data['bboxs']
+    Returns sequence of faces and clip['landmarks'] aligned to 224x224 resolution.
+    '''
+    cap = cv2.VideoCapture(vid_path)
+
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    num_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    start_frame, end_frame = round(clip_data['start']*25), round(clip_data['end']*25)
+    clip_frames = end_frame - start_frame
+    assert end_frame <= num_frames, f'End frame ({end_frame}) exceeds total number of frames ({num_frames})'
+    
+    landmarks_n, bboxs_n = np.array(clip_data['landmarks']), np.array(clip_data['bboxs'])
+    bboxs = np.multiply(bboxs_n, [frame_width, frame_height, frame_width, frame_height])
+    landmarks =  np.multiply(landmarks_n, [frame_width, frame_height])   
+    assert len(landmarks) == clip_frames, f'Landmarks length ({len(landmarks)}) does not match the number of frames in the clip ({clip_frames})'
+    
+    dets = {'x':[], 'y':[], 's':[]}
+    for det in bboxs:
+        dets['s'].append(max((det[3]-det[1]),(det[2]-det[0]))/2)     
+        dets['y'].append((det[1]+det[3])/2) # crop center x     
+        dets['x'].append((det[0]+det[2])/2) # crop center y
+    
+    # Smooth detections  
+    dets['s'] = signal.medfilt(dets['s'],kernel_size=13)     
+    dets['x'] = signal.medfilt(dets['x'],kernel_size=13)  
+    dets['y'] = signal.medfilt(dets['y'],kernel_size=13)
+    
+    image_seq = []
+    current_frame = start_frame
+    cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+    
+    while current_frame < end_frame:
+        ret, frame = cap.read()
+        count = current_frame - start_frame
+        current_frame += 1
+
+        if not ret:
+            break
+    
+        bs  = dets['s'][count]   # Detection box size   
+        bsi = int(bs*(1+2*CROP_SCALE))  # Pad videos by this amount 
+        
+        image = frame
+        lands = landmarks[count]
+        
+        frame_ = np.pad(image,((bsi,bsi),(bsi,bsi),(0,0)), 'constant', constant_values=(110,110))    
+        my  = dets['y'][count]+bsi  # BBox center Y    
+        mx  = dets['x'][count]+bsi  # BBox center X
+        
+        face = frame_[int(my-bs):int(my+bs*(1+2*CROP_SCALE)),int(mx-bs*(1+CROP_SCALE)):int(mx+bs*(1+CROP_SCALE))]
+
+        ## lands translation and scaling
+        lands[:,0] -= int(mx-bs*(1+CROP_SCALE) - bsi) 
+        lands[:,1] -= int(my - bs - bsi) 
+        lands[:,0] *= (224/face.shape[1])
+        lands[:,1] *= (224/face.shape[0])
+        
+        image_seq.append(cv2.resize(face,(224,224)))
+            
+    image_seq = np.array(image_seq)
+    
+    return image_seq, landmarks
+
+
+
+def landmarks_interpolate(landmarks):
+        """landmarks_interpolate.
+
+        :param landmarks: List, the raw landmark (in-place)
+        """
+        valid_frames_idx = [idx for idx, _ in enumerate(landmarks) if _ is not None]
+        if not valid_frames_idx:
+            return None
+        for idx in range(1, len(valid_frames_idx)):
+            if valid_frames_idx[idx] - valid_frames_idx[idx-1] == 1:
+                continue
+            else:
+                landmarks = linear_interpolate(landmarks, valid_frames_idx[idx-1], valid_frames_idx[idx])
+        valid_frames_idx = [idx for idx, _ in enumerate(landmarks) if _ is not None]
+        # -- Corner case: keep frames at the beginning or at the end failed to be detected.
+        if valid_frames_idx:
+            landmarks[:valid_frames_idx[0]] = [landmarks[valid_frames_idx[0]]] * valid_frames_idx[0]
+            landmarks[valid_frames_idx[-1]:] = [landmarks[valid_frames_idx[-1]]] * (len(landmarks) - valid_frames_idx[-1])
+        valid_frames_idx = [idx for idx, _ in enumerate(landmarks) if _ is not None]
+        assert len(valid_frames_idx) == len(landmarks), "not every frame has landmark"
+        return landmarks
+
+
+def crop_patch(image_seq, landmarks):
+        """crop_patch.
+
+        :param video_pathname: str, the filename for the processed video.
+        :param landmarks: List, the interpolated landmarks.
+        """
+        frame_idx = 0
+        sequence = []
+        for frame in image_seq:
+            
+            window_margin = min(WINDOW_MARGIN // 2, frame_idx, len(landmarks) - 1 - frame_idx)
+            smoothed_landmarks = np.mean([landmarks[x] for x in range(frame_idx - window_margin, frame_idx + window_margin + 1)], axis=0)
+            smoothed_landmarks += landmarks[frame_idx].mean(axis=0) - smoothed_landmarks.mean(axis=0)
+            transformed_frame, transformed_landmarks = affine_transform(frame, smoothed_landmarks, REFERENCE)
+            sequence.append( cut_patch( transformed_frame, transformed_landmarks[START_IDX : STOP_IDX], CROP_HEIGHT//2, CROP_WIDTH//2,))
+            frame_idx += 1
+
+        return np.array(sequence)
+
+def affine_transform(frame, landmarks, reference,
+        target_size=(256, 256),
+        reference_size=(256, 256),
+        stable_points=STABLE_POINTS,
+        interpolation=cv2.INTER_LINEAR,
+        border_mode=cv2.BORDER_CONSTANT,
+        border_value=0
+    ):
+        """affine_transform.
+
+        :param frame: numpy.array, the input sequence.
+        :param landmarks: List, the tracked landmarks.
+        :param reference: numpy.array, the neutral reference frame.
+        :param target_size: tuple, size of the output image.
+        :param reference_size: tuple, size of the neural reference frame.
+        :param stable_points: tuple, landmark idx for the stable points.
+        :param interpolation: interpolation method to be used.
+        :param border_mode: Pixel extrapolation method .
+        :param border_value: Value used in case of a constant border. By default, it is 0.
+        """
+
+        lands = [landmarks[x] for x in range(5)]
+            
+        stable_reference = np.vstack([reference[x] for x in stable_points])
+        stable_reference[:, 0] -= (reference_size[0] - target_size[0]) / 2.0
+        stable_reference[:, 1] -= (reference_size[1] - target_size[1]) / 2.0
+
+        # Warp the face patch and the landmarks
+        transform = cv2.estimateAffinePartial2D(np.vstack(lands), stable_reference, method=cv2.LMEDS)[0]
+        transformed_frame = cv2.warpAffine(
+            frame,
+            transform,
+            dsize=(target_size[0], target_size[1]),
+            flags=interpolation,
+            borderMode=border_mode,
+            borderValue=border_value,
+        )
+        transformed_landmarks = np.matmul(landmarks, transform[:, :2].transpose()) + transform[:, 2].transpose()
+
+        return transformed_frame, transformed_landmarks
+    
+    
+def cut_patch(img, landmarks, height, width, threshold=5):
+    """cut_patch.
+
+    :param img: ndarray, an input image.
+    :param landmarks: ndarray, the corresponding landmarks for the input image.
+    :param height: int, the distance from the centre to the side of of a bounding box.
+    :param width: int, the distance from the centre to the side of of a bounding box.
+    :param threshold: int, the threshold from the centre of a bounding box to the side of image.
+    """
+    center_x, center_y = np.mean(landmarks, axis=0)
+
+    if center_y - height < 0:                                                
+        center_y = height                                                    
+    if center_y - height < 0 - threshold:                                    
+        raise Exception('too much bias in height')                           
+    if center_x - width < 0:                                                 
+        center_x = width                                                     
+    if center_x - width < 0 - threshold:                                     
+        raise Exception('too much bias in width')                            
+                                                                             
+    if center_y + height > img.shape[0]:                                     
+        center_y = img.shape[0] - height                                     
+    if center_y + height > img.shape[0] + threshold:                         
+        raise Exception('too much bias in height')                           
+    if center_x + width > img.shape[1]:                                      
+        center_x = img.shape[1] - width                                      
+    if center_x + width > img.shape[1] + threshold:                          
+        raise Exception('too much bias in width')                            
+                                                                             
+    cutted_img = np.copy(img[ int(round(center_y) - round(height)): int(round(center_y) + round(height)),
+                         int(round(center_x) - round(width)): int(round(center_x) + round(width))])
+    return cutted_img
+
+
+def crop_face(image_seq, landmarks):
+    # Interpolate the landmarks
+    preprocessed_landmarks = landmarks_interpolate(list(landmarks))
+    # crop the face to obtain a sequence of 96x96 sized mouth rois
+    crop_seq = crop_patch(image_seq, preprocessed_landmarks)
+    
+    return crop_seq
+
+def merge_audio_video(tmp_path, audio_path, save_video_path):
+    # Will merge the corresponding audio and video tracks of the clip. The associated .wav file will be removed.
+    command = f"ffmpeg -loglevel error -y -i {tmp_path} -i {audio_path} -c:v libx264 -c:a aac -ar 16000 -ac 1 {save_video_path}"
+    tval = subprocess.call(command, shell=True)
+    tval = subprocess.call(f'rm {tmp_path}', shell=True)
+    tval = subprocess.call(f'rm {audio_path}', shell=True)
+
+def convert_ffmpeg(vid_path):
+    # converts the mpeg4 video to h264 using ffmpeg. Saves disk space, but takes additional time
+    tmp_path = vid_path[:-4] + 'temp2.mp4'
+    cmd = f"cp {vid_path} {tmp_path}"
+    tval = subprocess.call(cmd, shell=True)
+    cmd = f"ffmpeg -loglevel error -i {tmp_path} -r 25 -vcodec libx264 -q:v 1 -y {vid_path}"
+    tval = subprocess.call(cmd, shell=True)
+    tval = subprocess.call(f"rm {tmp_path}", shell=True)
+    
+    
+def write_video(save_video_path, crop_seq, audio_path=None, merge_audio=False, use_ffmpeg=False):
+    # Writes the clip video to disk. Merges with audio if enabled
+    tmp_path = save_video_path.replace('.mp4','_temp.mp4') if merge_audio else save_video_path
+    vid_writer = cv2.VideoWriter(tmp_path, cv2.VideoWriter_fourcc(*'mp4v'), 25, (96, 96))
+    for ci in crop_seq: 
+        vid_writer.write(ci)
+    vid_writer.release()
+    if use_ffmpeg and not merge_audio:
+        convert_ffmpeg(tmp_path)
+        
+    if merge_audio:
+        merge_audio_video(tmp_path, audio_path, save_video_path)
+        
+
+