Upload 18 files

.gitattributes

@@ -0,0 +1,3 @@
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+.env
+.venv/
+venv/
+env/
+.ipynb_checkpoints/
+outputs/
+checkpoints/
+wandb/
+.cache/
+*.zip
+*.tar.gz
+.DS_Store

LICENSE

@@ -0,0 +1,174 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      patent license to make, have made, use, offer to sell, sell, import,
+      and otherwise transfer the Work, where such license applies only to
+      those patent claims licensable by such Contributor that are necessarily
+      infringed by their Contribution(s) alone or by combination of their
+      Contribution(s) with the Work to which such Contribution(s) was
+      submitted. If You institute patent litigation against any entity
+      (including a cross-claim or counterclaim in a lawsuit) alleging that
+      the Work or a Contribution incorporated within the Work constitutes
+      direct or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate as of
+      the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

MANIFEST.json

@@ -0,0 +1,35 @@
+{
+  "repo_id": "HONGRIZON/JNU-TSB",
+  "root_files": [
+    ".gitattributes",
+    ".gitignore",
+    "LICENSE",
+    "MANIFEST.json",
+    "NOTICE",
+    "README.md",
+    "__init__.py",
+    "app.py",
+    "config.json",
+    "configuration_jnu_tsb.py",
+    "data/sample_news.json",
+    "data/sample_stock.csv",
+    "docs/classroom_guide_ko.md",
+    "docs/input_output_schema_ko.md",
+    "docs/usage_ko.md",
+    "event_extractor.py",
+    "examples/python_automodel.py",
+    "examples/python_quickstart.py",
+    "examples/r_http_client.R",
+    "examples/r_quickstart.R",
+    "handler.py",
+    "modeling_jnu_tsb.py",
+    "pipeline.py",
+    "pytorch_model.bin",
+    "requirements.txt",
+    "runtime.py",
+    "tests/smoke_test.py",
+    "upload_model_repo.py"
+  ],
+  "upload_command": "hf upload HONGRIZON/JNU-TSB . .",
+  "note": "이 폴더의 내용물 전체를 Hugging Face repo 루트에 업로드하세요."
+}

NOTICE

@@ -0,0 +1,9 @@
+JNU-TSB
+
+이 저장소는 교육 및 연구용 wrapper 코드를 포함합니다.
+다음 Hugging Face upstream model을 참조하지만, 해당 모델 가중치를 재배포하지 않습니다.
+
+- amazon/chronos-2
+- EleutherAI/polyglot-ko-1.3b
+
+JNU-TSB는 Amazon, EleutherAI, Hugging Face와 공식적으로 제휴된 프로젝트가 아닙니다.

README.md

