File size: 6,998 Bytes
13e95c8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | import torch
from typing import NewType, get_origin, get_args, Union
import attr
# Create distinct types that can be distinguished at runtime
LogitsType = NewType('LogitsType', torch.Tensor) # Tensor of Float, [N, C]
EmbeddingType = NewType('EmbeddingType', torch.Tensor) # Tensor of Float, [N, D]
PairwiseEmbeddingType = NewType('PairwiseEmbeddingType', torch.Tensor) # Tensor of Float, [N, N, D]
MaskType = NewType('MaskType', torch.Tensor) # Tensor of Boolean, [N, ...]
IndexType = NewType('IndexType', torch.Tensor) # Tensor of Integer, [N]
OneHotType = NewType('OneHotType', torch.Tensor) # Tensor of Integer, [N, ...]
FlagType = NewType('FlagType', torch.Tensor) # Tensor of Integer, [N, ...] nn.Embedding
FeatureType = NewType('FeatureType', torch.Tensor) # Tensor of Float, [N, D] nn.Linear
def to_mask_type(tensor: torch.Tensor) -> MaskType:
"""Convert tensor to boolean mask type"""
return tensor.bool()
def to_index_type(tensor: torch.Tensor) -> IndexType:
"""Convert tensor to integer index type, preserving existing integer types"""
if tensor.dtype in [torch.float32, torch.float16, torch.bfloat16, torch.bool]:
return tensor.long()
return tensor # Keep existing integer types (int32, int64)
def to_embedding_type(tensor: torch.Tensor) -> EmbeddingType:
"""Convert tensor to float embedding type, preserving bf16/fp16"""
if tensor.dtype in [torch.int32, torch.int64, torch.long, torch.bool]:
return tensor.float()
return tensor
def to_onehot_type(tensor: torch.Tensor) -> OneHotType:
"""Convert tensor to integer one-hot type"""
if tensor.dtype in [torch.float32, torch.float16, torch.bfloat16]:
class_num = tensor.shape[-1]
return torch.nn.functional.one_hot(tensor.argmax(-1), class_num).long()
elif tensor.dtype == torch.bool:
return tensor.long()
return tensor # Keep existing integer types
def to_pairwise_embedding_type(tensor: torch.Tensor) -> PairwiseEmbeddingType:
"""Convert tensor to float pairwise embedding type, preserving bf16/fp16"""
if tensor.dtype in [torch.int32, torch.int64, torch.long, torch.bool]:
return tensor.float()
return tensor
def to_logits_type(tensor: torch.Tensor) -> LogitsType:
"""Convert tensor to float logits type, preserving bf16/fp16"""
if tensor.dtype in [torch.int32, torch.int64, torch.long, torch.bool]:
return tensor.float()
return tensor
def to_flag_type(tensor: torch.Tensor) -> FlagType:
"""Convert tensor to int flag type, preserving existing integer types"""
if tensor.dtype in [torch.float32, torch.float16, torch.bfloat16]:
return tensor.long()
elif tensor.dtype == torch.bool:
return tensor.long()
return tensor # Keep existing integer types
def to_feature_type(tensor: torch.Tensor) -> FeatureType:
"""Convert tensor to float feature type, preserving bf16/fp16"""
if tensor.dtype in [torch.int32, torch.int64, torch.long, torch.bool]:
return tensor.float()
return tensor
def auto_type_convert(cls):
"""Decorator to automatically add type conversion to dataclass"""
# For attrs classes, we need to use __attrs_post_init__
original_attrs_post_init = getattr(cls, '__attrs_post_init__', None)
original_post_init = getattr(cls, '__post_init__', None)
def convert_types(self):
# Get type hints
type_hints = getattr(cls, '__annotations__', {})
# Type converter mapping
type_converter_map = {
'MaskType': to_mask_type,
'IndexType': to_index_type,
'EmbeddingType': to_embedding_type,
'OneHotType': to_onehot_type,
'PairwiseEmbeddingType': to_pairwise_embedding_type,
'LogitsType': to_logits_type,
'FlagType': to_flag_type,
}
# Apply conversions based on type hints
for field_name, field_type in type_hints.items():
if hasattr(self, field_name):
current_value = getattr(self, field_name)
if current_value is not None:
# Get the type name
if get_origin(field_type) is Union: # Handle Union types like IndexType | None
field_type = get_args(field_type)[0]
type_name = getattr(field_type, '__name__', str(field_type))
if type_name in type_converter_map:
converter = type_converter_map[type_name]
converted_value = converter(current_value)
setattr(self, field_name, converted_value)
else:
setattr(self, field_name, current_value)
def __attrs_post_init__(self):
convert_types(self)
# Call original __attrs_post_init__ if it exists
if original_attrs_post_init:
original_attrs_post_init(self)
def __post_init__(self):
convert_types(self)
# Call original __post_init__ if it exists
if original_post_init:
original_post_init(self)
# Set both methods to handle different dataclass implementations
cls.__attrs_post_init__ = __attrs_post_init__
cls.__post_init__ = __post_init__
return cls
class DictAccessMixin:
"""Mixin to add dict-like access to any class"""
def __getitem__(self, key):
return getattr(self, key)
def __setitem__(self, key, value):
setattr(self, key, value)
def __contains__(self, key):
return hasattr(self, key)
def keys(self):
# For attrs classes, get field names from class definition
if hasattr(attr, 'fields') and attr.has(self.__class__):
return [field.name for field in attr.fields(self.__class__)]
return vars(self).keys()
def values(self):
return [getattr(self, key) for key in self.keys()]
def items(self):
return [(key, getattr(self, key)) for key in self.keys()]
def get(self, key, default=None):
return getattr(self, key, default)
def update(self, other=None, **kwargs):
"""Update attributes from dict or keyword arguments
Usage:
obj.update({'attr1': value1, 'attr2': value2})
obj.update(attr1=value1, attr2=value2)
"""
if other is not None:
for key, value in other.items():
if hasattr(self, key) and value is not None:
setattr(self, key, value)
for key, value in kwargs.items():
if hasattr(self, key):
setattr(self, key, value)
def to_dict(self) -> dict:
"""Convert this object to a dictionary.
Args:
deep (bool): If True, recursively convert nested DictAccessMixin or dataclasses to dicts.
"""
return {key: getattr(self, key) for key in self.keys()} |