说明

使用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日发售哦，敬请期待！

前言

前面使用Jenkins+docker+shell脚本可以方便的实现单体应用部署，但如果是微服务架构，工程包较多，若是为每一个服务都建一个Jenkins job 会变得很繁琐，这个时候就需要用到docker-compose 容器编排工具，它可以只需一行命令就能帮我们完成多个服务的构建、推送、重启。

考虑到如果有多个服务需要部署到多台服务器，如果每台服务器都采用发送jar包再构建镜像的方式会产生许多重复工作，因此这种情况应该使用jenkins构建镜像->推送到私库->服务器拉取->docker-compose启动 如此流程来完成部署。

准备工作

需要安装如下软件：

1. Jenkins （包括git/svn、publish over ssh 这个插件，jenkins安装教程很多此处不再赘述）

2. docker

3. Node JS (可选，仅部署前端vue项目时需要安装)

4. docker compose

准备工作指路：

jenkins: https://www.jenkins.io/download/ 直接启动war包或者使用docker安装

docker: Install Docker Desktop on Linux

Node Js:Node.js

docker compose: GitHub - docker/compose: Define and run multi-container applications with Docker

或者直接使用curl下载安装，以CentOs为例执行如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1、下载docker-compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

2、增加可执行权限
sudo chmod +x /usr/local/bin/docker-compose

3、添加软链接
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

4、确认版本
$ docker-compose --version

sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

安装docker私库

为了使服务一次打包多次部署，需要安装docker私库来保存镜像

首先建好映射目录的文件夹：

1

mkdir /data/registry

执行docker命令启动私库镜像：

1

docker run -itd -v /data/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry:latest　

添加docker配置：

注意：如果是通过内网访问就配内网IP否则 配公网IP

vi /etc/docker/daemon.json
添加如下：

1

"insecure-registries": ["192.168.2.200:5000"]

如果需要设置账号密码：

1

docker run --rm --entrypoint htpasswd  httpd:2 -Bbn yourUserName yourPwd >> ./auth/htpasswd  

一般在内网环境部署私库，拉取推送也是全程内网，所以可装可不装

默认私库无法删除镜像，执行如下命令添加配置：

1
2
3
4
5
6
7

sudo docker exec -it registry /bin/sh
cd /etc/docker/registry
vi config.yml
加入
  delete:                                                                                                                                                                          
    # To allow image delete                                                                                                                                                        
    enabled: true 

前言

网上的资料比较杂，且少有成体系的资料，因此收集资料并按照自己的理解做了一下整合，本文为自我理解与总结，不代表标准答案。

从hello world开始

java从编写’System.out.println(“hello world”)’ 开始，并编译运行，在这期间到底发生了什么。

.java文件从编译到结束全过程（类加载过程）

一个.java文件的完整周期是 java编码成jvm可识别的.class文件， 然后大致流程是： 加载–>连接–>初始化–>使用–>卸载

1. 加载过程

1、通过全类名获取定义此类的二进制字节流（类似反射）
2、将字节流所代表的静态存储结构转换为JVM方法区的运行时数据结构
3、在内存中生成一个代表该类的 java.lang.Class 对象，作为方法区这些数据的访问入口(这样代码才能通过全类名访问到该对象)
PS:数组类型不通过类加载器创建，它由JAVA虚拟机直接创建，数组的加载可通过自定义类加载器控制加载方式

1.1 加载过程中所需要的类加载器

JVM中有三个类加载器，除了 BootstrapClassLoader 其他类加载器均由 Java 实现且全部继承自java.lang.ClassLoader

1、BootstrapClassLoader(启动类加载器) ：最顶层的加载类，由 C++实现，负责加载 %JAVA_HOME%/lib目录下的 jar 包和类或者被 -Xbootclasspath参数指定的路径中的所有类。
2、ExtensionClassLoader(扩展类加载器) ：主要负责加载 %JRE_HOME%/lib/ext 目录下的 jar 包和类，或被 java.ext.dirs 系统变量所指定的路径下的 jar 包。
3、AppClassLoader(应用程序类加载器) ：面向我们用户的加载器，负责加载当前应用 classpath 下的所有 jar 包和类。