@@ -0,0 +1,283 @@
+---
+license: apache-2.0
+base_model:
+- amazon/chronos-2
+- EleutherAI/polyglot-ko-1.3b
+library_name: transformers
+pipeline_tag: time-series-forecasting
+language:
+- ko
+tags:
+- jnu-tsb
+- time-series
+- forecasting
+- chronos-2
+- polyglot-ko
+- korean
+- finance
+- covariates
+- r
+- reticulate
+- education
+---
+
+# JNU-TSB
+
+**JNU-TSB**는 한국어 뉴스와 주가 시계열을 함께 다루기 위한 교육용 **Time-LLM-style time-series bridge/router**입니다.
+
+```text
+Repo ID: HONGRIZON/JNU-TSB
+Full name: Jeju National University Time-Series Bridge
+Nickname: TSB = Time-Series Bridge, also Time-Series Seungbin
+Time-series model: amazon/chronos-2
+Korean language model: EleutherAI/polyglot-ko-1.3b
+Router: stock only, news only, news + stock hybrid
+```
+
+이 저장소는 **Chronos-2 또는 Polyglot-Ko의 가중치를 재배포하지 않습니다.** 여기에는 가벼운 wrapper 코드, 설정 파일, 예제 코드, 수업용 샘플 데이터만 포함되어 있습니다. 두 base model은 실행 시 Hugging Face에서 다운로드됩니다.
+
+## 이 저장소는 무엇인가요?
+
+JNU-TSB는 **wrapper-style model repo**입니다. 학부생 수업 시연과 작은 연구 프로토타입을 위해 만들었으며, 한국어 금융 뉴스 제목을 일별 공변량으로 바꾸고 이를 Chronos-2에 전달하여 공변량 기반 시계열 예측을 수행합니다.
+
+```text
+뉴스 제목
+  -> Polyglot-Ko / keyword fallback
+  -> 일별 14차원 이벤트 공변량
+  -> Chronos-2 covariate-informed forecasting
+
+주가 시계열
+  -> Chronos-2 forecasting
+```
+
+이 구조는 **Time-LLM-style**입니다. 원 논문의 Time-LLM reprogramming architecture를 엄밀히 재구현한 것은 아닙니다. 의도적으로 숫자 시계열 예측은 Chronos-2가 담당하고, 한국어 LLM은 뉴스 텍스트를 구조화된 공변량으로 바꾸는 역할만 맡도록 설계했습니다.
+
+## 라우터 구조
+
+JNU-TSB는 입력에 따라 세 가지 경로 중 하나를 자동 선택합니다.
+
+| 입력 | 경로 | 출력 |
+|---|---|---|
+| `stock`만 있음 | Chronos-2 단독 경로 | 분위수 시계열 예측 |
+| `news`만 있음 | Polyglot-Ko / keyword fallback 경로 | 이벤트 카테고리, 감성, confidence, 일별 공변량 |
+| `stock` + `news` 모두 있음 | 하이브리드 경로 | 뉴스 공변량을 포함한 Chronos-2 예측 |
+
+하이브리드 경로는 다음 순서로 동작합니다.
+
+```text
+한국어 뉴스
+  -> 이벤트/감성 추출
+  -> 일별 14차원 covariate 생성
+  -> 주가 context dataframe과 merge
+  -> Chronos-2 predict_df 호출
+  -> forecast 반환
+```
+
+## 14차원 뉴스 공변량
+
+뉴스는 하루 단위로 집계되어 아래 14개 공변량으로 변환됩니다.
+
+| 컬럼 | 의미 |
+|---|---|
+| `cov_earnings_count` | 실적/매출/영업이익 관련 뉴스 수 |
+| `cov_product_count` | 제품 출시, 개발, 양산, 반도체 관련 뉴스 수 |
+| `cov_macro_count` | 금리, 환율, 경기, 해외시장 등 거시경제 뉴스 수 |
+| `cov_regulation_count` | 규제, 소송, 제재, 정부 정책 관련 뉴스 수 |
+| `cov_supply_chain_count` | 공급망, 수주, 계약, 생산, 물류 관련 뉴스 수 |
+| `cov_competition_count` | 경쟁사, 점유율, 가격 경쟁 관련 뉴스 수 |
+| `cov_other_count` | 위 범주에 명확히 속하지 않는 뉴스 수 |
+| `cov_sentiment_pos_count` | 긍정 감성 뉴스 수 |
+| `cov_sentiment_neg_count` | 부정 감성 뉴스 수 |
+| `cov_sentiment_neu_count` | 중립 감성 뉴스 수 |
+| `cov_news_count` | 해당 날짜의 전체 뉴스 수 |
+| `cov_sentiment_mean` | 평균 감성 점수, `-1`, `0`, `1` 기반 |
+| `cov_confidence_mean` | 평균 추출 confidence |
+| `cov_event_score` | 감성 × confidence의 합 |
+
+## 설치
+
+```bash
+pip install -U transformers torch accelerate pandas pyarrow chronos-forecasting
+```
+
+R에서 사용할 경우 `reticulate` 가상환경에 위 Python 패키지를 설치하면 됩니다. 예시는 `examples/r_quickstart.R`에 들어 있습니다.
+
+## Python 빠른 시작
+
+수업에서 빠르게 테스트할 때는 `use_llm_extractor=False`를 권장합니다. 이 경우 Polyglot-Ko를 로드하지 않고 keyword fallback만 사용하므로 훨씬 가볍게 실행됩니다.
+
+```python
+from transformers import pipeline
+
+pipe = pipeline(
+    task="jnu-tsb",
+    model="HONGRIZON/JNU-TSB",
+    trust_remote_code=True,
+    device=-1,  # CPU. GPU 0번을 쓰려면 0으로 변경
+)
+
+stock = [
+    {"timestamp": "2024-12-01", "target": 71000},
+    {"timestamp": "2024-12-02", "target": 71800},
+    {"timestamp": "2024-12-03", "target": 70400},
+    {"timestamp": "2024-12-04", "target": 70900},
+    {"timestamp": "2024-12-05", "target": 72100},
+]
+
+news = [
+    {"date": "2024-12-01", "title": "삼성전자 HBM 신제품 출시"},
+    {"date": "2024-12-02", "title": "반도체 업황 둔화 우려"},
+]
+
+result = pipe(
+    {"stock": stock, "news": news},
+    prediction_length=3,
+    use_llm_extractor=False,
+)
+
+print(result)
+```
+
+## AutoModel 직접 사용
+
+```python
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained(
+    "HONGRIZON/JNU-TSB",
+    trust_remote_code=True,
+)
+
+result = model.predict(
+    stock=[{"timestamp": "2024-12-01", "target": 71000}],
+    news=[{"date": "2024-12-01", "title": "삼성전자 HBM 신제품 출시"}],
+    prediction_length=3,
+    use_llm_extractor=False,
+)
+
+print(result)
+```
+
+## R 빠른 시작
+
+```r
+library(reticulate)
+
+# 최초 1회만 실행:
+# reticulate::virtualenv_create("jnu-tsb-env")
+# reticulate::virtualenv_install(
+#   "jnu-tsb-env",
+#   c("transformers", "torch", "accelerate", "pandas", "pyarrow", "chronos-forecasting")
+# )
+
+use_virtualenv("jnu-tsb-env", required = TRUE)
+transformers <- import("transformers")
+
+pipe <- transformers$pipeline(
+  task = "jnu-tsb",
+  model = "HONGRIZON/JNU-TSB",
+  trust_remote_code = TRUE,
+  device = -1L
+)
+
+stock <- list(
+  list(timestamp = "2024-12-01", target = 71000),
+  list(timestamp = "2024-12-02", target = 71800),
+  list(timestamp = "2024-12-03", target = 70400)
+)
+
+news <- list(
+  list(date = "2024-12-01", title = "삼성전자 HBM 신제품 출시"),
+  list(date = "2024-12-02", title = "반도체 업황 둔화 우려")
+)
+
+result <- pipe(
+  list(stock = stock, news = news),
+  prediction_length = 3L,
+  use_llm_extractor = FALSE
+)
+
+print(py_to_r(result))
+```
+
+## 입력 형식
+
+### `stock`
+
+`stock`은 pandas DataFrame, list of dicts, 또는 dict of columns 형식으로 넣을 수 있습니다. 최소 컬럼은 다음 두 개입니다.
+
+```text
+timestamp: 날짜 또는 시간
+target: 예측 대상 값, 예: 종가
+```
+
+`item_id`가 없으면 내부적으로 `series_0`이 자동 부여됩니다.
+
+### `news`
+
+`news`는 list of dicts 형식입니다. 각 항목은 최소한 날짜와 제목을 가져야 합니다.
+
+```json
+[
+  {"date": "2024-12-01", "title": "삼성전자 HBM 신제품 출시"},
+  {"date": "2024-12-02", "title": "반도체 업황 둔화 우려"}
+]
+```
+
+`title` 대신 `headline`, `text`, `content`도 인식합니다.
+
+### `future_news`와 `future_covariates`
+
+미래에 이미 알려진 뉴스나 일정이 있을 때만 `future_news` 또는 `future_covariates`를 사용하세요. 일반 뉴스 데이터는 보통 미래 값을 알 수 없으므로, 과거 뉴스는 context 구간의 past covariate로만 쓰는 것이 안전합니다.
+
+## Hugging Face 업로드 방법
+
+이 폴더의 **내용물 전체**를 `HONGRIZON/JNU-TSB` repo의 루트에 업로드하면 됩니다.
+
+```bash
+pip install -U huggingface_hub
+hf auth login
+hf upload HONGRIZON/JNU-TSB . .
+```
+
+또는 포함된 스크립트를 사용할 수 있습니다.
+
+```bash
+python upload_model_repo.py --repo_id HONGRIZON/JNU-TSB
+```
+
+다음은 업로드하지 마세요.
+
+```text
+.venv/
+venv/
+__pycache__/
+outputs/
+checkpoints/
+wandb/
+Hugging Face cache/
+Chronos-2 가중치
+Polyglot-Ko 가중치
+```
+
+## 수업용 권장 사용법
+
+수업 시연에서는 다음 순서를 추천합니다.
+
+1. `news`만 넣어서 이벤트/감성/공변량이 어떻게 만들어지는지 확인합니다.
+2. `stock`만 넣어서 Chronos-2 시계열 예측 경로를 확인합니다.
+3. `stock + news`를 함께 넣어서 하이브리드 라우터가 동작하는지 확인합니다.
+4. `use_llm_extractor=False`와 `True`의 차이를 비교합니다.
+
+`use_llm_extractor=True`는 Polyglot-Ko-1.3B를 로드하므로 CPU 환경에서는 느릴 수 있습니다. 학부생 실습에서는 fallback 모드부터 시작하는 편이 좋습니다.
+
+## 중요한 주의사항
+
+- 이 모델은 교육/연구 데모용입니다. 투자 조언이나 실제 매매 판단에 사용하지 마세요.
+- `EleutherAI/polyglot-ko-1.3b`는 instruction-tuned JSON extractor가 아니라 base language model입니다. 따라서 JSON 추출이 실패할 수 있고, 이 저장소는 keyword fallback을 함께 제공합니다.
+- Chronos-2 또는 Polyglot-Ko 가중치를 이 저장소에 포함하지 않습니다. 실행 시 각 upstream repo에서 다운로드합니다.
+- 이 저장소는 원 논문 Time-LLM을 그대로 재구현한 것이 아니라, 한국어 뉴스와 시계열 예측을 연결하는 Time-LLM-style wrapper/router입니다.
+
+## 라이선스
+
+Wrapper 코드는 Apache-2.0으로 배포됩니다. Upstream base model인 `amazon/chronos-2`와 `EleutherAI/polyglot-ko-1.3b`는 각 Hugging Face repo의 라이선스와 사용 조건을 따릅니다.

