1024程序员狂欢节特辑 | ELK+ 协同过滤算法构建个性化推荐引擎，智能实现“千人千面”

专栏集锦，大佬们可以收藏以备不时之需

Spring Cloud实战专栏：https://blog.csdn.net/superdangbo/category_9270827.html

Python 实战专栏：https://blog.csdn.net/superdangbo/category_9271194.html

Logback 详解专栏：https://blog.csdn.net/superdangbo/category_9271502.html

tensorflow专栏：https://blog.csdn.net/superdangbo/category_8691332.html

Redis专栏：https://blog.csdn.net/superdangbo/category_9950790.html

1024程序员节特辑文章：

1024程序员节特辑 | 解密Spring Cloud Hystrix熔断提高系统的可用性和容错能力

1024程序员节特辑 | ELK+ 用户画像构建个性化推荐引擎，智能实现“千人千面”

1024程序员节特辑 | OKR VS KPI谁更合适？

1024程序员节特辑 | Spring Boot实战 之 MongoDB分片或复制集操作

Spring实战系列文章：

Spring实战 | Spring AOP核心秘笈之葵花宝典

Spring实战 | Spring IOC不能说的秘密？

国庆中秋特辑系列文章：

国庆中秋特辑（八）Spring Boot项目如何使用JPA

国庆中秋特辑（七）Java软件工程师常见20道编程面试题

国庆中秋特辑（六）大学生常见30道宝藏编程面试题

国庆中秋特辑（五）MySQL如何性能调优？下篇

国庆中秋特辑（四）MySQL如何性能调优？上篇

国庆中秋特辑（三）使用生成对抗网络（GAN）生成具有节日氛围的画作，深度学习框架 TensorFlow 和 Keras 来实现

国庆中秋特辑（二）浪漫祝福方式 使用生成对抗网络（GAN）生成具有节日氛围的画作

国庆中秋特辑（一）浪漫祝福方式 用循环神经网络（RNN）或长短时记忆网络（LSTM）生成祝福诗词

目录

在这里插入图片描述

一、ELK介绍

ELK，全称 Elasticsearch、Logstash、Kibana，是一种流行的开源日志管理和分析平台。ELK Stack 的三个主要组件分别为 Elasticsearch（分布式搜索和分析引擎）、Logstash（数据收集和处理工具）以及 Kibana（数据可视化工具）。
在这里插入图片描述

1、发展历史
ELK 的历史可以追溯到 2012 年，当时 Elasticsearch 项目创始人 Shay Banon 发布了 Elasticsearch 的首个版本。随着项目的发展，Logstash 和 Kibana 相继诞生，并与 Elasticsearch 共同构成了 ELK Stack。
2、组件详细介绍

  1. Elasticsearch
    Elasticsearch 是一个高度可扩展的开源全文搜索和分析引擎，它基于 Apache Lucene 项目开发。Elasticsearch 提供了分布式、多台机器上的搜索和分析功能，能够快速存储、检索和分析大量数据。在 ELK Stack 中，Elasticsearch 负责存储和查询日志数据。
  2. Logstash
    Logstash 是一个数据收集和处理的强大工具，它可以从各种数据源（如日志文件、数据库和消息队列）收集数据，并对数据进行过滤、分析和格式化。Logstash 基于事件驱动架构，能够高并发地处理大量数据。在 ELK Stack 中，Logstash 负责从各种数据源收集日志数据，并将其发送到 Elasticsearch 进行存储和分析。
  3. Kibana
    Kibana 是一个用户友好的日志分析和可视化工具，它可以帮助用户通过图表、表格和仪表盘等直观的方式查看和分析日志数据。Kibana 基于 Web 界面，支持多种数据分析功能，如聚合、过滤和可视化。在 ELK Stack 中，Kibana 负责展示和分析 Elasticsearch 存储的日志数据。
    3、案例
  4. 日志收集和分析
    某公司有多个服务器，需要对各服务器的日志进行统一收集和分析。使用 ELK Stack，可以在各个服务器上安装 Filebeat，将日志收集到 Logstash，然后通过 Logstash 发送到 Elasticsearch 进行存储和分析。最后，通过 Kibana 进行可视化展示。
  5. 实时数据监控
    某公司在生产环境中需要实时监控各项关键指标，以确保系统的稳定运行。使用 ELK Stack，可以实时收集和分析各项指标数据，并通过 Kibana 进行可视化展示，以便实时了解系统运行状况。
  6. 安全事件分析
    某公司需要对安全事件进行实时监控和分析，以便及时发现并应对潜在的安全威胁。使用 ELK Stack，可以收集和分析安全事件数据，并通过 Kibana 进行可视化展示，以便快速识别异常并采取措施。
    4、总结
    ELK Stack 是一种强大的日志管理和分析工具，它可以帮助用户高效地收集、存储、分析和可视化大量日志数据。ELK Stack 的三个主要组件分别为 Elasticsearch（分布式搜索和分析引擎）、Logstash（数据收集和处理工具）以及 Kibana（数据可视化工具）。ELK Stack 在多个领域都有广泛的应用，如日志收集和分析、实时数据监控以及安全事件分析等。通过使用 ELK Stack，用户可以更加方便地管理和分析日志数据，从而提高运维效率。

