什么是大语言模型？

大语言模型（LLM）是一种 人工智能模型，它被设计用来 理解和生成人类语言。 关键在于 “大” 和 “语言模型” 这两个词：

• “大” (Large): 指的是模型具有 庞大的规模，主要体现在两个方面：

  • 大规模的训练数据： LLM 是在海量的文本数据上训练出来的，这些数据通常包括互联网上的文本、书籍、文章、代码等等，数量级可以达到 TB 甚至 PB 级别。

  • 大规模的参数量： 模型的内部结构（通常是基于 Transformer 架构的神经网络）拥有数亿、数十亿甚至数千亿的参数。参数越多，模型理论上可以学习和存储的信息就越多，能力也更强。

• “语言模型” (Language Model): 指的是模型的核心任务是 预测文本序列的概率分布。 简单来说，给定一段文本（例如，句子的一部分），语言模型的目标是预测接下来最有可能出现的词语。 虽然目标看似简单，但为了做好这个预测，模型必须学习到语言的各种规律，包括：

  • 语法规则： 词语的正确排列顺序，句子的结构。

  • 语义信息： 词语和句子的含义，上下文的理解。

  • 世界知识： 模型通过学习大量文本，间接地学习到了关于世界的知识。

  • 语用信息： 语言在不同情境下的使用方式，风格，语气等等。

总的来说，LLM 就是通过学习海量文本数据，拥有了理解和生成人类语言能力的超大规模神经网络模型。

人工智能常见领域

• 计算机视觉 (CV)：

  • 图像分类、目标检测、图像分割、图像生成

  • 常用模型：ResNet、YOLO、Mask R-CNN、GANs

• 自然语言处理 (NLP)：

  • 文本分类、情感分析、机器翻译、文本生成、问答系统

  • 常用模型：Word2Vec、GloVe、BERT、Transformer、GPT

• 语音识别 (ASR)：

  • 语音转文本、语音合成

  • 常用模型：DeepSpeech、Wav2Vec

• 推荐系统：

  • 协同过滤、基于内容的推荐、混合推荐

• 强化学习 (RL)：

  • 马尔可夫决策过程 (MDP)

  • Q-learning、Deep Q-Network (DQN)

  • 策略梯度

  • 应用场景：推荐系统、金融交易、游戏等

• 时间序列分析

  • 应用场景：预测股票价格、汇率走势和市场趋势、预测天气变化和气候变化预测交通流量和路况等

主流AI大模型

一、 文本生成与理解类模型 (以自然语言处理为主)

• 1. OpenAI GPT 系列 (GPT-3, GPT-3.5, GPT-4, GPT-4 Turbo等)

  • 开发者: OpenAI

  • 架构: Decoder-only Transformer (自回归模型)

  • 训练数据: 海量的文本和代码数据，包括互联网文本、书籍、代码库等，规模庞大且质量高。

  • 关键特点:

    • 强大的文本生成能力: 在文本生成、代码生成、创意写作、对话等方面表现卓越，生成文本流畅自然，逻辑连贯。

    • 上下文学习 (In-context Learning): 能够根据Prompt (提示词) 中的少量示例快速适应新任务，无需针对特定任务进行微调。

    • 指令遵循能力 (Instruction Following): 经过指令微调 (Instruction Tuning) 后，能更好地理解和执行用户指令，并生成符合指令的输出。

    • 多模态能力 (GPT-4): GPT-4 具备处理图像输入的能力，可以进行图像描述、视觉问答等任务，是真正的多模态大模型。

    • 持续进化: OpenAI 不断迭代和更新 GPT 系列模型，性能持续提升，例如 GPT-4 Turbo 拥有更长的上下文窗口，更低的API价格。

  • 优点:

    • 顶尖的文本生成质量和理解能力。

    • 强大的通用性和泛化能力，适用范围广泛。

    • 成熟的 API 服务和生态系统，易于集成和使用。

    • 持续创新和迭代，性能不断提升。

  • 缺点:

    • API 访问成本相对较高 (特别是 GPT-4)。

    • 模型细节和训练数据相对封闭 (特别是 GPT-4)。

    • 有时会产生幻觉 (Hallucination)，即生成不真实或与事实不符的内容。

    • 在某些特定领域或专业任务上，可能不如领域特定模型。

    • 对 Prompt 工程依赖性较高，需要精心设计 Prompt 才能发挥最佳性能。

