java训练的模型怎么保存？从训练到部署：Java环境下ML模型保存策略与测试数据构建

// 框架选型评估矩阵
public class FrameworkEvaluator {
    public enum Criteria {
        PERFORMANCE,    // 性能表现
        EASE_OF_USE,   // 易用性
        COMMUNITY,     // 社区支持
        SCALABILITY,   // 可扩展性
        DEPLOYMENT     // 部署便利性
    }
    
    public double evaluateFramework(String framework, Criteria criteria) {
        // 实现评估逻辑
        return 0.0;
    }
}

import java.io.*;

public class ModelSerializer {
    
    /**
     * 保存模型到文件
     */
    public static void saveModel(Serializable model, String filepath) 
            throws IOException {
        try (FileOutputStream fos = new FileOutputStream(filepath);
             ObjectOutputStream oos = new ObjectOutputStream(fos)) {
            oos.writeObject(model);
            System.out.println("模型已保存到: " + filepath);
        }
    }
    
    /**
     * 从文件加载模型
     */
    @SuppressWarnings("unchecked")
    public static <T> T loadModel(String filepath, Class<T> modelClass) 
            throws IOException, ClassNotFoundException {
        try (FileInputStream fis = new FileInputStream(filepath);
             ObjectInputStream ois = new ObjectInputStream(fis)) {
            Object model = ois.readObject();
            if (modelClass.isInstance(model)) {
                return modelClass.cast(model);
            } else {
                throw new ClassCastException("模型类型不匹配");
            }
        }
    }
}

import weka.classifiers.Classifier;
import weka.classifiers.trees.J48;
import weka.core.Instances;
import weka.core.SerializationHelper;

public class WekaModelManager {
    
    public void trainAndSaveModel(Instances trainingData, String modelPath) 
            throws Exception {
        // 创建分类器
        Classifier classifier = new J48();
        classifier.buildClassifier(trainingData);
        
        // 保存模型
        SerializationHelper.write(modelPath, classifier);
        System.out.println("Weka模型已保存");
    }
    
    public Classifier loadWekaModel(String modelPath) throws Exception {
        return (Classifier) SerializationHelper.read(modelPath);
    }
}

import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.util.ModelSerializer;

public class DL4JModelManager {
    
    public void saveDeepLearningModel(MultiLayerNetwork model, String basePath) 
            throws IOException {
        // 保存完整模型（配置+参数）
        ModelSerializer.writeModel(model, basePath + "_complete.zip", true);
        
        // 仅保存参数
        ModelSerializer.writeModel(model, basePath + "_params_only.zip", false);
        
        System.out.println("DL4J模型已保存");
    }
    
    public MultiLayerNetwork loadDeepLearningModel(String modelPath) 
            throws IOException {
        return ModelSerializer.restoreMultiLayerNetwork(modelPath);
    }
}

import org.jpmml.evaluator.*;
import org.jpmml.model.PMMLUtil;

public class PMMLModelHandler {
    
    public Evaluator loadPMMLModel(String pmmlPath) throws Exception {
        try (InputStream is = new FileInputStream(pmmlPath)) {
            PMML pmml = PMMLUtil.unmarshal(is);
            ModelEvaluatorBuilder builder = new ModelEvaluatorBuilder(pmml);
            return builder.build();
        }
    }
    
    public Map<String, ?> predict(Evaluator evaluator, 
                                  Map<String, Object> inputData) {
        Map<FieldName, FieldValue> arguments = new HashMap<>();
        
        for (Map.Entry<String, Object> entry : inputData.entrySet()) {
            FieldName fieldName = FieldName.create(entry.getKey());
            FieldValue fieldValue = evaluator.prepare(fieldName, entry.getValue());
            arguments.put(fieldName, fieldValue);
        }
        
        return evaluator.evaluate(arguments);
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import java.time.LocalDateTime;
import java.util.Map;

public class ModelMetadata {
    private String modelId;
    private String version;
    private LocalDateTime createdAt;
    private Map<String, Object> hyperParameters;
    private Map<String, Double> performanceMetrics;
    private String description;
    
    // 构造函数和getter/setter省略
    
    public void saveMetadata(String metadataPath) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.writeValue(new File(metadataPath), this);
    }
    
    public static ModelMetadata loadMetadata(String metadataPath) 
            throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(new File(metadataPath), ModelMetadata.class);
    }
}

public class ModelRepository {
    private final String basePath;
    
    public ModelRepository(String basePath) {
        this.basePath = basePath;
    }
    
