大模型入门学习路径（Java开发者版）下

Mr.朱鹏2025-12-21 18:41

文章目录

第四阶段：模型微调与部署（3-4周）

4.1 微调技术原理

LoRA（Low-Rank Adaptation）
python 复制代码 
# 原理解释（使用Python演示，Java在后面）
"""
LoRA原理：
不更新原模型权重 W，而是训练两个小矩阵 A 和 B

W_new = W_original + A * B

其中：
- W: d × d （如 4096 × 4096）
- A: d × r （如 4096 × 8）  
- B: r × d （如 8 × 4096）
- r: rank（通常 4-64）

优势：
1. 只需训练 2*d*r 个参数，相比全量微调减少 99%+
2. 多个任务可共享基座模型，只需切换 LoRA 权重
3. 推理时可合并到原模型，无额外延迟
"""

import torch
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

# 加载基座模型
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B")

# 配置LoRA
lora_config = LoraConfig(
    r=8,                    # Rank
    lora_alpha=32,          # 缩放系数
    target_modules=["q_proj", "v_proj"],  # 对哪些层应用LoRA
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)

# 应用LoRA
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 输出: trainable params: 4,194,304 || all params: 7,241,732,096 || trainable%: 0.0579

4.2 使用Java调用微调流程

方案一：使用Python脚本 + Java调用
java 复制代码 
// 1. Java控制微调流程
@Service
public class ModelFineTuneService {
    
    /**
     * 准备训练数据
     */
    public void prepareTrainingData(List<TrainingExample> examples, String outputPath) {
        // 转换为JSONL格式
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(outputPath))) {
            for (TrainingExample example : examples) {
                Map<String, Object> data = Map.of(
                    "instruction", example.getInstruction(),
                    "input", example.getInput(),
                    "output", example.getOutput()
                );
                writer.write(JSON.toJSONString(data));
                writer.newLine();
            }
        }
    }
    
    /**
     * 调用Python微调脚本
     */
    public void startFineTuning(FineTuneConfig config) throws IOException {
        ProcessBuilder pb = new ProcessBuilder(
            "python", "scripts/finetune.py",
            "--model_name", config.getBaseModel(),
            "--data_path", config.getDataPath(),
            "--output_dir", config.getOutputDir(),
            "--lora_rank", String.valueOf(config.getLoraRank()),
            "--num_epochs", String.valueOf(config.getEpochs()),
            "--learning_rate", String.valueOf(config.getLearningRate())
        );
        
        pb.redirectErrorStream(true);
        Process process = pb.start();
        
        // 实时读取输出
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                log.info("Training log: {}", line);
                // 可以解析进度、loss等信息
                parseTrainingProgress(line);
            }
        }
        
        int exitCode = process.waitFor();
        if (exitCode != 0) {
            throw new RuntimeException("微调失败");
        }
    }
}

@Data
class FineTuneConfig {
    private String baseModel = "Qwen/Qwen-7B";  // 基座模型
    private String dataPath;                     // 训练数据路径
    private String outputDir;                    // 输出目录
    private int loraRank = 8;                    // LoRA rank
    private int epochs = 3;                      // 训练轮数
    private double learningRate = 1e-4;          // 学习率
}
Python微调脚本
python 复制代码 
# scripts/finetune.py
import argparse
import torch
from datasets import load_dataset
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    TrainingArguments,
    Trainer
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model_name", type=str, required=True)
    parser.add_argument("--data_path", type=str, required=True)
    parser.add_argument("--output_dir", type=str, required=True)
    parser.add_argument("--lora_rank", type=int, default=8)
    parser.add_argument("--num_epochs", type=int, default=3)
    parser.add_argument("--learning_rate", type=float, default=1e-4)
    args = parser.parse_args()
    
    # 1. 加载模型和tokenizer
    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name,
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    # 2. 配置LoRA
    lora_config = LoraConfig(
        r=args.lora_rank,
        lora_alpha=32,
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
        lora_dropout=0.1,
        bias="none",
        task_type="CAUSAL_LM"
    )
    model = get_peft_model(model, lora_config)
    
    # 3. 加载数据
    dataset = load_dataset("json", data_files=args.data_path)
    
    def format_prompt(example):
        prompt = f"""### Instruction:
{example['instruction']}

### Input:
{example['input']}

### Response:
{example['output']}"""
        return tokenizer(prompt, truncation=True, max_length=512)
    
    tokenized_dataset = dataset.map(format_prompt, remove_columns=dataset["train"].column_names)
    
    # 4. 训练参数
    training_args = TrainingArguments(
        output_dir=args.output_dir,
        num_train_epochs=args.num_epochs,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=args.learning_rate,
        logging_steps=10,
        save_steps=100,
        save_total_limit=3,
        fp16=True,
    )
    
    # 5. 开始训练
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=tokenized_dataset["train"],
    )
    
    trainer.train()
    
    # 6. 保存模型
    model.save_pretrained(args.output_dir)
    tokenizer.save_pretrained(args.output_dir)
    print("Training completed!")

if __name__ == "__main__":
    main()

4.3 模型部署方案

方案一：Ollama本地部署（推荐入门）
java 复制代码 
// 1. 安装Ollama（Windows）
// 下载: https://ollama.com/download

