mirror of
https://github.com/ollama/ollama.git
synced 2026-03-29 03:18:44 +07:00
33ee7168ba
* WIP - MLX backend with gemma3 * MLX: add cmake and go tag build toggles To build the new MLX backend code: cmake --preset MLX cmake --build --preset MLX --parallel cmake --install build --component MLX go build -tags mlx . Note: the main.go entrypoint for the MLX engine will change in a follow up commit. * add experimental image generation runtime * add experimental image generation runtime * MLX: wire up cuda build for linux * MLX: get dependencies correct and dedup This is still too large for a unified github artifact, but is now "correct" for the mlx_cuda_v13 directory. * fix relative link bug in dedup * Add darwin build and readme * add go build tag for mlx dependent code and wire up build_darwin.sh * lint cleanup * macos: build mlx for x86 This will be CPU only. * cuda build instructions and fix drift from mlx bump * stale comment * Delete agent helper doc * Clean up readme.md * Revise README for tokenizer clarity and details Updated README to clarify tokenizer functionality and removed correctness section. --------- Co-authored-by: jmorganca <jmorganca@gmail.com>
61 lines
1.5 KiB
Go
61 lines
1.5 KiB
Go
//go:build mlx
|
|
|
|
package gemma3
|
|
|
|
import (
|
|
"image"
|
|
|
|
"github.com/ollama/ollama/fs"
|
|
"github.com/ollama/ollama/model/imageproc"
|
|
)
|
|
|
|
type ImageProcessor struct {
|
|
imageSize, patchSize, numChannels int
|
|
}
|
|
|
|
func newImageProcessor(c fs.Config) ImageProcessor {
|
|
return ImageProcessor{
|
|
imageSize: int(c.Uint("vision.image_size")),
|
|
patchSize: int(c.Uint("vision.patch_size")),
|
|
numChannels: int(c.Uint("vision.num_channels")),
|
|
}
|
|
}
|
|
|
|
func (p *ImageProcessor) pack(img image.Image, mean, std [3]float32) []float32 {
|
|
var pixelVals, rVals, gVals, bVals []float32
|
|
|
|
bounds := img.Bounds()
|
|
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
|
|
for x := bounds.Min.X; x < bounds.Max.X; x++ {
|
|
c := img.At(x, y)
|
|
r, g, b, _ := c.RGBA()
|
|
rVal := float32(r>>8) / 255.0
|
|
gVal := float32(g>>8) / 255.0
|
|
bVal := float32(b>>8) / 255.0
|
|
|
|
rVal = (rVal - mean[0]) / std[0]
|
|
gVal = (gVal - mean[1]) / std[1]
|
|
bVal = (bVal - mean[2]) / std[2]
|
|
|
|
rVals = append(rVals, rVal)
|
|
gVals = append(gVals, gVal)
|
|
bVals = append(bVals, bVal)
|
|
}
|
|
}
|
|
|
|
pixelVals = append(pixelVals, rVals...)
|
|
pixelVals = append(pixelVals, gVals...)
|
|
pixelVals = append(pixelVals, bVals...)
|
|
|
|
return pixelVals
|
|
}
|
|
|
|
func (p ImageProcessor) ProcessImage(img image.Image) ([]float32, error) {
|
|
outputSize := image.Point{p.imageSize, p.imageSize}
|
|
newImage := imageproc.Composite(img)
|
|
newImage = imageproc.Resize(newImage, outputSize, imageproc.ResizeBilinear)
|
|
|
|
data := p.pack(newImage, imageproc.ImageNetStandardMean, imageproc.ImageNetStandardSTD)
|
|
return data, nil
|
|
}
|