    public void saveModelWithMetadata(Object model, ModelMetadata metadata) 
            throws IOException {
        String modelDir = basePath + "/" + metadata.getModelId() + 
                         "_v" + metadata.getVersion();
        new File(modelDir).mkdirs();
        
        // 保存模型
        ModelSerializer.saveModel(model, modelDir + "/model.bin");
        
        // 保存元数据
        metadata.saveMetadata(modelDir + "/metadata.json");
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CompletableFuture;

public class ModelCache {
    private final ConcurrentHashMap<String, Object> modelCache = 
            new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, CompletableFuture<Object>> 
            loadingCache = new ConcurrentHashMap<>();
    
    public <T> CompletableFuture<T> getModel(String modelId, Class<T> modelClass) {
        // 检查缓存
        T cachedModel = modelClass.cast(modelCache.get(modelId));
        if (cachedModel != null) {
            return CompletableFuture.completedFuture(cachedModel);
        }
        
        // 检查是否正在加载
        CompletableFuture<Object> loadingFuture = loadingCache.get(modelId);
        if (loadingFuture != null) {
            return loadingFuture.thenApply(modelClass::cast);
        }
        
        // 异步加载模型
        CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
            try {
                T model = loadModelFromDisk(modelId, modelClass);
                modelCache.put(modelId, model);
                return model;
            } catch (Exception e) {
                throw new RuntimeException("模型加载失败: " + modelId, e);
            } finally {
                loadingCache.remove(modelId);
            }
        });
        
        loadingCache.put(modelId, future);
        return future.thenApply(modelClass::cast);
    }
    
    private <T> T loadModelFromDisk(String modelId, Class<T> modelClass) 
            throws Exception {
        // 实际的磁盘加载逻辑
        String modelPath = getModelPath(modelId);
        return ModelSerializer.loadModel(modelPath, modelClass);
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
public class ModelServingApplication {
    
    private final ModelCache modelCache;
    private final PredictionService predictionService;
    
    public ModelServingApplication() {
        this.modelCache = new ModelCache();
        this.predictionService = new PredictionService(modelCache);
    }
    
    @PostMapping("/predict/{modelId}")
    public CompletableFuture<PredictionResult> predict(
            @PathVariable String modelId,
            @RequestBody Map<String, Object> features) {
        
        return predictionService.predict(modelId, features);
    }
    
    @PostMapping("/models/{modelId}/reload")
    public ResponseEntity<String> reloadModel(@PathVariable String modelId) {
        try {
            modelCache.evictModel(modelId);
            return ResponseEntity.ok("模型重新加载成功");
        } catch (Exception e) {
            return ResponseEntity.status(500).body("模型重新加载失败: " + e.getMessage());
        }
    }
    
    public static void main(String[] args) {
        SpringApplication.run(ModelServingApplication.class, args);
    }
}

import java.util.Random;
import java.util.stream.DoubleStream;

public class StatisticalDataGenerator {
    private final Random random;
    
    public StatisticalDataGenerator(long seed) {
        this.random = new Random(seed);
    }
    
    /**
     * 生成正态分布数据
     */
    public double[] generateNormalDistribution(int count, double mean, double stdDev) {
        return DoubleStream.generate(() -> random.nextGaussian() * stdDev + mean)
                          .limit(count)
                          .toArray();
    }
    
    /**
     * 生成泊松分布数据
     */
    public int[] generatePoissonDistribution(int count, double lambda) {
        return random.ints(count)
                    .map(x -> poissonSample(lambda))
                    .toArray();
    }
    
    private int poissonSample(double lambda) {
        double L = Math.exp(-lambda);
        double p = 1.0;
        int k = 0;
        
        do {
            k++;
            p *= random.nextDouble();
        } while (p > L);
        
        return k - 1;
    }
    
    /**
     * 生成多元正态分布数据
     */
    public double[][] generateMultivariateNormal(int count, double[] means, 
                                                double[][] covariance) {
        int dimensions = means.length;
        double[][] result = new double[count][dimensions];
        
        // Cholesky分解协方差矩阵
        double[][] cholesky = choleskyDecomposition(covariance);
        
        for (int i = 0; i < count; i++) {
            double[] standardNormal = new double[dimensions];
            for (int j = 0; j < dimensions; j++) {
                standardNormal[j] = random.nextGaussian();
            }
            
            // 变换到目标分布
            result[i] = matrixVectorMultiply(cholesky, standardNormal);
            for (int j = 0; j < dimensions; j++) {
                result[i][j] += means[j];
            }
        }
        
        return result;
    }
    
    private double[][] choleskyDecomposition(double[][] matrix) {
        // 实现Cholesky分解
        int n = matrix.length;
        double[][] result = new double[n][n];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                if (i == j) {
                    double sum = 0;
                    for (int k = 0; k < j; k++) {
                        sum += result[j][k] * result[j][k];
                    }
                    result[j][j] = Math.sqrt(matrix[j][j] - sum);
                } else {
                    double sum = 0;
                    for (int k = 0; k < j; k++) {
                        sum += result[i][k] * result[j][k];
                    }
                    result[i][j] = (matrix[i][j] - sum) / result[j][j];
                }
            }
        }
        
        return result;
    }
    
