class_docstr: Dataclass that configures most of the hyperparameters used for ECD model training.
class_docstr_tok: ["Dataclass","that","configures","most","of","the","hyperparameters","used","for","ECD","model","training","."]
code: def __post_init__(self):
      if self.compile and not _torch_200:
          raise ConfigValidationError(
              "Trainer param `compile: true` requires PyTorch 2.0.0 or higher. Please upgrade PyTorch and try again."
          )
  
      if (
          self.effective_batch_size != AUTO
          and self.max_batch_size < self.effective_batch_size
      ):
          raise ConfigValidationError(
              f"`max_batch_size` ({self.max_batch_size}) must be greater than or equal to "
              f"`effective_batch_size` ({self.effective_batch_size})."
          )
  
      if self.effective_batch_size != AUTO and self.batch_size != AUTO:
          if self.effective_batch_size < self.batch_size:
              raise ConfigValidationError(
                  f"`effective_batch_size` ({self.effective_batch_size}) "
                  f"must be greater than or equal to `batch_size` ({self.batch_size})."
              )
  
          if self.effective_batch_size % self.batch_size != 0:
              raise ConfigValidationError(
                  f"`effective_batch_size` ({self.effective_batch_size}) "
                  f"must be divisible by `batch_size` ({self.batch_size})."
              )
  
      if (
          self.effective_batch_size != AUTO
          and self.gradient_accumulation_steps != AUTO
      ):
          if (
              self.effective_batch_size
              < self.gradient_accumulation_steps
          ):
              raise ConfigValidationError(
                  f"`effective_batch_size` ({self.effective_batch_size}) must be greater than or equal to "
                  f"`gradient_accumulation_steps` ({self.gradient_accumulation_steps})."
              )
  
          if (
              self.effective_batch_size
              % self.gradient_accumulation_steps
              != 0
          ):
              raise ConfigValidationError(
                  f"`effective_batch_size` ({self.effective_batch_size}) must be divisible by "
                  f"`gradient_accumulation_steps` ({self.gradient_accumulation_steps})."
              )
  
imports: from abc import ABC
  from typing import Optional, Type, Union
  import torch
  from packaging.version import parse
  from ludwig.api_annotations import DeveloperAPI
  from ludwig.constants import AUTO, EFFECTIVE_BATCH_SIZE, LOSS, MAX_BATCH_SIZE, MAX_POSSIBLE_BATCH_SIZE, MODEL_ECD, MODEL_GBM, MODEL_LLM, TRAINING
  from ludwig.error import ConfigValidationError
  from ludwig.schema import utils
  from ludwig.schema.lr_scheduler import LRSchedulerConfig, LRSchedulerDataclassField
  from ludwig.schema.metadata import TRAINER_METADATA
  from ludwig.schema.optimizers import BaseOptimizerConfig, GradientClippingConfig, GradientClippingDataclassField, OptimizerDataclassField
  from ludwig.schema.profiler import ProfilerConfig, ProfilerDataclassField
  from ludwig.schema.utils import ludwig_dataclass
  from ludwig.utils.registry import Registry
label_desc: Use image node_id 1 for calling the ECDTrainerConfig obj's underlying member method code with example usage: obj.__post_init__() without return types