• 2. Google PaLM 系列 (PaLM 2, Gemini 等)

  • 开发者: Google

  • 架构: Decoder-only Transformer (PaLM 2)，Transformer-based (Gemini)

  • 训练数据: 海量的文本和代码数据，规模庞大，并侧重于高质量、多语言和多领域数据。

  • 关键特点:

    • 强大的多语言能力: PaLM 2 在多语言理解和生成方面表现突出，支持超过100种语言。

    • 强大的推理能力: Gemini 系列模型 (特别是 Gemini Ultra) 在多项基准测试中表现出色，展现了强大的推理和理解能力，尤其在数学、逻辑推理等方面。

    • 多模态原生支持 (Gemini): Gemini 从设计之初就考虑了多模态，能够原生处理文本、图像、音频、视频等多种模态的数据，实现真正的多模态理解和生成。

    • Google 生态集成: 与 Google 搜索、Android 系统、Google Cloud 等生态系统深度集成，应用潜力巨大。

  • 优点:

    • 顶尖的多语言能力和强大的推理能力 (特别是 Gemini)。

    • 原生多模态支持 (Gemini)，具有广阔的应用前景。

    • 背靠 Google 强大的技术实力和生态系统。

    • 持续发展和迭代，Gemini 系列模型有望成为 GPT 系列的强有力竞争者。

  • 缺点:

    • API 访问和生态系统相对 GPT 系列稍逊 (但正在快速发展)。

    • Gemini Ultra 的访问权限目前较为受限。

    • 模型细节和训练数据相对封闭。

    • 在某些特定任务上，可能需要进一步优化和微调。

• 3. Meta Llama 系列 (Llama 2, Llama 3 等)

  • 开发者: Meta (原 Facebook)

  • 架构: Decoder-only Transformer (Llama 2)，Transformer-based (Llama 3)

  • 训练数据: 大规模的公开可用的文本数据，侧重于透明度和可复现性。

  • 关键特点:

    • 开源和可商用: Llama 2 系列模型开源且允许商业用途，降低了使用门槛，促进了社区发展。 Llama 3 延续开源策略。

    • 性能接近甚至在某些方面超越 GPT-3.5: Llama 2 在某些基准测试中表现出色，性能接近甚至在某些方面超越了 GPT-3.5。 Llama 3 更进一步，性能更强大。

    • 多种尺寸版本: 提供多种参数规模的版本 (7B, 13B, 70B 等)，满足不同资源和应用场景的需求。

    • 社区支持和生态快速发展: 开源特性吸引了大量开发者和研究者参与，社区活跃，生态系统快速发展，涌现出各种基于 Llama 的应用和工具。

  • 优点:

    • 开源和可商用，极大降低了使用门槛。

    • 高性能，在某些方面可媲美甚至超越闭源模型 (如 GPT-3.5)。

    • 多种尺寸版本，灵活性高。

    • 强大的社区支持和活跃的生态系统。

  • 缺点:

    • 性能上整体相比 GPT-4 和 Gemini 仍有差距 (但 Llama 3 正在缩小差距)。

    • 在某些复杂任务或多模态任务上，能力相对较弱。

    • 开源模型需要一定的技术能力进行部署和维护。