二、ELK安装部署

ELK 是指 Elasticsearch、Logstash 和 Kibana 三个开源工具的组合，通常用于大规模日志数据处理和可视化。以下是 ELK 的安装和部署步骤：

  1. 准备环境
    确保你的服务器满足以下要求：
  • 操作系统：Ubuntu 18.04 LTS
  • 内存：至少 4GB
  • 硬盘：至少 20GB
  1. 安装 Java
    在 Ubuntu 服务器上安装 Java，运行以下命令：
sudo apt-get update  
sudo apt-get install openjdk-11-jdk

检查 Java 版本：

java -version
  1. 下载并安装 Elasticsearch
    访问 Elasticsearch 官方网站下载合适版本的 Elasticsearch：https://www.elastic.co/downloads/elasticsearch
    下载完成后，将 Elasticsearch 压缩包上传到服务器，然后解压：
sudo mkdir -p /usr/share/elasticsearch  
sudo tar -xzf elasticsearch-7.10.2.tar.gz -C /usr/share/elasticsearch --strip-components=1

设置 Elasticsearch 的环境变量：

export ES_HOME=/usr/share/elasticsearch  
export PATH=$PATH:$ES_HOME/bin

创建 Elasticsearch 配置文件：

sudo tee /etc/elasticsearch/elasticsearch.yml << EOL  
cluster.name: my-cluster  
node.name: my-node  
network.host: 0.0.0.0  
http.port: 9200  
discovery.seed_hosts: ["host1", "host2"]  
cluster.initial_master_nodes: ["node-1", "node-2"]  
EOL

启动 Elasticsearch：

sudo systemctl start elasticsearch

检查 Elasticsearch 是否运行正常：

curl -X GET "localhost:9200/"
  1. 下载并安装 Logstash
    访问 Logstash 官方网站下载合适版本的 Logstash：https://www.elastic.co/downloads/logstash
    在这里插入图片描述

下载完成后，将 Logstash 压缩包上传到服务器，然后解压：

sudo mkdir -p /usr/share/logstash  
sudo tar -xzf logstash-7.10.2.tar.gz -C /usr/share/logstash --strip-components=1

创建 Logstash 配置文件：

sudo tee /etc/logstash/logstash.conf << EOL  
input {  
 beats {  
   port => 5044  
 }  
}
filter {  
 if "apache" in [$log][app] {  
   grok {  
     match => { "message" => "%{GREEDYDATA:apache_message}" }  
   }  
 } else if "nginx" in [$log][app] {  
   grok {  
     match => { "message" => "%{GREEDYDATA:nginx_message}" }  
   }  
 }  
}
output {  
 if "apache" in [$log][app] {  
   elasticsearch {  
     hosts => ["http://localhost:9200"]  
     index => "my-index-%{+YYYY.MM.dd}"  
   }  
 } else if "nginx" in [$log][app] {  
   elasticsearch {  
     hosts => ["http://localhost:9200"]  
     index => "my-index-%{+YYYY.MM.dd}"  
   }  
 }  
}
EOL

启动 Logstash：

sudo systemctl start logstash
  1. 下载并安装 Kibana
    访问 Kibana 官方网站下载合适版本的 Kibana：https://www.elastic.co/downloads/kibana
    在这里插入图片描述

下载完成后，将 Kibana 压缩包上传到服务器，然后解压：

sudo mkdir -p /usr/share/kibana  
sudo tar -xzf kibana-7.10.2.tar.gz -C /usr/share/kibana --strip-components=1