__init__.py

@@ -0,0 +1,4 @@
+from .configuration_jnu_tsb import JNUTSBConfig
+from .modeling_jnu_tsb import JNUTSBModel
+
+__all__ = ["JNUTSBConfig", "JNUTSBModel"]

app.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+import pandas as pd
+
+from runtime import JNUTSBRuntime
+
+runtime = JNUTSBRuntime.from_config_dir(Path(__file__).parent)
+
+DEFAULT_STOCK = """timestamp,target
+2024-12-01,71000
+2024-12-02,71800
+2024-12-03,70400
+2024-12-04,70900
+2024-12-05,72100
+"""
+
+DEFAULT_NEWS = """[
+  {"date": "2024-12-01", "title": "삼성전자 HBM 신제품 출시"},
+  {"date": "2024-12-02", "title": "반도체 업황 둔화 우려"}
+]"""
+
+
+def run_demo(stock_csv: str, news_json: str, prediction_length: int, use_llm_extractor: bool) -> Any:
+    from io import StringIO
+
+    stock = pd.read_csv(StringIO(stock_csv)) if stock_csv.strip() else None
+    news = json.loads(news_json) if news_json.strip() else None
+    result = runtime.predict(
+        inputs={"stock": stock, "news": news},
+        prediction_length=int(prediction_length),
+        use_llm_extractor=bool(use_llm_extractor),
+    )
+    return result
+
+
+with gr.Blocks(title="JNU-TSB") as demo:
+    gr.Markdown("# JNU-TSB: 한국어 뉴스 기반 Time-Series Bridge")
+    gr.Markdown(
+        "Chronos-2 + Polyglot-Ko + 3-way router 구조의 교육/연구용 데모입니다. "
+        "예측 결과는 투자 조언이 아닙니다."
+    )
+    with gr.Row():
+        stock_box = gr.Textbox(label="주가 CSV", value=DEFAULT_STOCK, lines=9)
+        news_box = gr.Textbox(label="뉴스 JSON", value=DEFAULT_NEWS, lines=9)
+    with gr.Row():
+        pred_len = gr.Slider(label="예측 길이 prediction_length", minimum=1, maximum=30, value=3, step=1)
+        use_llm = gr.Checkbox(label="Polyglot-Ko 추출기 사용", value=False)
+    btn = gr.Button("JNU-TSB 실행")
+    out = gr.JSON(label="결과")
+    btn.click(run_demo, inputs=[stock_box, news_box, pred_len, use_llm], outputs=out)
+
+if __name__ == "__main__":
+    demo.launch()

config.json

@@ -0,0 +1,62 @@
+{
+  "model_type": "jnu_tsb",
+  "architectures": [
+    "JNUTSBModel"
+  ],
+  "repo_id": "HONGRIZON/JNU-TSB",
+  "project_name": "JNU-TSB",
+  "project_full_name": "Jeju National University Time-Series Bridge",
+  "description": "한국어 뉴스 기반 공변량 추출과 Chronos-2 시계열 예측을 연결하는 교육용 Time-LLM-style router.",
+  "chronos_model_id": "amazon/chronos-2",
+  "llm_model_id": "EleutherAI/polyglot-ko-1.3b",
+  "timestamp_column": "timestamp",
+  "target_column": "target",
+  "id_column": "item_id",
+  "default_item_id": "series_0",
+  "prediction_length": 5,
+  "quantile_levels": [
+    0.1,
+    0.5,
+    0.9
+  ],
+  "event_categories": [
+    "earnings",
+    "product",
+    "macro",
+    "regulation",
+    "supply_chain",
+    "competition",
+    "other"
+  ],
+  "covariate_columns": [
+    "cov_earnings_count",
+    "cov_product_count",
+    "cov_macro_count",
+    "cov_regulation_count",
+    "cov_supply_chain_count",
+    "cov_competition_count",
+    "cov_other_count",
+    "cov_sentiment_pos_count",
+    "cov_sentiment_neg_count",
+    "cov_sentiment_neu_count",
+    "cov_news_count",
+    "cov_sentiment_mean",
+    "cov_confidence_mean",
+    "cov_event_score"
+  ],
+  "use_llm_extractor": true,
+  "allow_naive_fallback": true,
+  "auto_map": {
+    "AutoConfig": "configuration_jnu_tsb.JNUTSBConfig",
+    "AutoModel": "modeling_jnu_tsb.JNUTSBModel"
+  },
+  "custom_pipelines": {
+    "jnu-tsb": {
+      "impl": "pipeline.JNUTSBPipeline",
+      "pt": [
+        "AutoModel"
+      ],
+      "type": "multimodal"
+    }
+  }
+}

