tinygrad 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

tinygrad/runtime/ops_hip.py

@@ -1,82 +0,0 @@
-import numpy as np
-import ctypes, functools
-import extra.hip_wrapper as hip
-from tinygrad.helpers import DEBUG
-from tinygrad.ops import Compiled
-from tinygrad.runtime.lib import RawBufferCopyInOut, LRUAllocator
-from tinygrad.codegen.linearizer import LinearizerOptions
-from tinygrad.renderer.cstyle import uops_to_cstyle, CStyleLanguage
-
-# TODO: if you fork and exit the child process after creating anything with cl on AMD, it hangs on e.wait()
-if DEBUG >= 5:
-  from extra.helpers import enable_early_exec
-  early_exec = enable_early_exec()
-
-# The default HIP stream is used for everything.
-
-class HIPAllocator(LRUAllocator):
-  def _do_alloc(self, size, dtype, device, **kwargs): return hip.hipMalloc(size * dtype.itemsize)
-  def _do_free(self, buf): hip.hipFree(buf)
-  def _cached_bufkey(self, size, dtype, device): return (device, size*dtype.itemsize) # Buffers of the same length could be reused, no matter what dtype.
-HIPAlloc = HIPAllocator(hip.hipGetDeviceProperties(hip.hipGetDevice()).totalGlobalMem)
-
-class RawHIPBuffer(RawBufferCopyInOut):
-  def __init__(self, size, dtype): super().__init__(size, dtype, allocator=HIPAlloc)
-  def _copyin(self, x:np.ndarray): hip.hipMemcpyAsync_htod(self._buf, x.ctypes.data, self.size * self.dtype.itemsize, 0)
-  def _copyout(self, x:np.ndarray): hip.hipMemcpy_dtoh(x.ctypes.data, self._buf, self.size * self.dtype.itemsize)
-
-class HIPProgram:
-  def __init__(self, name:str, prg:str, binary=False):
-    try:
-      if not binary:
-        prog = hip.hiprtcCreateProgram(prg, name, [], [])
-        device_properties = hip.hipGetDeviceProperties(hip.hipGetDevice())
-        hip.hiprtcCompileProgram(prog, [f'--offload-arch={device_properties.gcnArchName}'])
-        prg = hip.hiprtcGetCode(prog)
-    except Exception as e:
-      if DEBUG >= 3: print("FAILED TO BUILD", prg)
-      raise e
-    if DEBUG >= 5:
-      asm = early_exec((["/opt/rocm/llvm/bin/llvm-objdump", '-d', '-'], prg))
-      print('\n'.join([x for x in asm.decode('utf-8').split("\n") if 's_code_end' not in x]))
-
-    module = hip.hipModuleLoadData(prg)
-    self.prg = hip.hipModuleGetFunction(module, name)
-
-  def __call__(self, global_size, local_size, *args, wait=False):
-    if wait:
-      start, end = hip.hipEventCreate(), hip.hipEventCreate()
-      hip.hipEventRecord(start)
-    class PackageStruct(ctypes.Structure):
-      _fields_ = [(f'field{idx}', ctypes.c_void_p) for idx in range(len(args))]
-    struct = PackageStruct(*[data._buf for data in args])
-    hip.hipModuleLaunchKernel(self.prg, global_size[0], global_size[1], global_size[2], local_size[0], local_size[1], local_size[2], 0, 0, struct)
-    if wait:
-      hip.hipEventRecord(end)
-      hip.hipEventSynchronize(end)
-      return hip.hipEventElapsedTime(start, end)*1e-3
-
-renderer = functools.partial(uops_to_cstyle, CStyleLanguage(
-  kernel_prefix = "#include <hip/hip_common.h>\n#define INFINITY (__builtin_inff())\n#define NAN (__builtin_nanf(\"\"))" + """
-__device__ float4 max(float4 x, float4 y) { return float4(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)); }
-__device__ float4 pow(float x, float4 y) { return float4(pow(x, y.x), pow(x, y.y), pow(x, y.z), pow(x, y.w)); }
-__device__ float4 pow(float4 x, float4 y) { return float4(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)); }
-__device__ float4 log2(float4 x) { return float4(log2(x.x), log2(x.y), log2(x.z), log2(x.w)); }
-__device__ float4 exp2(float4 x) { return float4(exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)); }
-__device__ float4 sin(float4 x) { return float4(sin(x.x), sin(x.y), sin(x.z), sin(x.w)); }
-typedef float float8 __attribute__((ext_vector_type(8)));
-typedef _Float16 half16 __attribute__((ext_vector_type(16)));
-extern "C" __global__
-  """, launch_bounds=True,
-  smem_prefix = "__shared__ ", barrier = "__syncthreads();", float4 = "make_float4", uses_vload=True, uses_ptr_arithmetic=True,
-  half_prekernel = "#include <hip/hip_fp16.h>\nusing half4 = HIP_vector_type<half, 4>;" + """
-__device__ float vload_half(size_t offset, const half *p) { return (float)*(p + offset); }
-__device__ float2 vload_half2(size_t offset, const half *p) { return make_float2((float)*(p + offset*2), (float)*(p + offset*2 + 1)); }
-__device__ float4 vload_half4(size_t offset, const half *p) { return make_float4((float)*(p + offset*4), (float)*(p + offset*4 + 1), (float)*(p + offset*4 + 2), (float)*(p + offset*4 + 3)); }
-__device__ void vstore_half(float data, size_t offset, half *p) { *(p + offset) = (half)data; }
-__device__ void vstore_half2(float2 data, size_t offset, half *p) { *(p + offset*2) = (half)data.x; *(p + offset*2 + 1) = (half)data.y; }
-__device__ void vstore_half4(float4 data, size_t offset, half *p) { *(p + offset*4) = (half)data.x; *(p + offset*4 + 1) = (half)data.y; *(p + offset*4 + 2) = (half)data.z; *(p + offset*4 + 3) = (half)data.w; }
-  """,
-  gid = [f'blockIdx.{chr(120+i)}' for i in range(3)],
-  lid = [f'threadIdx.{chr(120+i)}' for i in range(3)]))
-HIPBuffer = Compiled(RawHIPBuffer, LinearizerOptions(), renderer, HIPProgram, hip.hipDeviceSynchronize)

