llm.go 3.81 KB
Newer Older
1
2
3
package llm

import (
4
	"context"
5
	"fmt"
6
	"log"
7
	"os"
8
	"runtime"
9
10

	"github.com/jmorganca/ollama/api"
11
	"github.com/jmorganca/ollama/gpu"
12
13
14
)

type LLM interface {
Bruce MacDonald's avatar
Bruce MacDonald committed
15
	Predict(context.Context, PredictOpts, func(PredictResult)) error
16
17
18
	Embedding(context.Context, string) ([]float64, error)
	Encode(context.Context, string) ([]int, error)
	Decode(context.Context, []int) (string, error)
19
20
21
	Close()
}

Michael Yang's avatar
Michael Yang committed
22
func New(workDir, model string, adapters, projectors []string, opts api.Options) (LLM, error) {
23
24
25
26
27
28
29
30
	if _, err := os.Stat(model); err != nil {
		return nil, err
	}

	f, err := os.Open(model)
	if err != nil {
		return nil, err
	}
Michael Yang's avatar
Michael Yang committed
31
	defer f.Close()
32

Bruce MacDonald's avatar
Bruce MacDonald committed
33
	ggml, err := DecodeGGML(f)
34
35
36
37
	if err != nil {
		return nil, err
	}

38
39
40
41
	if opts.NumCtx < 4 {
		opts.NumCtx = 4
	}

42
43
	vram, _ := gpu.CheckVRAM()
	size := ggml.Size
44
45

	// fp16 k,v matrices require = n_ctx * n_layer * n_embd / n_head * n_head_kv * 2 bytes each * 2 key and value
46
	kv := 2 * 2 * int64(opts.NumCtx) * int64(ggml.NumLayers()) * int64(ggml.NumEmbed()) * int64(ggml.NumHeadKv()) / int64(ggml.NumHead())
47

48
	// this amount is the overhead + tensors in memory
Michael Yang's avatar
typo  
Michael Yang committed
49
	// TODO: get this from the llama.cpp's graph calculations instead of
50
	// estimating it's 1/6 * kv_cache_size * num_gqa
51
	graph := int64(ggml.NumGQA()) * kv / 6
52
53

	info := gpu.GetGPUInfo()
54
55
56
57
58
	switch runtime.GOOS {
	case "darwin":
		if opts.NumGPU == 0 {
			break
		}
59

60
61
		if size+kv+graph > vram {
			log.Println("not enough vram available, falling back to CPU only")
62
63
			info.Library = "cpu"
			info.Variant = gpu.GetCPUVariant()
64
65
66
67
68
69
			opts.NumGPU = 0
			break
		}

		opts.NumGPU = 1
	default:
70
		if info.Library == "cpu" {
71
72
73
74
75
76
77
			log.Println("GPU not available, falling back to CPU")
			opts.NumGPU = 0
			break
		}

		// don't use GPU at all if no layers are loaded
		if opts.NumGPU == 0 {
78
79
			info.Library = "cpu"
			info.Variant = gpu.GetCPUVariant()
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
			break
		}

		// user-defined GPU count
		if opts.NumGPU != -1 {
			break
		}

		// the "main" GPU needs the most memory and determines the limit
		// of how many layers can be loaded. It needs to fit:
		// 1. the full compute graph allocation for all devices (graph)
		// 2. the proportional kv cache for all devices (kv * % layers)
		// 3. the proportional model (size * % layers / # devices)
		// This estimates the number of layers
		maxlayers := int64(ggml.NumLayers()) + 1
		devices := int64(info.DeviceCount)
		avg := vram / devices
		layers := maxlayers * (avg - graph) / (kv + size/devices)
		if layers > maxlayers {
			layers = maxlayers
		}
101

102
103
104
105
		// 1 + 2 must fit on the main gpu
		min := graph + kv*layers/maxlayers
		if layers <= 0 || min > avg {
			log.Printf("not enough vram available, falling back to CPU only")
106
107
			info.Library = "cpu"
			info.Variant = gpu.GetCPUVariant()
108
109
			opts.NumGPU = 0
			break
110
		}
111
112

		opts.NumGPU = int(layers)
113
114
	}

Bruce MacDonald's avatar
Bruce MacDonald committed
115
116
	opts.RopeFrequencyBase = 0.0
	opts.RopeFrequencyScale = 0.0
117
	return newLlmServer(info, model, adapters, projectors, opts)
118
119
120
121
122
}

// Give any native cgo implementations an opportunity to initialize
func Init(workdir string) error {
	return nativeInit(workdir)
123
}
124

125
126
func newLlmServer(gpuInfo gpu.GpuInfo, model string, adapters, projectors []string, opts api.Options) (LLM, error) {
	dynLibs := getDynLibs(gpuInfo)
127
128
129
130

	// Check to see if the user has requested a specific library instead of auto-detecting
	demandLib := os.Getenv("OLLAMA_LLM_LIBRARY")
	if demandLib != "" {
131
		libPath := availableDynLibs[demandLib]
132
133
134
135
		if libPath == "" {
			log.Printf("Invalid OLLAMA_LLM_LIBRARY %s - not found", demandLib)
		} else {
			log.Printf("Loading OLLAMA_LLM_LIBRARY=%s", demandLib)
136
			dynLibs = []string{libPath}
137
138
139
		}
	}

140
141
142
	err2 := fmt.Errorf("unable to locate suitable llm library")
	for _, dynLib := range dynLibs {
		srv, err := newDynExtServer(dynLib, model, adapters, projectors, opts)
143
144
145
		if err == nil {
			return srv, nil
		}
146
147
		log.Printf("Failed to load dynamic library %s  %s", dynLib, err)
		err2 = err
148
149
	}

150
	return nil, err2
151
}