configuration_jnu_tsb.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from transformers import PretrainedConfig
+
+
+DEFAULT_EVENT_CATEGORIES = [
+    "earnings",
+    "product",
+    "macro",
+    "regulation",
+    "supply_chain",
+    "competition",
+    "other",
+]
+
+DEFAULT_COVARIATE_COLUMNS = [
+    "cov_earnings_count",
+    "cov_product_count",
+    "cov_macro_count",
+    "cov_regulation_count",
+    "cov_supply_chain_count",
+    "cov_competition_count",
+    "cov_other_count",
+    "cov_sentiment_pos_count",
+    "cov_sentiment_neg_count",
+    "cov_sentiment_neu_count",
+    "cov_news_count",
+    "cov_sentiment_mean",
+    "cov_confidence_mean",
+    "cov_event_score",
+]
+
+
+class JNUTSBConfig(PretrainedConfig):
+    """Configuration for the JNU-TSB router wrapper.
+
+    The repository stores lightweight code and metadata only. The upstream
+    models, amazon/chronos-2 and EleutherAI/polyglot-ko-1.3b, are loaded lazily
+    at runtime when the corresponding route is used.
+    """
+
+    model_type = "jnu_tsb"
+
+    def __init__(
+        self,
+        repo_id: str = "HONGRIZON/JNU-TSB",
+        project_name: str = "JNU-TSB",
+        project_full_name: str = "Jeju National University Time-Series Bridge",
+        chronos_model_id: str = "amazon/chronos-2",
+        llm_model_id: str = "EleutherAI/polyglot-ko-1.3b",
+        timestamp_column: str = "timestamp",
+        target_column: str = "target",
+        id_column: str = "item_id",
+        default_item_id: str = "series_0",
+        prediction_length: int = 5,
+        quantile_levels: Optional[List[float]] = None,
+        event_categories: Optional[List[str]] = None,
+        covariate_columns: Optional[List[str]] = None,
+        use_llm_extractor: bool = True,
+        allow_naive_fallback: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.repo_id = repo_id
+        self.project_name = project_name
+        self.project_full_name = project_full_name
+        self.chronos_model_id = chronos_model_id
+        self.llm_model_id = llm_model_id
+        self.timestamp_column = timestamp_column
+        self.target_column = target_column
+        self.id_column = id_column
+        self.default_item_id = default_item_id
+        self.prediction_length = int(prediction_length)
+        self.quantile_levels = quantile_levels or [0.1, 0.5, 0.9]
+        self.event_categories = event_categories or list(DEFAULT_EVENT_CATEGORIES)
+        self.covariate_columns = covariate_columns or list(DEFAULT_COVARIATE_COLUMNS)
+        self.use_llm_extractor = bool(use_llm_extractor)
+        self.allow_naive_fallback = bool(allow_naive_fallback)
+
+    def to_router_dict(self) -> Dict[str, Any]:
+        return {
+            "repo_id": self.repo_id,
+            "project_name": self.project_name,
+            "project_full_name": self.project_full_name,
+            "chronos_model_id": self.chronos_model_id,
+            "llm_model_id": self.llm_model_id,
+            "timestamp_column": self.timestamp_column,
+            "target_column": self.target_column,
+            "id_column": self.id_column,
+            "default_item_id": self.default_item_id,
+            "prediction_length": self.prediction_length,
+            "quantile_levels": self.quantile_levels,
+            "event_categories": self.event_categories,
+            "covariate_columns": self.covariate_columns,
+            "use_llm_extractor": self.use_llm_extractor,
+            "allow_naive_fallback": self.allow_naive_fallback,
+        }

event_extractor.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import json
+import re
+from collections import Counter
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterable, List, Optional
+
+import pandas as pd
+
+
+DEFAULT_CATEGORIES = [
+    "earnings",
+    "product",
+    "macro",
+    "regulation",
+    "supply_chain",
+    "competition",
+    "other",
+]
+
+COVARIATE_COLUMNS = [
+    "cov_earnings_count",
+    "cov_product_count",
+    "cov_macro_count",
+    "cov_regulation_count",
+    "cov_supply_chain_count",
+    "cov_competition_count",
+    "cov_other_count",
+    "cov_sentiment_pos_count",
+    "cov_sentiment_neg_count",
+    "cov_sentiment_neu_count",
+    "cov_news_count",
+    "cov_sentiment_mean",
+    "cov_confidence_mean",
+    "cov_event_score",
+]
+
+CATEGORY_KEYWORDS = {
+    "earnings": ["실적", "영업이익", "매출", "순이익", "가이던스", "어닝", "분기", "흑자", "적자"],
+    "product": ["신제품", "출시", "HBM", "AI칩", "반도체", "스마트폰", "제품", "개발", "양산"],
+    "macro": ["금리", "환율", "물가", "경기", "코스피", "나스닥", "연준", "미국", "중국", "수출"],
+    "regulation": ["규제", "정부", "공정위", "조사", "제재", "법안", "허가", "소송", "벌금"],
+    "supply_chain": ["공급", "수주", "계약", "공장", "생산", "물류", "공급망", "원재료", "납품"],
+    "competition": ["경쟁", "점유율", "가격인하", "경쟁사", "SK하이닉스", "엔비디아", "TSMC"],
+}
+
+POSITIVE_KEYWORDS = [
+    "상승", "호재", "개선", "증가", "수주", "계약", "출시", "성장", "최대", "돌파",
+    "흑자", "강세", "투자", "확대", "회복", "승인", "개발", "양산",
+]
+NEGATIVE_KEYWORDS = [
+    "하락", "악재", "둔화", "감소", "우려", "적자", "부진", "규제", "제재", "소송",
+    "중단", "감산", "약세", "리콜", "손실", "취소", "침체",
+]
+
+
+@dataclass
+class EventResult:
+    category: str
+    sentiment: int
+    confidence: float
+    source: str
+    raw_text: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "category": self.category,
+            "sentiment": int(self.sentiment),
+            "confidence": float(self.confidence),
+            "source": self.source,
+            "raw_text": self.raw_text,
+        }
+
+
+class EventExtractor:
+    """Korean financial news -> event/sentiment -> daily covariates.
+
+    The LLM path asks Polyglot-Ko to emit JSON. Since Polyglot-Ko-1.3B is a base
+    LM rather than an instruction-tuned JSON extractor, deterministic keyword
+    fallback is always available.
+    """
+
+    def __init__(
+        self,
+        generate_fn: Optional[Callable[[str], str]] = None,
+        categories: Optional[List[str]] = None,
+        use_llm: bool = True,
+    ) -> None:
+        self.generate_fn = generate_fn
+        self.categories = categories or list(DEFAULT_CATEGORIES)
+        self.use_llm = bool(use_llm)
+
+    def build_prompt(self, title: str) -> str:
+        cats = ", ".join(self.categories)
+        return (
+            "다음 한국어 금융뉴스 제목을 주가 예측용 공변량으로 분석하세요.\n"
+            f"가능한 category: {cats}\n"
+            "sentiment는 주가 관점에서 -1, 0, 1 중 하나입니다.\n"
+            "confidence는 0과 1 사이 숫자입니다.\n"
+            "반드시 JSON만 출력하세요.\n"
+            f"뉴스: {title}\n"
+            "JSON:"
+        )
+
+    def extract(self, title: str) -> Dict[str, Any]:
+        title = str(title or "").strip()
+        if self.use_llm and self.generate_fn is not None and title:
+            try:
+                raw = self.generate_fn(self.build_prompt(title))
+                parsed = self._parse_json(raw)
+                if parsed is not None:
+                    return parsed.to_dict()
+            except Exception:
+                pass
+        return self._keyword_fallback(title).to_dict()
+
+    def aggregate_to_daily(self, news: Iterable[Dict[str, Any]]) -> pd.DataFrame:
+        rows: List[Dict[str, Any]] = []
+        for item in news or []:
+            date_value = item.get("date") or item.get("timestamp") or item.get("datetime")
+            title = item.get("title") or item.get("headline") or item.get("text") or item.get("content") or ""
+            if date_value is None:
+                continue
+            day = pd.to_datetime(date_value).floor("D")
+            event = self.extract(str(title))
+            event["timestamp"] = day
+            rows.append(event)
+
+        if not rows:
+            return pd.DataFrame(columns=["timestamp", *COVARIATE_COLUMNS])
+
+        df = pd.DataFrame(rows)
+        daily_rows: List[Dict[str, Any]] = []
+        for day, group in df.groupby("timestamp"):
+            counter = Counter(group["category"].tolist())
+            sentiments = group["sentiment"].astype(float)
+            confidences = group["confidence"].astype(float).clip(0, 1)
+            out: Dict[str, Any] = {"timestamp": pd.to_datetime(day)}
+
+            for cat in DEFAULT_CATEGORIES:
+                out[f"cov_{cat}_count"] = float(counter.get(cat, 0))
+
+            out["cov_sentiment_pos_count"] = float((sentiments > 0).sum())
+            out["cov_sentiment_neg_count"] = float((sentiments < 0).sum())
+            out["cov_sentiment_neu_count"] = float((sentiments == 0).sum())
+            out["cov_news_count"] = float(len(group))
+            out["cov_sentiment_mean"] = float(sentiments.mean()) if len(group) else 0.0
+            out["cov_confidence_mean"] = float(confidences.mean()) if len(group) else 0.0
+            out["cov_event_score"] = float((sentiments * confidences).sum()) if len(group) else 0.0
+            daily_rows.append(out)
+
+        result = pd.DataFrame(daily_rows).sort_values("timestamp").reset_index(drop=True)
+        for col in COVARIATE_COLUMNS:
+            if col not in result.columns:
+                result[col] = 0.0
+        return result[["timestamp", *COVARIATE_COLUMNS]]
+
+    def _parse_json(self, raw: str) -> Optional[EventResult]:
+        if not raw:
+            return None
+        # Extract the first {...} block.
+        match = re.search(r"\{.*?\}", str(raw), flags=re.DOTALL)
+        if not match:
+            return None
+        payload = json.loads(match.group(0))
+        category = str(payload.get("category", "other")).strip()
+        if category not in self.categories:
+            category = "other"
+        sentiment = int(payload.get("sentiment", 0))
+        sentiment = -1 if sentiment < 0 else (1 if sentiment > 0 else 0)
+        confidence = float(payload.get("confidence", 0.5))
+        confidence = max(0.0, min(1.0, confidence))
+        return EventResult(category=category, sentiment=sentiment, confidence=confidence, source="llm", raw_text=str(raw))
+
+    def _keyword_fallback(self, title: str) -> EventResult:
+        text = title.lower()
+        scores: Dict[str, int] = {}
+        for category, keywords in CATEGORY_KEYWORDS.items():
+            scores[category] = sum(1 for kw in keywords if kw.lower() in text)
+
+        category = max(scores, key=scores.get) if scores else "other"
+        if scores.get(category, 0) == 0:
+            category = "other"
+
+        pos = sum(1 for kw in POSITIVE_KEYWORDS if kw.lower() in text)
+        neg = sum(1 for kw in NEGATIVE_KEYWORDS if kw.lower() in text)
+        sentiment = 1 if pos > neg else (-1 if neg > pos else 0)
+        confidence = 0.55 + 0.1 * min(3, abs(pos - neg) + scores.get(category, 0))
+        confidence = max(0.1, min(0.95, confidence))
+        return EventResult(category=category, sentiment=sentiment, confidence=confidence, source="keyword", raw_text=title)