tinygrad/runtime/ops_shm.py

@@ -1,29 +0,0 @@
-import os, mmap
-try: import _posixshmem    # type: ignore
-except Exception: pass
-from typing import Callable, Dict
-from tinygrad.helpers import DType
-from tinygrad.runtime.lib import RawBufferMapped
-from tinygrad.ops import Interpreted, Op, UnaryOps, MovementOps
-
-SHM_CACHE: Dict[str, mmap.mmap] = {}
-class RawShmBuffer(RawBufferMapped):
-  def __init__(self, size, dtype:DType, device:str):
-    device, self.cache_id = device.split(",")[0], None if "," not in device else device.split(",")[1]
-
-    if self.cache_id is not None and self.cache_id in SHM_CACHE: shm = SHM_CACHE[self.cache_id]
-    else:
-      fd = _posixshmem.shm_open(device, os.O_RDWR, 0o600)
-      # TODO: these flags are somewhat platform specific, but python doesn't expose the ones we need
-      shm = mmap.mmap(fd, size * dtype.itemsize, flags=mmap.MAP_SHARED | 0x2000 | 0x008000)
-      shm.madvise(mmap.MADV_HUGEPAGE)    # type: ignore
-      os.close(fd)
-      if self.cache_id is not None: SHM_CACHE[self.cache_id] = shm
-
-    super().__init__(size, dtype, shm)
-  def __del__(self):
-    if self.cache_id is None: self._buf.close()
-  def _buffer(self): return memoryview(self._buf)
-
-shm_fxn_for_op: Dict[Op, Callable] = { UnaryOps.NOOP: lambda x:x, MovementOps.RESHAPE: lambda x,_:x }
-ShmBuffer = Interpreted(RawShmBuffer, shm_fxn_for_op, to_underlying=lambda x:x, from_underlying=lambda x:x)

tinygrad/runtime/ops_torch.py