• 4. Anthropic Claude 系列 (Claude 2, Claude 3 等)

  • 开发者: Anthropic

  • 架构: Transformer-based (Claude 2, Claude 3)

  • 训练数据: 大规模的文本和代码数据，侧重于安全性和负责任的AI开发。

  • 关键特点:

    • 强调安全和负责任的AI: Anthropic 致力于开发安全、可靠、对人类有益的AI模型，Claude 系列模型在安全性方面进行了特别设计和优化。

    • 长上下文窗口: Claude 2 拥有超长的上下文窗口 (100K tokens, Claude 3 Opus 达到 200K tokens)，能够处理更长的文本输入，例如整本书籍或长篇文档。 Claude 3 Sonnet 和 Haiku 的上下文窗口也达到 200K tokens。

    • 强大的理解和推理能力: Claude 3 Opus 在复杂推理、数学、代码生成等方面表现出色，在某些基准测试中甚至超越了 GPT-4 和 Gemini Ultra。

    • 多种版本 (Claude 3): Claude 3 系列提供 Opus (最强性能)、Sonnet (性能和速度平衡)、Haiku (最快速度和低成本) 三个版本，满足不同需求。

  • 优点:

    • 强调安全和负责任的AI开发理念。

    • 超长的上下文窗口，擅长处理长文本输入。

    • 强大的理解和推理能力 (特别是 Claude 3 Opus)。

    • Claude 3 系列提供多种版本，选择更灵活。

  • 缺点:

    • API 访问和生态系统相对 GPT 系列和 Google 稍弱。

    • 模型细节和训练数据相对封闭。

    • 在某些任务上，例如代码生成，可能不如专门的代码生成模型。

• 5. Baidu ERNIE 系列 (ERNIE 3.0 Titan, ERNIE Bot 4.0 等)

  • 开发者: 百度

  • 架构: Transformer-based (ERNIE 3.0 Titan, ERNIE Bot 4.0)

  • 训练数据: 大规模中文和英文文本数据，侧重于中文理解和生成能力。

  • 关键特点:

    • 强大的中文理解和生成能力: ERNIE 系列模型在中文 NLP 任务上表现出色，尤其在中文文本生成、中文问答、中文信息检索等方面。

    • 知识增强 (Knowledge Enhanced): ERNIE 模型融入了知识图谱等知识信息，增强了模型的知识理解和推理能力。

    • 多任务学习: ERNIE 模型采用多任务学习框架进行训练，提升了模型的通用性和泛化能力。

    • 百度生态集成: 与百度搜索、百度智能云等生态系统深度集成，应用场景广泛。

  • 优点:

    • 顶尖的中文理解和生成能力，在中文 NLP 领域具有优势。

    • 知识增强，提升了知识理解和推理能力。

    • 百度生态集成，应用场景广泛。

    • 针对中文市场和用户进行了优化。

  • 缺点:

    • 英文能力相对 GPT 系列和 Google 等模型稍弱。

    • 模型细节和训练数据相对封闭。

    • 国际化程度相对较低，主要服务于中文市场。

• 6. 清华大学 ChatGLM 系列 (ChatGLM3 等)

  • 开发者: 清华大学 KEG 实验室

  • 架构: Transformer-based (ChatGLM3)

  • 训练数据: 大规模中英文文本数据，侧重于开源和研究。

  • 关键特点:

    • 开源和免费可商用 (部分版本): ChatGLM3 部分版本开源且免费可商用，降低了使用门槛，促进了学术研究和商业应用。

    • 强大的中文能力: ChatGLM 系列模型在中文 NLP 任务上表现出色，尤其在中文对话、中文问答等方面。

    • 轻量化版本 (ChatGLM3-6B): 提供轻量化版本 (ChatGLM3-6B)，资源需求较低，可以在消费级硬件上部署和运行。

    • 插件机制 (Tool API): ChatGLM3 提供了 Tool API，允许模型调用外部工具，扩展了模型的功能。

  • 优点:

    • 开源和免费可商用 (部分版本)，便于研究和应用。

    • 强大的中文能力，尤其在中文对话领域。

    • 轻量化版本，资源需求低，易于部署。

    • 插件机制，扩展了模型的功能。

  • 缺点:

    • 英文能力相对 GPT 系列和 Google 等模型稍弱。

    • 模型规模相对较小，整体性能相比顶尖闭源模型仍有差距 (但轻量化和开源是其优势)。

    • 生态系统和社区规模相对较小 (但正在快速发展)。