创建 Kibana 配置文件：

sudo tee /etc/kibana/kibana.yml << EOL  
server.port: 5601  
server.host: "0.0.0.0"  
elasticsearch.hosts: ["http://localhost:9200"]  
EOL

启动 Kibana：

sudo systemctl start kibana

在这里插入图片描述

检查 Kibana 是否运行正常，访问 http://your_server_ip:5601，如果看到 Kibana 的欢迎页面，则说明安装成功。

  1. 配置 Elasticsearch、Logstash 和 Kibana 的集成
    在 Elasticsearch 的配置文件中，添加以下内容：
http.port: 9200  
discovery.seed_hosts: ["host1", "host2"]  
cluster.initial_master_nodes: ["node-1", "node-2"]

在 Logstash 的配置文件中，添加以下内容：

output {  
 elasticsearch {  
   hosts => ["http://localhost:9200"]  
   index => "my-index-%{+YYYY.MM.dd}"  
 }  
}

在 Kibana 的配置文件中，添加以下内容：

server.port: 5601  
server.host: "0.0.0.0"  
elasticsearch.hosts: ["http://localhost:9200"]
  1. 启动 Elasticsearch、Logstash 和 Kibana
    在命令行中，分别启动 Elasticsearch、Logstash 和 Kibana：
sudo systemctl start elasticsearch  
sudo systemctl start logstash  
sudo systemctl start kibana

现在，你已经成功安装并部署了 ELK。

三、ELK跟不同技术结合，实现“千人千面”

ELK 技术可以与多种技术结合，实现千人千面的需求。以下是一些建议，并结合具体案例和代码进行说明：

  1. ELK + 用户画像：
    用户画像是对用户的基本信息、兴趣爱好、消费习惯等进行建模。可以通过收集用户的行为数据，结合机器学习和大数据技术，分析用户的兴趣和需求。将分析结果存储在用户画像系统中，为用户提供个性化推荐。
    案列：
  • 收集用户行为数据，如搜索记录、浏览记录、购买记录等。
  • 使用机器学习算法（如决策树、SVM、聚类等）分析用户行为数据，构建用户画像。
  • 将用户画像与 ELK 结合，实现基于用户画像的个性化推荐。
  1. ELK + 协同过滤：
    协同过滤是一种基于用户历史行为数据的推荐算法，可以挖掘用户之间的相似性以及物品之间的相似性。通过协同过滤算法，可以为用户提供个性化推荐。
    案列：
  1. ELK + 深度学习：
    深度学习可以在大规模数据上学习用户的兴趣和需求，为用户提供个性化推荐。可以通过神经网络、卷积神经网络、循环神经网络等算法进行深度学习。
    案列：
  • 收集用户行为数据，如点击记录、浏览记录等，并将其转化为适合深度学习模型输入的数据格式。
  • 使用深度学习模型（如神经网络、卷积神经网络、循环神经网络等）训练模型。
  • 将深度学习模型的输出与 ELK 结合，实现基于深度学习的个性化推荐。
    以上仅为示例，实际应用中可以根据业务需求和场景进行调整。在实际项目中，ELK 通常作为整个推荐系统的基础设施，与其他技术（如用户画像、协同过滤、深度学习等）相结合，实现千人千面的个性化推荐。

四、ELK + 协同过滤，用Java实现“千人千面”

ELK（Elasticsearch、Logstash、Kibana）是一个大数据处理和可视化平台，而用户画像则是根据用户的行为、兴趣、喜好等信息构建的用户模型。实现千人千面，即为目标用户提供个性化的内容和服务。
要实现 ELK + 用户画像的千人千面，你需要完成以下步骤：

  1. 收集用户数据：收集用户的行为数据、兴趣数据、喜好数据等。这些数据可以从用户的浏览记录、购买记录、搜索记录等渠道获取。
  2. 构建用户画像：根据收集到的用户数据，使用机器学习算法（例如决策树、支持向量机等）构建用户画像。用户画像包括用户的年龄、性别、职业、地域、消费水平等信息。
  3. 存储用户画像：将构建好的用户画像存储在 Elasticsearch 中，以便后续的查询和推荐。
  4. 实现推荐算法：使用 Logstash 处理用户行为数据，然后结合用户画像，实现个性化推荐。推荐算法可以使用基于内容的推荐、协同过滤、矩阵分解等。
  5. 输出推荐结果：将推荐结果可视化在 Kibana 中，提供给用户。
    Elasticsearch、Logstash 和 Kibana（简称 ELK）是一个流行的开源大数据处理平台，可以用于收集、存储和分析大量日志数据。协同过滤算法是一种用于推荐系统的常见算法，可以用于根据用户的行为数据预测他们可能感兴趣的内容。
    要实现一个包含 Java 协同过滤算法的 ELK 项目，你可以按照以下步骤进行：
  6. 首先，确保你已经正确安装并配置了 Elasticsearch、Logstash 和 Kibana。如果还没有安装，可以参考官方文档进行安装和配置：
  1. 准备数据源。为了训练协同过滤算法，你需要大量的用户行为数据，例如用户评分、观看电影等。这里假设你已经有一个包含用户行为数据的 MySQL 数据库。
  2. 创建一个 Java 项目，并添加以下依赖：
