Copilot commented on code in PR #19272: URL: https://github.com/apache/iotdb/pull/19272#discussion_r4572730538
########## iotdb-core/ainode/iotdb/ainode/core/model/timestral/pipeline_timestral.py: ########## @@ -0,0 +1,140 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +import torch + +from iotdb.ainode.core.inference.pipeline.basic_pipeline import ForecastPipeline +from iotdb.ainode.core.model.model_info import ModelInfo +from iotdb.ainode.core.model.timestral.forecaster import TimestralForecaster + + +class TimestralPipeline(ForecastPipeline): + """ + Forecasting pipeline of Timestral. + + Each input is one series of one or more targets, forecast jointly, with optional past + covariates and future-known covariates. The model predicts 21 quantiles (0.01 to 0.99); + horizons longer than one decode block (1024 steps) are forecast block by block, feeding + each block's median back as context. The pipeline returns the median. + """ + + def __init__(self, model_info: ModelInfo, **model_kwargs): + super().__init__(model_info, **model_kwargs) + self.forecaster = TimestralForecaster(self.model) + + def _preprocess(self, inputs, **infer_kwargs) -> list[dict]: + """ + Convert the validated inputs to the arguments of the forecaster. + + Parameters + ---------- + inputs : list of dict + Each dictionary contains: + - 'targets': A tensor of shape (input_length,) or (target_count, input_length). + - 'past_covariates' (optional): A dictionary of tensors of shape (input_length,). + - 'future_covariates' (optional): A dictionary of tensors of shape (output_length,), + whose keys are a subset of 'past_covariates'. + + Returns + ------- + list of dict + One dictionary per input, with: + - 'context': The targets, a (1, target_count, input_length) tensor. + - 'past_covariates': The covariates known only in the past, a + (1, count, input_length) tensor, or None. + - 'known_covariates': The covariates also known in the future, a + (1, count, input_length + output_length) tensor of their past and future + values, or None. + """ + series = [] + for item in inputs: + targets = item["targets"] + if targets.ndim == 1: + targets = targets.unsqueeze(0) + past_covariates = item.get("past_covariates") or {} + future_covariates = item.get("future_covariates") or {} + past_only = [k for k in past_covariates if k not in future_covariates] + known = [k for k in past_covariates if k in future_covariates] + series.append( + { + "context": targets.float().unsqueeze(0), + "past_covariates": ( + torch.stack([past_covariates[k] for k in past_only]) + .float() + .unsqueeze(0) + if past_only + else None + ), + "known_covariates": ( + torch.stack( + [ + torch.cat([past_covariates[k], future_covariates[k]]) + for k in known + ] + ) + .float() + .unsqueeze(0) + if known + else None + ), + } + ) + return series + + def forecast(self, inputs: list[dict], **infer_kwargs) -> list[torch.Tensor]: + """ + Forecast the series, batching those of the same shape without covariates. + + Returns + ------- + list of torch.Tensor + One tensor per series, of shape (target_count, output_length, quantile_count). + """ + output_length = infer_kwargs.get("output_length", 96) + outputs: list[torch.Tensor | None] = [None] * len(inputs) + batches: dict[tuple, list[int]] = {} + for i, item in enumerate(inputs): + if item["past_covariates"] is None and item["known_covariates"] is None: + batches.setdefault(tuple(item["context"].shape), []).append(i) + else: + batches[("series", i)] = [i] Review Comment: Combining independent series here makes the variate-attention mask grow with the square of the total target count, despite masking out interactions between series. Ten 100-target series at 1,056 patch slots require about 1 GB for this mask alone, so concurrent requests can exhaust memory even when each fits individually. Process series separately, or retain a separate batch dimension in variate attention. ########## iotdb-core/ainode/iotdb/ainode/core/model/model_storage.py: ########## @@ -132,55 +135,112 @@ def _process_builtin_model_directory(self, model_dir: str, model_id: str): if existing_model.state in (ModelStates.ACTIVATING, ModelStates.ACTIVE): return + model_info = BUILTIN_HF_TRANSFORMERS_MODEL_MAP[model_id] + self._models[ModelCategory.BUILTIN.value][model_id] = model_info + # A model whose weights are not downloaded at start stays INACTIVE until it is + # loaded, which downloads them (see download_builtin_model) + if not model_info.download_on_start and not self._builtin_files_exist( + model_dir + ): + model_info.state = ModelStates.INACTIVE + logger.info( + f"Model {model_id} is not downloaded at start; " + f"LOAD MODEL {model_id} downloads it from {model_info.repo_id}." + ) + return + # If model not exists or is INACTIVE, we'll try to update its info and download its weights - self._models[ModelCategory.BUILTIN.value][model_id] = ( - BUILTIN_HF_TRANSFORMERS_MODEL_MAP[model_id] - ) - self._models[ModelCategory.BUILTIN.value][ - model_id - ].state = ModelStates.ACTIVATING - - def _download_model_if_necessary() -> bool: - """Returns: True if the model is existed or downloaded successfully, False otherwise.""" - repo_id = BUILTIN_HF_TRANSFORMERS_MODEL_MAP[model_id].repo_id - weights_path = os.path.join(model_dir, MODEL_SAFETENSORS) - config_path = os.path.join(model_dir, CONFIG_JSON) - if not os.path.exists(weights_path): - try: - hf_hub_download( - repo_id=repo_id, - filename=MODEL_SAFETENSORS, - local_dir=model_dir, - ) - except Exception as e: - logger.error( - f"Failed to download model weights from HuggingFace: {e}" - ) - return False - if not os.path.exists(config_path): - try: - hf_hub_download( - repo_id=repo_id, - filename=CONFIG_JSON, - local_dir=model_dir, - ) - except Exception as e: - logger.error( - f"Failed to download model config from HuggingFace: {e}" - ) - return False - return True + model_info.state = ModelStates.ACTIVATING - future = self._executor.submit(_download_model_if_necessary) + future = self._executor.submit( + self._download_builtin_model_files, model_id, model_dir + ) future.add_done_callback( lambda f, mid=model_id: self._callback_model_download_result(f, mid) ) + @staticmethod + def _builtin_files_exist(model_dir: str) -> bool: + return os.path.exists( + os.path.join(model_dir, MODEL_SAFETENSORS) + ) and os.path.exists(os.path.join(model_dir, CONFIG_JSON)) + + def _download_builtin_model_files(self, model_id: str, model_dir: str) -> bool: + """Returns: True if the model is existed or downloaded successfully, False otherwise.""" + repo_id = BUILTIN_HF_TRANSFORMERS_MODEL_MAP[model_id].repo_id + weights_path = os.path.join(model_dir, MODEL_SAFETENSORS) + config_path = os.path.join(model_dir, CONFIG_JSON) + if not os.path.exists(weights_path): + try: + hf_hub_download( + repo_id=repo_id, + filename=MODEL_SAFETENSORS, + local_dir=model_dir, + ) + except Exception as e: + logger.error(f"Failed to download model weights from HuggingFace: {e}") + return False + if not os.path.exists(config_path): + try: + hf_hub_download( + repo_id=repo_id, + filename=CONFIG_JSON, + local_dir=model_dir, + ) + except Exception as e: + logger.error(f"Failed to download model config from HuggingFace: {e}") + return False + return True + + def download_builtin_model(self, model_id: str) -> bool: + """ + Download the weights of a built-in model that is not downloaded at start, and wait + until the download ends. + Args: + model_id (str): Unique identifier for the model. + Returns: + bool: True if the model is ready to use, False if the download failed. + Raises: + ModelNotExistException: If the model_id is not a built-in model. + """ + with self._download_lock: + with self._lock_pool.get_lock(model_id).write_lock(): + model_info = self._models[ModelCategory.BUILTIN.value].get(model_id) + if ( + model_info is None + or model_id not in BUILTIN_HF_TRANSFORMERS_MODEL_MAP + ): + raise ModelNotExistException(model_id) + if model_info.state == ModelStates.ACTIVE: + return True + model_info.state = ModelStates.ACTIVATING + logger.info( + f"Downloading model {model_id} from HuggingFace: {model_info.repo_id}" + ) + model_dir = os.path.join( + self._models_dir, ModelCategory.BUILTIN.value, model_id + ) + succeeded = False + try: + succeeded = self._download_builtin_model_files(model_id, model_dir) + finally: + self._set_model_download_result(model_id, succeeded) + return succeeded Review Comment: When `config.json` is malformed, `_set_model_download_result()` marks the model `INACTIVE`, but this method still returns `True`, so the controller continues creating inference pools with invalid metadata. Return success only when result processing also leaves the model `ACTIVE`. ########## iotdb-core/ainode/iotdb/ainode/core/inference/pool_controller.py: ########## @@ -201,6 +201,15 @@ def _worker_loop(self): self._task_queue.task_done() def _load_one_model_task(self, model_id: str, device_id_list: list[torch.device]): + model_info = self._model_manager.get_model_info(model_id) + if not model_info.download_on_start: + # Built-in models that are not downloaded at start are downloaded when loaded + if not self._model_manager.download_builtin_model(model_id): Review Comment: A slow first-time download runs on the controller's only management worker, delaying unrelated LOAD/UNLOAD operations until it completes. `stop()` joins that worker before closing existing pools, so shutdown is delayed too. Run downloads outside the shared worker while preserving load/unload ordering, and provide bounded cancellation during shutdown. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