• 7. 智谱 AI ChatYuan 系列 (ChatYuan-Large 等)

  • 开发者: 智谱 AI

  • 架构: Transformer-based (ChatYuan-Large)

  • 训练数据: 大规模中英文文本数据，侧重于中文通用能力。

  • 关键特点:

    • 强大的中文通用能力: ChatYuan 系列模型在中文通用能力方面表现出色，适用于多种中文 NLP 任务。

    • 指令遵循和对话能力: 经过指令微调，具备较好的指令遵循能力和对话能力。

    • 多领域应用: ChatYuan 模型应用于金融、法律、教育等多个领域。

  • 优点:

    • 强大的中文通用能力。

    • 指令遵循和对话能力较好。

    • 多领域应用场景。

  • 缺点:

    • 英文能力相对 GPT 系列和 Google 等模型稍弱。

    • 模型细节和训练数据相对封闭。

    • 社区和生态系统规模相对较小。

二、 代码生成类模型

• 1. OpenAI Codex (基于 GPT 系列)

  • 开发者: OpenAI

  • 架构: Decoder-only Transformer (基于 GPT 系列)

  • 训练数据: 海量的代码数据，包括 GitHub 代码库、公开代码数据集等。

  • 关键特点:

    • 强大的代码生成能力: 能够根据自然语言描述或代码注释生成代码片段或完整程序。

    • 支持多种编程语言: 支持 Python, JavaScript, C++, Java, Go 等多种主流编程语言。

    • 代码补全和代码修复: 可以进行代码自动补全、代码错误检测和修复等任务。

    • 集成于 GitHub Copilot 等工具: Codex 模型是 GitHub Copilot 等代码生成工具的核心引擎。

  • 优点:

    • 顶尖的代码生成质量和能力。

    • 支持多种编程语言。

    • 集成于流行的开发工具，易于使用。

  • 缺点:

    • API 访问成本相对较高。

    • 模型细节和训练数据相对封闭。

    • 在某些复杂或特定领域的代码生成任务上，可能需要人工辅助。

• 2. Google Codey (基于 PaLM 2)

  • 开发者: Google

  • 架构: Decoder-only Transformer (基于 PaLM 2)

  • 训练数据: 海量的代码数据，包括公开代码库、Google 内部代码数据等。

  • 关键特点:

    • 强大的代码生成和代码理解能力: Codey 模型在代码生成、代码补全、代码解释等方面表现出色。

    • 多语言支持: 支持 Python, JavaScript, Java, Go, C++ 等多种编程语言，并侧重于多语言代码生成能力。

    • 与 Google Cloud 集成: Codey 模型与 Google Cloud Codey API 和 Google Cloud Workbench 等工具集成，方便开发者使用。

  • 优点:

    • 强大的代码生成和代码理解能力。

    • 多语言支持，尤其在多语言代码生成方面具有优势。

    • 与 Google Cloud 生态集成，方便云端开发。

  • 缺点:

    • API 访问和生态系统相对 OpenAI 稍逊 (但正在快速发展)。

    • 模型细节和训练数据相对封闭。

    • 在某些复杂或特定领域的代码生成任务上，可能需要人工辅助。

• 3. Meta Code Llama 系列 (Code Llama, Code Llama - Instruct 等)

  • 开发者: Meta

  • 架构: Decoder-only Transformer (基于 Llama 2)

  • 训练数据: 海量的代码数据，包括公开代码库、Stack Overflow 等。

  • 关键特点:

    • 开源和免费可商用: Code Llama 系列模型开源且允许商业用途，降低了使用门槛。

    • 多种尺寸版本: 提供多种参数规模的版本 (7B, 13B, 34B 等)，满足不同资源和应用场景的需求。

    • 指令微调版本 (Code Llama - Instruct): 提供指令微调版本，针对代码生成指令进行了优化，更易于使用。

    • 支持多种编程语言: 支持 Python, C++, Java, PHP, TypeScript, C#, Bash, SQL 等多种编程语言。

  • 优点:

    • 开源和免费可商用，极大降低了使用门槛。

    • 高性能的代码生成能力，可媲美闭源模型。

    • 多种尺寸版本和指令微调版本，灵活性高。

    • 基于 Llama 2 开源生态，社区支持良好。

  • 缺点:

    • 在某些极端复杂的代码生成任务上，可能不如顶尖闭源模型。

    • 开源模型需要一定的技术能力进行部署和维护。

    • 生态系统相对 OpenAI 和 Google 稍逊 (但正在快速发展)。