handler.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+try:
+    from .runtime import JNUTSBRuntime
+except ImportError:  # pragma: no cover
+    from runtime import JNUTSBRuntime
+
+
+class EndpointHandler:
+    """Hugging Face Inference Endpoint custom handler."""
+
+    def __init__(self, model_dir: str, **kwargs: Any) -> None:
+        self.runtime = JNUTSBRuntime.from_config_dir(model_dir)
+
+    def __call__(self, data: Dict[str, Any]) -> Any:
+        inputs = data.get("inputs", data)
+        parameters = data.get("parameters", {})
+        return self.runtime.predict(inputs=inputs, **parameters)

modeling_jnu_tsb.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import torch
+from torch import nn
+from transformers import PreTrainedModel
+
+try:
+    from .configuration_jnu_tsb import JNUTSBConfig
+except ImportError:  # pragma: no cover - local execution fallback
+    from configuration_jnu_tsb import JNUTSBConfig
+
+
+class JNUTSBModel(PreTrainedModel):
+    """Tiny Hugging Face model wrapper for JNU-TSB.
+
+    The actual computation lives in ``runtime.JNUTSBRuntime``. This class exists
+    so that ``AutoModel.from_pretrained(..., trust_remote_code=True)`` and the
+    custom Transformers pipeline can load the repo like a normal HF model.
+    """
+
+    config_class = JNUTSBConfig
+    base_model_prefix = "jnu_tsb"
+    main_input_name = "inputs"
+
+    def __init__(self, config: JNUTSBConfig) -> None:
+        super().__init__(config)
+        self.dummy = nn.Parameter(torch.zeros(1), requires_grad=False)
+        self._runtime = None
+
+    def forward(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        return {
+            "message": "JNU-TSB is a router wrapper. Use model.predict(...) or pipeline(task='jnu-tsb', ...).",
+            "repo_id": self.config.repo_id,
+        }
+
+    def get_runtime(self):
+        if self._runtime is None:
+            try:
+                from .runtime import JNUTSBRuntime
+            except ImportError:  # pragma: no cover
+                from runtime import JNUTSBRuntime
+            self._runtime = JNUTSBRuntime.from_config(self.config)
+        return self._runtime
+
+    def predict(self, inputs: Optional[Dict[str, Any]] = None, **kwargs: Any) -> Any:
+        """Run the 3-way router.
+
+        Supports either:
+          model.predict({"stock": ..., "news": ...}, prediction_length=5)
+        or:
+          model.predict(stock=..., news=..., prediction_length=5)
+        """
+        payload = dict(inputs or {})
+        for key in ("stock", "news", "future_news", "future_covariates"):
+            if key in kwargs:
+                payload[key] = kwargs.pop(key)
+        return self.get_runtime().predict(inputs=payload, **kwargs)

pipeline.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Tuple
+
+from transformers import Pipeline
+
+
+class JNUTSBPipeline(Pipeline):
+    """Custom Transformers pipeline for JNU-TSB.
+
+    Example:
+        from transformers import pipeline
+        pipe = pipeline("jnu-tsb", model="HONGRIZON/JNU-TSB", trust_remote_code=True)
+        pipe({"stock": [...], "news": [...]}, prediction_length=5)
+    """
+
+    def _sanitize_parameters(
+        self,
+        prediction_length: Optional[int] = None,
+        quantile_levels: Optional[list] = None,
+        use_llm_extractor: Optional[bool] = None,
+        allow_naive_fallback: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any]]:
+        forward_params: Dict[str, Any] = dict(kwargs)
+        if prediction_length is not None:
+            forward_params["prediction_length"] = int(prediction_length)
+        if quantile_levels is not None:
+            forward_params["quantile_levels"] = quantile_levels
+        if use_llm_extractor is not None:
+            forward_params["use_llm_extractor"] = bool(use_llm_extractor)
+        if allow_naive_fallback is not None:
+            forward_params["allow_naive_fallback"] = bool(allow_naive_fallback)
+        return {}, forward_params, {}
+
+    def preprocess(self, inputs: Any, **preprocess_params: Any) -> Any:
+        if inputs is None:
+            raise ValueError("JNU-TSB expects a dict with 'stock', 'news', or both.")
+        return inputs
+
+    def _forward(self, model_inputs: Any, **forward_params: Any) -> Any:
+        if not hasattr(self.model, "predict"):
+            raise TypeError("The loaded model does not expose a predict(...) method.")
+        return self.model.predict(model_inputs, **forward_params)
+
+    def postprocess(self, model_outputs: Any, **postprocess_params: Any) -> Any:
+        return model_outputs

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee70794f4c8b7feed2ca6cfa91f3226ccfd5f22e19eb5d5f223beff4f4e479a1
+size 1619