@@ -1,30 +0,0 @@
-import torch
-from typing import Dict, Callable, Optional
-from tinygrad.ops import UnaryOps, BinaryOps, MovementOps, TernaryOps, Op, Interpreted
-from tinygrad.helpers import getenv, dtypes, prod, DType
-from tinygrad.runtime.ops_cpu import base_fxn_for_op, einsum_mulacc
-from tinygrad.runtime.lib import RawBuffer
-
-device = torch.device("cuda:0" if torch.cuda.is_available() else ("mps" if getenv("MPS", 0) else "cpu"))
-type_map = {torch.float64: dtypes.float64, torch.float16: dtypes.float16, torch.float32: dtypes.float32, torch.int8: dtypes.int8, torch.int32: dtypes.int32, torch.int64: dtypes.int64, torch.uint8: dtypes.uint8, torch.bool: dtypes.bool}
-inverse_type_map = {v:k for k,v in type_map.items()}
-
-torch_fxn_for_op: Dict[Op, Callable] = {**base_fxn_for_op, **{
-  UnaryOps.NOOP: lambda x: x.contiguous(), UnaryOps.SQRT: lambda x: x.sqrt(), UnaryOps.EXP2: lambda x: x.exp2(), UnaryOps.LOG2: lambda x: x.log2(), UnaryOps.SIN: torch.sin,
-  UnaryOps.CAST: lambda x,y: (x.view if y[1] else x.type)(next(k for k,v in type_map.items() if v==y[0])),
-  BinaryOps.MAX: torch.maximum, BinaryOps.CMPLT: lambda x,y: (x<y).type(torch.promote_types(x.dtype, y.dtype)),
-  MovementOps.PAD: lambda x, padding: torch.nn.functional.pad(x, [item for sublist in padding[::-1] for item in sublist]),
-  TernaryOps.MULACC: einsum_mulacc(lambda s,a,b: torch.einsum(s, a.float(), b.float()).type(torch.promote_types(a.dtype, b.dtype)), lambda x: x.stride(), lambda x,s: x.expand(s)),
-  TernaryOps.WHERE: lambda x, y, z: torch.where(x != 0, y, z),
-  MovementOps.STRIDE: lambda x, arg: x[tuple(slice(None, None, abs(i)) for i in arg)].flip([i for i,a in enumerate(arg) if a < 0]),
-  MovementOps.EXPAND: lambda x, arg: x.expand(arg), MovementOps.PERMUTE: lambda x, arg: x.permute(arg)
-}}
-
-class RawTorchBuffer(RawBuffer):
-  def __init__(self, size:int, dtype:DType, buf:Optional[torch.Tensor]=None): super().__init__(size, dtype, buf if buf is not None else torch.empty([size], dtype=inverse_type_map[dtype]))
-  @classmethod
-  def fromCPU(cls, x):
-    buf = torch.from_numpy(x).requires_grad_(False).to(device)
-    return cls(prod(x.shape), type_map[buf.dtype], buf)
-  def toCPU(self): return self._buf.cpu().numpy()
-TorchBuffer = Interpreted(RawTorchBuffer, torch_fxn_for_op, from_underlying=lambda x: RawTorchBuffer(prod(x.shape), type_map[x.dtype], x))

tinygrad/runtime/ops_webgpu.py

