bitsandbytes-cpu-fork 0.50.2.dev11__py3-none-win_amd64.whl → 0.50.2.dev12__py3-none-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
bitsandbytes/__init__.py CHANGED
@@ -75,7 +75,7 @@ __pdoc__ = {
75
75
  "optim.optimizer.MockArgs": False,
76
76
  }
77
77
 
78
- __version__ = "0.50.2.dev11"
78
+ __version__ = "0.50.2.dev12"
79
79
 
80
80
  # 挂载 gdn_cpu(GDN 融合内核 / patch_transformers 入口),让 bnb.gdn_cpu 可直接访问
81
81
  from . import gdn_cpu # noqa: E402,F401
Binary file
@@ -485,20 +485,39 @@ class Params4bit(torch.nn.Parameter):
485
485
 
486
486
 
487
487
  def fix_4bit_weight_quant_state_from_module(module: Union["Embedding4bit", "Linear4bit"]):
488
+ """Make sure a 4-bit module that is about to run has its quantization state attached.
489
+
490
+ Weights are quantized by ``.to(device)``, not by construction, so a freshly built layer that
491
+ never saw ``.to(...)`` still holds unquantized weights. That is by far the most common way to
492
+ hit this function, and it used to surface as a bare ``AssertionError`` (or, on CUDA builds, as
493
+ advice to move the layer to a CUDA device -- useless on this CPU-only fork). It now raises with
494
+ the fix in it.
495
+ """
488
496
  if getattr(module.weight, "quant_state", None) is not None:
489
497
  return
490
498
 
