Add Int2/Uint2 ConvertDType support, improve boolean naming

- Register Int2/Uint2 → {Int8,Uint8,Int32,Int64,Float32,Float64}
  converters via execConvertPackedSubByte with valuesPerByte=4
- Add unpackInt2Bits and unpackUint2Bits for 2-bit packed data
- Handle Int2/Uint2 in unpackWeightsToBuffer alongside Int4/Uint4
- Register mutableBytes and fillBuffer for Int2/Uint2
- Rename unpackedPooled → isUnpackedOwned, idxPooled → isIdxOwned
  for clarity (all buffers are pooled; the bool tracks ownership)

Author: ajroetker

backends/simplego/exec_convert_dtype.go

@@ -57,12 +57,30 @@ func init() {
 	convertDTypePairMap.Register(dtypes.Uint4, dtypes.Int64, priorityTyped, execConvertPackedSubByte[int64](unpackUint4Nibbles, 2))
 	convertDTypePairMap.Register(dtypes.Uint4, dtypes.Uint8, priorityTyped, execConvertPackedSubByte[uint8](unpackUint4Nibbles, 2))
 
+	// Register sub-byte type conversions (Int2, Uint2).
+	// Each byte packs 4 values (2 bits each). Bit layout: bits 0-1 = first value,
+	// bits 2-3 = second, bits 4-5 = third, bits 6-7 = fourth.
+	convertDTypePairMap.Register(dtypes.Int2, dtypes.Float32, priorityTyped, execConvertPackedSubByte[float32](unpackInt2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Int2, dtypes.Float64, priorityTyped, execConvertPackedSubByte[float64](unpackInt2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Int2, dtypes.Int32, priorityTyped, execConvertPackedSubByte[int32](unpackInt2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Int2, dtypes.Int64, priorityTyped, execConvertPackedSubByte[int64](unpackInt2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Int2, dtypes.Int8, priorityTyped, execConvertPackedSubByte[int8](unpackInt2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Uint2, dtypes.Float32, priorityTyped, execConvertPackedSubByte[float32](unpackUint2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Uint2, dtypes.Float64, priorityTyped, execConvertPackedSubByte[float64](unpackUint2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Uint2, dtypes.Int32, priorityTyped, execConvertPackedSubByte[int32](unpackUint2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Uint2, dtypes.Int64, priorityTyped, execConvertPackedSubByte[int64](unpackUint2Bits, 4))
+	convertDTypePairMap.Register(dtypes.Uint2, dtypes.Uint8, priorityTyped, execConvertPackedSubByte[uint8](unpackUint2Bits, 4))
+
 	// Register mutableBytes and fillBuffer for sub-byte types.
-	// Packed Int4/Uint4 buffers use []byte as the Go storage type.
+	// Packed sub-byte buffers use []byte as the Go storage type.
 	mutableBytesDTypeMap.Register(dtypes.Int4, priorityTyped, mutableBytesGeneric[byte])
 	mutableBytesDTypeMap.Register(dtypes.Uint4, priorityTyped, mutableBytesGeneric[byte])
+	mutableBytesDTypeMap.Register(dtypes.Int2, priorityTyped, mutableBytesGeneric[byte])
+	mutableBytesDTypeMap.Register(dtypes.Uint2, priorityTyped, mutableBytesGeneric[byte])
 	fillBufferDTypeMap.Register(dtypes.Int4, priorityTyped, fillBufferGeneric[byte])
 	fillBufferDTypeMap.Register(dtypes.Uint4, priorityTyped, fillBufferGeneric[byte])
+	fillBufferDTypeMap.Register(dtypes.Int2, priorityTyped, fillBufferGeneric[byte])
+	fillBufferDTypeMap.Register(dtypes.Uint2, priorityTyped, fillBufferGeneric[byte])
 
 	// Manually register bool x bfloat16 conversion functions.
 	convertDTypePairMap.Register(dtypes.BFloat16, dtypes.Bool, priorityTyped, execConvertDTypeBFloat16ToBool)
@@ -225,7 +243,34 @@ func unpackUint4Nibbles(packed []byte, dst []int8) {
 	}
 }
 
-// execConvertPackedSubByte returns a converter for packed sub-byte types (Int4, Uint4).
+// unpackInt2Bits unpacks packed Int2 data ([]byte, 4 signed 2-bit values per byte)
+// into dst []int8 (one value per element). Bit layout per byte:
+// bits 0-1 = first, bits 2-3 = second, bits 4-5 = third, bits 6-7 = fourth.
+// Signed range: [-2, 1] (values 2,3 sign-extend to -2,-1).
+func unpackInt2Bits(packed []byte, dst []int8) {
+	for i, b := range packed {
+		for j := range 4 {
+			v := int8((b >> uint(2*j)) & 0x03)
+			if v >= 2 {
+				v -= 4
+			}
+			dst[4*i+j] = v
+		}
+	}
+}
+
+// unpackUint2Bits unpacks packed Uint2 data ([]byte, 4 unsigned 2-bit values per byte)
+// into dst []int8 (one value per element). Unsigned range: [0, 3].
+func unpackUint2Bits(packed []byte, dst []int8) {
+	for i, b := range packed {
+		dst[4*i] = int8(b & 0x03)
+		dst[4*i+1] = int8((b >> 2) & 0x03)
+		dst[4*i+2] = int8((b >> 4) & 0x03)
+		dst[4*i+3] = int8((b >> 6) & 0x03)
+	}
+}
+
+// execConvertPackedSubByte returns a converter for packed sub-byte types (Int4, Uint4, Int2, Uint2).
 // The unpackFn parameter selects signed vs unsigned nibble interpretation.
 // Sub-byte types are always stored packed as []byte.
 // valuesPerByte is the number of logical values per packed byte (e.g. 2 for 4-bit, 4 for 2-bit).

backends/simplego/exec_convert_dtype_test.go

@@ -84,6 +84,54 @@ func TestConvertPackedInt4ToFloat32(t *testing.T) {
 	assert.Equal(t, float32(-8), result[3])
 }
 
+func TestConvertPackedInt2ToInt8(t *testing.T) {
+	// Packed Int2 → Int8: unpacks 2-bit values with sign extension.
+	// Byte 0b11_10_01_00 = 0xE4: values 0, 1, -2, -1.
+	srcData := []byte{0xE4}
+	srcShape := shapes.Make(dtypes.Int2, 4) // 4 Int2 elements packed in 1 byte
+	srcBuf := &Buffer{shape: srcShape, flat: srcData, inUse: true}
+
+	dstShape := shapes.Make(dtypes.Int8, 4)
+	dstBuf := &Buffer{shape: dstShape, flat: make([]int8, 4), inUse: true}
+
+	tmpAny, tmpErr := convertDTypePairMap.Get(dtypes.Int2, dtypes.Int8)
+	if tmpErr != nil {
+		panic(tmpErr)
+	}
+	convertFn := tmpAny.(convertFnType)
+	convertFn(srcBuf, dstBuf)
+
+	result := dstBuf.flat.([]int8)
+	assert.Equal(t, int8(0), result[0])
+	assert.Equal(t, int8(1), result[1])
+	assert.Equal(t, int8(-2), result[2])
+	assert.Equal(t, int8(-1), result[3])
+}
+
+func TestConvertPackedUint2ToUint8(t *testing.T) {
+	// Packed Uint2 → Uint8: unpacks 2-bit values (no sign extension).
+	// Byte 0b11_10_01_00 = 0xE4: values 0, 1, 2, 3.
+	srcData := []byte{0xE4}
+	srcShape := shapes.Make(dtypes.Uint2, 4) // 4 Uint2 elements packed in 1 byte
+	srcBuf := &Buffer{shape: srcShape, flat: srcData, inUse: true}
+
+	dstShape := shapes.Make(dtypes.Uint8, 4)
+	dstBuf := &Buffer{shape: dstShape, flat: make([]uint8, 4), inUse: true}
+
+	tmpAny, tmpErr := convertDTypePairMap.Get(dtypes.Uint2, dtypes.Uint8)
+	if tmpErr != nil {
+		panic(tmpErr)
+	}
+	convertFn := tmpAny.(convertFnType)
+	convertFn(srcBuf, dstBuf)
+
+	result := dstBuf.flat.([]uint8)
+	assert.Equal(t, uint8(0), result[0])
+	assert.Equal(t, uint8(1), result[1])
+	assert.Equal(t, uint8(2), result[2])
+	assert.Equal(t, uint8(3), result[3])
+}
+
 func TestExecSpecialOps_ConvertDType(t *testing.T) {
 	// Test int32 to float32
 	y0 := graph.MustExecOnce(backend, func(x *graph.Node) *graph.Node {

backends/simplego/exec_fused_quantized.go

@@ -76,11 +76,11 @@ func execFusedQuantizedDense(backend *Backend, node *Node, inputs []*Buffer, inp
 
 	// For packed sub-byte weights (from Bitcast), unpack nibbles via the buffer pool
 	// and ConvertDType infrastructure. Non-sub-byte types pass through unchanged.
-	unpackedBuf, unpackedPooled, err := unpackWeightsToBuffer(backend, wBuf)
+	unpackedBuf, isUnpackedOwned, err := unpackWeightsToBuffer(backend, wBuf)
 	if err != nil {
 		return nil, err
 	}
-	if unpackedPooled {
+	if isUnpackedOwned {
 		defer backend.putBuffer(unpackedBuf)
 	}
 	wFlat := unpackedBuf.flat
@@ -122,9 +122,9 @@ func execFusedQuantizedDense(backend *Backend, node *Node, inputs []*Buffer, inp
 func unpackWeightsToBuffer(backend *Backend, wBuf *Buffer) (*Buffer, bool, error) {
 	var targetDType dtypes.DType
 	switch wBuf.shape.DType {
-	case dtypes.Int4:
+	case dtypes.Int4, dtypes.Int2:
 		targetDType = dtypes.Int8
-	case dtypes.Uint4:
+	case dtypes.Uint4, dtypes.Uint2:
 		targetDType = dtypes.Uint8
 	default:
 		return wBuf, false, nil
@@ -173,11 +173,11 @@ func execQuantizedEmbeddingLookup(backend *Backend, node *Node, inputs []*Buffer
 	numIndices := indicesBuf.shape.Size()
 
 	// Convert indices to int64 via the buffer pool and ConvertDType infrastructure.
-	idxBuf, idxPooled, err := convertIndicesToInt64(backend, indicesBuf)
+	idxBuf, isIdxOwned, err := convertIndicesToInt64(backend, indicesBuf)
 	if err != nil {
 		return nil, errors.Wrapf(err, "QuantizedEmbeddingLookup")
 	}
-	if idxPooled {
+	if isIdxOwned {
 		defer backend.putBuffer(idxBuf)
 	}
 	indices := idxBuf.flat.([]int64)