@@ -1,45 +0,0 @@
-import numpy as np
-import functools
-from wgpu.utils._device import get_default_device  # type: ignore
-from tinygrad.runtime.lib import RawBufferCopyIn, LRUAllocator
-from tinygrad.helpers import dtypes, DType
-from tinygrad.ops import Compiled
-from tinygrad.codegen.linearizer import LinearizerOptions
-from tinygrad.renderer.cstyle import uops_to_cstyle
-from tinygrad.renderer.wgsl import WGSLLanguage
-import wgpu  # type: ignore
-
-wgpu_device = get_default_device()
-
-class WebGPUProgram:
-  def __init__(self, name: str, prg: str, binary=False): self.name,self.prg = name,wgpu_device.create_shader_module(code=prg)
-  def __call__(self, global_size, local_size, *bufs, wait=False):
-    assert len(bufs) <= 8, "WEBGPU only supports 8 buffers"
-    binding_layouts = [{"binding": i, "visibility": wgpu.ShaderStage.COMPUTE, "buffer": {"type": wgpu.BufferBindingType.storage}} for i in range(len(bufs))]
-    bindings = [{"binding": i, "resource": {"buffer": x._buf, "offset": 0, "size": x._buf.size}} for i, x in enumerate(bufs)]
-    bind_group_layout = wgpu_device.create_bind_group_layout(entries=binding_layouts)
-    pipeline_layout = wgpu_device.create_pipeline_layout(bind_group_layouts=[bind_group_layout])
-    bind_group = wgpu_device.create_bind_group(layout=bind_group_layout, entries=bindings)
-    compute_pipeline = wgpu_device.create_compute_pipeline(layout=pipeline_layout,compute={"module": self.prg, "entry_point": self.name},)
-    command_encoder = wgpu_device.create_command_encoder()
-    compute_pass = command_encoder.begin_compute_pass()
-    compute_pass.set_pipeline(compute_pipeline)
-    compute_pass.set_bind_group(0, bind_group, [], 0, 999999) # last 2 not used
-    compute_pass.dispatch_workgroups(*global_size)  # x y z
-    compute_pass.end()
-    wgpu_device.queue.submit([command_encoder.finish()])
-
-class RawWebGPUAllocator(LRUAllocator):
-  def _do_alloc(self, size, dtype, device, **kwargs): return wgpu_device.create_buffer(size=size*dtype.itemsize, usage=wgpu.BufferUsage.STORAGE | wgpu.BufferUsage.COPY_DST | wgpu.BufferUsage.COPY_SRC)
-  def _cached_bufkey(self, size, dtype, device): return (device, size*dtype.itemsize) # Buffers of the same length could be reused, no matter what dtype.
-WebGPUAlloc = RawWebGPUAllocator(wgpu_device.limits['max_buffer_size'])
-
-class RawWebGPUBuffer(RawBufferCopyIn):
-  def __init__(self, size:int, dtype:DType):
-    assert dtype not in [dtypes.int8,dtypes.uint8,dtypes.int64,dtypes.uint64,dtypes.double], f"dtype {dtype} not supported on WEBGPU"
-    super().__init__(size, dtype, allocator=WebGPUAlloc)
-  def _copyin(self, x:np.ndarray): wgpu_device.queue.write_buffer(self._buf, 0, np.ascontiguousarray(x))
-  def toCPU(self) -> np.ndarray: return np.frombuffer(wgpu_device.queue.read_buffer(self._buf, 0), dtype=np.dtype(self.dtype.np, metadata={"backing": self})) # type: ignore
-
-renderer = functools.partial(uops_to_cstyle, WGSLLanguage())
-WebGpuBuffer = Compiled(RawWebGPUBuffer, LinearizerOptions(supports_float4=False, local_max=[256, 256, 64], global_max=[65535, 65535, 65535]), renderer, WebGPUProgram)

tinygrad-0.7.0.dist-info/METADATA

