Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,125 @@
+---
+language:
+- en
+library_name: transformers
+pipeline_tag: image-text-to-text
+tags:
+- tachibana
+- valiant
+- valiant-labs
+- qwen
+- qwen-3.6
+- qwen-3.6-27b
+- 27b
+- reasoning
+- code
+- code-instruct
+- python
+- typescript
+- javascript
+- java
+- c++
+- c
+- c#
+- rust
+- go
+- haskell
+- shell
+- bash
+- azure
+- aws
+- gcp
+- cloud
+- scripting
+- powershell
+- problem-solving
+- architect
+- engineer
+- developer
+- creative
+- analytical
+- expert
+- rationality
+- conversational
+- chat
+- instruct
+base_model: Qwen/Qwen3.6-27B
+datasets:
+- sequelbox/Tachibana4-DeepSeek-V4-Pro
+license: apache-2.0
+---
+
+
+**[Support our open-source dataset and model releases!](https://huggingface.co/spaces/sequelbox/SupportOpenSource)**
+
+
+Tachibana-Agent is a Qwen 3.6 agentic coding finetune, trained on the [Tachibana 4](https://huggingface.co/datasets/sequelbox/Tachibana4-DeepSeek-V4-Pro) dataset.
+    - Questions prioritize real-world, challenging agentic coding tasks across a variety of programming languages and topics. Synthetic prompts utilize a variety of personas, experience levels, and styles of communication to maximize real-world flexibility and usability.
+    - Areas of focus include back-end and front-end development, systems programming, distributed systems, performance optimization, data structures, databases and data engineering, game and mobile development, security engineering, compiler design, custom tooling, task automation, practical bugfixes, and more!
+    - A wide variety of emphasized languages improves development capability: Python, C, C++, C#, Go, TypeScript, Java, JavaScript, Rust, Haskell, SQL, Shell, R, Ruby, assembly code, and more!
+
+
+## Prompting Guide
+Tachibana-Agent uses the [Qwen3.6-27B](https://huggingface.co/Qwen/Qwen3.6-27B) prompt format and the following recommended general structure:
+
+1) Start the prompt with your primary query
+2) Include reference information after the primary query, using subheaders; documentation should follow "Documentation:\n\n", a stack trace following "Stack Trace:\n\n", etc for logs, schemas, specs, etc.
+3) Attached files for the agent go at the end, with each file surrounded by file tags: <file path=""myStuff/myRepo/myFirstFile.scala"" language=""Scala""> </file>
+
+Adherence to the specific format above is not required, but reflects the structure of the training data.
+
+Example inference script to get started:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "sequelbox/Qwen3.6-27B-Tachibana-Agent"
+
+# load the tokenizer and the model
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype="auto",
+    device_map="auto"
+)
+
+# prepare the model input
+prompt = "Implement CQRS for network appliance config management.\n\nRequirements:\n- Write side: 200 commands/sec, 4 command handlers, SQLite with custom journaling\n- Read side: 1000 queries/sec, 3 read projections in shared memory segments\n- Eventual consistency window: 100ms max\n- Handle atomic swap of projection memory for rebuilds\n- Binary configuration format versioning for schema evolution\n- Framework: libevent with custom protocol parser\n\nConstraints:\n- Manual memory management only, no garbage collection\n- Lock-free data structures where possible\n- Shared memory projections must survive process restarts\n- Command handlers must be thread-safe with 4 worker threads\n- Projection rebuild must not block queries\n- Binary format must support forward/backward compatibility\n- Error handling for corrupted journal recovery\n- Memory-mapped I/O for shared segments\n- Zero-copy where possible for performance\n\nDeliverables:\n1. Command processing pipeline with journaling\n2. Projection engine with shared memory management\n3. Query dispatcher with read-your-writes consistency\n4. Schema evolution system with versioned binary format\n5. Integration with libevent for network I/O\n6. Stress test showing 200 cmd/s + 1000 q/s sustained\n\nAssume x86_64 Linux, pthreads, atomic operations. No high-level frameworks."
+#prompt = "Hey, I've been wrestling with state management for our Scala.js + Laminar trading dashboard, and I wanted to get your take on the best approach. We have five distinct state domains that all interact: financial portfolio positions, real-time market data (WebSocket feed), trade execution state, user risk limits, and chart visualization parameters. The current code uses a mix of `Var`s and manual subscriptions, but we're hitting nasty race conditions: a market data update can fire a trade execution callback that reads stale portfolio state, or an optimistic trade placement updates the portfolio before the server confirms but then the market data handler overwrites the pending state. The re-render count is around 40 components per action, which is way too high for our 10ms UI latency target.\n\nWe've got about 1500 normalized entities (positions, trades, symbols) with complex graph relationships — a trade references a position, a position references a symbol, and chart parameters depend on symbol+timeframe. Optimistic updates are required for three operations: trade placements, limit adjustments, and portfolio rebalances. The undo/redo scope is the entire trading day, with regulatory compliance requirements: every undo action must be logged with timestamp, user ID, and the before/after state snapshot. Oh, and our target is ≤5 re-renders on a typical action (like updating a single position's P&L).\n\nI'm torn between three approaches:\n1. **Cats State monad** for a pure functional core, with Laminar `EventBus` for side effects. This gives us referential transparency and composable state transformations, but I worry about wiring the whole graph into a single state transaction and whether we can keep the subscription graph fine-grained enough to hit ≤5 re-renders.\n2. **Laminar's own reactive primitives** (`Signal`, `Var`, `EventBus`) with careful manual wiring. It's simple and works well for small apps, but I've seen it become spaghetti as the state graph grows. Also, how do we ensure consistent snapshots for undo without global coordination?\n3. **A custom Redux-like store** built on Laminar `Var` + `Observer`, with a middleware stack for optimistic updates, undo logging, and audit trails. This is similar to what we used in React, but I'm not sure it's idiomatic in the Scala.js ecosystem.\n\nI've attached a very rough spec of the regulatory constraints we're under (mostly record-keeping and audit trail requirements). What's your gut feeling? Have you dealt with this kind of multi-domain reactive state in a financial context before? I'm leaning toward something like a two-layer approach: a functional core with `StateT[IO, ...]` for pure state transitions, then a thin Laminar adapter that subscribes to the latest snapshot and diffs for targeted re-renders. But I'd love to hear your thoughts before I go down any rabbit hole.\n\nOh, one more thing — the latency budget is tight. Market data ticks come every 50ms, and we must update the UI within 10ms of receiving a trade confirmation. So the state engine itself must be blazing fast (sub-millisecond for a typical action).\n\nDocumentation:\n## Regulatory Compliance Requirements for Trading Platform State Management\n\n### Record-Keeping (SEC Rule 17a-3 / MiFID II Article 25)\nAll state changes must be logged with:\n- Unique action ID (UUID)\n- Timestamp (nanosecond precision, UTC)\n- User ID who initiated the action\n- Action type (trade_placement, limit_adjustment, rebalance, undo_redo, manual_correction)\n- Before-state snapshot (full serialized copy of affected state domain)\n- After-state snapshot\n- Client IP / session identifier\n\n### Undo/Redo Constraints\n- Undo scope: current trading day (UTC). Previous day actions are immutable.\n- Undo stack depth: unlimited within the trading day, but must be persisted to PostgreSQL every 10 actions (crash recovery).\n- Undo must preserve optimistic updates: if an optimistic trade was later confirmed/rejected, undoing to a point before that trade must restore the optimistically updated state (which may have been overwritten by server confirmation).\n- Regulatory audit trail: every undo must record which action is being reversed, and the entire before/after chain must be reconstructable.\n\n### Target Performance\n- End-to-end UI update latency from WebSocket tick to DOM update: ≤10ms (p99).\n- State transition execution: ≤100µs for a single entity update.\n- Undo snapshot generation (full serialization of 1500 entities): ≤5ms.\n- Re-render count per action: ≤5 DOM operations.\n\n### Entity Relationships (simplified)\n- Portfolio: contains positions (1:N)\n- Position: references a symbol (N:1), contains trades (1:N)\n- Trade: references a position (N:1), may have a counter-trade (1:1)\n- Symbol: referenced by positions and chart parameters\n- ChartParameters: references a symbol (1:1), timeframe, indicators\n- UserRiskLimits: global limits per user, checked during optimistic operations\n\n### Optimistic Update Requirements\n- Trade placement: immediately show pending trade in position P&L, revert on rejection.\n- Limit adjustment: immediately reflect new limit in UI, revert if server denies.\n- Portfolio rebalance: immediately redistribute positions to target allocation, revert if any trade fails.\n- Optimistic state must be rolled back if the server response differs within 2 seconds, else the optimistic state becomes canonical.\n\n### Audit Log Format (JSON example)\n```json\n{\n  "action_id": "a1b2c3d4-...",\n  "timestamp": "2026-04-19T14:23:05.123456789Z",\n  "user_id": "trader-42",\n  "action_type": "trade_placement",\n  "before_state": {\n    "portfolio": { "positions": [/* serialized positions */] },\n    "execution": { "pending_trades": [] }\n  },\n  "after_state": {\n    "portfolio": { "positions": [/* updated */] },\n    "execution": { "pending_trades": [{ "id": "txn-001", "status": "optimistic" }] }\n  },\n  "client_ip": "10.0.1.42"\n}\n```"
+#prompt = "HFT order book. PriceLevel objects (48 bytes) allocated/freed 5M/s. General-purpose allocator 19% CPU. Locked pool gives p99 latency spikes from mutex contention. PriceLevel.cpp and LockedObjectPool.h attached.\n\nReplace LockedObjectPool with a wait-free pool. Single producer (book update thread) allocates/frees. Multiple consumer threads only read PriceLevel members (no dealloc). Must avoid any atomic RMW (no cmpxchg, no fetch_add) in fast path – only aligned loads/stores. Thread-local for the producer thread is acceptable. pool must support dynamic growth? No – static pool of 1M slots is fine. Override operator new/delete on PriceLevel to use this pool.\n\nTarget: <1% CPU overhead for allocation. No lock acquisitions. No syscalls.\n\nExisting code below. Write new Pool.hpp and modified PriceLevel.hpp.\n\n<file path="include/PriceLevel.hpp" language="C++">\n#ifndef PRICELEVEL_HPP\n#define PRICELEVEL_HPP\n\n#include <cstdint>\n#include <atomic>\n#include <cstddef>\n#include <new>\n\nclass PriceLevel {\npublic:\n    PriceLevel(uint64_t price, char side)\n        : price_(price)\n        , side_(side)\n        , order_list_(nullptr)\n        , order_count_(0)\n        , total_volume_(0)\n    {}\n\n    // Accessors (called by consumer threads – must be safe for concurrent read)\n    uint64_t price() const noexcept { return price_; }\n    char side() const noexcept { return side_; }\n    uint64_t totalVolume() const noexcept { return total_volume_.load(std::memory_order_acquire); }\n    uint32_t orderCount() const noexcept { return order_count_.load(std::memory_order_acquire); }\n\n    // Mutators (called only by producer thread – no concurrency)\n    void addOrder(void* order_node, uint64_t volume) noexcept {\n        // push to linked list, update counts – single thread\n        // (implementation omitted for brevity in existing code)\n        // In real code: order_list_ = insert; order_count_++; total_volume_ += volume;\n        // But for this test we just show the pattern.\n        order_count_.fetch_add(1, std::memory_order_release);\n        total_volume_.fetch_add(volume, std::memory_order_release);\n    }\n\n    void removeOrder(void* order_node, uint64_t volume) noexcept {\n        order_count_.fetch_sub(1, std::memory_order_release);\n        total_volume_.fetch_sub(volume, std::memory_order_release);\n    }\n\n    // Custom allocator support\n    static void* operator new(std::size_t sz) {\n        return Pool::allocate(sz);\n    }\n\n    static void operator delete(void* ptr) noexcept {\n        Pool::deallocate(ptr);\n    }\n\nprivate:\n    uint64_t price_;\n    char side_;\n    void* order_list_;          // head of intrusive list (single producer)\n    std::atomic<uint32_t> order_count_{0};\n    std::atomic<uint64_t> total_volume_{0};\n\n    // Current slow pool – will be replaced\n    class Pool {\n    public:\n        static void* allocate(std::size_t) { return nullptr; }\n        static void deallocate(void*) {}\n    };\n};\n\n#endif // PRICELEVEL_HPP\n\n</file>\n\n<file path="src/LockedObjectPool.hpp" language="C++">\n#ifndef LOCKEDOBJECTPOOL_HPP\n#define LOCKEDOBJECTPOOL_HPP\n\n#include <cstddef>\n#include <mutex>\n#include <vector>\n#include <cstdint>\n\n// Current slow implementation – lock-based object pool.\n// Used by PriceLevel via Pool forward-declaration.\n// Must be replaced with a wait-free version.\n\nclass LockedObjectPool {\npublic:\n    LockedObjectPool(std::size_t object_size, std::size_t capacity = 1'000'000)\n        : object_size_(object_size)\n        , capacity_(capacity)\n    {\n        // Pre-allocate contiguous chunk of memory\n        chunk_ = static_cast<char*>(::operator new(object_size_ * capacity_));\n        free_list_.reserve(capacity_);\n        for (std::size_t i = 0; i < capacity_; ++i) {\n            free_list_.push_back(i);\n        }\n    }\n\n    ~LockedObjectPool() {\n        ::operator delete(chunk_);\n    }\n\n    // Allocate a block – O(1) amortized, but takes a lock\n    void* allocate() {\n        std::lock_guard<std::mutex> lock(mutex_);\n        if (free_list_.empty()) {\n            // Out of memory – should not happen in tuned system\n            return nullptr;\n        }\n        std::size_t index = free_list_.back();\n        free_list_.pop_back();\n        return chunk_ + index * object_size_;\n    }\n\n    // Deallocate – returns block to free list\n    void deallocate(void* ptr) {\n        if (!ptr) return;\n        std::size_t index = (static_cast<char*>(ptr) - chunk_) / object_size_;\n        std::lock_guard<std::mutex> lock(mutex_);\n        free_list_.push_back(index);\n    }\n\nprivate:\n    std::size_t object_size_;\n    std::size_t capacity_;\n    char* chunk_;\n    std::vector<std::size_t> free_list_;\n    std::mutex mutex_;\n};\n\n#endif // LOCKEDOBJECTPOOL_HPP\n\n</file>"
+messages = [
+    {"role": "user", "content": prompt}
+]
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+    enable_thinking=True # Switches between thinking and non-thinking modes. Default is True.
+)
+model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+# conduct text completion
+generated_ids = model.generate(
+    **model_inputs,
+    max_new_tokens=100000
+)
+output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 
+
+# parsing thinking content
+try:
+    # rindex finding 248069 (</think>)
+    index = len(output_ids) - output_ids[::-1].index(248069)
+except ValueError:
+    index = 0
+
+thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
+content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")
+
+print("thinking content:", thinking_content)
+print("content:", content)
+```
+
+
+Tachibana-Agent is one of our [Experimental Reasoning Models.](https://huggingface.co/collections/sequelbox/experimental-reasoning-models)
+
+Do as you will.

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if (preserve_thinking is defined and preserve_thinking is true) or (loop.index0 > ns.last_query_index) %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | string if args_value is string else args_value | tojson | safe %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,115 @@
+{
+  "architectures": [
+    "Qwen3_5ForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_output_gate": true,
+  "bos_token_id": 248044,
+  "dtype": "bfloat16",
+  "eos_token_id": 248044,
+  "full_attention_interval": 4,
+  "head_dim": 256,
+  "hidden_act": "silu",
+  "hidden_size": 5120,
+  "initializer_range": 0.02,
+  "intermediate_size": 17408,
+  "layer_types": [
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention"
+  ],
+  "linear_conv_kernel_dim": 4,
+  "linear_key_head_dim": 128,
+  "linear_num_key_heads": 16,
+  "linear_num_value_heads": 48,
+  "linear_value_head_dim": 128,
+  "mamba_ssm_dtype": "float32",
+  "max_position_embeddings": 262144,
+  "model_type": "qwen3_5_text",
+  "mtp_num_hidden_layers": 1,
+  "mtp_use_dedicated_embeddings": false,
+  "num_attention_heads": 24,
+  "num_hidden_layers": 64,
+  "num_key_value_heads": 4,
+  "output_gate_type": "swish",
+  "pad_token_id": null,
+  "partial_rotary_factor": 0.25,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "mrope_interleaved": true,
+    "mrope_section": [
+      11,
+      11,
+      10
+    ],
+    "partial_rotary_factor": 0.25,
+    "rope_theta": 10000000,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "5.8.0",
+  "use_cache": true,
+  "vocab_size": 248320
+}

configuration.json

@@ -0,0 +1 @@
+{"framework":"Pytorch","task":"image-text-to-text"}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 248044,
+  "do_sample": true,
+  "eos_token_id": [
+    248046,
+    248044
+  ],
+  "pad_token_id": 248044,
+  "temperature": 1.0,
+  "top_k": 20,
+  "top_p": 0.95,
+  "transformers_version": "5.8.0"
+}

model-00001-of-00014.safetensors

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

model-00002-of-00014.safetensors

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

model-00003-of-00014.safetensors

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

model-00004-of-00014.safetensors

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

model-00005-of-00014.safetensors

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

model-00006-of-00014.safetensors

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

model-00007-of-00014.safetensors

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

model-00008-of-00014.safetensors

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

model-00009-of-00014.safetensors

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

model-00010-of-00014.safetensors

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

model-00011-of-00014.safetensors

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

model-00012-of-00014.safetensors

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

model-00013-of-00014.safetensors

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

model-00014-of-00014.safetensors

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

preprocessor_config.json

@@ -0,0 +1,21 @@
+{
+    "size": {
+        "longest_edge": 16777216,
+        "shortest_edge": 65536
+    },
+    "patch_size": 16,
+    "temporal_patch_size": 2,
+    "merge_size": 2,
+    "image_mean": [
+        0.5,
+        0.5,
+        0.5
+    ],
+    "image_std": [
+        0.5,
+        0.5,
+        0.5
+    ],
+    "processor_class": "Qwen3VLProcessor",
+    "image_processor_type": "Qwen2VLImageProcessorFast"
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,32 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": false,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

video_preprocessor_config.json

@@ -0,0 +1,21 @@
+{
+    "size": {
+        "longest_edge": 25165824,
+        "shortest_edge": 4096
+    },
+    "patch_size": 16,
+    "temporal_patch_size": 2,
+    "merge_size": 2,
+    "image_mean": [
+        0.5,
+        0.5,
+        0.5
+    ],
+    "image_std": [
+        0.5,
+        0.5,
+        0.5
+    ],
+    "processor_class": "Qwen3VLProcessor",
+    "video_processor_type": "Qwen3VLVideoProcessor"
+}