Ollama是一个强大的工具，它允许用户在本地环境中运行和定制大型语言模型。而通过Docker技术，可以简化Ollama的安装和部署过程，使得在本地运行如Llama 3这样的开源大型语言模型变得简单快捷。

硬件配置要求

由于大模型对硬件配置要求较高，建议使用配置更高的设备，本次测试暂时选用阿里云节点：

  • CPU：阿里云8vCPU
  • 内存：16GB
  • 显卡：无（使用CPU跑模型）

Docker安装Ollama

Ollama支持通过Docker安装，这极大地简化了服务器端的部署过程。以下是使用docker compose工具运行Ollama的步骤：

  1. 创建 docker-compose.yaml 文件，内容如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    version: '3'
    services:
        ollama:
          image: ollama/ollama:0.4.4
          container_name: ollama
          ports:
            - "11434:11434"
          volumes:
            - ./data:/root/.ollama
          restart: always

  2. 在命令行中输入以下命令启动容器：

    1
    docker compose up -d

  3. 访问 http://IP:11434，当看到提示“Ollama is running”时，说明Ollama已成功运行。

ollama主要指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Usage:
  ollama [flags]
  ollama [command]
  
Available Commands:
  serve       启动服务
  create      Create a model from a Modelfile
  show        Show information for a model
  run         运行一个模型
  stop        停止一个正在运行的模型
  pull        从仓库拉取模型
  push        推送模型到仓库
  list        显示当前模型清单
  ps          显示正在运行的模型清单
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

可以使用如下命令启动一个大模型，目前已支持的大模型参见 ollama library

1
2
ollama run llama3.2
ollama run qwen2.5-coder

下面是针对 ollama 3.2 的对话测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
>>> 请帮我用python写一个快速排序算法
快速排序（QuickSort）是一种分治算法。它通过选择pivot元素，并将小于pivot的元素移到左侧，large than pivot 的元素移到右侧，来排列元素。
下面是Python实现的快速排序算法：

def quicksort(arr):
    """
    快速排序函数
    
    :param arr: 列表
    :return: 排序后的列表
    """
    
    #_base case
    if len(arr) <= 1:
        return arr
    
    #选择pivot
    pivot = arr[len(arr) // 2]
    
    #分割
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    
    return quicksort(left) + middle + quicksort(right)

#测试函数
def test_quicksort():
    #测试列表
    lst = [38, 27, 43, 3, 9, 82, 10]
    sorted_lst = quicksort(lst)
    print("排序后的列表：", sorted_lst)
    
test_quicksort()

在这个例子中，快速排序首先选择pivot（在本例中是列表中值的中间位置）并将小于pivot 的元素移到左侧，大于pivot 的元素移到右侧。这样，每次递归分解时，将减少数量，直到最后得到一个最终的、无序但已经排列好的列表。

针对 qwen-coder 的对话测试 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
>>> 请帮我用python写一个快速排序算法
当然可以！以下是一个用Python实现的快速排序（QuickSort）算法：

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[len(arr) // 2]
        left = [x for x in arr if x < pivot]
        middle = [x for x in arr if x == pivot]
        right = [x for x in arr if x > pivot]
        return quick_sort(left) + middle + quick_sort(right)

# 示例用法
if __name__ == "__main__":
    example_array = [3, 6, 8, 10, 1, 2, 1]
    print("原始数组:", example_array)
    sorted_array = quick_sort(example_array)
    print("排序后的数组:", sorted_array)
   
### 解释                                                               

1. **基准条件**：如果数组的长度小于或等于1，则直接返回该数组，因为它已经是有序的。
2. **选择基准（Pivot）**：选择数组中间的元素作为基准。
3. **分区（Partitioning）**：
  - 将数组分成三个部分：`left`、`middle` 和 `right`。
    - `left` 包含所有小于基准的元素。
    - `middle` 包含所有等于基准的元素。
    - `right` 包含所有大于基准的元素。
4. **递归排序**：
    - 对 `left` 和 `right` 子数组分别进行快速排序。
    - 将排序后的 `left`、`middle` 和 `right` 子数组连接起来，得到最终的有序数组。

这个实现是递归的，并且使用了列表推导式来简化代码。希望这对你有帮助！

不过因为没有使用GPU，所以大模型基本上是一个字一个字的吐出的，性能比较低。