// 2. Java控制Ollama
@Service
public class OllamaService {
    private static final String OLLAMA_API = "http://localhost:11434";
    
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * 拉取模型
     */
    public void pullModel(String modelName) throws IOException {
        ProcessBuilder pb = new ProcessBuilder("ollama", "pull", modelName);
        pb.inheritIO();
        Process process = pb.start();
        process.waitFor();
    }
    
    /**
     * 调用本地模型
     */
    public String chat(String model, String prompt) {
        Map<String, Object> request = Map.of(
            "model", model,
            "prompt", prompt,
            "stream", false
        );
        
        ResponseEntity<Map> response = restTemplate.postForEntity(
            OLLAMA_API + "/api/generate",
            request,
            Map.class
        );
        
        return (String) response.getBody().get("response");
    }
    
    /**
     * 流式响应
     */
    public void chatStream(String model, String prompt, Consumer<String> callback) {
        // 使用OkHttp处理流式响应
        OkHttpClient client = new OkHttpClient();
        
        RequestBody body = RequestBody.create(
            MediaType.parse("application/json"),
            JSON.toJSONString(Map.of(
                "model", model,
                "prompt", prompt,
                "stream", true
            ))
        );
        
        Request request = new Request.Builder()
            .url(OLLAMA_API + "/api/generate")
            .post(body)
            .build();
            
        try (Response response = client.newCall(request).execute()) {
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(response.body().byteStream())
            );
            
            String line;
            while ((line = reader.readLine()) != null) {
                Map<String, Object> json = JSON.parseObject(line, Map.class);
                String chunk = (String) json.get("response");
                if (chunk != null) {
                    callback.accept(chunk);
                }
            }
        }
    }
    
    /**
     * 导入自定义模型
     */
    public void createCustomModel(String modelName, String modelPath) throws IOException {
        // 1. 创建Modelfile
        String modelfile = String.format("""
            FROM %s
            TEMPLATE \"\"\"{{ .System }}
            
            ### Instruction:
            {{ .Prompt }}
            
            ### Response:
            \"\"\"
            PARAMETER temperature 0.7
            PARAMETER top_p 0.9
            """, modelPath);
            
        Files.writeString(Paths.get("Modelfile"), modelfile);
        
        // 2. 创建模型
        ProcessBuilder pb = new ProcessBuilder(
            "ollama", "create", modelName, "-f", "Modelfile"
        );
        pb.inheritIO();
        pb.start().waitFor();
    }
}
方案二：vLLM服务化部署（生产环境）
yaml 复制代码 
# docker-compose.yml
version: '3.8'
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ./models:/models
    command: >
      --model /models/Qwen-7B-Chat
      --trust-remote-code
      --tensor-parallel-size 1
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
java 复制代码 
// vLLM Java客户端
@Service
public class VllmService {
    private static final String VLLM_API = "http://localhost:8000/v1";
    
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * 调用vLLM服务（兼容OpenAI API）
     */
    public String chat(String message) {
        Map<String, Object> request = Map.of(
            "model", "Qwen-7B-Chat",
            "messages", List.of(
                Map.of("role", "user", "content", message)
            ),
            "temperature", 0.7,
            "max_tokens", 1000
        );
        
        ResponseEntity<Map> response = restTemplate.postForEntity(
            VLLM_API + "/chat/completions",
            request,
            Map.class
        );
        
        Map<String, Object> body = response.getBody();
        List<Map<String, Object>> choices = (List) body.get("choices");
        Map<String, Object> message = (Map) choices.get(0).get("message");
        return (String) message.get("content");
    }
}

4.4 量化与性能优化

GPTQ量化（4bit）
python 复制代码 
# 量化脚本
from transformers import AutoTokenizer, GPTQConfig
from auto_gptq import AutoGPTQForCausalLM

model_name = "Qwen/Qwen-7B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 配置4bit量化
quantization_config = GPTQConfig(
    bits=4,
    group_size=128,
    desc_act=False,
)

# 加载并量化
model = AutoGPTQForCausalLM.from_pretrained(
    model_name,
    quantization_config=quantization_config
)

# 保存量化后模型
model.save_pretrained("Qwen-7B-Chat-GPTQ-4bit")
tokenizer.save_pretrained("Qwen-7B-Chat-GPTQ-4bit")

# 效果：模型大小从14GB减少到4GB，精度损失<2%
java 复制代码 
// Java加载量化模型
@Service
public class QuantizedModelService {
    /**
     * 通过Ollama使用量化模型
     */
    public void loadQuantizedModel() throws IOException {
        // Ollama自动使用4-bit量化
        ProcessBuilder pb = new ProcessBuilder(
            "ollama", "run", "qwen:7b-chat-q4_0"  // q4_0 = 4-bit量化
        );
        pb.start();
    }
}

4.5 实战项目：Java代码助手

