仅需三分钟，小白也能本地部署DeepSeek R1

大家好，我是全职all in 智能体创业的鹤涵

为什么 DeepSeek-R1 这么强

DeepSeek-R1 是由深度求索（DeepSeek）公司开发的高性能 AI 推理模型，专注于数学、代码和自然语言推理任务。它的核心优势包括：

强化学习驱动：利用强化学习技术大幅提升推理能力，只需少量标注数据就能实现高效训练。

长链推理（CoT）：支持多步骤逻辑推理，能够将复杂问题分解并逐步解决。

模型蒸馏：能够将推理能力迁移到更小的模型中，特别适合资源受限的场景。

开源生态：采用 MIT 开源协议，用户可以自由使用、修改和商用。

DeepSeek-R1 在多个基准测试中都表现出色，性能可与 OpenAI 的 o1 正式版相媲美，而且性价比更高。

由于DeepSeek太强，遭受了不明力量的大量DDOS攻击，导致网站经常崩溃，甚至API直接访问不了了。（用惯了R1，没有他我还怎么干活呀！～）

由于R1是全面开源的，我们只需要我们用自己的卡部署一个，就可以数据安全的无限使用了。

安装Ollama

首先安装ollama，地址如下：https://ollama.com/

下载对应操作系统的安装包，按照引导进行安装就ok了

终端中运行以下命令验证安装是否成功

python


(base) ➜  ~ ollama --version
ollama version is 0.5.7

部署DeepSeekR1模型

https://ollama.com/search?q=deepseek-r1

搜索deepseek-r1，运行以下命令下载8b参数版本

python


(base) ➜  Downloads (base) ➜  Downloads ollama run deepseek-r1:8b
pulling manifest 
pulling manifest 
pulling manifest 
pulling manifest 
pulling manifest 
pulling 6340dc3229b0... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 4.9 GB                         
pulling 369ca498f347... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  387 B                         
pulling 6e4c38e1172f... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 1.1 KB                         
pulling f4d24e9138dd... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  148 B                         
pulling 0cb05c6e4e02... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  487 B                         
verifying sha256 digest 
writing manifest 
success 
pulling manifest 
pulling manifest 
pulling manifest 
pulling manifest 
pulling manifest 
pulling 6340dc3229b0... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 4.9 GB                         
pulling 369ca498f347... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  387 B                         
pulling 6e4c38e1172f... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ 1.1 KB                         
pulling f4d24e9138dd... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  148 B                         
pulling 0cb05c6e4e02... 100% ▕█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▏  487 B                         
verifying sha256 digest 
writing manifest 
success

我是16g内存的mac m1,部署14b以下的蒸馏版本还很快的。输出的内容跟官网一样会先显示思考过程，再进行高质量的回答

plain


>>> 用java写一个快速排序,要求注意边界情况以及性能
<think>
嗯，我现在需要用Java来实现一个快速排序，而且要注意边界情况和性能。首先，快速排序是一种高效的排序算法，平均时间复杂度是O(n log n)，空间复杂度也是O(log n)。那我得先想一下快速排
序的基本步骤。

首先，选择一个数组的中间元素作为枢轴，然后将所有小于枢轴的元素放在左边，大于的放在右边，然后递归地对这两个子数组进行排序。那么，我应该如何实现这个过程呢？

我知道，在Java中可以通过递归或者迭代来实现快速排序。但是，递归可能在处理较大的数据时会遇到栈溢出的问题，所以如果需要处理非常大的数据，迭代方法可能更好。不过，对于一般情况，递
归的实现比较简单，也容易理解。所以我先考虑用递归的方式。

那接下来，我得想一下如何选择枢轴。对于一个数组，比如arr，从0到length-1，那么中间位置是left + (right - left)/2。这一步需要注意，当数组长度为奇数时，中间元素可能被多次选中，以
避免递归引起的问题。

然后，将小于、等于、大于枢轴的元素分开。或者，有时候为了优化性能，可以选择仅将小于和大于的元素分开，然后再处理相等的部分，这样可以减少比较次数，提高效率。但是，在代码实现中，
要如何处理这三个区域呢？可能需要一个辅助函数来进行。

另外，我得考虑边界情况，比如当数组只有一个或者零个元素的时候，不需要排序。这样在递归的终止条件里要特别注意。

那我先写一下大概的结构：

public class QuickSort {

    public void sort(int[] arr, int left, int right) {
        // base case: when left >= right, no sorting needed
        if (left >= right) return;

        // choose pivot
        int mid = getMid(left, right);
        // partition around pivot
        int value = arr[mid];
        int i = left;
        while (i < mid) {
            if (arr[i] <= value) i++;
            else swap(arr, i, mid-1);
        }
        int j = mid+1;
        while (j > mid) {
            if (arr[j] >= value) j++;
            else swap(arr, j, mid+1);
        }

        // recurse on subarrays
        sort(arr, left, mid);
        sort(arr, mid+1, right);

        // merge? 不，快速排序是分治，不需要合并步骤，只递归处理左右子数组。
    }

    private int getMid(int left, int right) {
        return (left + right)/2;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

等等，但是这里好像有点问题。因为在快速排序中，通常是把数组划分为左右两个部分，然后递归排序各自的子数组。而上面的代码是否正确呢？

...

以下是实现代码：

public class QuickSort {

    public void sort(int[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    private void sort(int[] arr, int left, int right) {
        if (left > right) return;

        int mid = (left + right) / 2;
        int pivot = arr[mid];

        int i = left;
        int j = right;

        while (i < j) {
            if (arr[i] <= pivot && arr[j] >= pivot) {
                // 交换左右两边的元素
                swap(arr, i, j);
                i++;
                j--;
            } else if (arr[i] > pivot) {
                // 将右侧小于等于枢轴的移到左边
                j--;
            } else {
                // 将左侧大于枢轴的移到右边
                i++;
            }
        }

        // 递归排序左右子数组
        sort(arr, left, mid - 1);
        sort(arr, mid + 1, right);
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

会经过大量的思考以及进行大量的单元测试，最终给出了几千字的结论，这个太强了，比一般的研发要厉害了。