@@ -1,212 +0,0 @@
-Metadata-Version: 2.1
-Name: tinygrad
-Version: 0.7.0
-Summary: You like pytorch? You like micrograd? You love tinygrad! <3
-Author: George Hotz
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: requests
-Requires-Dist: pillow
-Requires-Dist: tqdm
-Requires-Dist: networkx
-Requires-Dist: pyopencl
-Requires-Dist: PyYAML
-Provides-Extra: arm
-Requires-Dist: unicorn ; extra == 'arm'
-Provides-Extra: cuda
-Requires-Dist: pycuda ; extra == 'cuda'
-Provides-Extra: linting
-Requires-Dist: flake8 ; extra == 'linting'
-Requires-Dist: pylint ; extra == 'linting'
-Requires-Dist: mypy ; extra == 'linting'
-Requires-Dist: pre-commit ; extra == 'linting'
-Provides-Extra: llvm
-Requires-Dist: llvmlite ; extra == 'llvm'
-Provides-Extra: metal
-Requires-Dist: pyobjc-framework-Metal ; extra == 'metal'
-Requires-Dist: pyobjc-framework-Cocoa ; extra == 'metal'
-Requires-Dist: pyobjc-framework-libdispatch ; extra == 'metal'
-Provides-Extra: testing
-Requires-Dist: torch ; extra == 'testing'
-Requires-Dist: pytest ; extra == 'testing'
-Requires-Dist: pytest-xdist ; extra == 'testing'
-Requires-Dist: onnx ; extra == 'testing'
-Requires-Dist: onnx2torch ; extra == 'testing'
-Requires-Dist: opencv-python ; extra == 'testing'
-Requires-Dist: tabulate ; extra == 'testing'
-Requires-Dist: safetensors ; extra == 'testing'
-Requires-Dist: types-PyYAML ; extra == 'testing'
-Requires-Dist: cloudpickle ; extra == 'testing'
-Requires-Dist: transformers ; extra == 'testing'
-Provides-Extra: triton
-Requires-Dist: triton >=2.0.0.dev20221202 ; extra == 'triton'
-Provides-Extra: webgpu
-Requires-Dist: wgpu ; extra == 'webgpu'
-
-<div align="center">
-
-[![logo](https://raw.githubusercontent.com/tinygrad/tinygrad/master/docs/logo.png)](https://tinygrad.org)
-
-tinygrad: For something between [PyTorch](https://github.com/pytorch/pytorch) and [karpathy/micrograd](https://github.com/karpathy/micrograd). Maintained by [tiny corp](https://tinygrad.org).
-
-<h3>
-
-[Homepage](https://github.com/tinygrad/tinygrad) | [Documentation](/docs) | [Examples](/examples) | [Showcase](/docs/showcase.md) | [Discord](https://discord.gg/ZjZadyC7PK)
-
-</h3>
-
-[![GitHub Repo stars](https://img.shields.io/github/stars/tinygrad/tinygrad)](https://github.com/tinygrad/tinygrad/stargazers)
-[![Unit Tests](https://github.com/tinygrad/tinygrad/actions/workflows/test.yml/badge.svg)](https://github.com/tinygrad/tinygrad/actions/workflows/test.yml)
-[![Discord](https://img.shields.io/discord/1068976834382925865)](https://discord.gg/ZjZadyC7PK)
-[![Lines of code](https://img.shields.io/tokei/lines/github/tinygrad/tinygrad)](https://github.com/tinygrad/tinygrad)
-
-</div>
-
----
-
-This may not be the best deep learning framework, but it is a deep learning framework.
-
-Due to its extreme simplicity, it aims to be the easiest framework to add new accelerators to, with support for both inference and training. If XLA is CISC, tinygrad is RISC.
-
-tinygrad is still alpha software, but we [raised some money](https://geohot.github.io/blog/jekyll/update/2023/05/24/the-tiny-corp-raised-5M.html) to make it good. Someday, we will tape out chips.
-
-## Features
-
-### LLaMA and Stable Diffusion
-
-tinygrad can run [LLaMA](/docs/showcase.md#llama) and [Stable Diffusion](/docs/showcase.md#stable-diffusion)!
-
-### Laziness
-
-Try a matmul. See how, despite the style, it is fused into one kernel with the power of laziness.
-
-```sh
-DEBUG=3 python3 -c "from tinygrad.tensor import Tensor;
-N = 1024; a, b = Tensor.rand(N, N), Tensor.rand(N, N);
-c = (a.reshape(N, 1, N) * b.permute(1,0).reshape(1, N, N)).sum(axis=2);
-print((c.numpy() - (a.numpy() @ b.numpy())).mean())"
-```
-
-And we can change `DEBUG` to `4` to see the generated code.
-
-### Neural networks
-
-As it turns out, 90% of what you need for neural networks are a decent autograd/tensor library.
-Throw in an optimizer, a data loader, and some compute, and you have all you need.
-
-#### Neural network example (from test/models/test_mnist.py)
-
-```py
-from tinygrad.tensor import Tensor
-import tinygrad.nn.optim as optim
-
-class TinyBobNet:
-  def __init__(self):
-    self.l1 = Tensor.uniform(784, 128)
-    self.l2 = Tensor.uniform(128, 10)
-
-  def forward(self, x):
-    return x.dot(self.l1).relu().dot(self.l2).log_softmax()
-
-model = TinyBobNet()
-optim = optim.SGD([model.l1, model.l2], lr=0.001)
-
-# ... complete data loader here
-
-out = model.forward(x)
-loss = out.mul(y).mean()
-optim.zero_grad()
-loss.backward()
-optim.step()
-```
-
-## Accelerators
-
-tinygrad already supports numerous accelerators, including:
-
-- [x] [CPU](tinygrad/runtime/ops_cpu.py)
-- [x] [GPU (OpenCL)](tinygrad/runtime/ops_gpu.py)
-- [x] [C Code (Clang)](tinygrad/runtime/ops_clang.py)
-- [x] [LLVM](tinygrad/runtime/ops_llvm.py)
-- [x] [METAL](tinygrad/runtime/ops_metal.py)
-- [x] [CUDA](tinygrad/runtime/ops_cuda.py)
-- [x] [Triton](extra/accel/triton/ops_triton.py)
-- [x] [PyTorch](tinygrad/runtime/ops_torch.py)
-- [x] [HIP](tinygrad/runtime/ops_hip.py)
-- [x] [WebGPU](tinygrad/runtime/ops_webgpu.py)
-
-And it is easy to add more! Your accelerator of choice only needs to support a total of 26 (optionally 27) low level ops.
-More information can be found in the [documentation for adding new accelerators](/docs/adding_new_accelerators.md).
-
-## Installation
-
-The current recommended way to install tinygrad is from source.
-
-### From source
-
-```sh
-git clone https://github.com/tinygrad/tinygrad.git
-cd tinygrad
-python3 -m pip install -e .
-```
-Don't forget the `.` at the end!
-
-## Documentation
-
-Documentation along with a quick start guide can be found in the [docs/](/docs) directory.
-
-### Quick example comparing to PyTorch
-
-```py
-from tinygrad.tensor import Tensor
-
-x = Tensor.eye(3, requires_grad=True)
-y = Tensor([[2.0,0,-2.0]], requires_grad=True)
-z = y.matmul(x).sum()
-z.backward()
-
-print(x.grad.numpy())  # dz/dx
-print(y.grad.numpy())  # dz/dy
-```
-
-The same thing but in PyTorch:
-```py
-import torch
-
-x = torch.eye(3, requires_grad=True)
-y = torch.tensor([[2.0,0,-2.0]], requires_grad=True)
-z = y.matmul(x).sum()
-z.backward()
-
-print(x.grad.numpy())  # dz/dx
-print(y.grad.numpy())  # dz/dy
-```
-
-## Contributing
-
-There has been a lot of interest in tinygrad lately. Here are some basic guidelines for contributing:
-
-- Bug fixes are the best and always welcome! Like [this one](https://github.com/tinygrad/tinygrad/pull/421/files).
-- If you don't understand the code you are changing, don't change it!
-- All code golf PRs will be closed, but [conceptual cleanups](https://github.com/tinygrad/tinygrad/pull/372/files) are great.
-- Features are welcome. Though if you are adding a feature, you need to include tests.
-- Improving test coverage is great, with reliable non-brittle tests.
-
-Additional guidelines can be found in [CONTRIBUTING.md](/CONTRIBUTING.md).
-
-### Running tests
-
-For more examples on how to run the full test suite please refer to the [CI workflow](.github/workflows/test.yml).
-
-Some examples:
-```sh
-python3 -m pip install -e '.[testing]'
-python3 -m pytest
-python3 -m pytest -v -k TestTrain
-python3 ./test/models/test_train.py TestTrain.test_efficientnet
-```

tinygrad-0.7.0.dist-info/RECORD

@@ -1,40 +0,0 @@
-tinygrad/graph.py,sha256=s5f1OQKb9AF8oYFMAl2oTIH7FRAsK-IZDJ7oG_mEVsc,3933
-tinygrad/helpers.py,sha256=dGbfameyEU60Or6CYGOIhZZk5RShMegD4ZvNmQaweDM,7073
-tinygrad/jit.py,sha256=kHYEMr6YQYHPu26ff5zQldx9xuYAjWhmiK6ag3PpVGo,3801
-tinygrad/lazy.py,sha256=63O1kONydeocrRI88iAXbxPC559PnAZNPhr6Gi6SjdA,22926
-tinygrad/mlops.py,sha256=pWFGP96p06pY9r8SDdGiyw7RzC10HqGtuFbJ-2aWvSU,7910
-tinygrad/ops.py,sha256=_h1CpDHoghauB6m3DEyhB1d2g64t2xT26nzFJn5quMk,13966
-tinygrad/tensor.py,sha256=xI82653sfLLPDvvVpIHpdlj7LsBqOR1hTvjSFahRpno,42142
-tinygrad/codegen/assembly.py,sha256=Vv6wFyxqTkgmfkZFFpmRCkV71gVjT170--T6X4Y-JO0,11033
-tinygrad/codegen/kernel.py,sha256=miUZtef3JXbDYxPhcif0C2sgVe2QyMs8SPi94O7cEjg,7416
-tinygrad/codegen/linearizer.py,sha256=rymEs3E5tmYdRbdTKobGst7JlAQHkkJbZFwcR6hTIpA,22228
-tinygrad/codegen/optimizer.py,sha256=Eq6oro8lZlb3-8qss025j3yn1Sg4qbKG03kJUjYnjpo,19961
-tinygrad/codegen/search.py,sha256=sYU7tw2suC_9T4lMiOvdQ5uDaMj_Daj4xhLiVvB8eGw,2881
-tinygrad/nn/__init__.py,sha256=k5BnAeWmE3s6J4iNLozZsZe4tIaa9OjRQAyWHd9xApk,7225
-tinygrad/nn/image.py,sha256=MAjbIUPXpGETloctzJvKbWJ59koz60hqrsK7TrWyaKE,5007
-tinygrad/nn/optim.py,sha256=9mcy0Cs0HC68AZEV3j_jhxgmiNUrTYW-ZoTWB9_Rr38,3466
-tinygrad/nn/state.py,sha256=mHsW1W5KDrc2yLNV-Mk_OFjObpAvch7XhC5ybDSWz_w,6773
-tinygrad/renderer/assembly_arm64.py,sha256=dc_IZtFETl6naMIJ0InNurL2COP67CwooUnaA9jexbI,8997
-tinygrad/renderer/assembly_ptx.py,sha256=wj8--S-re8yXBZ5YsP1aCsLvguaUrsmn6qbRYAyxJhg,6508
-tinygrad/renderer/cstyle.py,sha256=v52rzVXkrEnb8OQYCmsa5g_90qwr5qiYUzaLjqujtlQ,11334
-tinygrad/renderer/llvmir.py,sha256=n0FGxjbztwyDv7AZZpjEDirCIHS07t9AuXFR_5rcrx4,8965
-tinygrad/renderer/wgsl.py,sha256=ATQVyrLwPh2K1Zgff-_ZF6v5JHHmaHwHKjlzwmV5ySI,3154
-tinygrad/runtime/lib.py,sha256=Xy8_4h7f72aeFakSQUflc5tyBprhLNzN2htQhWk5SHo,6383
-tinygrad/runtime/ops_clang.py,sha256=tCgjBiTn7sg6AGWWfBqVf_spaddkDNE0ctqbIGq3c5k,4929
-tinygrad/runtime/ops_cpu.py,sha256=dI813Q1l2k23NJFptgJZcrZBQNHJ7-WtprjxjZKZGCk,3676
-tinygrad/runtime/ops_cuda.py,sha256=-KmYL9dNrXEtveXNA9lM2cuDePYEAwx3nizJ3bMynPY,6333
-tinygrad/runtime/ops_disk.py,sha256=SJQVat4_ic-1EOmHA4A3HUzACZ6hZodH60OLvS26hfg,2224
-tinygrad/runtime/ops_gpu.py,sha256=0Rg_WVZRYbQPRe8xFxqGVBcOkIrf4nnNAqWQDxmYNj0,6980
-tinygrad/runtime/ops_hip.py,sha256=5UCgFwHZHm7Ta7-IqTv9T1ir4T35uAoWiPGSSLySOmc,5051
-tinygrad/runtime/ops_llvm.py,sha256=HDU1DwU43-EGMMu9k08piKKuglNZw8LViY-dFU_G2i0,2826
-tinygrad/runtime/ops_metal.py,sha256=eXXf-pkojU3LtHCy7MhKOg45p80G_f2UhwZ7t6qEQ2c,5284
-tinygrad/runtime/ops_shm.py,sha256=MgQwCDlP5n0h937tBlDTaCxuiIGRvBaJFW7vEqwKnnE,1363
-tinygrad/runtime/ops_torch.py,sha256=LDR_3ajKer6HECcs-UyhxCWwscooggKx_MS5zjVNops,2335
-tinygrad/runtime/ops_webgpu.py,sha256=8gbJa2sAeFXtBmFOCR1FbziV0ZXFl7mbFb8r5HGH_1Y,3070
-tinygrad/shape/shapetracker.py,sha256=ks5xoWg_8F4VNHtjJUlbxe_CGyCVD4SI78dmObO3xww,15046
-tinygrad/shape/symbolic.py,sha256=QI3ACNfGv8ZQUvjplmFguAs3w3W5lfbHz8b-Hk1NsmY,13921
-tinygrad-0.7.0.dist-info/LICENSE,sha256=6cp1Hqk0v7NMg1j6OXty_1vAZ4EIwZdCySIoHrCS6RI,1055
-tinygrad-0.7.0.dist-info/METADATA,sha256=SJaE_k9-bcaF3GkoMxSv_tN3lFyFkLZY38EjN3hmdk0,7180
-tinygrad-0.7.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-tinygrad-0.7.0.dist-info/top_level.txt,sha256=vDABMCWBFQnx2kn9Azueu88FP-1klQdePoHikQhHymc,9
-tinygrad-0.7.0.dist-info/RECORD,,