数据准备
java 复制代码 
@Service
public class CodeDatasetService {
    /**
     * 从GitHub收集Java代码
     */
    public List<TrainingExample> collectJavaCode(String repoUrl) {
        List<TrainingExample> examples = new ArrayList<>();
        
        // 1. Clone仓库
        Git git = Git.cloneRepository()
            .setURI(repoUrl)
            .setDirectory(new File("temp/repo"))
            .call();
            
        // 2. 遍历Java文件
        Files.walk(Paths.get("temp/repo"))
            .filter(p -> p.toString().endsWith(".java"))
            .forEach(path -> {
                try {
                    String code = Files.readString(path);
                    // 3. 提取方法级别的代码
                    List<MethodDeclaration> methods = parseJavaMethods(code);
                    
                    for (MethodDeclaration method : methods) {
                        examples.add(new TrainingExample(
                            "实现一个Java方法",
                            extractMethodSignature(method),
                            method.toString()
                        ));
                    }
                } catch (IOException e) {
                    log.error("读取文件失败", e);
                }
            });
            
        return examples;
    }
    
    /**
     * 生成代码解释数据
     */
    public List<TrainingExample> generateExplanations(List<String> codeSamples) {
        LlmService gpt4 = new OpenAiService("gpt-4");  // 使用强模型生成训练数据
        
        return codeSamples.stream()
            .map(code -> {
                String prompt = String.format("""
                    请解释以下Java代码的功能：
                    
                    ```java
                    %s
                    ```
                    
                    请给出详细的中文解释。
                    """, code);
                    
                String explanation = gpt4.chat(prompt);
                
                return new TrainingExample(
                    "解释代码",
                    code,
                    explanation
                );
            })
            .collect(Collectors.toList());
    }
}
微调后的模型使用
java 复制代码 
@RestController
@RequestMapping("/api/code-assistant")
public class CodeAssistantController {
    @Autowired
    private OllamaService ollama;
    
    /**
     * 代码生成
     */
    @PostMapping("/generate")
    public ResponseEntity<String> generateCode(@RequestBody CodeRequest request) {
        String prompt = String.format("""
            ### Instruction:
            实现一个Java方法
            
            ### Input:
            %s
            
            ### Response:
            """, request.getDescription());
            
        String code = ollama.chat("java-code-assistant", prompt);
        return ResponseEntity.ok(code);
    }
    
    /**
     * 代码解释
     */
    @PostMapping("/explain")
    public ResponseEntity<String> explainCode(@RequestBody CodeRequest request) {
        String prompt = String.format("""
            ### Instruction:
            解释代码
            
            ### Input:
            ```java
            %s
            ```
            
            ### Response:
            """, request.getCode());
            
        String explanation = ollama.chat("java-code-assistant", prompt);
        return ResponseEntity.ok(explanation);
    }
    
    /**
     * Bug修复建议
     */
    @PostMapping("/fix-bug")
    public ResponseEntity<BugFixResponse> fixBug(@RequestBody BugRequest request) {
        String prompt = String.format("""
            ### Instruction:
            分析并修复以下Java代码的Bug
            
            ### Input:
            代码：
            ```java
            %s
            ```
            
            错误信息：
            %s
            
            ### Response:
            """, request.getCode(), request.getErrorMessage());
            
        String response = ollama.chat("java-code-assistant", prompt);
        return ResponseEntity.ok(parseBugFixResponse(response));
    }
}

4.6 阶段性任务清单

  • 理解LoRA/QLoRA原理，计算参数量对比
  • 准备垂直领域训练数据（1000+条）
  • 搭建Python微调环境（transformers + peft）
  • 完成一次完整的LoRA微调（记录loss变化）
  • 部署Ollama并导入自定义模型
  • 对比微调前后模型效果（准确率、响应质量）
  • 尝试4bit量化，测试性能与精度
  • 开发Java代码助手应用（生成、解释、修复）

第五阶段：Agent与高级应用（2-3周）

5.1 Agent框架核心概念

什么是Agent？
java 复制代码 
/**
 * Agent = LLM + 工具调用 + 记忆 + 规划
 * 
 * 传统对话：用户 -> LLM -> 响应
 * Agent模式：用户 -> Agent(思考 -> 调用工具 -> 再思考) -> 响应
 * 
 * 示例场景：
 * 用户："帮我查一下明天北京的天气，如果下雨就发邮件提醒我"
 * 
 * Agent执行流程：
 * 1. 理解意图：需要查天气、条件判断、发邮件
 * 2. 调用天气API -> 获取："明天小雨 15-20℃"
 * 3. 判断：有雨，需要发邮件
 * 4. 调用邮件API -> 发送成功
 * 5. 回复用户："明天北京小雨，已经发邮件提醒您"
 */

5.2 使用LangChain4j构建Agent

Maven依赖
xml 复制代码 
<dependencies>
    <!-- LangChain4j 核心 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
        <version>0.27.0</version>
    </dependency>
    
    <!-- OpenAI集成 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>0.27.0</version>
    </dependency>
    
    <!-- 向量存储 -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-embeddings-all-minilm-l6-v2</artifactId>
        <version>0.27.0</version>
    </dependency>
</dependencies>
基础Agent实现
java 复制代码 
// 1. 定义工具
@Service
public class WeatherTool {
    
    @Tool("查询指定城市的天气信息")
    public String getWeather(
            @P("城市名称，如北京、上海") String city) {
        // 调用实际天气API
        RestTemplate restTemplate = new RestTemplate();
        String url = String.format("https://api.weather.com/v1?city=%s", city);
        WeatherResponse response = restTemplate.getForObject(url, WeatherResponse.class);
        
        return String.format("%s天气：%s，温度%d℃", 
            city, response.getCondition(), response.getTemperature());
    }
}