    private double[] matrixVectorMultiply(double[][] matrix, double[] vector) {
        int rows = matrix.length;
        double[] result = new double[rows];
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < vector.length; j++) {
                result[i] += matrix[i][j] * vector[j];
            }
        }
        
        return result;
    }
}

import com.github.javafaker.Faker;
import java.util.List;
import java.util.ArrayList;
import java.util.Locale;

public class FakerDataGenerator {
    private final Faker faker;
    
    public FakerDataGenerator(Locale locale) {
        this.faker = new Faker(locale);
    }
    
    /**
     * 生成用户数据
     */
    public List<User> generateUsers(int count) {
        List<User> users = new ArrayList<>();
        
        for (int i = 0; i < count; i++) {
            User user = new User();
            user.setId(faker.number().numberBetween(1, 1000000));
            user.setName(faker.name().fullName());
            user.setEmail(faker.internet().emailAddress());
            user.setAge(faker.number().numberBetween(18, 80));
            user.setPhone(faker.phoneNumber().phoneNumber());
            user.setAddress(faker.address().fullAddress());
            user.setRegistrationDate(faker.date().birthday());
            
            users.add(user);
        }
        
        return users;
    }
    
    /**
     * 生成电商订单数据
     */
    public List<Order> generateOrders(int count) {
        List<Order> orders = new ArrayList<>();
        
        for (int i = 0; i < count; i++) {
            Order order = new Order();
            order.setOrderId(faker.code().ean13());
            order.setUserId(faker.number().numberBetween(1, 10000));
            order.setProductName(faker.commerce().productName());
            order.setPrice(Double.parseDouble(faker.commerce().price()));
            order.setQuantity(faker.number().numberBetween(1, 10));
            order.setOrderDate(faker.date().birthday());
            order.setStatus(faker.options().option("PENDING", "SHIPPED", "DELIVERED"));
            
            orders.add(order);
        }
        
        return orders;
    }
    
    /**
     * 生成带业务规则的数据
     */
    public List<CustomerProfile> generateCustomerProfiles(int count) {
        List<CustomerProfile> profiles = new ArrayList<>();
        
        for (int i = 0; i < count; i++) {
            CustomerProfile profile = new CustomerProfile();
            
            int age = faker.number().numberBetween(18, 80);
            profile.setAge(age);
            
            // 根据年龄设置收入范围
            double income = generateIncomeByAge(age);
            profile.setIncome(income);
            
            // 根据收入设置信用等级
            String creditLevel = determineCreditLevel(income);
            profile.setCreditLevel(creditLevel);
            
            profile.setCustomerId(faker.idNumber().ssnValid());
            profile.setEducation(faker.options().option("HIGH_SCHOOL", "BACHELOR", "MASTER", "PhD"));
            profile.setOccupation(faker.job().title());
            
            profiles.add(profile);
        }
        
        return profiles;
    }
    
    private double generateIncomeByAge(int age) {
        // 年龄越大，收入潜在区间越高
        double baseIncome = 30000 + (age - 18) * 1000;
        double variance = baseIncome * 0.5;
        return baseIncome + (faker.random().nextDouble() - 0.5) * variance;
    }
    
    private String determineCreditLevel(double income) {
        if (income < 40000) return "LOW";
        else if (income < 80000) return "MEDIUM";
        else return "HIGH";
    }
}

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.concurrent.ThreadLocalRandom;

public class CustomDataGenerator {
    
    /**
     * 参数化数据工厂
     */
    public static class DataGeneratorBuilder<T> {
        private final Class<T> targetClass;
        private final Map<String, Function<Random, Object>> fieldGenerators;
        
        public DataGeneratorBuilder(Class<T> targetClass) {
            this.targetClass = targetClass;
            this.fieldGenerators = new HashMap<>();
        }
        