<dependencies>  
   <dependency>  
       <groupId>org.elasticsearch</groupId>  
       <artifactId>elasticsearch</artifactId>  
       <version>7.15.1</version>  
   </dependency>  
   <dependency>  
       <groupId>org.elasticsearch.client</groupId>  
       <artifactId>elasticsearch-rest-high-level-client</artifactId>  
       <version>7.15.1</version>  
   </dependency>  
   <dependency>  
       <groupId>mysql</groupId>  
       <artifactId>mysql-connector-java</artifactId>  
       <version>8.0.26</version>  
   </dependency>  
</dependencies>
  1. 创建一个 Java 类，用于与 Elasticsearch 进行交互。以下是一个简单的示例：
import org.elasticsearch.action.search.SearchRequest;  
import org.elasticsearch.action.search.SearchResponse;  
import org.elasticsearch.client.RestHighLevelClient;  
import org.elasticsearch.index.query.QueryBuilders;  
import org.elasticsearch.search.aggregations.AggregationBuilders;  
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;  
import org.elasticsearch.search.aggregations.metrics.AvgAggregationBuilder;
import java.io.IOException;  
import java.util.List;
public class ElasticsearchClient {
   private RestHighLevelClient client;
   public ElasticsearchClient(String host, int port) {  
       client = new RestHighLevelClient(RestClient.builder(host, port));  
   }
   public void close() {  
       client.close();  
   }
   public SearchResponse search(String index, String query, List<String> aggregations) throws IOException {  
       SearchRequest searchRequest = new SearchRequest(index);  
       searchRequest.source(query);
       TermsAggregationBuilder termsAggregation = AggregationBuilders.terms("bucket");  
       termsAggregation.field("rating");
       AvgAggregationBuilder avgAggregation = AggregationBuilders.avg("averageRating");  
       avgAggregation.field("rating");
       searchRequest.aggregations(termsAggregation, avgAggregation);
       return client.search(searchRequest, RequestOptions.DEFAULT);  
   }  
}
  1. 创建一个 Java 类，实现协同过滤算法。这里我们使用皮尔逊相关系数作为度量标准：
