from __future__ import annotations import logging from dataclasses import asdict, dataclass, field from glob import glob from pathlib import Path from typing import ( Any, Dict, Iterable, List, Optional, Tuple, Type, TypeVar, Union, cast, ) import torch from transformers import PretrainedConfig from omegaconf import DictConfig, ListConfig, OmegaConf from omegaconf import OmegaConf as om from omegaconf.errors import OmegaConfBaseException from torch.distributed.fsdp import MixedPrecision, ShardingStrategy import gin #from olmo.aliases import PathOrStr from .aliases import PathOrStr #from olmo.exceptions import OLMoConfigurationError from .exceptions import OLMoConfigurationError #from olmo.util import StrEnum, resource_path from .util import StrEnum, resource_path #from olmo.mm_data.data_utils import build_tokenizer from .data_utils import build_tokenizer #from olmo.multimodal_preprocessor import MultiModalPreprocessor from .multimodal_preprocessor import MultiModalPreprocessor __all__ = [ "ActivationType", "ActivationCheckpointingStrategy", "BlockType", "LayerNormType", "VisionBackboneType", "VisionBackboneConfig", "InitFnType", "ModelConfig", "OptimizerType", "OptimizerConfig", "SchedulerType", "SchedulerConfig", "DataConfig", "InstanceFilterConfig", "EvaluatorConfig", "TokenizerConfig", "TrainConfig", "PaddingDirection", "TruncationDirection", "SpeedMonitorConfig", "WandbConfig", "CompilerConfig", "WandbConfig", "FSDPPrecision", "FSDPWrapStrategy", "FSDPConfig", "CheckpointType", ] C = TypeVar("C", bound="BaseConfig") D = TypeVar("D", bound="DictConfig|ListConfig") class AttentionType(StrEnum): sdpa = "sdpa" direct = "direct" flash = "flash" class BaseConfig: @classmethod def _register_resolvers(cls, validate_paths: bool = True): # Expands path globs into a list. def path_glob(*paths) -> List[str]: out = [] for path in paths: matches = sorted(glob(path)) if not matches and validate_paths: raise FileNotFoundError(f"{path} does not match any files or dirs") out.extend(matches) return out # Chooses the first path in the arguments that exists. def path_choose(*paths) -> str: from .util import is_url for path in paths: if is_url(path) or Path(path).exists(): return path if validate_paths: raise FileNotFoundError(", ".join(paths)) else: return "" # Finds the latest checkpoint in a folder. def path_last_checkpoint(path) -> str: from .util import find_latest_checkpoint latest_checkpoint = find_latest_checkpoint(path) if latest_checkpoint is None: if validate_paths: raise FileNotFoundError(f"Could not find a latest checkpoint at {path}") else: return "" else: return str(latest_checkpoint) om.register_new_resolver("path.glob", path_glob, replace=True) om.register_new_resolver("path.choose", path_choose, replace=True) om.register_new_resolver("path.last_checkpoint", path_last_checkpoint, replace=True) @classmethod def update_legacy_settings(cls, config: D) -> D: """ Update the legacy config settings whose schemas have undergone backwards-incompatible changes. """ return config @classmethod def new(cls: Type[C], **kwargs) -> C: cls._register_resolvers() conf = om.structured(cls) try: if kwargs: conf = om.merge(conf, kwargs) return cast(C, om.to_object(conf)) except OmegaConfBaseException as e: raise OLMoConfigurationError(str(e)) @classmethod def load( cls: Type[C], path: PathOrStr, overrides: Optional[List[str]] = None, key: Optional[str] = None, validate_paths: bool = True, ) -> C: """Load from a YAML file.""" cls._register_resolvers(validate_paths=validate_paths) schema = om.structured(cls) try: raw = om.load(str(path)) # Backwards compatibility hack, we need this here not in `update_legacy_settings` # since it has to be applied before selecting with `key` if "tokenizer" in raw and "model" in raw: raw["model"]["tokenizer"] = raw.pop("tokenizer") if key is not None: raw = raw[key] # type: ignore raw = cls.update_legacy_settings(raw) conf = om.merge(schema, raw) if overrides: conf = om.merge(conf, om.from_dotlist(overrides)) return cast(C, om.to_object(conf)) except OmegaConfBaseException as e: raise OLMoConfigurationError(str(e)) def save(self, path: PathOrStr) -> None: """Save to a YAML file.""" om.save(config=self, f=str(path)) def asdict(self, exclude: Optional[Iterable[str]] = None) -> Dict[str, Any]: out = asdict(self) # type: ignore if exclude is not None: for name in exclude: if name in out: del out[name] return out class LayerNormType(StrEnum): default = "default" """ The default LayerNorm implementation, equivalent to PyTorch's built-in version. """ low_precision = "low_precision" """ A low-precision version of the default LayerNorm. """ rms = "rms" """ An RMSNorm implementation. When using ``torch.compile`` this is probably the fastest implementation. """ gemma_rms = "gemma_rms" """ A GemmaRMSNorm implementation. When using ``torch.compile`` this is probably the fastest implementation. """ class ActivationType(StrEnum): quick_gelu = "quick_gelu" gelu = "gelu" gelu_tanh = "gelu_tanh" relu = "relu" silu = "silu" llama_geglu = "llama_geglu" llama_geglu_tanh = "llama_geglu_tanh" llama_swiglu = "llama_swiglu" swiglu = "swiglu" class BlockType(StrEnum): sequential = "sequential" llama = "llama" """ A block similar to the sequential block with slightly different implementations of operations like attention to imitate the behavior of Llama. """ gemma = "gemma" """ A block similar to the sequential block with slightly different implementations of operations like attention to imitate the behavior of Gemma. """ moe = "moe" class InitFnType(StrEnum): mitchell = "mitchell" """ The strategy suggested to us by Mitchell Wortsman from UW. This uses a truncated normal distribution with an adaptive standard deviation that depends on the size of the weights as well as the depth of the layer. """ normal = "normal" """ All weights are initialized from the same normal distribution. """ kaiming_normal = "kaiming_normal" """ All weights are initialized with the Kaiming method from a normal distribution. Note this currently won't work with FSDP. """ fan_in = "fan_in" """ "Fan-in variance scaling", i.e. normal with a standard deviation of ``1/sqrt(d_in)`` where ``d_in`` is the input dimensionality of the kernel. """ full_megatron = "full_megatron" """ This is what metaseq calls "full megatron init". It is the init used for Llama 2. """ class VisionBackboneType(StrEnum): openai = "openai" class ImagePaddingEmbed(StrEnum): pad_and_partial_pad = "pad_and_partial_pad" pad_embed = "pad_embed" regress = "regress" class ImagePooling2DType(StrEnum): attention = "attention" attention_meanq = "attention-meanq" attention_2wide = "attention_2wide" attention_v2 = "attention-v2" none = "none" stack = "stack" class ImageProjectType(StrEnum): mlp = "mlp" mlpx2 = "2mlp" linear = "linear" @dataclass class VisionBackboneConfig(BaseConfig): image_model_type: VisionBackboneType = VisionBackboneType.openai image_default_input_size: Tuple[int, int] = (336, 336) image_patch_size: int = 14 image_pos_patch_size: int = 14 image_emb_dim: int = 1024 image_num_heads: int = 16 image_num_key_value_heads: int = 16 image_num_layers: int = 24 image_head_dim: int = 64 image_mlp_dim: int = 4096 image_mlp_activations: ActivationType = ActivationType.gelu image_dropout_rate: float = 0.0 image_num_pos: int = 577 image_norm_eps: float = 1e-5 attention_dropout: float = 0.0 residual_dropout: float = 0.0 initializer_range: float = 0.02 fsdp_wrap: bool = False # how to preprocess imagse for this ViT resize_mode: str = "default" def __post_init__(self): self.image_default_input_size = tuple(self.image_default_input_size) # type: ignore[assignment] @property def image_num_patch(self): h, w = self.image_default_input_size return h // self.image_patch_size, w // self.image_patch_size class TruncationDirection(StrEnum): right = "right" left = "left" @dataclass class TokenizerConfig(BaseConfig): identifier: str = "gpt2" truncate_direction: TruncationDirection = TruncationDirection.right # Does the tokenizer automatically start input text with a space tokenizer_adds_space: Optional[bool] = False tokenizer_dir: Optional[str] = None # tokenizer directory if using a seqio tokenizer olmo_bos_token_id: Optional[int] = None olmo_eos_token_id: Optional[int] = None @dataclass class ModelConfig(BaseConfig): """ OLMo (model) configuration. """ # Note that the defaults for these attributes are equivalent to the base GPT2 model. d_model: int = 768 """ The hidden size of the model. """ n_heads: int = 12 """ The number of self-attention heads. """ n_kv_heads: Optional[int] = None """ The number of heads to use for keys and values. Defaults to `n_heads`. Set this to ``None`` or ``n_heads`` for normal multi-head attention. Set this to 1 for multi-query attention. Set it to some in-between value for Llama2-style grouped query attention. """ qkv_bias: bool = False # qwen models use bias in kvq layers clip_qkv: Optional[float] = None """ Clip QKV to this value when set. """ n_layers: int = 12 """ The number of layers/blocks. """ mlp_ratio: int = 4 """ The ratio of the inner MLP dimensionality to ``d_model``. This is only used when ``mlp_hidden_size`` is not set. """ mlp_hidden_size: Optional[int] = None """ Set the exact hidden size for the MLP. Otherwise the inner MLP hidden size will be set to `mlp_ratio * d_model`. """ activation_type: ActivationType = ActivationType.swiglu """ The activation function to use within the MLP layers. """ block_type: BlockType = BlockType.sequential """ The transformer block implementation. """ block_group_size: int = 1 """ The number of blocks to group together into a single parent block. This has no affect on the number of parameters in the model and is only used to wrap groups of blocks together with a single FSDP wrapper during training. """ alibi: bool = False """ If ``True``, use ALiBi embeddings. Mutually exclusive with ``rope``. """ alibi_bias_max: float = 8.0 """ Maximum absolute value of ALiBi bias. """ rope: bool = False """ Use rotary positional embeddings (RoPE). Mutually exclusive with ``alibi``. """ rope_full_precision: bool = True """ If ``True``, apply RoPE embeddings at full precision regardless of the input type. Otherwise, apply RoPE at the precision of the input. """ rope_theta: float = 10000. rope_impl: str = "cockatoo" vision_backbone: Optional[VisionBackboneConfig] = None """ Vision backbone settings for multi-modal models. """ vit_load_path: Optional[str] = None """ Use this to load the vit model. """ llm_load_path: Optional[str] = None """ Use this to partially load the llm transformer. """ low_cpu_fsdp: bool = True """ If ``True``, we save cpu memory by loading the pretrained vision model on randk0 only when init_device is `meta`. If TrainConfig.load_path is set, this should be set to ``False`` (default: True) """ attention_type: AttentionType = AttentionType.sdpa """ Attention implementation to use. """ float32_attention: bool = True """ Compute attention in float32 """ attention_dropout: float = 0.1 """ The dropout probability within the attention modules. """ # Only apply dropout to response tokens response_attention_dropout: float = 0.0 multi_query_attention: Optional[bool] = None """ Deprecated. Use n_kv_heads instead. """ attention_layer_norm: bool = False """ Apply layer norm to the keys and queries within the attention mechanism. This can help stabilize training. """ residual_dropout: float = 0.1 """ The dropout probability for the MLP and attention output within each block. """ # Only apply dropout to response tokens response_residual_dropout: float = 0.0 embedding_dropout: float = 0.1 """ The dropout probability for embeddings. """ layer_norm_type: LayerNormType = LayerNormType.default """ The layernorm implementation to use. """ layer_norm_with_affine: bool = True """ Whether to include bias and weight parameters for the layer norms. This only affects layer norms that are immediately followed by a linear layer in the forward pass, so everything except QK-norms. To turn off affines for QK norms as well, set :attr:`attention_layer_norm_with_affine` to ``False``. """ layer_norm_eps: Optional[float] = None attention_layer_norm_with_affine: bool = True """ Toggle affine transform for the QK norms. """ max_sequence_length: int = 1024 """ The maximum input sequence length supported by the model. """ max_position_embeddings: Optional[int] = None include_bias: bool = True """ Whether or not to include bias parameters in linear layers. In PaLM, they got rid of all bias terms because they found that large models tend to have near 0 bias terms anyway. """ bias_for_layer_norm: Optional[bool] = None """ Whether or not to include bias parameters in layer norm. This is separate from the include_bias parameter, because of a ROCm crash when biases are disabled in layer norm. When this is None (the default), it inherits the setting from include_bias. """ scale_logits: bool = False """ If ``True``, scale the output logits by ``1 / sqrt(d_model)``. """ vocab_size: int = 50257 """ Vocabulary size of the model. """ embedding_size: Optional[int] = 50304 """ The number of embeddings, i.e. the number of tokens. If set to ``None`` it will default to ``vocab_size``. If ``vocab_size`` is not a multiple of 128, setting this to the next multiple of 128 that's greater than ``vocab_size`` can improve throughput substantially. """ # For new special tokens additional_vocab_size: Optional[int] = None new_embedding_init_range: float = 0.02 """ How to initialize embedding for new """ weight_tying: bool = True """ Whether to tie output linear weights to the input embedding. """ pad_token_id: int = -1 """ The ID of the token to use for padding. Defaults to the ID of the EOS token. """ init_device: Optional[str] = None """ The torch device to use when initializing the model parameters, e.g. "cpu", "cuda:0", "meta". """ init_fn: InitFnType = InitFnType.normal """ The weight initialization strategy. """ init_std: float = 0.02 """ The standard deviation to use when initializing weights with a "fixed distribution" ``init_fn``, such as "normal". """ init_cutoff_factor: Optional[float] = None """ A positive factor used to scale the cutoff values when initializing weights with a "fixed distribution" ``init_fn``, such as "normal". Setting this to None means values are not cutoff. """ norm_after: bool = False """ Apply norm after the attention/feedforward layers rather than before, as introduced in the Swin transformer paper (Liu et al). """ precision: Optional[str] = None """ Precision used to train/evaluate with. You shouldn't set this directly. See :data:`TrainConfig.precision` instead. """ moe_num_experts: Optional[int] = 8 """ The number of experts to use in the MoE block. """ moe_top_k: Optional[int] = 2 """ The number of experts to select for each token. """ moe_mlp_impl: Optional[str] = "sparse" """ Choose "grouped" for grouped GEMM installable via `pip install git+https://git@github.com/tgale96/grouped_gemm.git@66c7195e35e8c4f22fa6a014037ef511bfa397cb`. """ moe_log_expert_assignment: Optional[bool] = False """ Whether to log the expert assignment. """ moe_shared_expert: Optional[bool] = False """ Whether to have an always-used expert like in [DeepSeekMoE](https://arxiv.org/abs/2401.06066). """ moe_lbl_in_fp32: Optional[bool] = False """ Whether to perform load balancing in FP32. """ moe_interleave: Optional[bool] = False """ Interleave sequential with MoE blocks starting with sequential. """ moe_loss_weight: Optional[float] = 0.1 """ The weight to use for the MoE load balancing loss. """ moe_zloss_weight: Optional[float] = None """ Weight for MoE router z-loss where None means no router z-loss. 0.001 is a common value. """ moe_dropless: Optional[bool] = True """ Whether to use [dMoE](https://arxiv.org/abs/2211.15841). """ moe_capacity_factor: Optional[float] = 1.25 """ The capacity factor to use in the MoE block. Only applies if not using dMoE. """ # Image pre-processing options. max_crops: int = 12 crop_mode: str = "patchify-v2-and-resize-c2" do_random_scale: bool = True use_col_tokens: bool = True # How to prompt the model prompt_type: str = "none" # System prompt to use system_prompt_kind: str = "style" # How to format messages message_formatting: str = "none" always_start_with_space: bool = True prompt_override: Optional[str] = None default_inference_len: Optional[int] = 65 overlap_margins: Tuple[int, int] = (4, 4) image_padding_embed: Optional[ImagePaddingEmbed] = None # What layers to get from the image encoder vit_layers: Tuple = (-1,) # Controls the image/language connector image_pooling_h: int = 2 image_pooling_w: int = 2 image_pooling_2d: ImagePooling2DType = ImagePooling2DType.attention image_projector: ImageProjectType = ImageProjectType.mlp image_feature_dropout: float = 0.0 use_cls_feature: bool = False fix_image_input_idx: int = 2 # Makes the model ignore the image unconditioned: bool = False # Use in combination with sub-sequence experts to make imags/text tokens always # occupy particular sub-sequences of the input pad_to: Optional[int] = None # LLM Transformer settings initializer_range: float = 0.02 pad_tokenizer: bool = False normalize_input_embeds: bool = False use_position_ids: bool = True """ Whether to use position IDs in the model. The model operation regarding positional embeddings changes depending on this variable. """ query_pre_attn_scalar: int = 224 """ Scalar to apply to the queries before attention. Used for Gemma-2. """ attn_logit_softcapping: Optional[float] = None """ Softcap the logits in the attention mechanism. Used for Gemma-2. """ final_logit_softcapping: Optional[float] = None """ Softcap the final logits. Used for Gemma-2. """ head_dim: Optional[int] = None """ The head dimensionality for the attention mechanism. Used for Gemma-2. """ tokenizer: TokenizerConfig = field(default_factory=TokenizerConfig) """ Tokenizer configuration. """ loss_token_weighting: Optional[str] = None gin_bindings: Optional[str] = None def get_tokenizer(self): tokenizer_cfg = self.tokenizer assert tokenizer_cfg.identifier.startswith("mm:") kargs = {} if tokenizer_cfg.identifier[3:].startswith("olmo-"): kargs["olmo_bos_token_id"] = tokenizer_cfg.olmo_bos_token_id kargs["olmo_eos_token_id"] = tokenizer_cfg.olmo_eos_token_id return build_tokenizer( tokenizer_cfg.identifier[3:], adds_space=tokenizer_cfg.tokenizer_adds_space, tokenizer_dir=tokenizer_cfg.tokenizer_dir, pad_tokenizer_to=self.vocab_size if self.pad_tokenizer else None, **kargs ) def get_preprocessor(self): vision_cfg = self.vision_backbone h, w = self.llm_patches_per_crop() return MultiModalPreprocessor( loss_token_weighting=self.loss_token_weighting, always_start_with_space=self.always_start_with_space, tokenizer=self.get_tokenizer(), prompt_override=self.prompt_override, fix_image_input_idx=self.fix_image_input_idx, prompt_templates=self.prompt_type, system_prompt=self.system_prompt_kind, default_inference_len=self.default_inference_len, message_format=self.message_formatting, unconditioned=self.unconditioned, crop_mode=self.crop_mode, max_crops=self.max_crops, do_random_scale=self.do_random_scale, base_image_input_size=vision_cfg.image_default_input_size, image_patch_size=vision_cfg.image_patch_size, image_token_length_h=h, image_token_length_w=w, use_col_tokens=self.use_col_tokens, overlap_margins=self.overlap_margins, image_padding_mask=self.image_padding_embed is not None ) def __post_init__(self): self.vit_layers = tuple(self.vit_layers) # type: ignore[assignment] @classmethod def update_legacy_settings(cls, config: D) -> D: """ Update the legacy config settings whose schemas have undergone backwards-incompatible changes. """ if "flash_attention" in config: is_flash = config.flash_attention del config.flash_attention config.attention_type = AttentionType.flash if is_flash else AttentionType.sdpa if "bos_token_id" in config: config.tokenizer.olmo_bos_token_id = config.pop("bos_token_id") config.tokenizer.olmo_eos_token_id = config.pop("eos_token_id") if "image_padding_mask" in config: assert not config["image_padding_mask"] del config["image_padding_mask"] config["image_padding_embed"] = None elif "image_padding_embed" not in config: config["image_padding_embed"] = None return config @property def effective_n_kv_heads(self) -> int: if self.n_kv_heads is None: if self.multi_query_attention is True: return 1 else: return self.n_heads else: if self.multi_query_attention is None: return self.n_kv_heads if self.multi_query_attention: n_kv_heads_should_be = 1 else: n_kv_heads_should_be = self.n_heads if self.n_kv_heads == n_kv_heads_should_be: return n_kv_heads_should_be else: raise OLMoConfigurationError( "You can't set `multi_query_attention` and `n_kv_heads` at the same time." ) @property def image_num_patch(self): assert self.vision_backbone is not None return self.vision_backbone.image_num_patch @property def image_patch_size(self): assert self.vision_backbone is not None return self.visoin_backbone.image_patch_size def llm_patches_per_crop(self): h, w = self.image_num_patch # Round up in case we need to pad the image features for pooling h = (h + self.image_pooling_h - 1) // self.image_pooling_h w = (w + self.image_pooling_w - 1) // self.image_pooling_w return h, w def get_max_crops(self) -> int: """Max numbers of that can be built for one image""" if self.crop_mode == "resize": return 1 elif "resize" in self.crop_mode: return 1 + self.max_crops else: return self.max_crops class MolmoConfig(PretrainedConfig): model_type = "molmo" keys_to_ignore_at_inference = ["past_key_values"] # TODO: confirm def __init__(self, use_cache: bool = False, **kwargs): model_config = ModelConfig() all_kwargs = model_config.asdict() all_kwargs.update(kwargs) all_kwargs.update({"use_cache": use_cache}) all_kwargs.update( {"architectures": all_kwargs.get("architectures", ["OLMoForCausalLM"]) or ["OLMoForCausalLM"]} ) super().__init__(**all_kwargs) @property def num_attention_heads(self): return self.n_heads @property def num_hidden_layers(self): return self.n_layers @property def hidden_size(self): return self.d_model @property def image_num_patch(self): assert self.vision_backbone is not None return self.vision_backbone.image_num_patch @property def llm_patches_per_crop(self): h, w = self.image_num_patch # Round up in case we need to pad the image features for pooling h = (h + self.image_pooling_h - 1) // self.image_pooling_h w = (w + self.image_pooling_w - 1) // self.image_pooling_w return h, w