@Service
public class EmailTool {
    
    @Tool("发送邮件给指定收件人")
    public String sendEmail(
            @P("收件人邮箱") String to,
            @P("邮件主题") String subject,
            @P("邮件内容") String content) {
        // 调用邮件服务
        try {
            emailService.send(to, subject, content);
            return "邮件发送成功";
        } catch (Exception e) {
            return "邮件发送失败：" + e.getMessage();
        }
    }
}

@Service
public class DatabaseTool {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Tool("查询数据库中的数据")
    public String queryDatabase(@P("SQL查询语句") String sql) {
        try {
            List<Map<String, Object>> results = jdbcTemplate.queryForList(sql);
            return JSON.toJSONString(results);
        } catch (Exception e) {
            return "查询失败：" + e.getMessage();
        }
    }
}

// 2. 创建Agent
@Configuration
public class AgentConfig {
    
    @Bean
    public AiServices<AssistantAgent> createAgent(
            WeatherTool weatherTool,
            EmailTool emailTool,
            DatabaseTool databaseTool) {
        
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4")
            .temperature(0.0)  // Agent需要精准，不需要创意
            .build();
            
        return AiServices.builder(AssistantAgent.class)
            .chatLanguageModel(model)
            .tools(weatherTool, emailTool, databaseTool)
            .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
            .build();
    }
}

// 3. 定义Agent接口
interface AssistantAgent {
    String chat(String message);
}

// 4. 使用Agent
@RestController
@RequestMapping("/api/agent")
public class AgentController {
    
    @Autowired
    private AssistantAgent agent;
    
    @PostMapping("/chat")
    public ResponseEntity<String> chat(@RequestBody ChatRequest request) {
        String response = agent.chat(request.getMessage());
        return ResponseEntity.ok(response);
    }
}
工具调用原理（Function Calling）
java 复制代码 
/**
 * Function Calling流程：
 * 
 * 1. 用户："帮我查一下明天北京的天气"
 * 
 * 2. LLM分析后返回：
 * {
 *   "function_call": {
 *     "name": "getWeather",
 *     "arguments": {"city": "北京"}
 *   }
 * }
 * 
 * 3. Agent框架执行 getWeather("北京")
 * 
 * 4. 得到结果："北京天气：晴，温度25℃"
 * 
 * 5. 将结果反馈给LLM，LLM生成最终回复：
 *    "明天北京天气晴朗，温度大约25℃，适合出行。"
 */

5.3 ReAct Agent实现

ReAct模式（Reasoning + Acting）
java 复制代码 
@Service
public class ReactAgentService {
    @Autowired
    private LlmService llm;
    
    @Autowired
    private Map<String, Tool> tools;  // 所有可用工具
    
    /**
     * ReAct循环执行
     */
    public String execute(String task) {
        List<String> trajectory = new ArrayList<>();  // 记录执行轨迹
        int maxIterations = 10;
        
        for (int i = 0; i < maxIterations; i++) {
            // Step 1: Thought (思考)
            String prompt = buildReActPrompt(task, trajectory);
            String response = llm.chat(prompt);
            
            // Step 2: 解析响应
            ReActStep step = parseReActResponse(response);
            trajectory.add(response);
            
            if (step.getAction().equals("Finish")) {
                return step.getActionInput();
            }
            
            // Step 3: Action (行动)
            Tool tool = tools.get(step.getAction());
            if (tool == null) {
                trajectory.add("Observation: 工具不存在");
                continue;
            }
            
            String observation = tool.execute(step.getActionInput());
            trajectory.add("Observation: " + observation);
        }
        
        return "超过最大迭代次数";
    }
    
    private String buildReActPrompt(String task, List<String> trajectory) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("""
            你是一个能够使用工具解决问题的AI Agent。
            
            可用工具：
            - getWeather(city): 查询天气
            - sendEmail(to, subject, content): 发送邮件
            - queryDatabase(sql): 查询数据库
            - calculate(expression): 计算数学表达式
            
            你应该按照以下格式回复：
            Thought: 我需要做什么
            Action: 工具名称
            Action Input: 工具参数
            
            如果已经得到最终答案：
            Thought: 我现在知道答案了
            Action: Finish
            Action Input: 最终答案
            
            任务：
            """);
        prompt.append(task).append("\n\n");
        
        // 添加历史轨迹
        trajectory.forEach(t -> prompt.append(t).append("\n"));
        
        return prompt.toString();
    }
    
    private ReActStep parseReActResponse(String response) {
        // 解析 Thought/Action/Action Input
        Pattern pattern = Pattern.compile(
            "Thought: (.+?)\nAction: (.+?)\nAction Input: (.+)",
            Pattern.DOTALL
        );
        Matcher matcher = pattern.matcher(response);
        
        if (matcher.find()) {
            return new ReActStep(
                matcher.group(1).trim(),
                matcher.group(2).trim(),
                matcher.group(3).trim()
            );
        }
        
        throw new IllegalArgumentException("无法解析响应");
    }
}

@Data
@AllArgsConstructor
class ReActStep {
    private String thought;
    private String action;
    private String actionInput;
}

5.4 多智能体协作（Multi-Agent）

java 复制代码 
/**
 * 多智能体协作场景：软件开发团队
 */