三、 多模态模型

• 1. OpenAI GPT-4 (多模态版本)

  • 开发者: OpenAI

  • 架构: Transformer-based (多模态 Transformer)

  • 训练数据: 文本、图像、音频、视频等多种模态的数据。

  • 关键特点:

    • 原生多模态支持: 能够处理文本、图像输入，并生成文本输出，实现图像描述、视觉问答等多模态任务。

    • 强大的多模态理解和生成能力: 在多模态任务上表现出色，例如图像描述准确生动，视觉问答逻辑清晰。

    • 与 GPT 系列文本能力无缝衔接: 多模态能力与 GPT 系列强大的文本能力无缝衔接，可以实现更复杂的多模态应用。

  • 优点:

    • 顶尖的多模态理解和生成能力。

    • 与 GPT 系列文本能力融合，应用潜力巨大。

    • 成熟的 API 服务和生态系统。

  • 缺点:

    • API 访问成本更高 (相比纯文本模型)。

    • 模型细节和多模态训练数据相对封闭。

    • 多模态能力仍处于发展初期，可能存在一些局限性。

• 2. Google Gemini 系列 (Gemini Ultra, Gemini Pro, Gemini Nano)

  • 开发者: Google

  • 架构: Transformer-based (原生多模态 Transformer)

  • 训练数据: 文本、图像、音频、视频等多种模态的大规模数据。

  • 关键特点:

    • 原生多模态架构: Gemini 从设计之初就考虑了多模态，采用原生多模态 Transformer 架构，能够更有效地融合和处理多种模态的数据。

    • 顶尖的多模态性能: Gemini Ultra 在多项多模态基准测试中表现出色，超越了 GPT-4 等模型。

    • 多种尺寸版本: Gemini 系列提供 Ultra (最强性能), Pro (性能和效率平衡), Nano (移动端部署) 三个版本，满足不同需求。

    • Google 生态集成: 与 Google 搜索、Android 系统、Google Cloud 等生态系统深度集成，多模态应用场景广阔。

  • 优点:

    • 顶尖的多模态性能，在多模态领域具有领先优势。

    • 原生多模态架构，更有效地融合和处理多模态数据。

    • 多种尺寸版本，灵活性高。

    • 背靠 Google 强大的技术实力和生态系统，应用前景广阔。

  • 缺点:

    • Gemini Ultra 的访问权限目前较为受限。

    • API 访问和生态系统相对 GPT 系列稍逊 (但正在快速发展)。

    • 模型细节和多模态训练数据相对封闭。

    • 多模态能力仍处于发展初期，仍有提升空间。

总结与选择建议:

选择合适的AI大模型需要根据具体的应用场景、需求和资源情况进行权衡：

• 文本生成与理解任务:

  • 追求顶尖性能和通用性: GPT-4 或 Gemini Ultra 是首选，但成本较高。

  • 追求高性能和相对较低成本: GPT-3.5 Turbo, PaLM 2, Claude 3 Sonnet/Opus 是不错的选择。

  • 追求开源和可商用: Llama 3 或 Code Llama 系列是最佳选择。

  • 中文 NLP 任务: ERNIE Bot 4.0 或 ChatGLM3 系列在中文领域具有优势。

• 代码生成任务:

  • 追求顶尖代码生成能力: Codex (GitHub Copilot) 或 Codey 是首选。

  • 追求开源和可商用: Code Llama 系列是最佳选择。

• 多模态任务:

  • 追求顶尖多模态性能: Gemini Ultra 或 GPT-4 (多模态版本) 是首选，但成本较高。

  • 需要考虑成本和易用性: Gemini Pro 或 GPT-4 (多模态版本) 的API 也是可行的选择。