import java.util.ArrayList;  
import java.util.List;  
import java.util.Random;
public class CollaborativeFiltering {
   public static void main(String[] args) {  
       // 创建模拟数据  
       List<double[]> ratings = new ArrayList<>();  
       ratings.add(new double[]{1, 1, 1, 1});  
       ratings.add(new double[]{1, 2, 3, 4});  
       ratings.add(new double[]{2, 3, 4, 5});
       // 训练集和测试集划分  
       int[] trainIndexes = new int[ratings.size() - 2];  
       int[] testIndexes = new int[2];  
       for (int i = 0; i < ratings.size(); i++) {  
           if (i % 2 == 0) {  
               trainIndexes[trainIndexes.length - 1] = i;  
           } else {  
               testIndexes[testIndexes.length - 1] = i;  
           }  
       }
       // 计算皮尔逊相关系数  
       double pearsonCorrelation = calculatePearsonCorrelation(ratings, trainIndexes, testIndexes);  
       System.out.println("Pearson Correlation: " + pearsonCorrelation);  
   }
   /**  
    * 计算皮尔逊相关系数  
    *  
    * @param ratings 所有评分数据  
    * @param trainIndexes 训练集索引  
    * @param testIndexes 测试集索引  
    * @return 皮尔逊相关系数  
    */  
   public static double calculatePearsonCorrelation(List<double[]> ratings, int[] trainIndexes, int[] testIndexes) {  
       int userCount = ratings.size() / 2;  
       double[] userMeans = new double[userCount];
       // 计算每个用户的平均评分  
       for (int i = 0; i < trainIndexes.length; i++) {  
           userMeans[i] = calculateMean(ratings.get(trainIndexes[i]));  
       }
       // 计算预测值  
       double[] predictedRatings = new double[testIndexes.length];  
       for (int i = 0; i < testIndexes.length; i++) {  
           double prediction = predict(ratings.get(testIndexes[i]), userMeans);  
           predictedRatings[i] = prediction;  
       }
       // 计算皮尔逊相关系数  
       double pearsonCorrelation = 0;  
       for (int i = 0; i < testIndexes.length; i++) {  
           double realRating = ratings.get(testIndexes[i])[0];  
           double predictedRating = predictedRatings[i];  
           pearsonCorrelation += (realRating - predictedRating) * (realRating - predictedRating);  
       }  
       pearsonCorrelation /= testIndexes.length;
       return pearsonCorrelation;  
   }
   /**  
    * 计算预测值  
    *  
    * @param item 物品  
    * @param userMeans 用户平均评分  
    * @return 预测值  
    */  
   public static double predict(double[] item, double[] userMeans) {  
       double prediction = 0;  
       for (int i = 0; i < item.length; i++) {  
           prediction += userMeans[i] * item[i];  
       }  
       return prediction / item.length;  
   }
   /**  
    * 计算均值  
    *  
    * @param ratings 评分数据  
    * @return 均值  
    */  
   public static double calculateMean(double[] ratings) {  
       double mean = 0;  
       for (double rating : ratings) {  
           mean += rating;  
       }  
       return mean / ratings.length;  
   }  
}

这个 Java 类实现了协同过滤算法，使用皮尔逊相关系数作为度量标准。在 main 方法中，我们创建了一个模拟数据集，并将其划分为训练集和测试集。然后计算皮尔逊相关系数，并输出结果。

五、ELK + 协同过滤，用Python实现“千人千面”

Elasticsearch、Logstash 和 Kibana（简称 ELK）是一个流行的开源大数据处理平台，可以用于收集、存储和分析大量日志数据。协同过滤算法是一种用于推荐系统的算法，可以结合 Python 实现。下面将分别介绍如何使用 ELK 和 Python 实现协同过滤算法。
首先，确保已安装 Elasticsearch、Logstash 和 Kibana。然后，安装 Python 及其相关库，如 elasticsearch 和 pandas。

  1. 安装 Elasticsearch
pip install elasticsearch
  1. 安装 Logstash
pip install logstash
  1. 安装 Kibana
pip install kibana
  1. 安装相关库
pip install pandas numpy

接下来，实现协同过滤算法。这里我们使用一个简单的 Python 代码示例，你可以根据自己的需求进行修改：

import numpy as np  
import pandas as pd  
from sklearn.metrics.pairwise import euclidean  
from elasticsearch import Elasticsearch
# 假设你有以下数据，存储在一个 DataFrame 中  
data = {  
   'user_id': [1, 1, 1, 2, 2, 2],  
   'item_id': [1, 2, 3, 1, 2, 3],  
   'rating': [4, 5, 3, 4, 5, 3]  
}
df = pd.DataFrame(data)
# 将数据存储到 Elasticsearch 中  
es = Elasticsearch()  
df.to_json(df.reset_index().to_dict(), orient='records', index=False)  
es.index(index='ratings', doc_type='doc', body=df.reset_index().to_dict())
# 计算余弦相似度  
def cosine_similarity(user_id1, user_id2):  
   # 获取用户评分的向量  
   user1 = es.mget(index='ratings', ids=[user_id1], doc_type='doc')  
   user2 = es.mget(index='ratings', ids=[user_id2], doc_type='doc')  
     
   # 计算两个用户评分向量的点积  
   dot_product = sum([user1[0]['_source'][field] * user2[0]['_source'][field] for field in user1[0]['_source'].keys()])  
     
   # 计算两个向量的模长  
   user1_norm = sum([value ** 2 for value in user1[0]['_source'].values()]) ** 0.5  
   user2_norm = sum([value ** 2 for value in user2[0]['_source'].values()]) ** 0.5  
     
   # 计算余弦相似度  
   return dot_product / (user1_norm * user2_norm)