// 1. 产品经理Agent
@Service
public class ProductManagerAgent {
    @Autowired
    private LlmService llm;
    
    public String writeRequirements(String userStory) {
        String prompt = String.format("""
            你是一个产品经理。请根据用户需求编写详细的PRD文档。
            
            用户需求：%s
            
            请包含：
            1. 功能描述
            2. 产品目标
            3. 用户故事
            4. 验收标准
            """, userStory);
            
        return llm.chat(prompt);
    }
}

// 2. 架构师Agent
@Service
public class ArchitectAgent {
    @Autowired
    private LlmService llm;
    
    public String designArchitecture(String requirements) {
        String prompt = String.format("""
            你是一个资深架构师。请根据需求设计技术架构。
            
            需求文档：%s
            
            请输出：
            1. 技术选型
            2. 系统架构图
            3. 数据库设计
            4. API设计
            """, requirements);
            
        return llm.chat(prompt);
    }
}

// 3. 开发者Agent
@Service
public class DeveloperAgent {
    @Autowired
    private LlmService llm;
    
    public String writeCode(String architecture, String task) {
        String prompt = String.format("""
            你是一个高级Java开发者。请根据架构设计实现代码。
            
            架构设计：%s
            
            当前任务：%s
            
            请生成完整的Java代码，包括单元测试。
            """, architecture, task);
            
        return llm.chat(prompt);
    }
}

// 4. 测试工程师Agent
@Service
public class TesterAgent {
    @Autowired
    private LlmService llm;
    
    public String reviewCode(String code) {
        String prompt = String.format("""
            你是一个QA工程师。请审查代码并生成测试用例。
            
            代码：
            ```java
            %s
            ```
            
            请输出：
            1. 代码审查意见
            2. 潜在问题
            3. 测试用例（正常、异常、边界）
            """, code);
            
        return llm.chat(prompt);
    }
}

// 5. 协调器
@Service
public class TeamCoordinator {
    @Autowired
    private ProductManagerAgent pmAgent;
    
    @Autowired
    private ArchitectAgent architectAgent;
    
    @Autowired
    private DeveloperAgent developerAgent;
    
    @Autowired
    private TesterAgent testerAgent;
    
    /**
     * 完整的开发流程
     */
    public ProjectOutput developFeature(String userStory) {
        ProjectOutput output = new ProjectOutput();
        
        // Step 1: PM编写PRD
        log.info("产品经理正在编写PRD...");
        String prd = pmAgent.writeRequirements(userStory);
        output.setPrd(prd);
        
        // Step 2: 架构师设计架构
        log.info("架构师正在设计架构...");
        String architecture = architectAgent.designArchitecture(prd);
        output.setArchitecture(architecture);
        
        // Step 3: 开发者编写代码
        log.info("开发者正在编写代码...");
        String code = developerAgent.writeCode(architecture, prd);
        output.setCode(code);
        
        // Step 4: 测试工程师审查
        log.info("测试工程师正在审查...");
        String testReport = testerAgent.reviewCode(code);
        output.setTestReport(testReport);
        
        return output;
    }
}

@Data
class ProjectOutput {
    private String prd;
    private String architecture;
    private String code;
    private String testReport;
}

5.5 实战项目：智能DevOps助手

java 复制代码 
@Service
public class DevOpsAgent {
    @Autowired
    private LlmService llm;
    
    @Autowired
    private GitTool gitTool;
    
    @Autowired
    private DockerTool dockerTool;
    
    @Autowired
    private KubernetesTool k8sTool;
    
    /**
     * 自动化部署流程
     */
    public DeploymentResult autoDeploy(String projectName, String environment) {
        DeploymentResult result = new DeploymentResult();
        
        try {
            // 1. 检查代码
            log.info("正在从 Git 拉取最新代码...");
            gitTool.pull(projectName);
            
            // 2. 构建 Docker 镜像
            log.info("正在构建 Docker 镜像...");
            String imageTag = dockerTool.build(projectName);
            result.setImageTag(imageTag);
            
            // 3. 推送到镜像仓库
            log.info("正在推送镜像...");
            dockerTool.push(imageTag);
            
            // 4. 更新 Kubernetes 部署
            log.info("正在更新 K8s 部署...");
            k8sTool.updateDeployment(projectName, imageTag, environment);
            
            // 5. 检查健康状态
            boolean healthy = k8sTool.checkHealth(projectName, environment);
            result.setSuccess(healthy);
            
            if (!healthy) {
                // 使用LLM分析问题
                String logs = k8sTool.getLogs(projectName, environment);
                String analysis = analyzeError(logs);
                result.setErrorAnalysis(analysis);
            }
            
        } catch (Exception e) {
            result.setSuccess(false);
            result.setError(e.getMessage());
            
            // AI分析异常
            String suggestion = suggestFix(e);
            result.setSuggestion(suggestion);
        }
        
        return result;
    }
    
    private String analyzeError(String logs) {
        String prompt = String.format("""
            你是一个DevOps专家。请分析以下部署日志，找出问题原因。
            
            日志：
            %s
            
            请给出：
            1. 问题诊断
            2. 可能的原因
            3. 解决建议
            """, logs);
            
        return llm.chat(prompt);
    }
}

