Following this instruction : 1. Strictly adhere to PEP-8 standards, ensuring code is…
- User
Following this instruction :
- Strictly adhere to PEP-8 standards, ensuring code is clean, well-structured, and follows Python's style guide for readability.
- Use appropriate modules like
typingfor type hints, ensuring code clarity, maintainability, and leveraging Python's standard libraries effectively. - Focus on time, space, robustness, scalability; write optimized, efficient code that can handle large datasets and scale seamlessly.
- Implement comprehensive error handling, catching exceptions gracefully, providing meaningful error messages, and ensuring code robustness under unexpected conditions.
- Ensure the developer agent writes advanced, maintainable Python code, balancing performance and readability while adhering to best practices.
TASK:
using all below api make generalised , reusable, robustness, stability most novel and very advanced , (keep in the mind * , ** all arguments access to the user)
- datasets module : we should able make generalised dataset loader video , caption : may be any splits , any number of columns , (str , list(str) dic(str, list(str) ) column nature
video ,path of absolute path or may be https:// link
loading should properly all columns properly
2)transformers module : Autotokenizer api
make robustness tokenization : special tokenization , bos, eos, special token, max_lenth padding batch encode , batch decode decode , encode
- using torchvision module , , transformers, loading ( any extension keep this in the mind)
- properly dataset collection , mixing dataset , continue datset for day of day training , datacollection, dataloader
from torch.utils.data.dataset import ( ChainDataset, ConcatDataset, Dataset,)
DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, *, prefetch_factor=2, persistent_workers=False)
- Assistant
import logging import os import tempfile from io import BytesIO from typing import Any, Callable, Dict, List, Optional, Union import requests import torch from torch.utils.data import ChainDataset, ConcatDataset, DataLoader, Dataset from torchvision.io import read_video from transformers import AutoTokenizer, PreTrainedTokenizer # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) class GeneralizedVideoCaptionDataset(Dataset): """ A generalized dataset loader for video-caption data. Supports any number of splits, columns, and data formats. """ def __init__( self, data: List[Dict[str, Any]], video_column: str, caption_column: str, tokenizer: PreTrainedTokenizer, max_length: Optional[int] = None, padding: Union[bool, str] = False, truncation: bool = True, special_tokens: Optional[Dict[str, str]] = None, transform: Optional[Callable[[torch.Tensor], torch.Tensor]] = None, *args, **kwargs ): """ Initialize the dataset. Args: data (List[Dict[str, Any]]): List of data entries. video_column (str): Key for video paths in data entries. caption_column (str): Key for captions in data entries. tokenizer (PreTrainedTokenizer): Tokenizer for captions. max_length (Optional[int]): Max tokenization length. padding (Union[bool, str]): Padding strategy. truncation (bool): If True, truncate sequences. special_tokens (Optional[Dict[str, str]]): Special tokens. transform (Optional[Callable]): Transform function for videos. *args: Additional arguments. **kwargs: Additional keyword arguments. """ self.data = data self.video_column = video_column self.caption_column = caption_column self.tokenizer = tokenizer self.max_length = max_length self.padding = padding self.truncation = truncation self.special_tokens = special_tokens or {} self.transform = transform # Add special tokens to the tokenizer if self.special_tokens: special_tokens_dict = {'additional_special_tokens': list(self.special_tokens.values())} num_added_toks = self.tokenizer.add_special_tokens(special_tokens_dict) logger.info(f"Added {num_added_toks} special tokens.") def __len__(self) -> int: return len(self.data) def __getitem__(self, idx: int) -> Dict[str, Any]: entry = self.data[idx] video_path = entry.get(self.video_column) captions = entry.get(self.caption_column) if not video_path: raise ValueError(f"No video path found for index {idx} in column '{self.video_column}'.") if not captions: raise ValueError(f"No caption found for index {idx} in column '{self.caption_column}'.") video = self._load_video(video_path) if self.transform: video = self.transform(video) tokenized_captions = self._tokenize_captions(captions) additional_columns = {k: v for k, v in entry.items() if k not in [self.video_column, self.caption_column]} return {'video': video, 'captions': tokenized_captions, **additional_columns} def _load_video(self, video_path: str) -> torch.Tensor: """ Load a video from a path or URL. Args: video_path (str): Local path or URL to the video. Returns: torch.Tensor: Video tensor. Raises: ValueError: If the video cannot be loaded. """ try: if video_path.startswith(('http://', 'https://')): logger.info(f"Downloading video from URL: {video_path}") response = requests.get(video_path, stream=True) response.raise_for_status() with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(video_path)[1]) as tmp_file: for chunk in response.iter_content(chunk_size=8192): tmp_file.write(chunk) temp_video_path = tmp_file.name video, _, _ = read_video(temp_video_path) os.remove(temp_video_path) else: video, _, _ = read_video(video_path) return video except Exception as e: logger.error(f"Error loading video from {video_path}: {e}") raise ValueError(f"Error loading video from {video_path}: {e}") from e def _tokenize_captions( self, captions: Union[str, List[str], Dict[str, Union[str, List[str]]]] ) -> Dict[str, torch.Tensor]: """ Tokenize captions. Args: captions: Captions to tokenize. Returns: Dict[str, torch.Tensor]: Tokenized captions. Raises: ValueError: If tokenization fails. """ try: if isinstance(captions, str): captions = [captions] elif isinstance(captions, dict): captions = [v for v in captions.values() if isinstance(v, (str, list))] tokenized = self.tokenizer( captions, max_length=self.max_length, padding=self.padding, truncation=self.truncation, return_tensors='pt', ) return tokenized except Exception as e: logger.error(f"Error tokenizing captions: {e}") raise ValueError(f"Error tokenizing captions: {e}") from e def batch_encode(self, texts: List[str], *args, **kwargs) -> Dict[str, torch.Tensor]: """ Batch encode texts. Args: texts (List[str]): Texts to encode. *args: Additional arguments. **kwargs: Additional keyword arguments. Returns: Dict[str, torch.Tensor]: Encoded texts. """ return self.tokenizer( texts, max_length=self.max_length, padding=self.padding, truncation=self.truncation, return_tensors='pt', *args, **kwargs, ) def batch_decode(self, token_ids: torch.Tensor, *args, **kwargs) -> List[str]: """ Batch decode token IDs. Args: token_ids (torch.Tensor): Token IDs to decode. *args: Additional arguments. **kwargs: Additional keyword arguments. Returns: List[str]: Decoded texts. """ return self.tokenizer.batch_decode(token_ids, *args, **kwargs) def create_data_loader( dataset: Dataset, batch_size: int = 1, shuffle: bool = False, sampler: Optional[Any] = None, batch_sampler: Optional[Any] = None, num_workers: int = 0, collate_fn: Optional[Callable[[List[Any]], Any]] = None, pin_memory: bool = False, drop_last: bool = False, timeout: float = 0, worker_init_fn: Optional[Callable[[int], None]] = None, prefetch_factor: int = 2, persistent_workers: bool = False, *args, **kwargs ) -> DataLoader: """ Create a DataLoader with the specified parameters. Args: dataset (Dataset): Dataset to load. batch_size (int): Batch size. shuffle (bool): Shuffle data. sampler: Sampler instance. batch_sampler: BatchSampler instance. num_workers (int): Number of worker threads. collate_fn (Optional[Callable]): Collate function. pin_memory (bool): Pin memory. drop_last (bool): Drop last batch if incomplete. timeout (float): Timeout for collecting batch. worker_init_fn (Optional[Callable]): Worker init function. prefetch_factor (int): Number of samples prefetched. persistent_workers (bool): Keep workers alive. *args: Additional arguments. **kwargs: Additional keyword arguments. Returns: DataLoader: Configured DataLoader. """ return DataLoader( dataset, batch_size=batch_size, shuffle=shuffle, sampler=sampler, batch_sampler=batch_sampler, num_workers=num_workers, collate_fn=collate_fn, pin_memory=pin_memory, drop_last=drop_last, timeout=timeout, worker_init_fn=worker_init_fn, prefetch_factor=prefetch_factor, persistent_workers=persistent_workers, *args, **kwargs, ) def collate_fn(batch: List[Dict[str, Any]]) -> Dict[str, Any]: """ Custom collate function to handle variable-sized data. Args: batch (List[Dict[str, Any]]): List of samples. Returns: Dict[str, Any]: Batch with padded sequences. """ videos = [item['video'] for item in batch] captions = [item['captions'] for item in batch] additional_keys = set(batch[0].keys()) - {'video', 'captions'} additional_data = {key: [item[key] for item in batch] for key in additional_keys} # Pad videos (assuming videos are tensors of shape [T, H, W, C]) padded_videos = torch.nn.utils.rnn.pad_sequence( [v.permute(0, 3, 1, 2) for v in videos], batch_first=True ) # Output shape: [B, T, C, H, W] # Pad captions input_ids = torch.nn.utils.rnn.pad_sequence( [c['input_ids'].squeeze(0) for c in captions], batch_first=True, padding_value=0 ) attention_mask = torch.nn.utils.rnn.pad_sequence( [c['attention_mask'].squeeze(0) for c in captions], batch_first=True, padding_value=0 ) merged_captions = {'input_ids': input_ids, 'attention_mask': attention_mask} return {'video': padded_videos, 'captions': merged_captions, **additional_data} # Example usage: # Initialize tokenizer tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') # Example data data_entries = [ { 'video_path': '/path/to/video1.mp4', 'captions': 'A cat sitting on the mat.', 'additional_info': 'Sample 1', }, { 'video_path': 'https://example.com/video2.mp4', 'captions': ['A dog playing with a ball.', 'The dog is happy.'], 'additional_info': 'Sample 2', }, ] # Create dataset dataset = GeneralizedVideoCaptionDataset( data=data_entries, video_column='video_path', caption_column='captions', tokenizer=tokenizer, max_length=128, padding='max_length', special_tokens={'eos_token': '[EOS]'}, ) # Create DataLoader data_loader = create_data_loader( dataset, batch_size=2, shuffle=True, num_workers=4, collate_fn=collate_fn, pin_memory=True, drop_last=False, prefetch_factor=2, persistent_workers=True, )
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.