起因

最近家里人因为我一句无心的话而生气了好几天，因此我想聊一聊背后深层原因。

基于这个事我就一直在想，为什么她明知道我是无心的但还是生气了？为什么生气了这么久？

说明

使用ollama可以很方便的运行本地大模型(包括官方模型和gguf量化模型)，使用streamlit快速构建对话界面。

安装ollama

以linux系统为例

在线安装

在线安装直接按官方命令执行：curl -fsSL https://ollama.com/install.sh | sh ，但鉴于国内网络下不动，可以考虑手动安装

手动安装

下载安装包： curl -L https://ollama.com/download/ollama-linux-amd64.tgz -o ollama-linux-amd64.tgz
解压： sudo tar -C /usr -xzf ollama-linux-amd64.tgz
运行服务： ollama serve

下载模型文件

此处使用modelscope下载qwen的gguf量化模型

安装modelscope下载工具:pip install -U modelscope

下载模型文件： modelscope download --model=Qwen/Qwen2.5-Coder-32B-Instruct-GGUF --include "qwen2.5-coder-32b-instruct-q5_k_m*.gguf" --local_dir .

创建ModelFile

ModelFile用于ollama构建本地模型，示例如下：

1
2
3
4
5
6
7
8

FROM ./QwQ-32B-Preview-GGUF/qwen2.5-coder-32b-instruct-q5_k_m.gguf
# sets the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1
# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token
PARAMETER num_ctx 4096

# sets a custom system message to specify the behavior of the chat assistant
SYSTEM You are Mario from super mario bros, acting as an assistant.

构建ollama本地大模型

执行:ollama create mymodel -f ./Modelfile 名字可以随便起，Modelfile为刚才创建的Modelfile文件路径。

创建完成后运行： ollama run mymodel

编写streamlit页面并与ollama对接

依赖

需要安装的依赖如下：

1
2
3
4

pip install transformers
pip install ctransformers
pip install streamlit
pip install torch

如无法运行可能需要安装torch cuda环境，具体安装此处省略。

编写python代码

创建main.py编写如下代码：

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

from transformers import AutoTokenizer
from ctransformers import AutoModelForCausalLM
from transformers import TextStreamer
import logging
import torch
import json
import requests

logger = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(),  # 输出到控制台
        logging.FileHandler('qwen-chat-gguf.log')  # 输出到文件
    ]
)

import streamlit as st
st.set_page_config(
    page_title="MY AI",
    page_icon="🤖"  
)
"""
AI对话模块，支持流式输出 
"""

class QwenChat:
    def __init__(self):
        self.api_base = "http://localhost:11434"  # Ollama默认地址
        self.model = "mymodel"  # 使用的模型名称
    
    
    def stream_chat(self, prompt,history=None):

        # 构建API请求
        url = f"{self.api_base}/api/generate"
        headers = {
            "Content-Type": "application/json"
        }
        data = {
            "model": self.model,
            "prompt": prompt,
            "stream": True,
            "system": "你是AI助手",
            "messages": history
        }
        

        try:
            # 发送流式请求
            response = requests.post(url, headers=headers, json=data, stream=True)
            response.raise_for_status()
            return response
                        
        except Exception as e:
            logger.error(f"调用Ollama API时发生错误: {str(e)}")
            raise e
        
        
@st.cache_resource
def get_qwen_chat_instance():
    return QwenChat()


