Datasets:

beatsprom
/

deepseek-r1-systems-kernel-reasoning

id large_stringlengths 14 14	domain_id int64 1 20	domain large_stringclasses 20 values	language large_stringclasses 4 values	user_prompt large_stringclasses 80 values	assistant_response large_stringlengths 3.54k 6.61k	think_trace large_stringclasses 193 values	code_snippet large_stringlengths 1.89k 5.32k	tier large_stringclasses 1 value	lines_count int64 82 144
R1-SYS-01-0000	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Implement an ultra-low-latency, production-grade Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 targeting mission-critical 2026 systems infrastructure. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering where strictly r...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscLockFreeRingBuffer { public: static constexpr size_t Capacity = 1024; static constexpr size_t IndexMask = 1023; static constexpr siz...	starter	110
R1-SYS-01-0001	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Design an end-to-end high-throughput Lock-Free SPSC Cache-Aligned Ring Buffer implementation in C++20 with zero runtime heap allocation and strict cache line isolation. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering wh...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscAudioQueue { public: static constexpr size_t Capacity = 2048; static constexpr size_t IndexMask = 2047; static constexpr size_t Alig...	starter	110
R1-SYS-01-0002	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Architect a lock-free, boundary-resilient Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 engineered for sub-microsecond determinism under continuous high-frequency load. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency orderin...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscTelemetryRing { public: static constexpr size_t Capacity = 4096; static constexpr size_t IndexMask = 4095; static constexpr size_t A...	starter	110
R1-SYS-01-0003	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Construct an authentic hardware-sympathetic Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 ensuring complete memory barriers, acquire-release invariants, and zero false sharing. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscFixPacketPipe { public: static constexpr size_t Capacity = 8192; static constexpr size_t IndexMask = 8191; static constexpr size_t A...	starter	110
R1-SYS-01-0004	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Implement an ultra-low-latency, production-grade Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 targeting mission-critical 2026 systems infrastructure. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering where strictly r...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscOrderStream { public: static constexpr size_t Capacity = 16384; static constexpr size_t IndexMask = 16383; static constexpr size_t A...	starter	110
R1-SYS-01-0005	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Design an end-to-end high-throughput Lock-Free SPSC Cache-Aligned Ring Buffer implementation in C++20 with zero runtime heap allocation and strict cache line isolation. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering wh...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscMarketFeed { public: static constexpr size_t Capacity = 1024; static constexpr size_t IndexMask = 1023; static constexpr size_t Alig...	starter	110
R1-SYS-01-0006	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Architect a lock-free, boundary-resilient Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 engineered for sub-microsecond determinism under continuous high-frequency load. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency orderin...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscSensorChannel { public: static constexpr size_t Capacity = 2048; static constexpr size_t IndexMask = 2047; static constexpr size_t A...	starter	110
R1-SYS-01-0007	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Construct an authentic hardware-sympathetic Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 ensuring complete memory barriers, acquire-release invariants, and zero false sharing. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscTickBuffer { public: static constexpr size_t Capacity = 4096; static constexpr size_t IndexMask = 4095; static constexpr size_t Alig...	starter	110
R1-SYS-01-0008	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Implement an ultra-low-latency, production-grade Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 targeting mission-critical 2026 systems infrastructure. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering where strictly r...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscExecutionPipe { public: static constexpr size_t Capacity = 8192; static constexpr size_t IndexMask = 8191; static constexpr size_t A...	starter	110
R1-SYS-01-0009	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Design an end-to-end high-throughput Lock-Free SPSC Cache-Aligned Ring Buffer implementation in C++20 with zero runtime heap allocation and strict cache line isolation. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering wh...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscEventRing { public: static constexpr size_t Capacity = 16384; static constexpr size_t IndexMask = 16383; static constexpr size_t Ali...	starter	110
R1-SYS-01-0010	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Architect a lock-free, boundary-resilient Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 engineered for sub-microsecond determinism under continuous high-frequency load. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency orderin...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscLockFreeRingBuffer { public: static constexpr size_t Capacity = 1024; static constexpr size_t IndexMask = 1023; static constexpr siz...	starter	110
R1-SYS-01-0011	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Construct an authentic hardware-sympathetic Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 ensuring complete memory barriers, acquire-release invariants, and zero false sharing. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscAudioQueue { public: static constexpr size_t Capacity = 2048; static constexpr size_t IndexMask = 2047; static constexpr size_t Alig...	starter	110
R1-SYS-01-0012	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Implement an ultra-low-latency, production-grade Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 targeting mission-critical 2026 systems infrastructure. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering where strictly r...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscTelemetryRing { public: static constexpr size_t Capacity = 4096; static constexpr size_t IndexMask = 4095; static constexpr size_t A...	starter	110
R1-SYS-01-0013	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Design an end-to-end high-throughput Lock-Free SPSC Cache-Aligned Ring Buffer implementation in C++20 with zero runtime heap allocation and strict cache line isolation. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency ordering wh...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscFixPacketPipe { public: static constexpr size_t Capacity = 8192; static constexpr size_t IndexMask = 8191; static constexpr size_t A...	starter	110
R1-SYS-01-0014	1	Lock-Free SPSC Cache-Aligned Ring Buffer	C++20	Task Specification: Architect a lock-free, boundary-resilient Lock-Free SPSC Cache-Aligned Ring Buffer in C++20 engineered for sub-microsecond determinism under continuous high-frequency load. Technical Architecture Requirements: 1. Concurrency & Memory Model: Explicit acquire-release or sequential consistency orderin...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	<think> 1. Hardware Topology & Cache Coherency: The system targets x86-64 and AArch64 low-latency pipelines. L1 data cache lines are 64 bytes (or 128 bytes on dual-line prefetchers). To eliminate false sharing between the producer (writing head cursor) and consumer (writing tail cursor), each atomic sequence variabl...	#pragma once #include <atomic> #include <cstdint> #include <cstddef> #include <array> #include <new> #include <utility> #include <immintrin.h> template <typename T> class SpscOrderStream { public: static constexpr size_t Capacity = 16384; static constexpr size_t IndexMask = 16383; static constexpr size_t A...	starter	110

End of preview. Expand in Data Studio

🧠 DeepSeek-R1 Low-Level Systems & Kernel Reasoning Suite (2026)

🛒 Commercial Full Suite Available: The full production suite with 10,000 SFT Hardware Reasoning Traces + 2,500 High-Contrast DPO Alignment Pairs across all 20 domains is available on Gumroad:

👉 Download Full Commercial Dataset on Gumroad (Starter \ / Pro \ / Enterprise )

A Tier-1 Commercial Dataset Suite engineered specifically for fine-tuning DeepSeek-R1, DeepSeek-R1-Distill-Qwen-14B/32B, and frontier reasoning LLMs on mission-critical low-level systems engineering.

Every single sample features an authentic <think>...</think> hardware reasoning execution trace (cache hierarchy, memory ordering, boundary singularities) followed by 80 to 144 dense lines of production C++20, Rust, or C code.

⚡ Key Highlights

Free Hugging Face Preview: 1,000 verified reasoning rows in train.parquet.
100% Census Gatekeeper Passed:
- Zero placeholder stubs (TODO, FIXME, pass, // implement here) across 100% of rows.
- Exactly 0 rows under 80 lines of dense code.
- 100% real AST structural entropy across all clusters.
1-Click Unsloth Colab Harness: Fine-tune DeepSeek-R1-Distill-Qwen-14B in under 30 minutes with 4-bit QLoRA.

🏛️ The 20 Low-Level Systems Engineering Domains

Lock-Free SPSC Ring Buffer (C++20): alignas(64) false-sharing defense, acquire-release memory orders.
SIMD AVX-512 Vectorized Parser (C++20): Intrinsics _mm512_mask_loadu_epi8, branchless tokenizing.
Linux eBPF XDP Packet Filter (C): In-kernel verifier bounded memory, zero-copy packet interception.
Zero-Copy io_uring Event Loop (C/C++): Kernel SQE/CQE ring buffer lifecycle, direct I/O submission.
NUMA Static Arena Memory Allocator (C++20): 2MB hugepage bindings, zero dynamic heap fragmentation.
Hazard Pointers Reclaim Engine (C++20): Safe memory reclamation, ABA prevention, batch scans.
Rust Async Memory-Mapped WAL (Rust): msync durability pacing, hardware CRC32C framing.
Generational RCU Synchronizer (C++20): Quiescent epoch tracking, wait-free reader locks.
DPDK Network Burst Engine (C/C++): Poll-Mode Driver (PMD) zero-copy mbuf descriptor pools.
Chase-Lev Work-Stealing Deque (C++20): LIFO owner push/pop, FIFO worker steal with seq_cst fences.
Cache-Partitioned Robin Hood Hash Table (C++20): Backward-shift deletion, DFD variance bounding.
Rust Vectorized Limit Order Book (Rust): Pre-allocated level arrays, zero heap allocation on execution.
Hierarchical Hardware Timer Wheel (C++20): Deterministic O(1) scheduling, bitmask slot cascading.
Disruptor Multi-Producer Sequencer (C++20): Ring wrap gating defenses, published flag arrays.
PCIe P2P DMA Controller (C/C++): MMIO doorbell fences (_mm_sfence), 64-byte descriptor alignment.
POSIX Shared Memory & Futex IPC (C/C++): FUTEX_WAIT/FUTEX_WAKE, deadlock resilience.
Rust Safe Wire Protocol Parser (Rust): Zero-copy slice verification, network-to-host byte conversions.
Concurrent W-TinyLFU Cache (C++20): 4-bit Count-Min Sketch, scan-resistant frequency admission.
SIMD Roaring Bitset (C++20): AVX2 256-bit intersection, hardware _mm_popcnt_u64.
Kernel RDMA (RoCEv2) Queue Pair Engine (C/C++): Verbs memory registration, inline data limits.

📦 Commercial Tiers (Available on Gumroad)

Tier	Price	Contents	Target Audience
Starter Pack	$9	5,000 SFT Rows + Unsloth Colab + Whitepaper	Individual AI Builders & Engineers
Pro Suite	$29	5,000 SFT Rows + 2,500 DPO Alignment Pairs + Benchmark Dashboard + Eval Suite	Applied AI Teams & FinTech Startups
Enterprise Pack	$59	Full 10,000 SFT Rows + 2,500 DPO Pairs + SQLite DB + Commercial Enterprise License	Trading Firms & AI Labs

👉 Click Here to Purchase on Gumroad (Instant Download)

🛠️ Quickstart: Fine-Tuning with Unsloth

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/DeepSeek-R1-Distill-Qwen-14B",
    max_seq_length=max_seq_length,
    load_in_4bit=True,
)

Downloads last month: 56