        public DataGeneratorBuilder<T> withField(String fieldName, 
                                               Function<Random, Object> generator) {
            fieldGenerators.put(fieldName, generator);
            return this;
        }
        
        public List<T> generate(int count) {
            List<T> result = new ArrayList<>();
            Random random = ThreadLocalRandom.current();
            
            for (int i = 0; i < count; i++) {
                try {
                    T instance = targetClass.getDeclaredConstructor().newInstance();
                    
                    for (Map.Entry<String, Function<Random, Object>> entry : 
                         fieldGenerators.entrySet()) {
                        String fieldName = entry.getKey();
                        Object value = entry.getValue().apply(random);
                        setFieldValue(instance, fieldName, value);
                    }
                    
                    result.add(instance);
                } catch (Exception e) {
                    throw new RuntimeException("数据生成失败", e);
                }
            }
            
            return result;
        }
        
        private void setFieldValue(T instance, String fieldName, Object value) 
                throws Exception {
            Field field = targetClass.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(instance, value);
        }
    }
    
    /**
     * 使用示例
     */
    public List<SalesRecord> generateSalesData(int count) {
        return new DataGeneratorBuilder<>(SalesRecord.class)
            .withField("id", random -> random.nextLong())
            .withField("productId", random -> "PROD_" + random.nextInt(1000))
            .withField("salesAmount", random -> 100 + random.nextDouble() * 900)
            .withField("salesDate", random -> generateRandomDate())
            .withField("region", random -> getRandomRegion(random))
            .generate(count);
    }
    
    private LocalDateTime generateRandomDate() {
        LocalDateTime start = LocalDateTime.now().minusYears(1);
        LocalDateTime end = LocalDateTime.now();
        
        long days = ChronoUnit.DAYS.between(start, end);
        long randomDays = ThreadLocalRandom.current().nextLong(days + 1);
        
        return start.plusDays(randomDays);
    }
    
    private String getRandomRegion(Random random) {
        String[] regions = {"North", "South", "East", "West", "Central"};
        return regions[random.nextInt(regions.length)];
    }
}

import java.time.LocalDateTime;
import java.util.List;
import java.util.ArrayList;

public class TimeSeriesGenerator {
    
    /**
     * 生成带趋势的时间序列数据
     */
    public List<TimeSeriesPoint> generateTrendData(LocalDateTime startTime, 
                                                   int points, 
                                                   double trend, 
                                                   double noiseLevel) {
        List<TimeSeriesPoint> series = new ArrayList<>();
        Random random = new Random();
        
        double baseValue = 100.0;
        
        for (int i = 0; i < points; i++) {
            LocalDateTime timestamp = startTime.plusHours(i);
            
            // 线性趋势
            double trendValue = baseValue + trend * i;
            
            // 添加噪声
            double noise = random.nextGaussian() * noiseLevel;
            double finalValue = trendValue + noise;
            
            series.add(new TimeSeriesPoint(timestamp, finalValue));
        }
        
        return series;
    }
    
    /**
     * 生成季节性数据
     */
    public List<TimeSeriesPoint> generateSeasonalData(LocalDateTime startTime,
                                                      int points,
                                                      double amplitude,
                                                      int period) {
        List<TimeSeriesPoint> series = new ArrayList<>();
        Random random = new Random();
        
        for (int i = 0; i < points; i++) {
            LocalDateTime timestamp = startTime.plusHours(i);
            
            // 季节性模式（正弦波）
            double seasonalValue = amplitude * Math.sin(2 * Math.PI * i / period);
            
            // 基础值 + 季节性 + 噪声
            double baseValue = 100.0;
            double noise = random.nextGaussian() * 5.0;
            double finalValue = baseValue + seasonalValue + noise;
            
            series.add(new TimeSeriesPoint(timestamp, finalValue));
        }
        
        return series;
    }
    
    /**
     * 生成复合时间序列（趋势 + 季节性 + 噪声）
     */
    public List<TimeSeriesPoint> generateComplexTimeSeries(
            LocalDateTime startTime,
            int points,
            double trend,
            double seasonalAmplitude,
            int seasonalPeriod,
            double noiseLevel) {
        
        List<TimeSeriesPoint> series = new ArrayList<>();
        Random random = new Random();
        
        double baseValue = 100.0;
        
        for (int i = 0; i < points; i++) {
            LocalDateTime timestamp = startTime.plusHours(i);
            
            // 趋势分量
            double trendComponent = trend * i;
            
            // 季节性分量
            double seasonalComponent = seasonalAmplitude * 
                Math.sin(2 * Math.PI * i / seasonalPeriod);
            
            // 噪声分量
            double noiseComponent = random.nextGaussian() * noiseLevel;
            
            // 组合所有分量
            double finalValue = baseValue + trendComponent + 
                               seasonalComponent + noiseComponent;
            
            series.add(new TimeSeriesPoint(timestamp, finalValue));
        }
        
        return series;
    }
}