5.6 阶段性任务清单

  • 理解Agent核心概念和Function Calling原理
  • 使用LangChain4j开发带工具调用的Agent
  • 实现ReAct Agent（Thought-Action-Observation循环）
  • 开发至少55个自定义工具（天气、邮件、数据库、计算器等）
  • 实现多智能体协作系统（PM+架构师+开发+测试）
  • 完成DevOps自动化助手项目
  • 对比普通对话和Agent模式的任务完成质量

学习资源汇总

理论学习

1. 基础课程

  • 《动手学深度学习》（李沐）

  • 吴恩达《ChatGPT Prompt Engineering for Developers》

  • Hugging Face NLP Course

2. 论文阅读（必读）
  • Attention is All You Need (Transformer原始论文)
  • BERT: Pre-training of Deep Bidirectional Transformers
  • Language Models are Few-Shot Learners (GPT-3)
  • LoRA: Low-Rank Adaptation of Large Language Models
  • Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (RAG)
3. 视频资源

  • 3Blue1Brown - Transformer可视化

    • YouTube/Bilibili搜索
    • 直观理解注意力机制

  • 李沐老师课程

    • Bilibili搜索"李沐动手学深度学习"
    • 讲解清晰，适合入门

实践资源

1. Java生态框架

LangChain4j

xml 复制代码 
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j</artifactId>
    <version>0.27.0</version>
</dependency>

Spring AI

xml 复制代码 
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>0.8.0</version>
</dependency>

Deep Java Library (DJL)

xml 复制代码 
<dependency>
    <groupId>ai.djl</groupId>
    <artifactId>api</artifactId>
    <version>0.25.0</version>
</dependency>
2. 实战项目参考

ChatGPT-Java

LangChain4j Examples

Awesome LLM Apps

3. 数据集资源

Hugging Face Datasets

python 复制代码 
from datasets import load_dataset

# 中文对话数据集
dataset = load_dataset("BelleGroup/train_2M_CN")

# Java代码数据集
code_dataset = load_dataset("codeparrot/github-code", "Java")

中文数据集推荐

4. 模型资源

国内开源模型

国际模型

  • Llama 2: Meta开源，70B性能强
  • Mistral-7B: 性价比高
  • Phi-2: 微软小模型，2.7B

Kaggle竞赛与项目

社区与论坛

技术社区

  • GitHub: 搜索"awesome-llm"、"awesome-langchain"
  • Hugging Face: https://huggingface.co/
  • 知乎: 搜索"大模型"、"LLM"话题

Discord/Slack

工具与平台

1. 本地开发工具

Ollama

bash 复制代码 
# Windows/Mac/Linux
ollama run qwen:7b
ollama run llama2:13b

LM Studio

2. 向量数据库

Milvus

bash 复制代码 
# Docker部署
docker run -d --name milvus \
  -p 19530:19530 \
  milvusdb/milvus:latest

Chroma

python 复制代码 
import chromadb
client = chromadb.Client()
collection = client.create_collection("my_collection")

Pinecone (云服务)

3. Prompt工程工具

PromptPerfect

LangSmith

博客与教程

中文博客推荐

英文资源

课程与认证

免费课程

  • DeepLearning.AI: 吴恩达系列课程
  • Fast.ai: Practical Deep Learning for Coders
  • Stanford CS224N: NLP with Deep Learning

付费课程

  • Coursera: Natural Language Processing Specialization
  • Udacity: AI Programming with Python
  • 极客时间: 大模型应用开发实战

快速上手计划（12周达成）

周数 阶段 学习目标 实践项目 交付物 时间分配
1 理论基础 Transformer原理 Prompt工程 阅读论文 手写Attention 学习笔记 伪代码 20h
2 API集成 OpenAI/Qwen API Token管理 Spring Boot集成 流式对话 工作原Demo 20h
3-4 企业应用 多模型适配 上下文管理 智能客服系统 WebSocket实时通信 完整项目 40h
5 向量技术 Embedding原理 余弦相似度 Milvus搭建 文档向量化 向量检索Demo 20h
6-7 RAG应用 RAG架构 混合检索 知识库问答 Rerank优化 企业知识库 40h
8-9 模型微调 LoRA原理 数据准备 Java代码数据集 Qwen-7B微调 自定义模型 40h
10 模型部署 Ollama使用 vLLM部署 Docker容器化 API服务化 部署文档 20h
11 Agent开发 Function Calling ReAct模式 LangChain4j Agent 工具调用 Agent Demo 20h
12 综合项目 多智能体协作 系统集成 Java代码助手 DevOps Agent 完整产品 20h

总计：260小时 ≈ 每天 3小时 × 12周

每周学习计划模板

工作日（周一至周五）

  • 19:00-20:30: 理论学习（视频/论文）
  • 20:30-22:00: 动手实践（代码编写）

周末（周六、周日）

  • 上午 9:00-12:00: 项目开发
  • 下午 14:00-17:00: 问题调试、总结复盘

关键里程碑

第1个月（第1-4周）

  • ✅ 成功调用GPT API完成对话
  • ✅ 开发一个可演示的智能客服系统
  • ✅ 理解Prompt工程的核心技巧

第2个月（第5-8周）

  • ✅ 掌握向量检索原理与实现
  • ✅ 完成RAG知识库项目
  • ✅ 对比传统检索和RAG的效果差异