# 计算两个用户的相似度  
similarity = cosine_similarity(1, 2)  
print(similarity)

上面的代码只是一个简单的示例，你可以根据自己的需求修改数据和算法。这里我们使用的是基于余弦相似度的协同过滤算法。
最后，通过 Kibana 分析和可视化结果。在 Kibana 中，选择 “Management” -> “Kibana” -> “Index Patterns”，创建一个名为 “ratings” 的索引模式。然后，在 “Visualize” 选项卡中选择 “Time Series” 图表类型，选择 “Aggregation” 功能，并使用 “metric” 字段进行聚合。在 “Style” 选项卡中，可以选择图表样式和颜色。


http://www.niftyadmin.cn/n/5115125.html

相关文章

K8S集群实践之九: Ceph

K8S集群实践之九: Ceph

Rook is an open source cloud-native storage orchestrator, providing the platform, framework, and support for Ceph storage to natively integrate with cloud-native environments.1. 说明 因香橙派和树莓派资源所限&#xff0c;转移到基于VirtualBox建立的VMs继续实践…
阅读更多...
朋友圈推广如何做？

朋友圈推广如何做？

为什么在朋友圈做推广是如此重要&#xff0c;以及如何充分利用这个平台来推动你的业务增长。 不仅仅是分享生活点滴&#xff0c;朋友圈也可以成为你的事业起飞的跳板。快来了解一下吧&#xff01; 为什么在朋友圈做推广&#xff1f; 1、人脉力量&#xff1a;朋友圈是一个连接…
阅读更多...
Windows桌面便笺 - 置顶任务TODO - 便利贴工具

Windows桌面便笺 - 置顶任务TODO - 便利贴工具

效果图 一直置顶 免费 步骤 1. 打开便笺 win10找不到自带的便签怎么办-百度经验win10找不到自带的便签怎么办,很多朋友都在问wi10找不到自带的便签怎么办&#xff0c;今天就来给大家介绍一下wi10找不到自带的便签怎么办的方法。https://jingyan.baidu.com/article/b2c186c8…
阅读更多...
Deployments

Deployments

Deployments 一个 Deployment 为 Pod 和 ReplicaSet 提供声明式的更新能力。 你负责描述 Deployment 中的目标状态&#xff0c;而 Deployment 控制器&#xff08;Controller&#xff09; 以受控速率更改实际状态&#xff0c; 使其变为期望状态。你可以定义 Deployment 以创建新…
阅读更多...
软考-des题目案例

软考-des题目案例

1.补全图片中的数字 &#xff08;1&#xff09;10 &#xff0c;&#xff08;2&#xff09;6&#xff0c;&#xff08;3&#xff09;1&#xff0c;&#xff08;4&#xff09;11 2.初始置换简单计算 置换时&#xff0c;从左上角的第一个元素开始&#xff0c;表示输入的明文的第5…
阅读更多...
2023/10/23学习记录

2023/10/23学习记录

1.VS2019中sln对应解决方案 修改sln的文件名&#xff0c;对应的解决方案名称也会变化。 2.如何修改生成的exe文件名呢&#xff1f; 属性--->杂项--->&#xff08;名称) 3.这是任务管理器&#xff0c;这里红色部分显示的是“这是文件描述”。 当通过属性查看详细信息的时…
阅读更多...
scp通过跳板机向服务器传文件的方法

scp通过跳板机向服务器传文件的方法

scp上传 scp -P 端口号 要传的文件 服务器用户名服务器IP:服务器目录scp下载 scp -P 端口号 服务器用户名服务器IP:服务器目录 要下载的文件在实际情况下如果目标服务器无法通过ssh直接连接&#xff0c;需要跳板机才能连接&#xff0c;如何使用scp呢&#xff1f; 跳板机host…
阅读更多...
DB-GPT发布：用私有LLM技术彻底改革数据库互动

DB-GPT发布：用私有LLM技术彻底改革数据库互动

01 项目介绍 随着大模型的发布迭代&#xff0c;大模型变得越来越智能&#xff0c;在使用大模型的过程当中&#xff0c;遇到极大的数据安全与隐私挑战。在利用大模型能力的过程中我们的私密数据跟环境需要掌握自己的手里&#xff0c;完全可控&#xff0c;避免任何的数据隐私泄…
阅读更多...
最新文章

Copyright @ 2022~2023