491
- if getattr(module, "quant_state", None) is None:
492
- logger.warning(
493
- "FP4 quantization state not initialized. Please call .cuda() or .to(device) on the LinearFP4 layer first.",
499
+ quant_state = getattr(module, "quant_state", None)
500
+ if quant_state is None:
501
+ raise RuntimeError(
502
+ f"{type(module).__name__} has no quantization state: its weights are still unquantized. "
503
+ "Weights are quantized by calling `.to(device)` on the layer, for example "
504
+ "`layer = layer.to('cpu')` on this CPU-only build. If you are restoring a checkpoint, "
505
+ "load a state dict that contains the 4-bit entries "
506
+ "(weight.absmax / weight.quant_map / weight.quant_state.bitsandbytes__*) "
507
+ "with `load_state_dict()`."
494
508
  )
495
509
 
496
- # the quant state got lost when the parameter got converted. This happens for example for fsdp
497
- # since we registered the module, we can recover the state here
498
- assert module.weight.shape[1] == 1
510
+ # The state was dropped from the parameter when it got converted (e.g. FSDP); the module still
511
+ # holds it, so recover it here.
512
+ if module.weight.shape[1] != 1:
513
+ raise RuntimeError(
514
+ f"{type(module).__name__} weight is not 4-bit packed (shape {tuple(module.weight.shape)}), "
515
+ "so the lost quantization state cannot be restored. Re-quantize the layer with `.to(device)`."
516
+ )
517
+ logger.debug("recovering lost 4-bit quantization state from the module")
499
518
  if not isinstance(module.weight, Params4bit):
500
519
  module.weight = Params4bit(module.weight, quant_storage=module.quant_storage, bnb_quantized=True)
501
- module.weight.quant_state = module.quant_state
520
+ module.weight.quant_state = quant_state
502
521
 
503
522
 
504
523
  class Linear4bit(nn.Linear):
@@ -606,6 +625,62 @@ class Linear4bit(nn.Linear):
606
625
  for k, v in self.weight.quant_state.as_dict(packed=True).items():
607
626
  destination[prefix + "weight." + k] = v if keep_vars else v.detach()
608
627
 
628
+ def _load_from_state_dict(
629
+ self,
630
+ state_dict,
631
+ prefix,
632
+ local_metadata,
633
+ strict,
634
+ missing_keys,
635
+ unexpected_keys,
636
+ error_msgs,
637
+ ):
638
+ """Load a state dict saved by :meth:`_save_to_state_dict`, quantization state included.
639
+
640
+ The 4-bit payload lives in ``weight`` while the extra entries written by
641
+ ``QuantState.as_dict(packed=True)`` (``weight.absmax``, ``weight.quant_map``,
642
+ ``weight.quant_state.bitsandbytes__nf4`` ...) are not parameters or buffers, so PyTorch's
643
+ default loader reports them as unexpected and a plain ``load_state_dict()`` of a quantized
644
+ layer used to fail. Rebuild the ``QuantState`` here instead.
645
+ """
646
+ weight_key = prefix + "weight"
647
+ stats_prefix = weight_key + "."
648
+ quantized_stats = {}
649
+ for key in list(state_dict.keys()):
650
+ if not key.startswith(stats_prefix):
651
+ continue
652
+ suffix = key[len(stats_prefix):]
653
+ if suffix in QuantState.valid_qs_keys or suffix.split(".")[-1] in QuantState.valid_qs_type_keys:
654
+ quantized_stats[suffix] = state_dict.pop(key)
655
+
656
+ if not quantized_stats or weight_key not in state_dict:
657
+ # Unquantized checkpoint (or a nested state dict): keep the default behaviour.
658
+ super()._load_from_state_dict(
659
+ state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs,
660
+ )
661
+ return
662
+
663
+ data = state_dict.pop(weight_key)
664
+ super()._load_from_state_dict(
665
+ state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs,
666
+ )
667
+ if weight_key in missing_keys: # `weight` was consumed above, not missing
668
+ missing_keys.remove(weight_key)
669
+ try:
670
+ self.weight = Params4bit.from_prequantized(
671
+ data=data, quantized_stats=quantized_stats, device=self.weight.device, module=self,
672
+ )
673
+ except Exception as exc: # noqa: BLE001 - reported through torch's error channel
674
+ error_msgs.append(
675
+ f"{type(self).__name__} could not rebuild its 4-bit quantization state from the "
676
+ f"checkpoint ({type(exc).__name__}: {exc}). Save the layer with `state_dict()` and "
677
+ "load it with `load_state_dict()`, or restore it manually with "
678
+ "`Params4bit.from_prequantized(...)`.",
679
+ )
680
+ return
681
+ self.quant_state = self.weight.quant_state
682
+ self.compute_type_is_set = self.compute_dtype is not None
683
+
609
684
  def forward(self, x: torch.Tensor):
610
685
  fix_4bit_weight_quant_state_from_module(self)
611
686
  quant_state = self.weight.quant_state
@@ -861,7 +936,10 @@ class Embedding8bit(nn.Embedding):
861
936
 
862
937
  def forward(self, input: Tensor) -> Tensor:
863
938
  if not hasattr(self.weight, "SCB"):
864
- raise RuntimeError("Embedding layer is not quantized. Please call .cuda() or .to(device) first.")
939
+ raise RuntimeError(
940
+ "Embedding layer is not quantized: weights are quantized by calling `.to(device)` "
941
+ "on the layer, for example `.to('cpu')` on this CPU-only build.",
942
+ )
865
943
 
866
944
  rows = self.weight.data
867
945
  row_stats = self.weight.SCB
@@ -1144,8 +1222,9 @@ class Linear8bitLt(nn.Linear):
1144
1222
  if weight_scb is None:
1145
1223
  # buffers not yet initialized, can't access them directly without quantizing first
1146
1224
  raise RuntimeError(
1147
- "Loading a quantized checkpoint into non-quantized Linear8bitLt is "
1148
- "not supported. Please call module.cuda() before module.load_state_dict()",
1225
+ "Loading a quantized checkpoint into non-quantized Linear8bitLt is not "
1226
+ "supported. Call `.to(device)` on the module before `load_state_dict()` "
1227
+ "(on this CPU-only build: `.to('cpu')`).",
1149
1228
  )
1150
1229
 
1151
1230
  input_param = state_dict[key]
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.4
2
2
  Name: bitsandbytes-cpu-fork
3
- Version: 0.50.2.dev11
3
+ Version: 0.50.2.dev12
4
4
  Summary: bitsandbytes with a pure-CPU training backend (AVX2 / NEON): 8-bit optimizers, fused GDN, gemm_8bit, disk balancer. No GPU required.
5
5
  License-Expression: MIT
6
6
  Project-URL: repository, https://github.com/Ganyvnanoaa09-0906/bitsandbytes-CPU
@@ -36,7 +36,7 @@ Dynamic: license-file
36
36
  > toolkit and no driver** — just an AVX2 x86-64 CPU (or ARM64 NEON), the CPU build of PyTorch,
37
37
  > and 12–16 GB of RAM.
38
38
 
39
- **Version: `0.50.2.dev11`** · import name is unchanged (`import bitsandbytes as bnb`) · MIT.
39
+ **Version: `0.50.2.dev12`** · import name is unchanged (`import bitsandbytes as bnb`) · MIT.
40
40
 
41
41
  What the CPU backend provides: 8-bit blockwise optimizers (≈2.3 bytes of state per parameter
42
42
  instead of 8; the 4-bit optimizer ≈1.03), 4/8-bit layers that run on CPU tensors, the fused
@@ -57,6 +57,15 @@ pip install bitsandbytes-cpu-fork
57
57
  python -m bitsandbytes # prints version / platform / library info
58
58
  ```
59
59
 
60
+ If upstream `bitsandbytes` is already installed, **uninstall bitsandbytes first**: this fork
61
+ deliberately keeps the `bitsandbytes` import name (so transformers / peft / diffusers integrations
62
+ need no change), and pip will let the two distributions overwrite each other's files.
63
+
64
+ ```bash
65
+ pip uninstall -y bitsandbytes
66
+ pip install bitsandbytes-cpu-fork
67
+ ```
68
+
60
69
  Requirements: Python ≥ 3.10 (64-bit), PyTorch ≥ 2.0 CPU build, x86-64 with AVX2 (a generic
61
70
  SSE2 fallback is shipped) or ARM64 with NEON, Windows 10/11 or Linux glibc ≥ 2.17.
62
71
 
@@ -130,6 +139,31 @@ layer = layer.to("cpu") # .to() is what quantises the weights
130
139
  y = layer(torch.randn(2, 1024))
131
140
  ```
132
141
 
142
+ Quantising an **existing** fp32/bf16 layer (the usual case) means moving the weights in first:
143
+
144
+ ```python
145
+ orig = torch.nn.Linear(1024, 1024)
146
+ layer = bnb.nn.Linear4bit(orig.in_features, orig.out_features,
147
+ quant_type="nf4", compute_dtype=torch.float32)
148
+ layer.weight = bnb.nn.Params4bit(orig.weight.detach().clone(), quant_type="nf4", blocksize=64)
149
+ layer = layer.to("cpu") # quantisation happens here; calling forward() before this raises
150
+ out = layer(torch.randn(2, 1024))
151
+ ```
152
+
153
+ Checkpoints round-trip through the ordinary API -- the 4-bit payload and the quantization state are
154
+ saved together and restored by `load_state_dict()`:
155
+
156
+ ```python
157
+ sd = layer.state_dict()
158
+ fresh = bnb.nn.Linear4bit(1024, 1024, quant_type="nf4", compute_dtype=torch.float32)
159
+ fresh.load_state_dict(sd)
160
+ fresh = fresh.to("cpu") # already quantized: this keeps the loaded state
161
+ assert torch.equal(layer(x), fresh(x))
162
+ ```
163
+
164
+ Only if you split the state dict by hand do you need the low-level form:
165
+ `bnb.nn.Params4bit.from_prequantized(quantized_stats=sd, data=sd.pop("weight"), device="cpu")`.
166
+
133
167
  ### Fused Gated DeltaNet (Qwen3-Next / Qwen3.5 linear attention)
134
168
 
135
169
  ```python
@@ -197,6 +231,36 @@ Also: `estimate_training_memory_gb()`, `spawn_training_jobs(cmds, plan)` (logs p
197
231
 
198
232
  ---
199
233
 
234
+ ## Threading: which knob actually controls the CPU kernels
235
+
236
+ The CPU kernels parallelise with **OpenMP**. `torch.set_num_threads()` only affects PyTorch's own
237
+ operators; it does **not** change how many threads a bnb kernel uses. Use the environment, set
238
+ before the process starts (it is read at import time):
239
+
240
+ ```bash
241
+ OMP_NUM_THREADS=4 python train.py
242
+ ```
243
+
244
+ Measured on the 6-core reference laptop (4-bit dequantize, 2048x4096, one process at a time):
245
+
246
+ | setting | time |
247
+ |---|---|
248
+ | `torch.set_num_threads(1)` | 4.5 ms |
249
+ | `torch.set_num_threads(6)` | 5.2 ms -- not the knob |
250
+ | `OMP_NUM_THREADS=1` | 6.7 ms |
251
+ | `OMP_NUM_THREADS=6` | 4.4 ms |
252
+
253
+ Two consequences for training loops:
254
+
255
+ - **Match the two settings.** `torch.set_num_threads(6)` on a 6-thread CPU plus the default
256
+ OpenMP pool oversubscribes the machine; set `OMP_NUM_THREADS` to the same value.
257
+ - **DataLoader workers inherit the environment.** Set `OMP_NUM_THREADS` before workers are forked,
258
+ otherwise every worker starts a full OpenMP pool.
259
+
260
+ `torch_cpu_kit.tune_threads()` (above) calibrates a real step instead of guessing.
261
+
262
+ ---
263
+
200
264
  ## What is inside the CPU backend
201
265
 
202
266
  | Area | What it does |
@@ -308,6 +372,47 @@ the full trade-off tables, including negative results.
308
372
 
309
373
  ---
310
374
 
375
+ ### What the quantized paths cost
376
+
377
+ Numbers from one 6-core reference laptop (R5-4500U, AVX2, no GPU), one process at a time. Read them
378
+ as the shape of the trade-off, not as universal constants.
379
+
380
+ **4-bit layer inference on CPU is a memory win, not a speed win.** Weight memory drops ~20x
381
+ (a 2048x2048 layer: 4.0 MB fp32 -> 0.2 MB) but every forward pass dequantizes, so it is slower than
382
+ the fp32 layer:
383
+
384
+ | batch | fp32 | 4-bit | 4-bit / fp32 |
385
+ |---|---|---|---|
386
+ | 1 | 1.33 ms | 5.32 ms | 4.00x slower |
387
+ | 8 | 4.34 ms | 7.66 ms | 1.76x slower |
388
+ | 64 | 5.67 ms | 9.57 ms | 1.69x slower |
389
+
390
+ **8-bit optimizer: the win depends on the tensor size, not only on the parameter count.** The same
391
+ 32M parameters, arranged differently (`optimizer.step()` only):
392
+
393
+ | layout | fp32 | 8-bit | ratio |
394
+ |---|---|---|---|
395
+ | 1 tensor x 32M | 177.1 ms | 93.6 ms | 0.53x (faster) |
396
+ | 32 tensors x 1M | 155.8 ms | 127.0 ms | 0.82x |
397
+ | 128 tensors x 250k | 126.9 ms | 154.7 ms | 1.22x (slower) |
398
+
399
+ There is a fixed **per-tensor** cost, so 8-bit pays off once a tensor holds roughly **1M elements**
400
+ or more; on many tiny tensors it can be slower than fp32. Real transformer layouts are dominated by
401
+ large matrices, which is why full-model numbers still favour it (GPT2-124M, 148 tensors: 445 ms vs
402
+ 688 ms fp32).
403
+
404
+ **8-bit vs 4-bit vs fp32, three-way** (`optimizer.step()`, real GPT-2 architectures):
405
+
406
+ | model | fp32 | 8-bit | 4-bit | state per parameter |
407
+ |---|---|---|---|---|
408
+ | GPT2-124M (148 tensors) | 688 ms | **445 ms** | 1151 ms | 8.00 / 2.04 / 1.03 B |
409
+ | GPT2-345M (292 tensors) | 1962 ms | **1304 ms** | 3995 ms | 8.00 / 2.04 / 1.03 B |
410
+
411
+ Default to 8-bit. Reach for 4-bit only when the optimizer state has to be smaller than the 4x
412
+ reduction 8-bit already gives, and accept the ~2x slower step.
413
+
414
+ ---
415
+
311
416
  ## Platform limitations
312
417
 
313
418
  - **CPU only.** CUDA/ROCm/XPU kernels are not built; a GPU is never required or used.
@@ -384,6 +489,38 @@ The long-form docs live in the repository (`bitsandbytes/docs_cpu/`, Chinese and
384
489
  - [`ISA_MATRIX.md`](https://github.com/Ganyvnanoaa09-0906/bitsandbytes-CPU/blob/HEAD/bitsandbytes/docs_cpu/ISA_MATRIX.md) — x86 AVX2/generic/AVX-512 + aarch64 test matrix
385
490
  - [`WHEEL_PLATFORM_NOTES.md`](https://github.com/Ganyvnanoaa09-0906/bitsandbytes-CPU/blob/HEAD/bitsandbytes/docs_cpu/WHEEL_PLATFORM_NOTES.md) — which wheel runs where, and why
386
491
 
492
+ ## Video on CPU (verified)
493
+
494
+ Inference is verified: LCM-LoRA 3.7–4.4× (512² / 192²-6f), ONNX Runtime fp32 UNet + async VAE
495
+ **43 frames 257.0 s vs 280.9 s (1.09×)** with per-frame PSNR **73.2 dB** vs torch fp32 (18-frame
496
+ control run: 71.95 dB); int8 UNet is unusable (11.04 dB). Training (AnimateDiff 5D LoRA) runs
497
+ end-to-end on CPU (~11.2 s/step, 5.9 GB, loss/checkpoint/sample produced) but **learned motion
498
+ is not demonstrated** — all seven demo runs report `has_global_motion=False`; temporal-only LoRA
499
+ measured harmful, spatial rank4/151 steps is the usable recipe so far. Details and negative
500
+ results: `VIDEO_GUIDE.md`.
501
+
502
+ ## Project extras (outside the library API)
503
+
504
+ The repository also ships the tooling used to build and verify the releases; none of it is
505
+ imported by the library:
506
+
507
+ - **Audio capability benches** — `scripts/bench/audio/`: ASR `faster-whisper-small` int8
508
+ **5.8x realtime / WER 0**, Piper TTS **15-18x**, Kokoro-82M **1.9-2.1x**, training-cost tiers
509
+ (tiny CNN / 19M VITS-proxy / 185M Whisper-proxy) and a real KWS training demo. Weights are
510
+ never committed; bad input exits 2.
511
+ - **Video E2E pipeline** — `scripts/video/` + `VIDEO_GUIDE.md`: stage-wise generation/training,
512
+ motion diagnostics, and the six dev11 perf fixes (all six cores, no grad checkpointing,
513
+ flush denormals, 5-thread training default).
514
+ - **NTFS recovery toolkit** — `bitsandbytes/tools/`: `sector_mirror` (bad-sector mirror with
515
+ resume), `mft_recover` (deleted files straight from `$MFT`), `sector_carve` (PNG/JPEG/GIF/
516
+ ZIP incl. docx-xlsx-pptx/PDF/MP4); each has a CLI + GUI and a byte-for-byte selftest.
517
+ - **Release engineering** — `tools/`: `normalize_sdist.py` + `check_sdist_identity.py` audit the
518
+ **uploaded bytes** (2-DLL policy, sha256-only; 16 selftest + 20 adversarial cases), plus the
519
+ normalize-limit and docs-gate suites. dev11's sdist was rebuilt twice from `git archive` and
520
+ matched on the normalized tar sha.
521
+ - **AR experiments** — `gt1030/ar_*`, `scripts/lib/small_image_model_v2.py` (documented in the
522
+ devlog; not part of the library API).
523
+
387
524
  ## Changelog
388
525
 
389
526
  | Version | Changes |
@@ -398,6 +535,7 @@ The long-form docs live in the repository (`bitsandbytes/docs_cpu/`, Chinese and
398
535
  | `0.50.2.dev8` | **restored `AdamW4bit`** (the kernel was dropped when dev4 vendored upstream; now scalar C kernel + torch fallback, 1.031 B/param); **new `bitsandbytes.q3bit` API** — `quantize_3bit`/`dequantize_3bit`/`gemm_3bit`/`gemm_3bit_transposed`, `QuantLinear3bit` (frozen 3-bit base + LoRA), `convert_linears_3bit`, native kernels on Linux with identical pure-torch fallback; CLI reference now includes 4bitopt/q3bit and all 43 examples execute in CI-style verification |
399
536
  | `0.50.2.dev9` | **Windows native kernels**: CI now compiles the MSVC DLL from the current csrc and the export list includes the 4-bit optimizer and 2/3-bit symbols (they were silently missing before); **q3bit real-model validation** on Qwen3-1.7B (frozen 3-bit base + LoRA, eval 4.34→4.03 over 80 steps, RSS −67%, native step 7.7 s vs fp32 5.5 s); fixed the causal-LM **double-shift** label bug in the iGPU training kit (Windows package v0.1.2) |
400
537
  | `0.50.2.dev10` | **NTFS recovery toolkit** (`sector_carve`, `mft_recover`, CLI + GUI, selftests) and the **video E2E pipeline** (generation/training, LCM and motion diagnostics); AVX2 4-bit GEMV fixes (wrong FP4 codebook, lazy-init race, non-divisible blocksize); gt1030 probe scripts and docs |
538
+ | `0.50.2.dev12` | description sync with the verified video results (43 frames 257.0 vs 280.9 s, per-frame PSNR 73.2 dB; training is loop-verified only), 4-bit CPU usability audit fixes (9 issues), `exp/ue8m0/` negative-result archive |
401
539
  | `0.50.2.dev11` | **NT-store fast paths**: 4-bit dequant writes bypass the cache above 16 MiB (1.7–2.0× at 32–64 MB) and RMSNorm chooses NT by total footprint (x+res+out vs per-CCX L3); CPUID L3-sharing mask fix and the NT threshold wired to one macro; **byte-reproducible sdist** with an identity gate that audits the uploaded bytes (`--sdist`, 2-DLL policy, 20 adversarial cases) plus a docs gate requiring all six ZH/EN docs; repo regrouping into `scripts/*`; UTF-8 BOM strip; 5 reproducible CPU audio benches; 6 video perf fixes and 3 AR fixes |
402
540
 
403
541
  ## License and attribution
@@ -1,5 +1,5 @@
1
1
  bitsandbytes_cpu_cli.py,sha256=s3ujm0Z4v-rgiQyNuCsvN09R9PcVL9hm2KgyhU-AYkQ,54395
2
- bitsandbytes/__init__.py,sha256=Uf8S9hd88rw3MlVFxJu-Iaw9ohYg6-QDfXEvNr0Nfng,2599
2
+ bitsandbytes/__init__.py,sha256=oh3ZjskHsCwsJv_j8XuSU7Ao8xToZay6XX1C-NUfzio,2599
3
3
  bitsandbytes/__main__.py,sha256=_ObgXmW-NG395jj_oP86gSOw2LgqMtrGBmpjZOiRcuY,94
4
4
  bitsandbytes/_cpu_caps.py,sha256=dhSCbMNDV6DQXkYQLlWBJqV4llci4SSmue-ST9lyOYM,4801
5
5
  bitsandbytes/_ops.py,sha256=G6jalkQVarTc0riBO7EEPYfC4u1iEAX-JGmlnkzxB8g,21166
@@ -12,7 +12,7 @@ bitsandbytes/disk_balancer.py,sha256=TpoN03oGRumaea_80zFnqdV3r6NnX8K2nsHKGoW2tVQ
12
12
  bitsandbytes/efst.py,sha256=pSOx0QOkX8hKmfGGPEaPqfFvy85r4KW4kJMl3wFPkmk,32004
13
13
  bitsandbytes/functional.py,sha256=Varc_MDtT0fUQxRmvFkesKmRpUVnZyonpHzNcl_ZAAk,68650
14
14
  bitsandbytes/gdn_cpu.py,sha256=3q2U1Ci6nYqNvnedn_tgFPegYLLjIBkpSlIHv9r1rPI,28028
15
- bitsandbytes/libbitsandbytes_cpu.dll,sha256=VyaFnYJtYGTcPVTDqyILE_ZoIPBt4Np1n3VCcFeCPb8,403968
15
+ bitsandbytes/libbitsandbytes_cpu.dll,sha256=3hrjoZ8snxAAdIg6Rkv-RdMQMOmRVKQ38kS0w0tczuw,403968
16
16
  bitsandbytes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
17
17
  bitsandbytes/q3bit.py,sha256=jgO9hkl-0hmDleT8ajiBOI1J-griBUlnxsaRmHsUlH0,22247
18
18
  bitsandbytes/torch_cpu_kit.py,sha256=G5iH2-r39kh3z4Ml5PCAP54qB5XRxJqAcBqYBmW02vI,33638
@@ -47,7 +47,7 @@ bitsandbytes/fused/__init__.py,sha256=cmo7kxroCx7qfJZDApR5cHBCScCM89QxdHz7nVoED8
47
47
  bitsandbytes/fused/_native.py,sha256=dNqboa2mSDG6oGrMnKJA2AN3mY6hbrTIP9nX5quMdUI,2083
48
48
  bitsandbytes/fused/_ref.py,sha256=h2aBZ8ZDOt-iD64xOMgyIYeWsJjByLOQEFukGzoiNnE,2466
49
49
  bitsandbytes/nn/__init__.py,sha256=MHhyc2sKbGEQNOb0-tyiDHkmiVI_XYVV3swD1K1Y7uI,451
50
- bitsandbytes/nn/modules.py,sha256=iQJUedMwq-NQA-tG6gqRGZKXi9QI5RW99gIIi2ESwlA,45482
50
+ bitsandbytes/nn/modules.py,sha256=S-Vv92f-s1EN5jWLZGQjVlYM-FAB-1yTz-xW1SgEEKU,49564
51
51
  bitsandbytes/nn/parametrize.py,sha256=thoaELsxt09Xe6GhOnZL-GI8EqxBWncXEQu-TqLo1lM,8571
52
52
  bitsandbytes/optim/__init__.py,sha256=EkIYA4vgFG5xst5EIsm0YLawg8iXgvLCT5goXiGyqBE,1118
53
53
  bitsandbytes/optim/adagrad.py,sha256=5KV3AyV-aA6NL9c43owtwe_5tlEwXRDS2WF5v3OQg6M,6961
@@ -61,9 +61,9 @@ bitsandbytes/optim/lion.py,sha256=WmRuaeVntkjkKvIivVh7t3Ac-nqKWFxtZ3NShQc3rJM,85
61
61
  bitsandbytes/optim/optimizer.py,sha256=pS8X47Bo3sgkDDIkGEp8C6stE-ZM_Hx1DvFWExyg9MI,28883
62
62
  bitsandbytes/optim/rmsprop.py,sha256=wJel4HgLjCPEHjcB5vPFZF6HleKD4vh1ILYt0dPR0is,6304
63
63
  bitsandbytes/optim/sgd.py,sha256=UYydMLYpBnW3nj4tnIq5FYjkhOLXz8YBaISKHQ3go6Q,5068
64
- bitsandbytes_cpu_fork-0.50.2.dev11.dist-info/licenses/LICENSE,sha256=8IqUv7C9wdfxy1m62vD4xVGxDbhxGFYi2_H9A2r_qcs,1107
65
- bitsandbytes_cpu_fork-0.50.2.dev11.dist-info/METADATA,sha256=G6CdHT9pgnKlRgGvVsSaMLvyuFWBJ6rI2DrqO1WEE1w,23954
66
- bitsandbytes_cpu_fork-0.50.2.dev11.dist-info/WHEEL,sha256=5s7VO_HUPfjwcO4LINqxGe8JSFZAGgaurQKPGA4cx_g,97
67
- bitsandbytes_cpu_fork-0.50.2.dev11.dist-info/entry_points.txt,sha256=GqLu5Rm-j-9_CvhqX0jVecyJShA1XGmxRoPEiibJpcI,99
68
- bitsandbytes_cpu_fork-0.50.2.dev11.dist-info/top_level.txt,sha256=l9ip7vjQq1JV6CB_ZGntWtjfxpkH119NDxupnJho9k0,34
69
- bitsandbytes_cpu_fork-0.50.2.dev11.dist-info/RECORD,,
64
+ bitsandbytes_cpu_fork-0.50.2.dev12.dist-info/licenses/LICENSE,sha256=8IqUv7C9wdfxy1m62vD4xVGxDbhxGFYi2_H9A2r_qcs,1107
65
+ bitsandbytes_cpu_fork-0.50.2.dev12.dist-info/METADATA,sha256=RBlUF_WqtVPXMf2uglUI8g_UIJ33frIyxcsLoEYUcm0,30749
66
+ bitsandbytes_cpu_fork-0.50.2.dev12.dist-info/WHEEL,sha256=5s7VO_HUPfjwcO4LINqxGe8JSFZAGgaurQKPGA4cx_g,97
67
+ bitsandbytes_cpu_fork-0.50.2.dev12.dist-info/entry_points.txt,sha256=GqLu5Rm-j-9_CvhqX0jVecyJShA1XGmxRoPEiibJpcI,99
68
+ bitsandbytes_cpu_fork-0.50.2.dev12.dist-info/top_level.txt,sha256=l9ip7vjQq1JV6CB_ZGntWtjfxpkH119NDxupnJho9k0,34
69
+ bitsandbytes_cpu_fork-0.50.2.dev12.dist-info/RECORD,,