第3个月（第9-12周）

  • ✅ 完成一次完整的模型微调
  • ✅ 部署自己的本地模型
  • ✅ 开发带工具调用的Agent系统
  • ✅ 交付一个完整的综合项目

学习评估标准

理论掌握程度

  • 能解释Transformer的工作原理
  • 理解预训练和微调的区别
  • 掌握Prompt工程的最佳实践
  • 理解RAG架构的核心流程
  • 掌握LoRA微调的数学原理

实践能力

  • 能快速集成主流LLM API
  • 能设计并实现RAG系统
  • 能完成模型微调并评估效果
  • 能部署和服务化模型
  • 能开发复杂的Agent应用

项目交付

  • 至少完成3个完整项目（客服、知识库、Agent）
  • 有可演示的前端界面
  • 代码上GitHub并编写README
  • 写技术博客记录学习过程

关键建议与最佳实践

1. 学习方法论

边学边做

java 复制代码 
// 错误做法：花一个月只学理论
// 正确做法：学完一个概念立即用Java实现

// 例子：学完注意力机制后
1. 阅读论文/视频 (1小时)
2. 立刻手写伪代码 (30分钟)
3. 用Java调用OpenAI API测试 (1小时)

项目驱动

java 复制代码 
// 不要为了学习而学习，要为了解决问题而学习

// 好的学习目标：
✅ "我要开发一个能回答公司技术文档的机器人"
✅ "我要实现一个能生成单元测试的工具"

// 糟糕的学习目标：
❌ "我要学习Transformer"
❌ "我要掌握RAG"

快速迭代

java 复制代码 
// 第一版：最简单的实现 (1天)
@GetMapping("/chat")
public String chat(@RequestParam String message) {
    return openAiService.chat(message);
}

// 第二版：添加上下文 (2天)
// 第三版：集成知识库 (3天)
// 第四版：添加流式响应 (2天)

// 每次只添加一个功能，保证可运行

2. 成本控制策略

API调用成本

java 复制代码 
// 优先级排序（从低到高）

// 1. 开源本地模型（推荐入门）
Ollama + Qwen-7B  // 完全免费，需要16GB内存

// 2. 国内低成本商用API
通义千问: ¥0.0008/1K tokens  // 约GPT-3.5的1/3
文心一言: ¥0.012/1K tokens
智谱GLM: ¥0.005/1K tokens

// 3. OpenAI API
GPT-3.5-Turbo: $0.002/1K tokens  // 性价比高
GPT-4: $0.03/1K tokens            // 用于复杂任务

// 成本估算例子
// 1万次对话，每次平均500 tokens
// GPT-3.5: $0.002 * 500 * 10000 / 1000 = $10
// 通义千问: ¥0.0008 * 500 * 10000 / 1000 = ¥4

节省策略

java 复制代码 
@Service
public class CostOptimizationService {
    
    // 1. 缓存重复请求
    @Cacheable("llm:cache")
    public String chat(String message) {
        return llmService.chat(message);
    }
    
    // 2. 使用更小的模型
    public String smartRoute(String message) {
        if (isSimpleQuery(message)) {
            return qwen7B.chat(message);  // 7B小模型
        } else {
            return gpt4.chat(message);     // 复杂任务才用GPT-4
        }
    }
    
    // 3. 控制Token数量
    public String chat(String message) {
        return llmService.chat(
            message,
            maxTokens: 500  // 限制输出长度
        );
    }
}

3. 技术选型建议

开发阶段

java 复制代码 
// 第1-2周：快速验证
OpenAI API + Spring Boot
// 优势：零配置，效果最好
// 劣势：有成本，需要翻墙

// 第3-4周：企业应用
通义千问 API + Spring Boot + Redis
// 优势：国内访问快，成本低
// 适用：生产环境

// 第5-8周：RAG应用
Milvus + LangChain4j + Qwen API
// 优势：开源方案，可控性强
// 适用：知识密集型任务

// 第9-12周：本地部署
Ollama + Qwen-7B + LoRA微调
// 优势：完全本地，无成本，数据安全
// 适用：垂直领域、隐私敏感场景

生产部署选择

yaml 复制代码 
# 小型项目（<1000 QPS）
vLLM + Qwen-7B + Docker
硬件：1张 RTX 4090 (24GB)
成本：¥15000

# 中型项目（1000-10000 QPS）
vLLM + Qwen-14B + K8s
硬件：2张 A100 (80GB)
成本：云服务器 ¥20/小时

# 大型项目（>10000 QPS）
商用API（阿里云/腾讯云）
成本：按量计费，无需维护

4. 常见错误与解决

错误1：Prompt设计不当

java 复制代码 
// ❌ 糟糕的Prompt
String prompt = "帮我写代码";

// ✅ 良好的Prompt
String prompt = """
    你是一个高级Java工程师。请按照以下要求实现一个方法：
    
    功能：计算两个日期之间的工作日天数
    输入：LocalDate startDate, LocalDate endDate
    输出：int 工作日天数
    约束：
    - 排除周末
    - 排除法定节假日
    - 使用Java 8 Date API
    - 添加单元测试
    """;

错误2：不处理异常