class TimeSeriesPoint {
    private LocalDateTime timestamp;
    private double value;
    
    public TimeSeriesPoint(LocalDateTime timestamp, double value) {
        this.timestamp = timestamp;
        this.value = value;
    }
    
    // getter和setter方法省略
}

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
import org.apache.commons.math3.stat.inference.TestUtils;

public class DataQualityValidator {
    
    /**
     * 统计特征比较
     */
    public QualityReport compareStatistics(double[] originalData, 
                                         double[] generatedData) {
        DescriptiveStatistics originalStats = new DescriptiveStatistics(originalData);
        DescriptiveStatistics generatedStats = new DescriptiveStatistics(generatedData);
        
        QualityReport report = new QualityReport();
        
        // 均值比较
        double meanDiff = Math.abs(originalStats.getMean() - generatedStats.getMean());
        report.setMeanDifference(meanDiff);
        
        // 标准差比较
        double stdDiff = Math.abs(originalStats.getStandardDeviation() - 
                                generatedStats.getStandardDeviation());
        report.setStdDeviationDifference(stdDiff);
        
        // 偏度比较
        double skewnessDiff = Math.abs(originalStats.getSkewness() - 
                                     generatedStats.getSkewness());
        report.setSkewnessDifference(skewnessDiff);
        
        // 峰度比较
        double kurtosisDiff = Math.abs(originalStats.getKurtosis() - 
                                     generatedStats.getKurtosis());
        report.setKurtosisDifference(kurtosisDiff);
        
        return report;
    }
    
    /**
     * Kolmogorov-Smirnov分布检验
     */
    public boolean performKSTest(double[] originalData, double[] generatedData, 
                               double significance) {
        double pValue = TestUtils.kolmogorovSmirnovTest(originalData, generatedData);
        return pValue > significance; // 如果p值大于显著性水平，接受分布相同的假设
    }
    
    /**
     * 数据完整性检验
     */
    public ValidationResult validateDataCompleteness(List<?> dataList) {
        ValidationResult result = new ValidationResult();
        
        if (dataList == null || dataList.isEmpty()) {
            result.addError("数据集为空");
            return result;
        }
        
        // 检查空值
        long nullCount = dataList.stream()
                                .mapToLong(this::countNullFields)
                                .sum();
        
        if (nullCount > 0) {
            result.addWarning("发现 " + nullCount + " 个空值字段");
        }
        
        // 检查重复值
        long uniqueCount = dataList.stream().distinct().count();
        if (uniqueCount < dataList.size()) {
            result.addWarning("发现重复数据，原始: " + dataList.size() + 
                            ", 去重后: " + uniqueCount);
        }
        
        return result;
    }
    
    private long countNullFields(Object obj) {
        return Arrays.stream(obj.getClass().getDeclaredFields())
                    .peek(field -> field.setAccessible(true))
                    .mapToLong(field -> {
                        try {
                            return field.get(obj) == null ? 1 : 0;
                        } catch (IllegalAccessException e) {
                            return 0;
                        }
                    })
                    .sum();
    }
}

class QualityReport {
    private double meanDifference;
    private double stdDeviationDifference;
    private double skewnessDifference;
    private double kurtosisDifference;
    
    // getter和setter方法省略
    
    public boolean isAcceptable(double threshold) {
        return meanDifference < threshold && 
               stdDeviationDifference < threshold &&
               skewnessDifference < threshold * 2 &&
               kurtosisDifference < threshold * 2;
    }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.CompletableFuture;

public class PerformanceBenchmark {
    
    public BenchmarkResult benchmarkDataGeneration(Supplier<List<?>> generator,
                                                   int iterations) {
        long startTime = System.nanoTime();
        long totalMemoryBefore = getUsedMemory();
        
        List<Long> executionTimes = new ArrayList<>();
        
        for (int i = 0; i < iterations; i++) {
            long iterationStart = System.nanoTime();
            
            List<?> data = generator.get();
            
            long iterationEnd = System.nanoTime();
            executionTimes.add(iterationEnd - iterationStart);
            
            // 强制垃圾回收以测量真实内存使用
            if (i % 10 == 0) {
                System.gc();
            }
        }
        
        long endTime = System.nanoTime();
        long totalMemoryAfter = getUsedMemory();
        
        BenchmarkResult result = new BenchmarkResult();
        result.setTotalExecutionTime(TimeUnit.NANOSECONDS.toMillis(endTime - startTime));
        result.setAverageExecutionTime(executionTimes.stream()
                                                   .mapToLong(Long::longValue)
                                                   .average()
                                                   .orElse(0.0));
        result.setMemoryUsage(totalMemoryAfter - totalMemoryBefore);
        result.setIterations(iterations);
        
        return result;
    }
    