if __name__ == "__main__":
    
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
     # 创建 QwenChat 实例
    # 使用共享的 QwenChat 实例
    qwen_chat = get_qwen_chat_instance()
    
    st.title("AI助手")
    st.write("请问有什么可以帮您的？")
    
    
    # 初始化对话历史
    if "messages" not in st.session_state:
        st.session_state.messages = []
    
    # 显示历史对话
    for message in st.session_state.messages:
        with st.chat_message(message["role"]):
            st.markdown(message["content"])
    
    # 用户输入
    if prompt := st.chat_input("请输入您的问题"):
        # 显示用户问题
        with st.chat_message("user"):
            st.markdown(prompt)
        st.session_state.messages.append({"role": "user", "content": prompt})
        
        # 显示AI回答
        with st.chat_message("assistant"):
            message_placeholder = st.empty()
            full_response = ""
            
            full_text = ""
            # 获取历史消息（不包括最新的用户消息）
            history = st.session_state.messages[:-1] if len(st.session_state.messages) > 0 else None
            response = qwen_chat.stream_chat(prompt, history)
            
            for line in response.iter_lines():
                if line:
                    # 解析JSON响应
                    chunk = json.loads(line)
                    if "response" in chunk:
                        text_chunk = chunk["response"]
                        # print(text_chunk)
                        full_text += text_chunk
                        # 更新ui
                        message_placeholder.markdown(full_text + "▌")
                    
                    # 如果生成结束,退出循环    
                    if chunk.get("done", False):
                        break
            
            # 更新最终响应
            message_placeholder.markdown(full_text)
            
            st.session_state.messages.append({"role": "assistant", "content": full_text})
            

最终运行启动命令： streamlit run main.py

JAVA分布式服务常见面试题

分布式事务

Seata

seata是阿里开源的分布式事务调度框架，支持TCC、AT、SAGA、XA四种模式

• AT
  SEATA默认是AT模式，通过@GlobalTrancation 动态代理生成全局事务ID，并通过RM来管理全局事务，如中间出错需要回滚事务时则通过数据库中的undo-log回写，undolog记录了数据提交前的状态

• XA
  二阶段提交，需要数据库本身支持XA协议

• TCC
  即 尝试(Try)-确认(Confirm)-取消(Cancel)，每个事务都分成这三个阶段，在提交事务前向另一个系统发送确认消息，两边系统都确认OK了才执行提交操作，有一方出现异常则执行Cancel（补偿方法），缺点在于三个方法都需要自已手动完成

• SAGA
  与TCC类似，不同点在于一阶段直接提交事务，失败则执行补偿操作，无锁，因此性能相对较好，但同时由于没有事务隔离性会带来赃写

场景

当某些简单的定时任务需要通过后台修改执行时间时，通过spring boot自带的定时任务来实现是个不错的选择。

代码实现

创建定时任务类

需要实现SchedulingConfigurer接口

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

@Slf4j
@Component
@Configuration
public class Scheduled implements SchedulingConfigurer{

    private String cron;
    TaskScheduler taskScheduler;
	@Autowired
	CronMapper cronMapper;

    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(30);
        scheduler.setThreadNamePrefix("TaskScheduler-");
        scheduler.initialize();
        return scheduler;
    }

	@Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		this.taskRegistrar=taskRegistrar;
		this.taskScheduler=taskScheduler();
		scheduleTask();
    }

	 public void scheduleTask() {
		 taskScheduler.schedule(this.task, triggerContext -> {
             //从数据库获取执行周期
             if(!StringUtils.hasText(this.cron)) {
             	Cron c = cronMapper.selectById("1");
             	//如果为空设置默认
             	if(c==null) {
             		c=new Cron();
                 	c.setCronId("1");
                 	c.setCron("0 0 0/6 * * ? ");
                 	cronMapper.insert(c);
             	}
             	this.cron = c.getCron();
             }
             //返回执行周期
             return new CronTrigger(this.cron).nextExecutionTime(triggerContext);
         });
	 }

    public void setCron(String cron) {
		this.cron = cron;
	}
}

通过接口触发修改执行时间

1
2
3
4
5
6
7
8
9
10
11

@PostMapping
public String updateCron(String cron){
	 //此处省略修改数据库中的cron 值 
     ...

     //修改为新的执行时间
     scheduled.setCron(cron);
     scheduled.scheduleTask();
     return "修改成功";
}

用途

由于服务器上部署了caddy torjan 作为代理服务器，想要配置域名时发现80端口已经被caddy占用，无法使用nginx，干掉80端口代理又无法使用，于是打算直接使用caddy反向代理域名。

配置caddy时走了一些弯路，按照官方文档配置怎么都访问不了，在此记录一下最终解决方案

