weed-loader-cpu 0.3.1__tar.gz

weed_loader_cpu-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2023 vm6502q
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

weed_loader_cpu-0.3.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include weed_loader/weed_system/weed_lib/*
+include weed_loader/weed_system/cl_precompile/*
+include Makefile

weed_loader_cpu-0.3.1/Makefile

@@ -0,0 +1,81 @@
+PYTHON3 := $(shell which python3 2>/dev/null)
+
+PYTHON := python3
+
+UNAME_S := $(shell uname -s)
+UNAME_P := $(shell uname -p)
+QRACK_PRESENT := $(wildcard qrack/.)
+WEED_PRESENT := $(wildcard weed/.)
+
+ifeq ("$(wildcard /usr/local/bin/cmake)", "/usr/local/bin/cmake")
+CMAKE_L := /usr/local/bin/cmake
+else
+ifeq ("$(wildcard /usr/bin/cmake)", "/usr/bin/cmake")
+CMAKE_L := /usr/bin/cmake
+else
+CMAKE_L := cmake
+endif
+endif
+
+.PHONY: help
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  build-deps         to build Weed-Loader C++ dependencies"
+	@echo "  install            to install Weed-Loader"
+	@echo "  wheel              to build the Weed-Loader wheel"
+	@echo "  dist               to package the source distribution"
+
+.PHONY: build-deps
+build-deps:
+ifneq ($(OS),Windows_NT)
+ifeq ($(QRACK_PRESENT),)
+	git clone https://github.com/unitaryfund/qrack.git; cd qrack; git checkout f11a8c6a402b6e230328a5934d07b71d8429a423; cd ..
+endif
+	mkdir -p qrack/build
+ifeq ($(UNAME_S),Linux)
+ifneq ($(filter $(UNAME_P),x86_64 i386),)
+	cd qrack/build; $(CMAKE_L) -DENABLE_OPENCL=OFF -DCPP_STD=14 -DENABLE_RDRAND=OFF -DENABLE_DEVRAND=ON -DQBCAPPOW=8 ..; make qrack qrack_cl_precompile; cd ../..
+else
+	cd qrack/build; $(CMAKE_L) -DENABLE_OPENCL=OFF -DCPP_STD=14 -DENABLE_RDRAND=OFF -DENABLE_DEVRAND=ON -DENABLE_COMPLEX_X2=OFF -DENABLE_SSE3=OFF -DQBCAPPOW=8 ..; make qrack qrack_cl_precompile; cd ../..
+endif
+	mkdir -p qrack/build/qrack
+	cp -r qrack/include/* qrack/build/qrack
+	cp -r qrack/build/include/* qrack/build/qrack
+endif
+ifeq ($(UNAME_S),Darwin)
+ifneq ($(filter $(UNAME_P),x86_64 i386),)
+	cd qrack/build; $(CMAKE_L) -DENABLE_OPENCL=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCPP_STD=14 -DENABLE_OPENCL=OFF -DQBCAPPOW=8 ..; sudo make install; cd ../..
+else
+	cd qrack/build; $(CMAKE_L) -DENABLE_OPENCL=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCPP_STD=14 -DENABLE_OPENCL=OFF -DENABLE_RDRAND=OFF -DENABLE_COMPLEX_X2=OFF -DENABLE_SSE3=OFF -DQBCAPPOW=8 ..; sudo make install; cd ../..
+endif
+endif
+	rm -rf weed_loader/weed_system/weed_lib
+	rm -rf weed_loader/weed_system/weed_cl_precompile
+ifeq ($(WEED_PRESENT),)
+	git clone https://github.com/vm6502q/weed.git; cd weed; git checkout e1a4769f2bc15ae20a07095f0e991ced8a387e29; cd ..
+endif
+	mkdir -p weed/build
+ifeq ($(UNAME_S),Linux)
+	cd weed/build; $(CMAKE_L) -DWEED_ENABLE_OPENCL=OFF -DWEED_TCAPPOW=6 -DWEED_CPP_STD=14 -DQRACK_INCLUDE="../qrack/build" -DQRACK_DIR="../qrack/build" ..; make weed_shared weed_cl_precompile; cd ../..
+endif
+ifeq ($(UNAME_S),Darwin)
+	cd weed/build; cmake -DWEED_ENABLE_OPENCL=OFF -DWEED_TCAPPOW=6 -DWEED_CPP_STD=14 ..; make weed_shared weed_cl_precompile; cd ../..
+endif
+	mkdir weed_loader/weed_system/weed_lib; cp weed/build/libweed_shared.* weed_loader/weed_system/weed_lib/
+	mkdir weed_loader/weed_system/cl_precompile; cp weed/build/weed_cl_precompile weed_loader/weed_system/cl_precompile/; cp qrack/build/qrack_cl_precompile weed_loader/weed_system/cl_precompile/
+endif
+
+.PHONY: install
+install:
+ifndef PYTHON3
+	@echo "To install Weed-Loader you need to have Python 3 installed"
+endif
+	$(PYTHON) setup.py install
+
+.PHONY: wheel
+wheel:
+	$(PYTHON) setup.py bdist_wheel
+
+.PHONY: dist
+dist:
+	$(PYTHON) setup.py sdist

weed_loader_cpu-0.3.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: weed_loader_cpu
+Version: 0.3.1
+Summary: Weed (Loader) - Minimalist AI/ML inference and backprogation
+Home-page: https://github.com/vm6502q/weed
+Author: Daniel Strano
+Author-email: stranoj@gmail.com
+License: MIT
+Keywords: weed ai ml inference gpu opencl
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.0
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+<img width="1536" height="1024" alt="weed_logo" src="https://github.com/vm6502q/weed/blob/main/weed_logo.png" />
+
+# Weed
+Minimalist AI/ML inference and backprogation in the style of [Qrack](https://github.com/unitaryfoundation/qrack)
+
+## Weed Loader
+This repository is for the **Python loader** for (C++) Weed models. Once you have trained models in C++, you can load them for use by Python with this project. See the [Weed repository](https://github.com/vm6502q/weed) for more information.
+
+## Development Status
+**Weed** is a rapidly-developing **work-in-progress**. Its ABI may change drastically and without notice.
+
+The project provides a set of essential CPU and GPU **kernels**, used by `Tensor` instances that perform _autograd._ We also provide _stochastic gradient descent (SGD)_ and _Adam_ optimizer implementations. (Build and check the API reference to get started.)
+
+GPT-2, BERT, and Qwen loading is experimental and mostly provided as proof-of-concept, also of the fine-tuning pipeline. Implementation was from published literature design, rather than direct analysis of any open source, to implement these model architectures. Their outputs, in **Weed**, are not yet coherent English, as a result.
+
+## Why try Weed?
+
+With the growing popularity of AI/ML tools and workflows (including LLMs), legacy frameworks often carry "code debt" from over a decade of rapidly developing research history. This has led them to "bolt on" new features and advancements to design principles decided before the latest research. Popular frameworks also commonly started based in Python (maybe to capture early adoption), only later potentially "tacking on" a C++ library for special-case deployment needs. These conditions have produced libraries and frameworks with complicated dependency trees that occupy upward of a GB of disk footprint. This entire ecosystem might be due for a "refresh."
+
+**Weed** does not seek to fully replace or supplant established frameworks. However, it aims for **minimalist complete closure** on the primitives necessary for high-performance AI/ML inference and back-propagation. Chiefly, this includes **kernels**, and a `Tensor` interface that immediately produces an **autograd** graph appropriate for training. Allowing **optional** OpenCL for **hardware acceleration**, it will remain **free of required dependencies** outside of C++(11) language standard.
+
+Rethinking AI/ML library design this way, `Weed` has realized a rather unique and powerful form of _sparsification_ of `Tensor` **storage**. _Sparseness_ should **not** be a **`Tensor` interface concern**, but rather a **`Storage` concern**. Inspired by the design of the [Qrack](https://github.com/unitaryfoundation/qrack) quantum computer simulation framework, the `Tensor` interface treats **sparse and dense** tensors as **functionally equivalent**. Sparse optimization is so "transparently streamlined," this way, that it defaults to enabled for CPU-based tensors, and we recommend you leave it enabled at all times.
+
+Much like `Qrack`, `Weed` is designed to make the correct thing the default—and the expensive thing explicit.
+
+## Copyright, License, and Acknowledgments
+
+Copyright (c) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+
+In its `include/common` folder, Weed bundles a copy of [`rapidcsv` by Kristofer Berggren](https://github.com/d99kris/rapidcsv), reused under a BSD 3-Clause License. (This is a convenience and suggestion to Weed's users, for loading CSVs.)
+
+The Weed logo was produced with assistance from "Elara," an OpenAI custom GPT, and it is in the **public domain**. Elara has also been responsible for a huge amount of coaching and implementation drafts for Dan Strano to review and bring into line with standards, so she should be credited with coauthorship in any capacity that can be allowed. (Anthropic) Claude has also helped mostly with debugging, as well as developing an LLM front-end, fine-tuning interface, and modules for popular transformer model architectures, so they should rightly be credited similarly as a coauthor.
+
+Licensed under the GNU Lesser General Public License V3.
+
+See [LICENSE.md](https://github.com/vm6502q/qrack/blob/main/LICENSE.md) in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html for details.

weed_loader_cpu-0.3.1/README.md

@@ -0,0 +1,36 @@
+<img width="1536" height="1024" alt="weed_logo" src="https://github.com/vm6502q/weed/blob/main/weed_logo.png" />
+
+# Weed
+Minimalist AI/ML inference and backprogation in the style of [Qrack](https://github.com/unitaryfoundation/qrack)
+
+## Weed Loader
+This repository is for the **Python loader** for (C++) Weed models. Once you have trained models in C++, you can load them for use by Python with this project. See the [Weed repository](https://github.com/vm6502q/weed) for more information.
+
+## Development Status
+**Weed** is a rapidly-developing **work-in-progress**. Its ABI may change drastically and without notice.
+
+The project provides a set of essential CPU and GPU **kernels**, used by `Tensor` instances that perform _autograd._ We also provide _stochastic gradient descent (SGD)_ and _Adam_ optimizer implementations. (Build and check the API reference to get started.)
+
+GPT-2, BERT, and Qwen loading is experimental and mostly provided as proof-of-concept, also of the fine-tuning pipeline. Implementation was from published literature design, rather than direct analysis of any open source, to implement these model architectures. Their outputs, in **Weed**, are not yet coherent English, as a result.
+
+## Why try Weed?
+
+With the growing popularity of AI/ML tools and workflows (including LLMs), legacy frameworks often carry "code debt" from over a decade of rapidly developing research history. This has led them to "bolt on" new features and advancements to design principles decided before the latest research. Popular frameworks also commonly started based in Python (maybe to capture early adoption), only later potentially "tacking on" a C++ library for special-case deployment needs. These conditions have produced libraries and frameworks with complicated dependency trees that occupy upward of a GB of disk footprint. This entire ecosystem might be due for a "refresh."
+
+**Weed** does not seek to fully replace or supplant established frameworks. However, it aims for **minimalist complete closure** on the primitives necessary for high-performance AI/ML inference and back-propagation. Chiefly, this includes **kernels**, and a `Tensor` interface that immediately produces an **autograd** graph appropriate for training. Allowing **optional** OpenCL for **hardware acceleration**, it will remain **free of required dependencies** outside of C++(11) language standard.
+
+Rethinking AI/ML library design this way, `Weed` has realized a rather unique and powerful form of _sparsification_ of `Tensor` **storage**. _Sparseness_ should **not** be a **`Tensor` interface concern**, but rather a **`Storage` concern**. Inspired by the design of the [Qrack](https://github.com/unitaryfoundation/qrack) quantum computer simulation framework, the `Tensor` interface treats **sparse and dense** tensors as **functionally equivalent**. Sparse optimization is so "transparently streamlined," this way, that it defaults to enabled for CPU-based tensors, and we recommend you leave it enabled at all times.
+
+Much like `Qrack`, `Weed` is designed to make the correct thing the default—and the expensive thing explicit.
+
+## Copyright, License, and Acknowledgments
+
+Copyright (c) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+
+In its `include/common` folder, Weed bundles a copy of [`rapidcsv` by Kristofer Berggren](https://github.com/d99kris/rapidcsv), reused under a BSD 3-Clause License. (This is a convenience and suggestion to Weed's users, for loading CSVs.)
+
+The Weed logo was produced with assistance from "Elara," an OpenAI custom GPT, and it is in the **public domain**. Elara has also been responsible for a huge amount of coaching and implementation drafts for Dan Strano to review and bring into line with standards, so she should be credited with coauthorship in any capacity that can be allowed. (Anthropic) Claude has also helped mostly with debugging, as well as developing an LLM front-end, fine-tuning interface, and modules for popular transformer model architectures, so they should rightly be credited similarly as a coauthor.
+
+Licensed under the GNU Lesser General Public License V3.
+
+See [LICENSE.md](https://github.com/vm6502q/qrack/blob/main/LICENSE.md) in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html for details.

weed_loader_cpu-0.3.1/pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

weed_loader_cpu-0.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

weed_loader_cpu-0.3.1/setup.py

@@ -0,0 +1,75 @@
+# Adapted from https://github.com/Qiskit/qiskit-aer/blob/master/setup.py
+
+import os
+import sys
+import subprocess
+from setuptools import setup
+from setuptools.command.build_py import build_py
+
+
+VERSION = "0.3.1"
+
+# Read long description from README.
+README_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'README.md')
+with open(README_PATH) as readme_file:
+    README = readme_file.read()
+
+
+class Build(build_py):
+    def run(self):
+        protoc_command = ["make", "build-deps"]
+        if os.name != "nt":
+            if subprocess.call(protoc_command) != 0:
+                sys.exit(-1)
+        super().run()
+
+
+setup(
+    name='weed_loader_cpu',
+    version=VERSION,
+    packages=['weed_loader', 'weed_loader.weed_system'],
+    cmdclass={"build_py": Build},
+    description="Weed (Loader) - Minimalist AI/ML inference and backprogation",
+    long_description=README,
+    long_description_content_type='text/markdown',
+    url="https://github.com/vm6502q/weed",
+    author="Daniel Strano",
+    author_email="stranoj@gmail.com",
+    license="MIT",
+    classifiers=[
+        "Environment :: Console",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "Operating System :: Microsoft :: Windows",
+        "Operating System :: MacOS",
+        "Operating System :: POSIX :: Linux",
+        "Programming Language :: C++",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.5",
+        "Programming Language :: Python :: 2.6",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.0",
+        "Programming Language :: Python :: 3.1",
+        "Programming Language :: Python :: 3.2",
+        "Programming Language :: Python :: 3.3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    keywords="weed ai ml inference gpu opencl",
+    install_requires=[],
+    setup_requires=[],
+    extras_require={},
+    include_package_data=True,
+    zip_safe=False
+)

weed_loader_cpu-0.3.1/weed_loader/__init__.py

@@ -0,0 +1,12 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+#
+# Weed is for minimalist AI/ML inference and backprogation in the style of
+# Qrack.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+from .dtype import DType
+from .weed_module import WeedModule
+from .weed_tensor import WeedTensor
+from .weed_system import WeedSystem, Weed

weed_loader_cpu-0.3.1/weed_loader/dtype.py

@@ -0,0 +1,17 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+#
+# Weed is for minimalist AI/ML inference and backprogation in the style of
+# Qrack.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+from enum import IntEnum
+
+
+class DType(IntEnum):
+    NONE_DTYPE = 0
+    REAL = 1
+    COMPLEX = 2
+    INT = 3
+    DEFAULT_DTYPE = REAL

weed_loader_cpu-0.3.1/weed_loader/weed_module.py

@@ -0,0 +1,157 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+import ctypes
+
+from .weed_system import Weed
+from .dtype import DType
+from .weed_tensor import WeedTensor
+
+
+class WeedModule:
+    """Holds a Weed module loaded from disk
+
+    Attributes:
+        mid(int): Corresponding module id.
+    """
+
+    def _get_error(self):
+        return Weed.weed_lib.get_error(self.mid)
+
+    def _throw_if_error(self):
+        if self._get_error() != 0:
+            raise RuntimeError("Weed C++ library raised exception.")
+
+    def __init__(self, file_path):
+        byte_string = file_path.encode('utf-8')
+        c_string_ptr = ctypes.c_char_p(byte_string)
+        self.mid = Weed.weed_lib.load_module(c_string_ptr)
+        self._throw_if_error()
+
+    def __del__(self):
+        mid = self.mid
+        self.mid = None
+        if mid is not None:
+            Weed.weed_lib.free_module(mid)
+
+    @staticmethod
+    def _int_byref(a):
+        return (ctypes.c_int * len(a))(*a)
+
+    @staticmethod
+    def _ulonglong_byref(a):
+        return (ctypes.c_ulonglong * len(a))(*a)
+
+    @staticmethod
+    def _longlong_byref(a):
+        return (ctypes.c_longlong * len(a))(*a)
+
+    @staticmethod
+    def _double_byref(a):
+        return (ctypes.c_double * len(a))(*a)
+
+    @staticmethod
+    def _complex_byref(a):
+        t = [(c.real, c.imag) for c in a]
+        return WeedModule._double_byref([float(item) for sublist in t for item in sublist])
+
+    @staticmethod
+    def _bool_byref(a):
+        return (ctypes.c_bool * len(a))(*a)
+
+    def reset_kv_cache(self):
+        return Weed.weed_lib.reset_kv_cache(self.mid)
+
+    def save(self, file_path):
+        byte_string = file_path.encode('utf-8')
+        c_string_ptr = ctypes.c_char_p(byte_string)
+        self.mid = Weed.weed_lib.save_module(self.mid, c_string_ptr)
+        self._throw_if_error()
+
+    def forward(self, t):
+        """Applies forward inference on tensor.
+
+        Applies the loaded model to the tensor "t" as input.
+
+        Args:
+            t (WeedTensor): The Tensor on which to apply the Module
+
+        Returns:
+            The WeedTensor output from the Module
+
+        Raises:
+            RuntimeError: Weed C++ library raised an exception.
+        """
+        if t.dtype == DType.INT:
+            Weed.weed_lib.forward_int(
+                self.mid,
+                t.dtype,
+                len(t.shape),
+                WeedModule._ulonglong_byref(t.shape),
+                WeedModule._longlong_byref(t.data)
+            )
+        else:
+            Weed.weed_lib.forward(
+                self.mid,
+                t.dtype,
+                len(t.shape),
+                WeedModule._ulonglong_byref(t.shape),
+                WeedModule._double_byref(t.data) if t.dtype == DType.REAL else WeedModule._complex_byref(t.data)
+            )
+        self._throw_if_error()
+
+        n = Weed.weed_lib.get_result_index_count(self.mid)
+
+        shape_out = (ctypes.c_ulonglong * n)()
+        stride_out = (ctypes.c_ulonglong * n)()
+        Weed.weed_lib.get_result_dims(self.mid, shape_out, stride_out)
+
+        dtype_out = DType(Weed.weed_lib.get_result_type(self.mid))
+
+        d_size_out = Weed.weed_lib.get_result_size(self.mid)
+        d_offset = Weed.weed_lib.get_result_offset(self.mid)
+
+        data_out = (ctypes.c_double * d_size_out)() if dtype_out == DType.REAL else (ctypes.c_double * (d_size_out << 1))()
+        Weed.weed_lib.get_result(self.mid, data_out)
+
+        self._throw_if_error()
+
+        shape_ptr = ctypes.cast(shape_out, ctypes.POINTER(ctypes.c_longlong))
+        stride_ptr = ctypes.cast(stride_out, ctypes.POINTER(ctypes.c_longlong))
+        double_ptr = ctypes.cast(data_out, ctypes.POINTER(ctypes.c_double))
+
+        if dtype_out == DType.REAL:
+            data = double_ptr[:d_size_out]
+        else:
+            data = []
+            for i in range(d_size_out):
+                j = i << 1
+                complex_num = complex(double_ptr[j], double_ptr[j + 1])
+                data.append(complex_num)
+
+        del double_ptr
+        del data_out
+
+        return WeedTensor(data, shape_ptr[:n], stride_ptr[:n], dtype_out, d_offset)
+
+    # Drafted by (Anthropic) Claude, improved by Dan Strano (iteratively)
+    def train_step(self, input_ids, target_ids, learning_rate):
+        """
+        Single fine-tuning step.
+        input_ids: list[int] — token ids for input sequence
+        target_ids: list[int] — token ids for targets (typically input shifted by 1)
+        """
+        seq_len = len(input_ids)
+
+        Weed.weed_lib.train_step(
+            self.mid,
+            1,                                           # n: number of shape dims
+            WeedModule._ulonglong_byref([seq_len]),      # shape: [seq_len]
+            WeedModule._longlong_byref(input_ids),       # input_ids
+            len(target_ids),                             # n_target
+            WeedModule._longlong_byref(target_ids),      # target_ids
+            ctypes.c_double(learning_rate)               # learning_rate
+        )
+        self._throw_if_error()

weed_loader_cpu-0.3.1/weed_loader/weed_system/__init__.py

@@ -0,0 +1,12 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+#
+# Weed is for minimalist AI/ML inference and backprogation in the style of
+# Qrack.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+from .weed_system import WeedSystem
+
+# Global entry-point for Weed shared library
+Weed = WeedSystem()

weed_loader_cpu-0.3.1/weed_loader/weed_system/weed_system.py

@@ -0,0 +1,121 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+#
+# Weed is for minimalist AI/ML inference and backprogation in the style of
+# Qrack.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+import os
+from ctypes import *
+from sys import platform as _platform
+
+
+class WeedSystem:
+    def __init__(self):
+        shared_lib_path = ""
+        if os.environ.get("WEED_SHARED_LIB_PATH") != None:
+            shared_lib_path = os.environ.get("WEED_SHARED_LIB_PATH")
+        elif _platform == "win32":
+            shared_lib_path = os.path.dirname(__file__) + "/weed_lib/weed_shared.dll"
+        elif _platform == "darwin":
+            shared_lib_path = os.path.dirname(__file__) + "/weed_lib/libweed_shared.dylib"
+        else:
+            shared_lib_path = os.path.dirname(__file__) + "/weed_lib/libweed_shared.so"
+
+        try:
+            self.weed_lib = CDLL(shared_lib_path)
+        except Exception as e:
+            if _platform == "win32":
+                shared_lib_path = "C:/Program Files (x86)/Weed/bin/weed_shared.dll"
+            elif _platform == "darwin":
+                shared_lib_path = "/usr/local/lib/weed/libweed_shared.dylib"
+            else:
+                shared_lib_path = "/usr/local/lib/weed/libweed_shared.so"
+
+            try:
+                self.weed_lib = CDLL(shared_lib_path)
+            except Exception as e:
+                if _platform == "win32":
+                    shared_lib_path = "C:/Program Files (x86)/Weed/bin/weed_shared.dll"
+                elif _platform == "darwin":
+                    shared_lib_path = "/usr/lib/weed/libweed_shared.dylib"
+                else:
+                    shared_lib_path = "/usr/lib/weed/libweed_shared.so"
+
+                try:
+                    self.weed_lib = CDLL(shared_lib_path)
+                except Exception as e:
+                    print(
+                        "IMPORTANT: Did you remember to install OpenCL, if your Weed version was built with OpenCL?"
+                    )
+                    raise e
+
+        self.weed_lib.get_error.restype = c_int
+        self.weed_lib.get_error.argtypes = [c_ulonglong]
+
+        self.weed_lib.load_module.restype = c_ulonglong
+        self.weed_lib.load_module.argtypes = [c_char_p]
+
+        self.weed_lib.save_module.restype = c_ulonglong
+        self.weed_lib.save_module.argtypes = [c_ulonglong, c_char_p]
+
+        self.weed_lib.free_module.restype = None
+        self.weed_lib.free_module.argtypes = [c_ulonglong]
+
+        self.weed_lib.forward.restype = None
+        self.weed_lib.forward.argtypes = [
+            c_ulonglong,
+            c_ulonglong,
+            c_ulonglong,
+            POINTER(c_ulonglong),
+            POINTER(c_double)
+        ]
+
+        self.weed_lib.forward_int.restype = None
+        self.weed_lib.forward_int.argtypes = [
+            c_ulonglong,
+            c_ulonglong,
+            c_ulonglong,
+            POINTER(c_ulonglong),
+            POINTER(c_longlong)
+        ]
+
+        self.weed_lib.get_result_index_count.restype = c_ulonglong
+        self.weed_lib.get_result_index_count.argtypes = [c_ulonglong]
+
+        self.weed_lib.get_result_dims.restype = None
+        self.weed_lib.get_result_dims.argtypes = [
+            c_ulonglong,
+            POINTER(c_ulonglong),
+            POINTER(c_ulonglong)
+        ]
+
+        self.weed_lib.get_result_size.restype = c_ulonglong
+        self.weed_lib.get_result_size.argtypes = [c_ulonglong]
+
+        self.weed_lib.get_result_offset.restype = c_ulonglong
+        self.weed_lib.get_result_offset.argtypes = [c_ulonglong]
+
+        self.weed_lib.get_result_type.restype = c_ulonglong
+        self.weed_lib.get_result_type.argtypes = [c_ulonglong]
+
+        self.weed_lib.get_result.restype = None
+        self.weed_lib.get_result.argtypes = [
+            c_ulonglong,
+            POINTER(c_double)
+        ]
+
+        self.weed_lib.train_step.restype = None
+        self.weed_lib.train_step.argtypes = [
+            c_ulonglong,
+            c_ulonglong,
+            POINTER(c_ulonglong),
+            POINTER(c_longlong),
+            c_ulonglong,
+            POINTER(c_longlong),
+            c_double
+        ]
+
+        self.weed_lib.reset_kv_cache.restype = None
+        self.weed_lib.reset_kv_cache.argtypes = [c_ulonglong]

weed_loader_cpu-0.3.1/weed_loader/weed_tensor.py

@@ -0,0 +1,60 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+import ctypes
+
+from .dtype import DType
+
+
+class WeedTensor:
+    """Container to hold tensor inputs and outputs
+
+    This is a "dumb" container that performs no math.
+    All it does is validate that (column-major) data
+    dimension matches "shape" and "stride."
+
+    Attributes:
+        offset(int): Offset into data storage
+        shape(List[int]): Shape of tensor indices
+        stride(List[int]): Stride of tensor storage
+        data(List): Real or complex data values
+        dtype(DType): Real or complex type of data
+    """
+
+    def __init__(self, data, shape, stride=None, dtype=DType.REAL, offset=0):
+        if stride is None:
+            st = 1
+            stride = []
+            for i in range(len(stride)):
+              stride.append(st)
+              st *= shape[i]
+        else:
+            if len(shape) != len(stride):
+                raise ValueError("WeedTensor shape length must match stride length!")
+            st = 1
+            for i in range(len(stride)):
+              if stride[i] == 0:
+                  continue
+
+              if stride[i] != st:
+                  raise ValueError("WeedTensor shape and stride must be contiguous!")
+
+              st *= shape[i]
+
+        sz = offset
+        for i in range(len(stride)):
+            sz += (shape[i] - 1) * stride[i]
+
+        if len(shape):
+            sz = sz + 1
+
+        if sz > len(data):
+            raise ValueError("WeedTensor shape and stride do not match data length!")
+
+        self.offset = offset
+        self.data = data
+        self.shape = shape
+        self.stride = stride
+        self.dtype = dtype

weed_loader_cpu-0.3.1/weed_loader_cpu.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: weed_loader_cpu
+Version: 0.3.1
+Summary: Weed (Loader) - Minimalist AI/ML inference and backprogation
+Home-page: https://github.com/vm6502q/weed
+Author: Daniel Strano
+Author-email: stranoj@gmail.com
+License: MIT
+Keywords: weed ai ml inference gpu opencl
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.0
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+<img width="1536" height="1024" alt="weed_logo" src="https://github.com/vm6502q/weed/blob/main/weed_logo.png" />
+
+# Weed
+Minimalist AI/ML inference and backprogation in the style of [Qrack](https://github.com/unitaryfoundation/qrack)
+
+## Weed Loader
+This repository is for the **Python loader** for (C++) Weed models. Once you have trained models in C++, you can load them for use by Python with this project. See the [Weed repository](https://github.com/vm6502q/weed) for more information.
+
+## Development Status
+**Weed** is a rapidly-developing **work-in-progress**. Its ABI may change drastically and without notice.
+
+The project provides a set of essential CPU and GPU **kernels**, used by `Tensor` instances that perform _autograd._ We also provide _stochastic gradient descent (SGD)_ and _Adam_ optimizer implementations. (Build and check the API reference to get started.)
+
+GPT-2, BERT, and Qwen loading is experimental and mostly provided as proof-of-concept, also of the fine-tuning pipeline. Implementation was from published literature design, rather than direct analysis of any open source, to implement these model architectures. Their outputs, in **Weed**, are not yet coherent English, as a result.
+
+## Why try Weed?
+
+With the growing popularity of AI/ML tools and workflows (including LLMs), legacy frameworks often carry "code debt" from over a decade of rapidly developing research history. This has led them to "bolt on" new features and advancements to design principles decided before the latest research. Popular frameworks also commonly started based in Python (maybe to capture early adoption), only later potentially "tacking on" a C++ library for special-case deployment needs. These conditions have produced libraries and frameworks with complicated dependency trees that occupy upward of a GB of disk footprint. This entire ecosystem might be due for a "refresh."
+
+**Weed** does not seek to fully replace or supplant established frameworks. However, it aims for **minimalist complete closure** on the primitives necessary for high-performance AI/ML inference and back-propagation. Chiefly, this includes **kernels**, and a `Tensor` interface that immediately produces an **autograd** graph appropriate for training. Allowing **optional** OpenCL for **hardware acceleration**, it will remain **free of required dependencies** outside of C++(11) language standard.
+
+Rethinking AI/ML library design this way, `Weed` has realized a rather unique and powerful form of _sparsification_ of `Tensor` **storage**. _Sparseness_ should **not** be a **`Tensor` interface concern**, but rather a **`Storage` concern**. Inspired by the design of the [Qrack](https://github.com/unitaryfoundation/qrack) quantum computer simulation framework, the `Tensor` interface treats **sparse and dense** tensors as **functionally equivalent**. Sparse optimization is so "transparently streamlined," this way, that it defaults to enabled for CPU-based tensors, and we recommend you leave it enabled at all times.
+
+Much like `Qrack`, `Weed` is designed to make the correct thing the default—and the expensive thing explicit.
+
+## Copyright, License, and Acknowledgments
+
+Copyright (c) Daniel Strano and the Qrack contributors 2017-2026. All rights reserved.
+
+In its `include/common` folder, Weed bundles a copy of [`rapidcsv` by Kristofer Berggren](https://github.com/d99kris/rapidcsv), reused under a BSD 3-Clause License. (This is a convenience and suggestion to Weed's users, for loading CSVs.)
+
+The Weed logo was produced with assistance from "Elara," an OpenAI custom GPT, and it is in the **public domain**. Elara has also been responsible for a huge amount of coaching and implementation drafts for Dan Strano to review and bring into line with standards, so she should be credited with coauthorship in any capacity that can be allowed. (Anthropic) Claude has also helped mostly with debugging, as well as developing an LLM front-end, fine-tuning interface, and modules for popular transformer model architectures, so they should rightly be credited similarly as a coauthor.
+
+Licensed under the GNU Lesser General Public License V3.
+
+See [LICENSE.md](https://github.com/vm6502q/qrack/blob/main/LICENSE.md) in the project root or https://www.gnu.org/licenses/lgpl-3.0.en.html for details.

weed_loader_cpu-0.3.1/weed_loader_cpu.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+Makefile
+README.md
+pyproject.toml
+setup.py
+weed_loader/__init__.py
+weed_loader/dtype.py
+weed_loader/weed_module.py
+weed_loader/weed_tensor.py
+weed_loader/weed_system/__init__.py
+weed_loader/weed_system/weed_system.py
+weed_loader_cpu.egg-info/PKG-INFO
+weed_loader_cpu.egg-info/SOURCES.txt
+weed_loader_cpu.egg-info/dependency_links.txt
+weed_loader_cpu.egg-info/not-zip-safe
+weed_loader_cpu.egg-info/top_level.txt

weed_loader_cpu-0.3.1/weed_loader_cpu.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

weed_loader_cpu-0.3.1/weed_loader_cpu.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

weed_loader_cpu-0.3.1/weed_loader_cpu.egg-info/top_level.txt

@@ -0,0 +1 @@
+weed_loader