requirements.txt

@@ -0,0 +1,8 @@
+transformers>=4.45
+accelerate>=0.33
+torch>=2.2
+pandas>=2.0
+pyarrow>=14.0
+chronos-forecasting>=2.0
+huggingface_hub>=0.25
+gradio>=4.44

runtime.py

@@ -0,0 +1,358 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Union
+
+import pandas as pd
+import torch
+
+try:
+    from .configuration_jnu_tsb import JNUTSBConfig
+    from .event_extractor import COVARIATE_COLUMNS, EventExtractor
+except ImportError:  # pragma: no cover - local execution fallback
+    from configuration_jnu_tsb import JNUTSBConfig
+    from event_extractor import COVARIATE_COLUMNS, EventExtractor
+
+
+class JNUTSBRuntime:
+    """Runtime used by the model wrapper, pipeline, Endpoint handler, Gradio, and R examples.
+
+    Routes inputs into three paths:
+      1. stock only -> Chronos-2 forecast
+      2. news only -> event extraction and daily covariates
+      3. stock + news -> news covariates + stock context -> Chronos-2 forecast
+    """
+
+    def __init__(
+        self,
+        config: Union[JNUTSBConfig, Dict[str, Any]],
+        chronos_device_map: Optional[str] = None,
+        llm_device_map: Optional[str] = None,
+    ) -> None:
+        if isinstance(config, dict):
+            config = JNUTSBConfig(**config)
+        self.config = config
+        self.chronos_device_map = chronos_device_map or os.getenv("JNU_TSB_CHRONOS_DEVICE_MAP", "cpu")
+        self.llm_device_map = llm_device_map or os.getenv("JNU_TSB_LLM_DEVICE_MAP", "cpu")
+        self._chronos = None
+        self._llm_pipe = None
+        self._extractor = None
+
+    @classmethod
+    def from_config(cls, config: Union[JNUTSBConfig, Dict[str, Any]], **kwargs: Any) -> "JNUTSBRuntime":
+        return cls(config=config, **kwargs)
+
+    @classmethod
+    def from_config_dir(cls, path: Union[str, os.PathLike[str]], **kwargs: Any) -> "JNUTSBRuntime":
+        path = Path(path)
+        with open(path / "config.json", "r", encoding="utf-8") as f:
+            payload = json.load(f)
+        return cls(config=payload, **kwargs)
+
+    @property
+    def chronos(self):
+        if self._chronos is None:
+            try:
+                from chronos import Chronos2Pipeline
+            except Exception as exc:  # pragma: no cover
+                raise ImportError(
+                    "chronos-forecasting is required for Chronos-2 inference. "
+                    "Install it with: pip install chronos-forecasting"
+                ) from exc
+            self._chronos = Chronos2Pipeline.from_pretrained(
+                self.config.chronos_model_id,
+                device_map=self.chronos_device_map,
+            )
+        return self._chronos
+
+    @property
+    def extractor(self) -> EventExtractor:
+        if self._extractor is None:
+            self._extractor = EventExtractor(
+                generate_fn=self._generate_with_polyglot if self.config.use_llm_extractor else None,
+                categories=self.config.event_categories,
+                use_llm=self.config.use_llm_extractor,
+            )
+        return self._extractor
+
+    def _generate_with_polyglot(self, prompt: str) -> str:
+        if self._llm_pipe is None:
+            from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline as hf_pipeline
+
+            tokenizer = AutoTokenizer.from_pretrained(self.config.llm_model_id)
+            model = AutoModelForCausalLM.from_pretrained(
+                self.config.llm_model_id,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map=self.llm_device_map,
+            )
+            self._llm_pipe = hf_pipeline(
+                "text-generation",
+                model=model,
+                tokenizer=tokenizer,
+            )
+        output = self._llm_pipe(
+            prompt,
+            max_new_tokens=96,
+            do_sample=False,
+            return_full_text=False,
+        )
+        if isinstance(output, list) and output:
+            return output[0].get("generated_text", "")
+        return str(output)
+
+    def predict(
+        self,
+        inputs: Optional[Dict[str, Any]] = None,
+        prediction_length: Optional[int] = None,
+        quantile_levels: Optional[Sequence[float]] = None,
+        use_llm_extractor: Optional[bool] = None,
+        allow_naive_fallback: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = dict(inputs or {})
+        payload.update(kwargs)
+
+        if use_llm_extractor is not None and bool(use_llm_extractor) != self.config.use_llm_extractor:
+            # Rebuild extractor with the requested setting for this runtime instance.
+            self.config.use_llm_extractor = bool(use_llm_extractor)
+            self._extractor = None
+
+        prediction_length = int(prediction_length or self.config.prediction_length)
+        quantile_levels = list(quantile_levels or self.config.quantile_levels)
+        allow_naive_fallback = self.config.allow_naive_fallback if allow_naive_fallback is None else bool(allow_naive_fallback)
+
+        news = payload.get("news")
+        stock = payload.get("stock")
+        future_news = payload.get("future_news")
+        future_covariates = payload.get("future_covariates")
+
+        has_news = bool(news)
+        stock_df = self._prepare_stock_df(stock)
+        has_stock = stock_df is not None and not stock_df.empty
+
+        if has_news and has_stock:
+            context_df = self._merge_news_covariates(stock_df, news)
+            future_df = self._prepare_future_covariates(
+                stock_df=context_df,
+                future_news=future_news,
+                future_covariates=future_covariates,
+                prediction_length=prediction_length,
+            )
+            return self._forecast(
+                context_df=context_df,
+                prediction_length=prediction_length,
+                quantile_levels=quantile_levels,
+                route="hybrid",
+                future_df=future_df,
+                allow_naive_fallback=allow_naive_fallback,
+            )
+
+        if has_stock:
+            return self._forecast(
+                context_df=stock_df,
+                prediction_length=prediction_length,
+                quantile_levels=quantile_levels,
+                route="chronos_only",
+                future_df=None,
+                allow_naive_fallback=allow_naive_fallback,
+            )
+
+        if has_news:
+            events = [self.extractor.extract(item.get("title") or item.get("headline") or item.get("text") or "") for item in news]
+            daily_covariates = self.extractor.aggregate_to_daily(news)
+            return {
+                "route": "text_only",
+                "repo_id": self.config.repo_id,
+                "events": events,
+                "daily_covariates": self._df_to_records(daily_covariates),
+            }
+
+        raise ValueError("JNU-TSB expects at least one of: stock, news.")
+
+    def _forecast(
+        self,
+        context_df: pd.DataFrame,
+        prediction_length: int,
+        quantile_levels: Sequence[float],
+        route: str,
+        future_df: Optional[pd.DataFrame] = None,
+        allow_naive_fallback: bool = True,
+    ) -> Dict[str, Any]:
+        try:
+            kwargs = dict(
+                prediction_length=prediction_length,
+                quantile_levels=list(quantile_levels),
+                id_column=self.config.id_column,
+                timestamp_column=self.config.timestamp_column,
+                target=self.config.target_column,
+            )
+            if future_df is not None and not future_df.empty:
+                pred = self.chronos.predict_df(context_df, future_df=future_df, **kwargs)
+            else:
+                pred = self.chronos.predict_df(context_df, **kwargs)
+            return {
+                "route": route,
+                "repo_id": self.config.repo_id,
+                "engine": self.config.chronos_model_id,
+                "forecast": self._df_to_records(pred),
+                "used_naive_fallback": False,
+            }
+        except Exception as exc:
+            if not allow_naive_fallback:
+                raise
+            pred = self._naive_forecast(context_df, prediction_length, quantile_levels)
+            return {
+                "route": route,
+                "repo_id": self.config.repo_id,
+                "engine": "naive_last_value_fallback",
+                "forecast": self._df_to_records(pred),
+                "used_naive_fallback": True,
+                "warning": f"Chronos-2 inference failed or was unavailable: {type(exc).__name__}: {exc}",
+            }
+
+    def _prepare_stock_df(self, stock: Any) -> Optional[pd.DataFrame]:
+        if stock is None:
+            return None
+        if isinstance(stock, pd.DataFrame):
+            df = stock.copy()
+        elif isinstance(stock, list):
+            df = pd.DataFrame(stock)
+        elif isinstance(stock, dict):
+            df = pd.DataFrame(stock)
+        else:
+            raise TypeError("stock must be a pandas DataFrame, list of dicts, or dict of columns.")
+
+        if df.empty:
+            return df
+
+        timestamp_col = self.config.timestamp_column
+        if timestamp_col not in df.columns:
+            for cand in ("date", "Date", "datetime", "time"):
+                if cand in df.columns:
+                    df = df.rename(columns={cand: timestamp_col})
+                    break
+
+        target_col = self.config.target_column
+        if target_col not in df.columns:
+            for cand in ("close", "Close", "price", "value", "y"):
+                if cand in df.columns:
+                    df = df.rename(columns={cand: target_col})
+                    break
+
+        if timestamp_col not in df.columns or target_col not in df.columns:
+            raise ValueError(f"stock must contain '{timestamp_col}' and '{target_col}' columns.")
+
+        if self.config.id_column not in df.columns:
+            df[self.config.id_column] = self.config.default_item_id
+
+        df[timestamp_col] = pd.to_datetime(df[timestamp_col])
+        df = df.sort_values([self.config.id_column, timestamp_col]).reset_index(drop=True)
+        return df
+
+    def _prepare_future_df(self, data: Any) -> Optional[pd.DataFrame]:
+        if data is None:
+            return None
+        if isinstance(data, pd.DataFrame):
+            df = data.copy()
+        elif isinstance(data, list):
+            df = pd.DataFrame(data)
+        elif isinstance(data, dict):
+            df = pd.DataFrame(data)
+        else:
+            raise TypeError("future_covariates must be a pandas DataFrame, list of dicts, or dict of columns.")
+
+        if df.empty:
+            return df
+
+        timestamp_col = self.config.timestamp_column
+        if timestamp_col not in df.columns:
+            for cand in ("date", "Date", "datetime", "time"):
+                if cand in df.columns:
+                    df = df.rename(columns={cand: timestamp_col})
+                    break
+        if timestamp_col not in df.columns:
+            raise ValueError(f"future_covariates must contain a '{timestamp_col}' column.")
+        if self.config.id_column not in df.columns:
+            df[self.config.id_column] = self.config.default_item_id
+
+        df[timestamp_col] = pd.to_datetime(df[timestamp_col])
+        df = df.sort_values([self.config.id_column, timestamp_col]).reset_index(drop=True)
+        return df
+
+    def _merge_news_covariates(self, stock_df: pd.DataFrame, news: Iterable[Dict[str, Any]]) -> pd.DataFrame:
+        cov = self.extractor.aggregate_to_daily(news)
+        context = stock_df.copy()
+        day_col = "__day__"
+        context[day_col] = pd.to_datetime(context[self.config.timestamp_column]).dt.floor("D")
+        cov = cov.rename(columns={"timestamp": day_col})
+        merged = context.merge(cov, on=day_col, how="left").drop(columns=[day_col])
+        for col in COVARIATE_COLUMNS:
+            if col in merged.columns:
+                merged[col] = merged[col].fillna(0).astype(float)
+        return merged
+
+    def _prepare_future_covariates(
+        self,
+        stock_df: pd.DataFrame,
+        future_news: Optional[Iterable[Dict[str, Any]]],
+        future_covariates: Any,
+        prediction_length: int,
+    ) -> Optional[pd.DataFrame]:
+        if future_covariates is not None:
+            fut = self._prepare_future_df(future_covariates)
+            if fut is not None and not fut.empty:
+                return fut.drop(columns=[self.config.target_column], errors="ignore")
+
+        if not future_news:
+            return None
+
+        first_id = stock_df[self.config.id_column].iloc[0]
+        last_ts = pd.to_datetime(stock_df[self.config.timestamp_column]).max()
+        freq = pd.infer_freq(pd.to_datetime(stock_df[self.config.timestamp_column]).drop_duplicates().sort_values()) or "D"
+        future_dates = pd.date_range(start=last_ts, periods=prediction_length + 1, freq=freq)[1:]
+        base = pd.DataFrame({
+            self.config.timestamp_column: future_dates,
+            self.config.id_column: first_id,
+        })
+
+        cov = self.extractor.aggregate_to_daily(future_news)
+        if cov.empty:
+            return base
+        cov_day = cov.rename(columns={"timestamp": "__day__"})
+        base["__day__"] = pd.to_datetime(base[self.config.timestamp_column]).dt.floor("D")
+        merged = base.merge(cov_day, on="__day__", how="left").drop(columns=["__day__"])
+        for col in COVARIATE_COLUMNS:
+            if col in merged.columns:
+                merged[col] = merged[col].fillna(0).astype(float)
+        return merged
+
+    def _naive_forecast(self, context_df: pd.DataFrame, prediction_length: int, quantile_levels: Sequence[float]) -> pd.DataFrame:
+        timestamp_col = self.config.timestamp_column
+        target_col = self.config.target_column
+        id_col = self.config.id_column
+
+        rows: List[Dict[str, Any]] = []
+        for item_id, group in context_df.groupby(id_col):
+            group = group.sort_values(timestamp_col)
+            last_ts = pd.to_datetime(group[timestamp_col].iloc[-1])
+            last_value = float(group[target_col].iloc[-1])
+            freq = pd.infer_freq(pd.to_datetime(group[timestamp_col]).drop_duplicates().sort_values()) or "D"
+            dates = pd.date_range(start=last_ts, periods=prediction_length + 1, freq=freq)[1:]
+            for ts in dates:
+                row: Dict[str, Any] = {id_col: item_id, timestamp_col: ts}
+                for q in quantile_levels:
+                    row[str(q)] = last_value
+                    row[f"q{q}"] = last_value
+                row["mean"] = last_value
+                row["prediction"] = last_value
+                rows.append(row)
+        return pd.DataFrame(rows)
+
+    def _df_to_records(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
+        out = df.copy()
+        for col in out.columns:
+            if pd.api.types.is_datetime64_any_dtype(out[col]):
+                out[col] = out[col].astype(str)
+        return out.to_dict(orient="records")

upload_model_repo.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from huggingface_hub import HfApi, create_repo
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Upload JNU-TSB files to Hugging Face Hub")
+    parser.add_argument("--repo_id", default="HONGRIZON/JNU-TSB", help="Hugging Face repo id")
+    parser.add_argument("--private", action="store_true", help="Create/upload as a private repo")
+    parser.add_argument("--folder", default=".", help="Folder to upload")
+    args = parser.parse_args()
+
+    folder = Path(args.folder).resolve()
+    create_repo(args.repo_id, repo_type="model", private=args.private, exist_ok=True)
+    api = HfApi()
+    api.upload_folder(
+        folder_path=str(folder),
+        repo_id=args.repo_id,
+        repo_type="model",
+        ignore_patterns=[
+            ".git/*",
+            "__pycache__/*",
+            "*.pyc",
+            "*.zip",
+            ".venv/*",
+            "venv/*",
+            "env/*",
+            "outputs/*",
+            "checkpoints/*",
+            "wandb/*",
+        ],
+    )
+    print(f"Uploaded {folder} to https://huggingface.co/{args.repo_id}")
+
+
+if __name__ == "__main__":
+    main()