java 复制代码 
// ❌ 没有异常处理
public String chat(String message) {
    return openAiService.chat(message);  // 可能抛出RateLimitException
}

// ✅ 正确的做法
public String chat(String message) {
    try {
        return openAiService.chat(message);
    } catch (RateLimitException e) {
        // 限流后重试
        Thread.sleep(1000);
        return chat(message);
    } catch (TimeoutException e) {
        return "请求超时，请稍后再试";
    } catch (Exception e) {
        log.error("调用LLM失败", e);
        return "服务异常，请联系管理员";
    }
}

错误3：RAG检索精度低

java 复制代码 
// ❌ 简单的向量检索
List<Doc> docs = vectorStore.search(query, 3);

// ✅ 混合检索 + Rerank
// 1. 向量检索 + BM25检索
List<Doc> vectorDocs = vectorStore.search(query, 10);
List<Doc> bm25Docs = elasticsearchService.search(query, 10);

// 2. 融合结果
List<Doc> merged = mergeResults(vectorDocs, bm25Docs);

// 3. 使用LLM重排序
List<Doc> reranked = reranker.rerank(query, merged, 3);

错误4：微调数据质量差

python 复制代码 
# ❌ 糟糕的训练数据
{
    "instruction": "写代码",
    "output": "public void test() {}"
}

# ✅ 高质量的训练数据
{
    "instruction": "实现一个线程安全的单例模式",
    "input": "需要支持懒加载和双重检查锁定",
    "output": """
        public class Singleton {
            private static volatile Singleton instance;
            
            private Singleton() {}
            
            public static Singleton getInstance() {
                if (instance == null) {
                    synchronized (Singleton.class) {
                        if (instance == null) {
                            instance = new Singleton();
                        }
                    }
                }
                return instance;
            }
        }
        """
}

# 数据要求：
- 数量：至少1000条
- 多样性：覆盖各种场景
- 高质量：代码可运行，有注释

5. 社区参与与求职

GitHub贡献

bash 复制代码 
# 1. Fork一个开源项目
git clone https://github.com/langchain4j/langchain4j

# 2. 修复Bug或添加功能
# 3. 提交Pull Request
# 4. 积累贡献记录

技术博客

  • 在CSDN/掌书/知乎发文
  • 分享学习过程和踩坑经验
  • 建立个人技术品牌

项目展示

markdown 复制代码 
# GitHub README 示例

## 智能客服系统
基于LangChain4j和Qwen-7B的企业级智能客服系统

### 技术栈
- Spring Boot 3.2
- LangChain4j 0.27
- Qwen-7B-Chat
- Milvus 2.3
- Redis 7.0

### 功能特性
- ✅ 多轮对话管理
- ✅ RAG知识库检索
- ✅ 意图识别与路由
- ✅ WebSocket实时通信

### 快速开始
\`\`\`bash
git clone ...
mvn spring-boot:run
\`\`\`

### Demo
![screenshot](demo.png)

简历亮点

复制代码 
项目经验：
• 基于LangChain4j开发企业知识库问答系统，支持10万+文档检索
• 使用LoRA微调Qwen-7B模型，在Java代码生成任务上准确率提升35%
• 开发多Agent协作系统，实现自动化代码审查和测试用例生成

技术栈：
Java 17 | Spring Boot | LangChain4j | Milvus | Qwen | LoRA

6. 进阶方向

模型训练方向

  • 从零预训练小模型（<1B）
  • RLHF对齐技术
  • 模型压缩（剪枝、蒸馏）

多模态方向

  • CLIP/BLIP：图像+文本
  • Whisper：语音识别
  • SAM：图像分割

工程化方向

  • 模型监控与可观测性
  • A/B测试与效果评估
  • 成本优化与性能调优

领域专家

  • 金融LLM：风控、报告生成
  • 医疗LLM：诊断辅助、病历分析
  • 法律LLM：合同审查、案例检索

进阶方向

  • 模型训练：从零预训练小模型
  • 多模态：图像+文本（CLIP、BLIP）
  • 强化学习：RLHF对齐技术
  • 推理优化：量化、剪枝、蒸馏
相关推荐
Lucky_Turtle2 小时前
【Springboot】解决PageHelper在实体转Vo下出现total数据问题
java·spring boot·后端
期待のcode2 小时前
验证码实现
java·vue.js
simplify202 小时前
SWEDeepDiver：从哪里来，去往何处
开源·llm
老华带你飞2 小时前
志愿者服务管理|基于springboot 志愿者服务管理系统(源码+数据库+文档)
java·数据库·vue.js·spring boot·后端·spring
weixin_421585012 小时前
PYTHON中的索引操作
python
_Li.2 小时前
机器学习-特征选择
人工智能·python·机器学习
汤姆yu2 小时前
基于springboot的宠物服务管理系统
java·spring boot·后端
魔镜前的帅比2 小时前
Agent 错误恢复与回退策略
python·ai
鹿角片ljp2 小时前
智能家居控制系统Java实现
java·开发语言·智能家居
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04BongoCat - 跨平台键盘猫动画工具05jdk21下载、安装（Windows、Linux、macOS）06在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Open-AutoGLM Windows 安装部署教程09sqli-labs靶场通关笔记：第18-19关 HTTP头部注入10Labelme从安装到标注：零基础完整指南