Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+torch25-cxx11-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch25-cxx11-cu121-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch25-cxx11-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch25-cxx98-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch25-cxx98-cu121-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch25-cxx98-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch26-cxx11-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch26-cxx11-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch26-cxx11-cu126-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch26-cxx98-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch26-cxx98-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch26-cxx98-cu126-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch27-cxx11-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch27-cxx11-cu126-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text
+torch27-cxx11-cu128-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so filter=lfs diff=lfs merge=lfs -text

torch25-cxx11-cu118-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch25-cxx11-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch25-cxx11-cu118-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch25-cxx11-cu121-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch25-cxx11-cu121-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch25-cxx11-cu121-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch25-cxx11-cu124-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch25-cxx11-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch25-cxx11-cu124-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch25-cxx98-cu118-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch25-cxx98-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch25-cxx98-cu118-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch25-cxx98-cu121-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch25-cxx98-cu121-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch25-cxx98-cu121-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch25-cxx98-cu124-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch25-cxx98-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch25-cxx98-cu124-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch26-cxx11-cu118-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch26-cxx11-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch26-cxx11-cu118-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch26-cxx11-cu124-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch26-cxx11-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch26-cxx11-cu124-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch26-cxx11-cu126-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch26-cxx11-cu126-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch26-cxx11-cu126-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch26-cxx98-cu118-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch26-cxx98-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch26-cxx98-cu118-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch26-cxx98-cu124-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch26-cxx98-cu124-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch26-cxx98-cu124-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch26-cxx98-cu126-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch26-cxx98-cu126-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch26-cxx98-cu126-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch27-cxx11-cu118-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch27-cxx11-cu118-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch27-cxx11-cu118-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch27-cxx11-cu126-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch27-cxx11-cu126-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch27-cxx11-cu126-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"

torch27-cxx11-cu128-x86_64-linux/ggml/__init__.py

@@ -0,0 +1,44 @@
+import torch
+
+try:
+    from ._ops import ops
+except ImportError as e:
+    # Fallback for local development.
+    try:
+        import _ggml
+
+        ops = torch.ops._ggml
+    except ImportError:
+        raise e
+
+
+def ggml_dequantize(
+    W: torch.Tensor,
+    quant_type: int,
+    m: int,
+    n: int,
+) -> torch.Tensor:
+    """Dequantize the GGML tensor."""
+    return ops.ggml_dequantize(W, quant_type, m, n)
+
+
+def ggml_mul_mat_vec_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat with MMVQ kernel, require batch_size==1."""
+    batch = X.size(0)
+    assert batch == 1, "Batch size must be 1 for MMVQ kernel"
+    return ops.ggml_mul_mat_vec_a8(W, X, quant_type, row)
+
+
+def ggml_mul_mat_a8(
+    W: torch.Tensor,
+    X: torch.Tensor,
+    quant_type: int,
+    row: int,
+) -> torch.Tensor:
+    """Mulmat through MMQ kernel for arbitrary batch size."""
+    return ops.ggml_mul_mat_a8(W, X, quant_type, row)

torch27-cxx11-cu128-x86_64-linux/ggml/_ggml_4fb4e1d_dirty.abi3.so

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

torch27-cxx11-cu128-x86_64-linux/ggml/_ops.py

@@ -0,0 +1,9 @@
+import torch
+from . import _ggml_4fb4e1d_dirty
+ops = torch.ops._ggml_4fb4e1d_dirty
+
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_ggml_4fb4e1d_dirty::{op_name}"