    public void benchmarkConcurrentGeneration(Supplier<List<?>> generator,
                                            int threadCount,
                                            int iterationsPerThread) {
        List<CompletableFuture<BenchmarkResult>> futures = new ArrayList<>();
        
        for (int i = 0; i < threadCount; i++) {
            CompletableFuture<BenchmarkResult> future = CompletableFuture
                .supplyAsync(() -> benchmarkDataGeneration(generator, iterationsPerThread));
            futures.add(future);
        }
        
        // 等待所有任务完成并收集结果
        List<BenchmarkResult> results = futures.stream()
                                             .map(CompletableFuture::join)
                                             .collect(Collectors.toList());
        
        // 分析并发性能
        analyzeConcurrentPerformance(results, threadCount);
    }
    
    private long getUsedMemory() {
        Runtime runtime = Runtime.getRuntime();
        return runtime.totalMemory() - runtime.freeMemory();
    }
    
    private void analyzeConcurrentPerformance(List<BenchmarkResult> results, 
                                            int threadCount) {
        double avgTotalTime = results.stream()
                                   .mapToDouble(BenchmarkResult::getTotalExecutionTime)
                                   .average()
                                   .orElse(0.0);
        
        long totalMemory = results.stream()
                                .mapToLong(BenchmarkResult::getMemoryUsage)
                                .sum();
        
        System.out.println("并发性能分析:");
        System.out.println("线程数: " + threadCount);
        System.out.println("平均执行时间: " + avgTotalTime + " ms");
        System.out.println("总内存使用: " + totalMemory / (1024 * 1024) + " MB");
        System.out.println("内存使用效率: " + (totalMemory / threadCount / (1024 * 1024)) + " MB/线程");
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
public class RecommendationSystemApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(RecommendationSystemApplication.class, args);
    }
}

@RestController
@RequestMapping("/api/recommendation")
public class RecommendationController {
    
    private final RecommendationService recommendationService;
    private final TestDataService testDataService;
    
    public RecommendationController(RecommendationService recommendationService,
                                  TestDataService testDataService) {
        this.recommendationService = recommendationService;
        this.testDataService = testDataService;
    }
    
    @PostMapping("/predict")
    public ResponseEntity<List<ProductRecommendation>> getRecommendations(
            @RequestBody UserProfile userProfile) {
        try {
            List<ProductRecommendation> recommendations = 
                recommendationService.recommend(userProfile);
            return ResponseEntity.ok(recommendations);
        } catch (Exception e) {
            return ResponseEntity.status(500).build();
        }
    }
    
    @PostMapping("/test-data/generate")
    public ResponseEntity<String> generateTestData(
            @RequestParam int userCount,
            @RequestParam int productCount,
            @RequestParam int interactionCount) {
        try {
            testDataService.generateCompleteTestDataset(
                userCount, productCount, interactionCount);
            return ResponseEntity.ok("测试数据生成完成");
        } catch (Exception e) {
            return ResponseEntity.status(500).body("生成失败: " + e.getMessage());
        }
    }
}

import smile.base.mlp.MultilayerPerceptron;
import smile.data.DataFrame;
import smile.regression.MLP;

@Service
public class RecommendationService {
    
    private final ModelCache modelCache;
    private final FeatureExtractor featureExtractor;
    
    public RecommendationService() {
        this.modelCache = new ModelCache();
        this.featureExtractor = new FeatureExtractor();
    }
    
