目录
一、运行环境
系统：Ubuntu 18.04.4
CUDA：cuda_11.0.2_450.51.05_linux
cuDNN：cudnn-11.1-linux-x64-v8.0.5.39
显卡驱动版本：450.80.02
TensorRT：TensorRT-8.4.0.6.Linux.x86_64-gnu.cuda-11.6.cudnn8.3
二、安装CUDA环境
三、安装TensorRT
1.下载地址： https://developer.nvidia.com/nvidia-tensorrt-8x-download，一定要下载TAR版本的
2.安装
tar zxvf TensorRT-8.4.0.6.Linux.x86_64-gnu.cuda-11.6.cudnn8.3.tar.gz
cd TensorRT-8.4.0.6/python
# 根据自己的python版本选择
pip install tensorrt-8.4.0.6-cp37-none-linux_x86_64.whl
cd ../graphsurgeon
pip install graphsurgeon-0.4.5-py2.py3-none-any.whl
3.配置环境变量,将/data/setup/TensorRT-8.4.0.6/lib加入环境变量
vi ~/.bashrc
四、代码验证
我用一个简单的facenet做例子，将pytorch转ONNX再转TensorRT，在验证的时候顺便跑了一下速度，可以看到ONNX速度比pytorch快一倍，TensorRT比ONNX快一倍，好像TensorRT没有传的这么神，我想应该还可以优化。
import torch
from torch.autograd import Variable
import onnx
import traceback
import os
import tensorrt as trt
from torch import nn
# import utils.tensortrt_util as trtUtil
# import pycuda.autoinit
import pycuda.driver as cuda
import cv2
import numpy as np
import onnxruntime
import time
from nets.facenet import Facenet
print(torch.__version__)
print(onnx.__version__)
def torch2onnx(src_path, target_path):
'''
pytorch转换onnx
:param src_path:
:param target_path:
:return:
'''
input_name = ['input']
output_name = ['output']
# input = Variable(torch.randn(1, 3, 32, 32)).cuda()
# model = torchvision.models.resnet18(pretrained=True).cuda()
input = Variable(torch.randn(1, 3, 160, 160))
model = Facenet(backbone="inception_resnetv1", mode="predict").eval()
state_dict = torch.load(src_path, map_location=torch.device('cuda'))
for s_dict in state_dict:
print(s_dict)
model.load_state_dict(state_dict, strict=False)
# torch.onnx.export(model, input, target_path, input_names=input_name, output_names=output_name, verbose=True,
# dynamic_axes={'input' : {0 : 'batch_size'},
# 'output' : {0 : 'batch_size'}})
torch.onnx.export(model, input, target_path, input_names=input_name, output_names=output_name, verbose=True)
test = onnx.load(target_path)
onnx.checker.check_model(test)
print('run success:', target_path)
def run_onnx(model_path):
'''
验证onnx
:param model_path:
:return:
'''
onnx_model = onnxruntime.InferenceSession(model_path, providers=onnxruntime.get_available_providers())
# onnx_model.get_modelmeta()
img = cv2.imread(r'img/002.jpg')
img = cv2.resize(img, (160, 160))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, (2, 1, 0))
img = img[np.newaxis, :, :, :]
img = img / 255.
img = img.astype(np.float32)
img = torch.from_numpy(img)
t = time.time()
tt = 0
# for i in range(1):
# img = np.random.rand(1, 3, 160, 160).astype(np.float32)
# # img = torch.rand((1, 3, 224, 224)).cuda()
# results = onnx_model.run(["output"], {"input": img, 'batch'})Z
img = np.random.rand(1, 3, 160, 160).astype(np.float32)
# img = torch.rand((1, 3, 224, 224)).cuda()
results = onnx_model.run(["output"], {"input": img})
print('cost:', time.time() - t)
for i in range(5000):
img = np.random.rand(1, 3, 160, 160).astype(np.float32)
t1 = time.time()
results = onnx_model.run(["output"], {"input": img})
tt += time.time() - t1
# predict = torch.from_numpy(results[0])
print('onnx cost:', time.time() - t, tt)
# print("predict:", results)
def run_torch(src_path):
model = Facenet(backbone="inception_resnetv1", mode="predict").eval()
state_dict = torch.load(src_path, map_location=torch.device('cuda'))
# for s_dict in state_dict:
# print(s_dict)
model.load_state_dict(state_dict, strict=False)
model = model.eval()
model = model.cuda()
img = cv2.imread(r'img/002.jpg')
img = cv2.resize(img, (160, 160))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, (2, 1, 0))
img = img[np.newaxis, :, :, :]
img = img / 255.
img = img.astype(np.float32)
img = torch.from_numpy(img)
t = time.time()
tt = 0
for i in range(1):
img = torch.rand((1, 3, 160, 160)).cuda()
results = model(img)
print('cost:', time.time() - t)
for i in range(5000):
img = torch.rand((1, 3, 160, 160)).cuda()
t1 = time.time()
results = model(img)
tt += time.time() - t1
print('torch cost:', time.time() - t, tt)
# print("predict:", results)
def onnx2rt(onnx_file_path, engine_file_path):
'''
ONNX转换TensorRT
:param onnx_file_path: onnx文件路径
:param engine_file_path: TensorRT输出文件路径
:return: engine
'''
# 打印日志
G_LOGGER = trt.Logger(trt.Logger.WARNING)
explicit_batch = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
print('explicit_batch:', explicit_batch)
with trt.Builder(G_LOGGER) as builder, builder.create_network(explicit_batch) as network, trt.OnnxParser(network,
G_LOGGER) as parser:
builder.max_batch_size = 100
builder.max_workspace_size = 1 << 20
print('Loading ONNX file from path {}...'.format(onnx_file_path))
with open(onnx_file_path, 'rb') as model:
print('Beginning ONNX file parsing')
parser.parse(model.read())
print('Completed parsing of ONNX file')
print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))
engine = builder.build_engine(network)
print("Completed creating Engine")
# 保存计划文件
with open(engine_file_path, "wb") as f:
f.write(engine.serialize())
return engine
def check_trt(model_path, image_size):
# 必须导入包，import pycuda.autoinit，否则cuda.Stream()报错
import pycuda.autoinit
"""
验证TensorRT结果
"""
print('[Info] model_path: {}'.format(model_path))
img_shape = (1, 3, image_size, image_size)
print('[Info] img_shape: {}'.format(img_shape))
trt_logger = trt.Logger(trt.Logger.WARNING)
trt_path = model_path # TRT模型路径
with open(trt_path, 'rb') as f, trt.Runtime(trt_logger) as runtime:
engine = runtime.deserialize_cuda_engine(f.read())
for binding in engine:
binding_idx = engine.get_binding_index(binding)
size = engine.get_binding_shape(binding_idx)
dtype = trt.nptype(engine.get_binding_dtype(binding))
print("[Info] binding: {}, binding_idx: {}, size: {}, dtype: {}"
.format(binding, binding_idx, size, dtype))
t = time.time()
tt = 0
tt1 = 0
with engine.create_execution_context() as context:
for i in range(5000):
input_image = np.random.randn(*img_shape).astype(np.float32) # 图像尺寸
t1 = time.time()
input_image = np.ascontiguousarray(input_image)
tt1 += time.time() - t1
# print('[Info] input_image: {}'.format(input_image.shape))
stream = cuda.Stream()
bindings = [0] * len(engine)
for binding in engine:
idx = engine.get_binding_index(binding)
if engine.binding_is_input(idx):
input_memory = cuda.mem_alloc(input_image.nbytes)
bindings[idx] = int(input_memory)
cuda.memcpy_htod_async(input_memory, input_image, stream)
else:
dtype = trt.nptype(engine.get_binding_dtype(binding))
shape = context.get_binding_shape(idx)
output_buffer = np.empty(shape, dtype=dtype)
output_buffer = np.ascontiguousarray(output_buffer)
output_memory = cuda.mem_alloc(output_buffer.nbytes)
bindings[idx] = int(output_memory)
context.execute_async_v2(bindings, stream.handle)
stream.synchronize()
cuda.memcpy_dtoh(output_buffer, output_memory)
tt += time.time() - t1
print('trt cost:', time.time() - t, tt, tt1)
# print("[Info] output_buffer: {}".format(output_buffer))
if __name__ == '__main__':
torch2onnx(r"model_data/facenet_inception_resnetv1.pth", r"model_data/facenet_inception_resnetv1.onnx")
onnx2rt(r"model_data/facenet_inception_resnetv1.onnx", r"model_data/facenet_inception_resnetv1.trt")
run_onnx(r"model_data/facenet_inception_resnetv1.onnx")
run_torch(r"model_data/facenet_inception_resnetv1.pth")
check_trt(r"model_data/facenet_inception_resnetv1.trt", 160)
运行结果：ONNX速度比pytorch快一倍，TensorRT比ONNX快一倍
torch cost: 95.99401450157166
onnx cost: 56.98542881011963
trt cost: 26.91579008102417
Original: https://blog.csdn.net/xian0710830114/article/details/124047362
Author: 小殊小殊
Title: 一文看懂pytorch转换ONNX再转换TenserRT
相关阅读
Title: 基于K-MEANS聚类的客户价值分群
-
*实 验目的及要求：
-
学会以层次聚类、K-means聚类模型为代表的聚类分析模型的建模方法；
-
学会借助R软件进行基本的数据建模分析。
-
*实验仪器：
Windows10系统，R Studio软件等。
- *实验原理：
聚类分析是研究如何对事物进行分类的一种多元统计方法，将几种不同的事物依据属性对其进行辨认，将相似的事物聚成一类，使得同一类事物有高度的相似性。其中常用的聚类方法有层次聚类以及K-means聚类。
1、层次聚类;
（1）初始化：每个样本归为一类，并计算每个类之间的距离
（2）寻找距离最近的两个类，合并为一个类
（3）重新计算合并后的类和其他类之间的距离
（4）重复2和3，直至所有样本都划分到某一类
2、K-means聚类：
（1） 选择K个中心点（随机选择K行）；
（2） 把每个数据点分配到离它最近的中心点；
（3） 重新计算每类中的点到该类中心点距离的平均值（也就说，得到长度为p的均值向量，，这里的p是变量的个数）；
(4) 分配每个数据到它最近的中心点；
(5) 重复步骤(3)和步骤(4)直到所有的观测值不再被分配或是达到最大的迭代次数（R把10次作为默认迭代次数）。
- *实验方法
聚类分析的应用十分广泛，在商业中被用来发现不同的客户群，并且通过购买模式刻画不同的客户群的特征。聚类分析是细分市场的有效工具，同时也可用于研究消费者行为，寻找新的潜在市场、选择实验的市场，并作为多元分析的预处理。聚类分析在电子商务中网站建设数据挖掘中也是很重要的一个方面，通过分组聚类出具有相似浏览行为的客户，并分析客户的共同特征，可以更好的帮助电子商务的用户了解自己的客户，向客户提供更合适的服务。本实验报告以某餐饮公司客户数据为例，利用聚类的方法对客户进行价值分类，以便商家根据分类结果对不同价值类别的客户提供个性化的服务，制定相应的营销策略，从而达到精准营销以及利润最大化的目标。
[En]
Cluster analysis is widely used in business to find different customer groups, and through the purchase model to describe the characteristics of different customer groups. Cluster analysis is an effective tool for market segmentation, and it can also be used to study consumer behavior, to find new potential markets, to choose experimental markets, and to preprocess multivariate analysis. Clustering analysis is also a very important aspect in website construction data mining in e-commerce. By grouping and clustering customers with similar browsing behavior, and analyzing the common characteristics of customers, it can better help e-commerce users understand their customers and provide customers with more appropriate services. Taking the customer data of a catering company as an example, this experimental report uses the clustering method to classify the value of customers, so that merchants can provide personalized services to customers of different value categories and formulate corresponding marketing strategies according to the classification results. in order to achieve the goal of accurate marketing and profit maximization.
- *实验过程
餐饮客户消费行为特征数据（部分）：
其中R代表消费时间间隔，F代表消费次数，M代表消费金额。
图1 层次聚类树状图
首先利用层次聚类绘制出层次聚类的树状图如图1所示。直接根据树状图结果较难判断最佳聚类个数，故我们进一步借助R包NbClust中的函数对最佳聚类个数做出判断。
图2 层次聚类-最佳聚类个数柱状图
图3 层次聚类-最佳聚类个数运行结果
结果显示层次聚类模型下的最佳聚类个数为2，故我们以聚类个数n=2做层次聚类：
图4 n=2的层次聚类树状图
图5 层次聚类运行结果
从结果可以看出，层次聚类的效果十分不理想，无法达到对客户进行有效价值分类的目标，故本报告进一步使用K-means聚类对客户价值分类进行尝试。首先我们对数据进行标准化处理，这一步的目的是为了消除不同指标数量级不同所带来的影响。然后我们进一步借助factoextra包中的函数确定K-means聚类模型下的最佳聚类个数。
图6 K-means聚类-最佳聚类个数
从图6中的结果可知，更推荐k=4为聚类个数。故我们以k=4做下一步K-means聚类分析。
图7 k=4时的K-means聚类可视化
从可视化结果可知，第二类以及第三类直接按的区分度并不明显，故我们考虑以k=3再做一次K-means聚类。
图8 K=3时的聚类结果展示
图9 k=3时的K-means聚类可视化
由运行结果可知，数据被分为了三类，每类中的数目分别为：218、370、352。
图10 客户分群1的概率密度图
图11 客户分群2的概率密度图
图12客户分群3的概率密度图
结果中展示了三个类别中所含有的样本数分别为;372,211,357,根据各个客户分群的概率密度函数我们可以发现：
客户分群1的时间间隔R主要集中在15-30天之间，消费次数主要集中在5-10次，消费金额在200-800元；
客户分群2的时间间隔R主要集中在15-35天之间，消费次数主要集中在5-25次，消费金额在800-1600元；
客户分群3的时间间隔R主要集中在8-20天之间，消费次数主要集中在8-20次，消费金额在1600-2000元.
综合以上结果，我们发现客户分群3消费时间间隔较短，消费次数以及消费金额较高，属于较高价值的客户群体，在实际的生产生活中，商家可以针对不同的客户分群特征对其采取相应的消费措施促进营业额的增长。
六、实验代码
library(factoextra)
library(cluster)
#读取数据
data<-read.table(file = "c: recv consum.csv",sep="," ,header="T)[," 2:4] library(ggplot2) df<-scale(data) #可视化层次聚类的过程 d<-dist(df) fit<-hclust(d,method="average" ) plot(fit,hang="-1,cex=0.8)#hang的作用在于让名字显示得更加规整" #选择最佳的聚类点数量 library(nbclust) devasknewpage(ask="TRUE)" nc<-nbclust(df,distance="euclidean" ,min.nc="2,max.nc=15,method='average')" table(nc$best.n[1,]) barplot(table(nc$best.n[1,])) nc$best.n[1,] #故我们选择聚为2类 cluster<-cutree(fit,k="2)" table(cluster) aggregate(data,by="list(clustes=cluster),mean)" rect.hclust(fit,k="2,)" #利用k-means进行聚类 #确定最佳聚类数目 fviz_nbclust(df, kmeans, method="wss" + geom_vline(xintercept="4," linetype="2)" #设置随机数种子，保证实验的可重复进行 set.seed(123) km<-kmeans(df,4,nstart="25)" #查看聚类的一些结果 print(km) dd<-cbind(data,cluster="km.res$cluster)" head(dd) data.cluster <- data.frame(data, km$cluster) data1 data[which(data.cluster$km.cluster="=" 1), ] data2 2), data3 3), data4 4), #提取类标签并且与原始数据进行合并 dd cbind(data, cluster="km$cluster)" #查看每一类的数目 table(dd$cluster) #进行可视化展示 fviz_cluster(km, data="df," palette="c("#2E9FDF"," "#00afbb", "#e7b800", "#fc4e07"), ellipse.type="euclid" , star.plot="TRUE," repel="TRUE," ggtheme="theme_minimal()" #k="4" km<-kmeans(df,3,nstart="25)" #客户分群1的概率密度图 par(mfrow="c(1," 3)) plot(density(data1[, 1]), col="red" main="R" 2]), 3]), #客户分群2的概率密度图 plot(density(data2[, #客户分群3的概率密度图 plot(density(data3[, )< code></-read.table(file>
Original: https://blog.csdn.net/yeye1107/article/details/125425770
Author: 椰子糖精
Title: 基于K-MEANS聚类的客户价值分群
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/244506/
转载文章受原作者版权保护。转载请注明原作者出处！