弯路

按照官方文档我找到了caddyFile的位置：/etc/caddy/Caddyfile

接着vi 编辑，如下配置：

1
2
3

reiner.host {
    reverse_proxy localhost:8000
}

保存后重启caddy: systemctl restart caddy.service

访问配置的域名，结果发现域名访问不进来，官方的说法是，不配置前缀只配置域名，默认转发http://reiner.host 以及 https://reiner.host 的80和443端口，理论上这么配置应该没错。

这里我的版本是caddy 2.6.x

最终解决

最终我打算不再相信官方文档，手动配置每个需要转发的端口，如下：

1
2
3
4
5
6
7
8
9
10

www.reiner.host:80 www.reiner.host:443 reiner.host:80 reiner.host:443 {
        tls [email protected]
        root * /data/pages
        file_server
}

gateway.reiner.host:80 gateway.reiner.host:443 {
        tls [email protected]
        reverse_proxy localhost:8000
}

其中第一段配置是将/data/pages文件夹下所有文件作为HTTP服务器，通过访问如 reiner.host 或者 www.reiner.host 转发到 /data/pages/index.html

第二段是配置后台接口的地址，通过访问gateway.reiner.host 转发到本地的8000端口服务

tls 的作用是帮你申请ssl证书，这一点比nginx方便很多，当配置完重启后已经可以直接通过https访问了

2023-8-26 update
针对同一个域名，根据不同的路径转换到不同的服务，配置示例如下：

1
2
3
4
5
6
7

www.reiner.host:80 www.reiner.host:443 reiner.host:80 reiner.host:443 {
        tls [email protected]
        reverse_proxy localhost:8080
        handle_path /api/user/* {
            reverse_proxy localhost:8081
        }
}

例如访问reiner.host/api/user/xxx 就会转发到服务器的8081端口

Based

• Langchain

• llama_index >=0.6.5

• GPT-3.5

• websockets

• python >=3.10

dependence

1
2
3
4
5
6
7
8
9
10
11

pip install llama-index

pip install openai 

pip install langchain

pip install websockets

pip install pandas

pip install llama-hub

What use

Supporting private knowledge base AI question-answering chatbot, capable of both knowledge-based Q&A and casual conversation.

前言

随着OPENAI开放API接口后，各大厂商的AI如雨后春笋般涌现，如同十年前的互联网大火，未来的风口必然是在AI上。

当然，基于自训模型/自研AI 门槛过高，不是个人或中小厂能干的，而且即使有也与OPENAI差距不小，因此一般人能卷的也只有应用层了。

基于此背景，我开始研究基于GPT的自定义数据索引问答机器人，接着我发现了llama_index和langchain这两个框架，在此记录一下它的使用方法。

llama_index: GitHub - jerryjliu/llama_index: LlamaIndex (GPT Index) is a project that provides a central interface to connect your LLM's with external data.

langchain: GitHub - hwchase17/langchain: ⚡ Building applications with LLMs through composability ⚡

OPENAI模型微调？

最初我尝试使用OPENAI的模型微调，我试着弄了几百KB的文本数据喂进去，然而发现当我使用微调模型对话时AI的回复总是只言片语连一句完整的句子都无法返回。

通过搜索资料后我意识到模型微调不是几百或者几兆文本数据就能达到我想要的目地的。

最终我发现llama_index + langchain可以实现想要的效果

llama_index + langchian实现智能问答机器人

step 1.安装环境

• 安装python3.10以上版本

• 安装依赖库：

  1. pip install llama-index

  2. pip install openai

  3. pip install langchain

  4. pip install pandas

• 准备OPENAI的API KEY

step 2.准备数据

准备好机器人要回答的资料库，可以有PDF、HTML、WORD文档、SQL、API接口甚至GITHUB、WIKI等网络资源也可以，在本章我将使用简单的TXT文本，举例大概内容如下：

塞尔达传说：王国之泪什么时候出？ 《塞尔达传说：王国之泪》将于2023年5月12日发售哦，敬请期待！