    /**
     * 训练推荐模型
     */
    public void trainRecommendationModel(List<UserInteraction> interactions) 
            throws Exception {
        
        // 特征工程
        DataFrame features = featureExtractor.extractFeatures(interactions);
        double[] ratings = interactions.stream()
                                     .mapToDouble(UserInteraction::getRating)
                                     .toArray();
        
        // 训练神经网络模型
        MLP model = MLP.fit(features.toArray(), ratings);
        
        // 保存模型和元数据
        ModelMetadata metadata = new ModelMetadata();
        metadata.setModelId("recommendation_mlp");
        metadata.setVersion("1.0");
        metadata.setCreatedAt(LocalDateTime.now());
        metadata.setDescription("用户商品推荐神经网络模型");
        
        // 计算性能指标
        double[] predictions = model.predict(features.toArray());
        double rmse = calculateRMSE(ratings, predictions);
        metadata.getPerformanceMetrics().put("RMSE", rmse);
        
        // 保存到存储库
        ModelRepository repository = new ModelRepository("./models");
        repository.saveModelWithMetadata(model, metadata);
        
        System.out.println("模型训练完成，RMSE: " + rmse);
    }
    
    /**
     * 生成推荐
     */
    public List<ProductRecommendation> recommend(UserProfile userProfile) 
            throws Exception {
        
        // 加载模型
        CompletableFuture<MLP> modelFuture = 
            modelCache.getModel("recommendation_mlp", MLP.class);
        MLP model = modelFuture.get();
        
        // 获取候选商品
        List<Product> candidateProducts = getCandidateProducts(userProfile);
        
        // 为每个候选商品生成特征并预测评分
        List<ProductRecommendation> recommendations = new ArrayList<>();
        
        for (Product product : candidateProducts) {
            double[] features = featureExtractor.extractUserProductFeatures(
                userProfile, product);
            double predictedRating = model.predict(features);
            
            recommendations.add(new ProductRecommendation(
                product.getId(), 
                product.getName(), 
                predictedRating
            ));
        }
        
        // 按预测评分排序并返回Top-N
        return recommendations.stream()
                            .sorted((a, b) -> Double.compare(b.getPredictedRating(), 
                                                           a.getPredictedRating()))
                            .limit(10)
                            .collect(Collectors.toList());
    }
    
    private double calculateRMSE(double[] actual, double[] predicted) {
        double sumSquaredError = 0.0;
        for (int i = 0; i < actual.length; i++) {
            double error = actual[i] - predicted[i];
            sumSquaredError += error * error;
        }
        return Math.sqrt(sumSquaredError / actual.length);
    }
    
    private List<Product> getCandidateProducts(UserProfile userProfile) {
        // 实现候选商品选择逻辑
        // 可以基于用户历史、商品类别、热门商品等
        return new ArrayList<>();
    }
}

@Service
public class TestDataService {
    
    private final FakerDataGenerator fakerGenerator;
    private final CustomDataGenerator customGenerator;
    private final StatisticalDataGenerator statisticalGenerator;
    
    public TestDataService() {
        this.fakerGenerator = new FakerDataGenerator(Locale.CHINA);
        this.customGenerator = new CustomDataGenerator();
        this.statisticalGenerator = new StatisticalDataGenerator(12345L);
    }
    
    /**
     * 生成完整的测试数据集
     */
    public void generateCompleteTestDataset(int userCount, 
                                          int productCount, 
                                          int interactionCount) {
        
        System.out.println("开始生成测试数据...");
        
        // 生成用户数据
        List<User> users = generateRealisticUsers(userCount);
        saveToDatabase(users, "users");
        
        // 生成商品数据
        List<Product> products = generateRealisticProducts(productCount);
        saveToDatabase(products, "products");
        
        // 生成用户-商品交互数据
        List<UserInteraction> interactions = generateRealisticInteractions(
            users, products, interactionCount);
        saveToDatabase(interactions, "interactions");
        
        // 生成用户行为序列
        List<UserBehavior> behaviors = generateUserBehaviorSequences(users, products);
        saveToDatabase(behaviors, "user_behaviors");
        
        System.out.println("测试数据生成完成!");
    }
    
    /**
     * 生成真实感用户数据
     */
    private List<User> generateRealisticUsers(int count) {
        return new CustomDataGenerator.DataGeneratorBuilder<>(User.class)
            .withField("id", random -> random.nextLong())
            .withField("name", random -> fakerGenerator.faker.name().fullName())
            .withField("age", random -> {
                // 年龄分布更符合实际（20-60岁为主）
                return (int) statisticalGenerator.generateNormalDistribution(1, 35, 12)[0];
            })
            .withField("gender", random -> random.nextBoolean() ? "M" : "F")
            .withField("city", random -> fakerGenerator.faker.address().city())
            .withField("registrationDate", random -> generateRegistrationDate())
            .withField("preferredCategories", random -> generatePreferredCategories())
            .generate(count);
    }
    
    /**
     * 生成真实感商品数据
     */
    private List<Product> generateRealisticProducts(int count) {
        String[] categories = {"Electronics", "Fashion", "Books", "Home", "Sports"};
        
        return new CustomDataGenerator.DataGeneratorBuilder<>(Product.class)
            .withField("id", random -> "PROD_" + random.nextInt(100000))
            .withField("name", random -> fakerGenerator.faker.commerce().productName())
            .withField("category", random -> categories[random.nextInt(categories.length)])
            .withField("price", random -> {
                // 价格分布：大部分商品在100-1000元，少数高价商品
                double basePrice = statisticalGenerator.generateNormalDistribution(1, 300, 200)[0];
                return Math.max(10, basePrice);
            })
            .withField("rating", random -> 1.0 + random.nextDouble() * 4.0) // 1-5星
            .withField("reviewCount", random -> (int) Math.max(0, 
                statisticalGenerator.generatePoissonDistribution(1, 50)[0]))
            .generate(count);
    }
    
    /**
     * 生成真实感交互数据
     */
    private List<UserInteraction> generateRealisticInteractions(
            List<User> users, List<Product> products, int count) {
        
        List<UserInteraction> interactions = new ArrayList<>();
        Random random = new Random();
        
        for (int i = 0; i < count; i++) {
            User user = users.get(random.nextInt(users.size()));
            Product product = selectProductForUser(user, products, random);
            
            UserInteraction interaction = new UserInteraction();
            interaction.setUserId(user.getId());
            interaction.setProductId(product.getId());
            interaction.setRating(generateRealisticRating(user, product));
            interaction.setInteractionType(selectInteractionType(random));
            interaction.setTimestamp(generateInteractionTime());
            
            interactions.add(interaction);
        }
        
        return interactions;
    }
    
    /**
     * 根据用户特征选择商品（模拟用户偏好）
     */
    private Product selectProductForUser(User user, List<Product> products, Random random) {
        // 年轻用户更喜欢电子产品和时尚
        // 年长用户更喜欢家居和图书
        
        List<Product> filteredProducts;
        
        if (user.getAge() < 30) {
            filteredProducts = products.stream()
                .filter(p -> p.getCategory().equals("Electronics") || 
                           p.getCategory().equals("Fashion"))
                .collect(Collectors.toList());
        } else if (user.getAge() > 50) {
            filteredProducts = products.stream()
                .filter(p -> p.getCategory().equals("Home") || 
                           p.getCategory().equals("Books"))
                .collect(Collectors.toList());
        } else {
            filteredProducts = products;
        }
        
        if (filteredProducts.isEmpty()) {
            filteredProducts = products;
        }
        
        return filteredProducts.get(random.nextInt(filteredProducts.size()));
    }
    
    /**
     * 生成真实感评分（考虑用户和商品特征）
     */
    private double generateRealisticRating(User user, Product product) {
        double baseRating = product.getRating();
        
        // 根据价格调整：价格过高的商品评分可能偏低
        if (product.getPrice() > 1000) {
            baseRating -= 0.5;
        }
        
        // 根据用户年龄调整：年长用户评分更严格
        if (user.getAge() > 50) {
            baseRating -= 0.3;
        }
        
        // 添加随机波动
        Random random = new Random();
        double variation = (random.nextDouble() - 0.5) * 2; // -1到1的随机数
        
        double finalRating = baseRating + variation;
        return Math.max(1.0, Math.min(5.0, finalRating)); // 限制在1-5范围内
    }
    
    private void saveToDatabase(List<?> data, String tableName) {
        // 实现数据库保存逻辑
        System.out.println("保存 " + data.size() + " 条记录到表 " + tableName);
    }
}

public class ModelSecurityManager {
    
    /**
     * 模型文件完整性验证
     */
    public boolean verifyModelIntegrity(String modelPath, String expectedChecksum) {
        try {
            String actualChecksum = calculateFileChecksum(modelPath);
            return actualChecksum.equals(expectedChecksum);
        } catch (Exception e) {
            return false;
        }
    }
    
    /**
     * 数据脱敏处理
     */
    public <T> List<T> anonymizeData(List<T> originalData, 
                                    List<String> sensitiveFields) {
        return originalData.stream()
                          .map(item -> anonymizeObject(item, sensitiveFields))
                          .collect(Collectors.toList());
    }
    
    private String calculateFileChecksum(String filePath) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        try (FileInputStream fis = new FileInputStream(filePath)) {
            byte[] buffer = new byte[8192];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                digest.update(buffer, 0, bytesRead);
            }
        }
        return bytesToHex(digest.digest());
    }
    
    private String bytesToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        return result.toString();
    }
}