|
|
51CTO旗下网站
|
|
移动端

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

本数据集共收集了发生在一个月内的28010条数据,包含以下字段: ['订单编号', '总金额', '买家实际支付金额', '收货地址', '订单创建时间', '订单付款时间 ', '退款金额']。

作者:野猫谈Python来源:今日头条|2020-06-22 13:41

数据集简介

本数据集共收集了发生在一个月内的28010条数据,包含以下字段:

  • ['订单编号', '总金额', '买家实际支付金额', '收货地址', '订单创建时间', '订单付款时间 ', '退款金额']

7个字段说明:

  • 订单编号:订单编号;
  • 总金额:订单总金额;
  • 买家实际支付金额:总金额 - 退款金额(在已付款的情况下)。金额为0(在未付款的情况下);
  • 收货地址:各个省份;
  • 订单创建时间:下单时间;
  • 订单付款时间:付款时间;
  • 退款金额:付款后申请退款的金额。如无付过款,退款金额为0。

数据概览:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

相关库、函数和数据的导入

  1. # 相关库和函数的导入 
  2.  
  3. import numpy as np 
  4. from sklearn import metrics 
  5. import math 
  6. import copy 
  7. import pandas as pd           
  8. import scipy as sp导入常用的基本库 
  9.  
  10. import datetime as date                                 # 导入datetime库 
  11. import seaborn as sns                                   # 导入seaborn库,用于数据可视化 
  12. from IPython.display import display                     # 载入数据查看时需要使用的函数 
  13. from sklearn.model_selection import train_test_split    # 导入数据集划分时需要使用的函数 
  14. from sklearn.metrics import confusion_matrix            # 导入生成混淆矩阵的函数 
  15. from sklearn.preprocessing import LabelEncoder          # 导入分类变量编码时需要使用的函数 
  16. from sklearn.metrics import classification_report       # 导入分类结果评价时要用到的函数 
  17.  
  18. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis     # 导入LDA判别时需要使用的函数 
  19. from sklearn.naive_bayes import MultinomialNB           # 导入朴素贝叶斯时需要使用的额函数 
  20. from sklearn.neighbors import KNeighborsClassifier      # 导入KNN判别时需要使用的函数 
  21. from sklearn.tree import DecisionTreeClassifier         # 导入决策树函数 
  22. from sklearn.neural_network import MLPClassifier        # 导入神经网络函数 
  23. from sklearn import svm                                 # 导入支持向量机函数 
  24.  
  25. from sklearn.model_selection import GridSearchCV        # 导入模型优化方法中的网格搜索法需要用到的函数 
  26. from sklearn.cross_validation import KFold              # 导入模型评估时使用的函数 
  27.  
  28. # 数据导入 
  29.  
  30. dt = pd.read_csv('D:资料/数据分析/数据分析与数据挖掘/实战演练/5(tmall_order_report)/tmall_order_report.csv',encoding='gbk',engine='python'

数据检查与清洗

首先,查看一下数据集的变量类型:

  1. dt.dtypes                                               # 查看数据集有哪些变量  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

然后,将变量中右侧的空格去除(以免影响后续调用变量),并进行重复值和缺失值检查:

  1. dt.columns = dt.columns.str.rstrip()                    # 去除列名右侧的空格 
  2. dt.duplicated().sum()                                   # 检查数据是否有重复值,发现并没有重复值 
  3. display(sum(dt.isnull().sum()))                         # 检查数据集是否有缺失值  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

检查出来有缺失值(约占数据总量的12-15%),考虑原数据中是否是因为“订单付款时间”这一列存在缺失值而导致产生这样的检查结果:

  1. col = dt.columns.values.tolist()                        # 提取数据集中的所有列变量的名称 
  2. col.remove('订单付款时间')                               # 将订单付款时间这一列去除 
  3. display(sum(dt[col].isnull().sum()))                    # 再次检查是否有缺失值,发现并没有缺失值,也就是缺失值均来自“订单付款时间”这一列  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

结果表明,缺失值仅来自“订单付款时间”这一列。接下来就是处理缺失值,处理的思路可以是先计算出各订单付款时间和下单时间的平均值,然后用下单时间 + 平均值,作为缺失值的填补对象:

  1. c = np.array(['订单创建时间','订单付款时间'])             # 提取订单创建时间、付款时间这两列的列名 
  2. for i in c: 
  3.     dt[i] = pd.to_datetime(dt[i])                       # 将订单创建时间、付款时间由object类型转为datetime类型,方便运算 
  4. for i in range(0,dt.shape[0]): 
  5.     if (dt['订单付款时间'].iloc[i] < dt['订单创建时间'].iloc[i]) == True
  6.         dt['订单付款时间'].iloc[i] = dt['订单付款时间'].iloc[i] + date.timedelta(days=1)     # 将订单付款时间 < 订单创建时间的时间数据往后加1天(因为原数据中没有考虑日期差异情况)  
  7. mu = np.mean(dt['订单付款时间']-dt['订单创建时间'])       # 计算时间差的均值,用于之后进行缺失值替换 
  8. for i in range(0,dt.shape[0]): 
  9.     if pd.isnull(dt['订单付款时间'].iloc[i]) == True:    # 进行缺失值填补 
  10.         dt['订单付款时间'].iloc[i] = dt['订单创建时间'].iloc[i] + mu 

在填补完成之后,再次检查缺失值和重复值的情况:

  1. display(sum(dt.isnull().sum()))                         # 再次检查数据集是否有缺失值,发现已经处理完了,但是还要检查是否增加正确 
  2. display(dt.duplicated().sum())                          # 再次检查数据是否有重复值,发现并没有重复值,发现也没有重复值 
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

结果显示已经没有缺失值和重复值了。

描述性分析

首先,对订单总金额进行描述性分析:

  1. display(dt['总金额'].describe())                        # 查看订单总金额的情况,发现最大的订单价格达到了188320元,最小的则只有1元,平均订单价为107元左右  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

从描述统计的结果中可以看到,最大的订单价格达到了188320元,最小的只有1元,平均订单价在107元左右,中位数为1元,说明应该是一个左偏分布,即大部分订单的价格应该都不高。然后查看买家实际支付金额为0(支付未完成)的订单比例:

  1. sum(dt['买家实际支付金额']==0) / dt.shape[0]             # 查看买家实际支付金额为0(也就是支付未完成)的订单比例,占比约为32.3%  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

从结果中可以看到,大概有32.3%的买家未完成支付,这一比例还是比较高的。再看看订单付款时间相比于订单创建时间的延迟情况:

  1. display((dt['订单付款时间']-dt['订单创建时间']).describe())     # 查看订单付款时间相比于订单创建时间的延迟情况,发现最慢的支付延迟了接近1天,而大部分订单在10分钟内就完成了支付 

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

从中可以看到,最慢的支付延迟了接近1天,而大部分订单在10分钟内就完成了支付。最后,来对收货地址情况进行描述性分析:

  1. siz = dt.groupby(dt['收货地址']).size()                 # 对收货地址进行分组统计 
  2. idx_sort = np.argsort(-siz)                            # 对分组统计的结果进行降序排序 
  3. display(siz[idx_sort].head())                          # 查看降序排序的结果的前5名,发现收货地址选择上海、广东、江苏、浙江、北京的最多 
  4. siz[idx_sort].tail()                                   # 查看降序排序的结果的最后5名,发现收货地址选择湖北、新疆、宁夏、青海和西藏的最少,其中湖北可能受疫情影响所致 
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

从结果中可以看到,收货地址选择上海、广东、江苏、浙江、北京的最多,而选湖北、新疆、宁夏、青海和西藏的最少,其中湖北可能受疫情影响所致。

建模预处理

首先,进行特征构建,并生成用于建模的数据集,处理过程如下:

  1. d1 = (dt['订单付款时间']-dt['订单创建时间'])            # 输出订单付款和创建之间的时间差,作为一个新变量 
  2. d1 = (d1 / np.timedelta64(1, 's')).astype(int)        # 将时间差的格式进行转换,转换为按秒计数,并把格式变为int类型 
  3. le_train = LabelEncoder()                             # 使用从sklearn.preprocessing中import的LabelEncoder对分类数据进行编码,以便于后续使用交叉验证建模  
  4. le_train.fit(dt['收货地址'].tolist())                  # 对模型进行训练 
  5. d2 = le_train.transform(dt['收货地址'].tolist())       # 转化数据,作为第2个变量 
  6. d3 = np.zeros(dt.shape[0])                            # 构建一个全为0的数组 
  7. for i in range(0,dt.shape[0]): 
  8.     if (dt['总金额'].iloc[i]-dt['买家实际支付金额'].iloc[i]) == dt['退款金额'].iloc[i]: 
  9.         d3[i] = 1                                     # 生成一个新变量(类别变量),当买家有支付(无论退不退款)时为1,没有支付时为0(无支付时上述等式不成立,实际支付金额和退款金额均为0),表明支付的情况 
  10. dt_use = np.vstack((d1,d2,d3)).T                      # 生成用于建模分析的数据集,np.vstack用于数组的垂直连接   

然后是对数据集进行划分,形成训练集和测试集,为之后的建模做准备:

  1. x_train,x_test, y_train, y_test = train_test_split(dt_use[:,0:2],dt_use[:,2:3],test_size=0.25, random_state=0)     # 使用从sklearn.model_selection中import的train_test_split函数进行训练集、测试集的划分 
  2. print('训练集的自变量数据的维度',x_train.shape) 
  3. print('训练集的因变量量数据的维度',x_test.shape) 
  4. print('测试集的自变量数据的维度',y_train.shape)           
  5. print('测试集的因变量数据的维度',y_test.shape)          # 查看数据集划分后的维度情况  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

数据建模

首先,构建初始的模型,这里完成的是分类预测任务,选择经典的几个模型,分别是 SVM、LDA、朴素贝叶斯NB、KNN判别、决策树Detree和神经网络Network:

  1. models = {}                                           # 构建一个models集合 
  2. models['SVM'] = svm.SVC()                             # 支持向量机模型 
  3. models['LDA'] = LinearDiscriminantAnalysis()          # LDA判别模型 
  4. models['NB'] = MultinomialNB()                        # 朴素贝叶斯模型 
  5. models['KNN'] = KNeighborsClassifier()                # KNN判别模型 
  6. models['Detree'] = DecisionTreeClassifier()           # 决策树模型 
  7. models['Network'] = MLPClassifier()                   # 神经网络模型 

然后,对模型进行训练和分析:

  1. target_names = ['有支付','没有支付']                   # 生成类别的名称 
  2. for key in models: 
  3.     models[key].fit(x_train,y_train)                  # 模型训练 
  4.     display(confusion_matrix(y_test,models[key].predict(x_test)))                                               # 对y_test进行预测,输出混淆矩阵 
  5.     print(classification_report(y_test,models[key].predict(x_test),target_names=target_names))                  # 对y_test进行预测,输出预测的分类评价 
  6.     print('\n')    

SVM模型的混淆矩阵和准确率:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

LDA模型的混淆矩阵和准确率:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

朴素贝叶斯NB模型的混淆矩阵和准确率:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

KNN判别模型的混淆矩阵和准确率:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

决策树Detree模型的混淆矩阵和准确率:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

神经网络Network模型的混淆矩阵和准确率:

Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

从上述结果中可以看到,SVM和KNN的准确率较高。下面对朴素贝叶斯NB模型进行调参,看是否能改善其预测准确率:

  1. param_grid_nb = {'alpha':[0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]}    # 设定贝叶斯模型中不同alpha值 
  2. model_nb_ty = MultinomialNB()                          # 设定贝叶斯的模型 
  3. kfold = KFold(10, 6)                                   # 采用10折交叉验证,初始随机起点为6 
  4. grid = GridSearchCV(estimator=model_nb_ty,  
  5.                     param_grid=param_grid_nb, scoring='neg_mean_squared_error', cv=kfold)         # 设置网格搜索的模型 
  6. grid_result = grid.fit(x_train, y_train)               # 利用构建好的模型对数据集进行训练,搜索最优的k值 
  7. print('最优:%s 使用%s' % (grid_result.best_score_, grid_result.best_params_))                     # 输出最优的参数情况 
  8. nb_model = MultinomialNB(alpha=0)                      # 根据模型调参的结果,重新设定朴素贝叶斯模型 
  9. nb_model.fit(x_train,y_train)                          # 模型训练 
  10. display(confusion_matrix(y_test,nb_model.predict(x_test)))                                        # 对y_test进行预测,输出混淆矩阵 
  11. print(classification_report(y_test,nb_model.predict(x_test),target_names=target_names))           # 对y_test进行预测,输出预测的分类评价,发现并没有什么改进  
Python数据分析难?手把手教你处理上万条京东订单数据(附源码)

调参后的结果和调参前并没有多少改善,说明NB模型在本次预测中受限于数据情况,而不是模型参数。

最后放上全过程的代码,供大家学习使用:

  1. ### 数据分析前期准备工作 ### 
  2.  
  3. # 相关库和函数的导入 
  4.  
  5. import numpy as np 
  6. from sklearn import metrics 
  7. import math 
  8. import copy 
  9. import pandas as pd           
  10. import scipy as sp 
  11. import matplotlib.pyplot as plt               # 导入常用的基本库 
  12.  
  13. import datetime as date                                 # 导入datetime库 
  14. import seaborn as sns                                   # 导入seaborn库,用于数据可视化 
  15. from IPython.display import display                     # 载入数据查看时需要使用的函数 
  16. from sklearn.model_selection import train_test_split    # 导入数据集划分时需要使用的函数 
  17. from sklearn.metrics import confusion_matrix            # 导入生成混淆矩阵的函数 
  18. from sklearn.preprocessing import LabelEncoder          # 导入分类变量编码时需要使用的函数 
  19. from sklearn.metrics import classification_report       # 导入分类结果评价时要用到的函数   
  20.  
  21. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis     # 导入LDA判别时需要使用的函数 
  22. from sklearn.naive_bayes import MultinomialNB           # 导入朴素贝叶斯时需要使用的额函数 
  23. from sklearn.neighbors import KNeighborsClassifier      # 导入KNN判别时需要使用的函数 
  24. from sklearn.tree import DecisionTreeClassifier         # 导入决策树函数 
  25. from sklearn.neural_network import MLPClassifier        # 导入神经网络函数 
  26. from sklearn import svm                                 # 导入支持向量机函数 
  27.  
  28. from sklearn.model_selection import GridSearchCV        # 导入模型优化方法中的网格搜索法需要用到的函数 
  29. from sklearn.cross_validation import KFold              # 导入模型评估时使用的函数 
  30.  
  31. # 全局设定 
  32.  
  33. plt.rcParams['font.sans-serif']=['SimHei']              # 设定中文字符的显示设定 
  34.  
  35. # 数据导入 
  36.  
  37. dt = pd.read_csv('D:资料/数据分析/数据分析与数据挖掘/实战演练/5(tmall_order_report)/tmall_order_report.csv',encoding='gbk',engine='python'
  38.  
  39.  
  40.  
  41. ### 数据整理与查看 ### 
  42.  
  43. # 数据检查与清洗 
  44.  
  45. dt.dtypes                                               # 查看数据集有哪些变量 
  46.  
  47. dt.columns = dt.columns.str.rstrip()                    # 去除列名右侧的空格 
  48.  
  49. dt.duplicated().sum()                                   # 检查数据是否有重复值,发现并没有重复值 
  50.  
  51. display(sum(dt.isnull().sum()))                         # 检查数据集是否有缺失值 
  52.  
  53. col = dt.columns.values.tolist()                        # 提取数据集中的所有列变量的名称 
  54.  
  55. col.remove('订单付款时间')                               # 将订单付款时间这一列去除 
  56.  
  57. display(sum(dt[col].isnull().sum()))                    # 再次检查是否有缺失值,发现并没有缺失值,也就是缺失值均来自“订单付款时间”这一列 
  58.  
  59. c = np.array(['订单创建时间','订单付款时间'])             # 提取订单创建时间、付款时间这两列的列名 
  60.  
  61. for i in c: 
  62.     dt[i] = pd.to_datetime(dt[i])                       # 将订单创建时间、付款时间由object类型转为datetime类型,方便运算 
  63.  
  64. for i in range(0,dt.shape[0]): 
  65.     if (dt['订单付款时间'].iloc[i] < dt['订单创建时间'].iloc[i]) == True
  66.         dt['订单付款时间'].iloc[i] = dt['订单付款时间'].iloc[i] + date.timedelta(days=1)     # 将订单付款时间 < 订单创建时间的时间数据往后加1天(因为原数据中没有考虑日期差异情况)  
  67.  
  68. mu = np.mean(dt['订单付款时间']-dt['订单创建时间'])       # 计算时间差的均值,用于之后进行缺失值替换 
  69.  
  70. for i in range(0,dt.shape[0]): 
  71.     if pd.isnull(dt['订单付款时间'].iloc[i]) == True:    # 进行缺失值填补 
  72.         dt['订单付款时间'].iloc[i] = dt['订单创建时间'].iloc[i] + mu 
  73.  
  74. display(sum(dt.isnull().sum()))                         # 再次检查数据集是否有缺失值,发现已经处理完了,但是还要检查是否增加正确 
  75.  
  76. display(dt.duplicated().sum())                          # 再次检查数据是否有重复值,发现并没有重复值,发现也没有重复值 
  77.  
  78. # 描述性分析 
  79.  
  80. display(dt['总金额'].describe())                        # 查看订单总金额的情况,发现最大的订单价格达到了188320元,最小的则只有1元,平均订单价为107元左右 
  81.  
  82. sum(dt['买家实际支付金额']==0) / dt.shape[0]             # 查看买家实际支付金额为0(也就是支付未完成)的订单比例,占比约为32.3% 
  83.  
  84. display((dt['订单付款时间']-dt['订单创建时间']).describe())     # 查看订单付款时间相比于订单创建时间的延迟情况,发现最慢的支付延迟了接近1天,而大部分订单在10分钟内就完成了支付 
  85.  
  86. siz = dt.groupby(dt['收货地址']).size()                 # 对收货地址进行分组统计 
  87. idx_sort = np.argsort(-siz)                            # 对分组统计的结果进行降序排序 
  88. display(siz[idx_sort].head())                          # 查看降序排序的结果的前5名,发现收货地址选择上海、广东、江苏、浙江、北京的最多 
  89. siz[idx_sort].tail()                                   # 查看降序排序的结果的最后5名,发现收货地址选择湖北、新疆、宁夏、青海和西藏的最少,其中湖北可能受疫情影响所致 
  90.  
  91.  
  92.  
  93. ### 建模预处理 ### 
  94.  
  95. # 特征构建 
  96.  
  97. d1 = (dt['订单付款时间']-dt['订单创建时间'])            # 输出订单付款和创建之间的时间差,作为一个新变量 
  98. d1 = (d1 / np.timedelta64(1, 's')).astype(int)        # 将时间差的格式进行转换,转换为按秒计数,并把格式变为int类型 
  99.  
  100. le_train = LabelEncoder()                             # 使用从sklearn.preprocessing中import的LabelEncoder对分类数据进行编码,以便于后续使用交叉验证建模  
  101. le_train.fit(dt['收货地址'].tolist())                  # 对模型进行训练 
  102. d2 = le_train.transform(dt['收货地址'].tolist())       # 转化数据,作为第2个变量 
  103.  
  104. d3 = np.zeros(dt.shape[0])                            # 构建一个全为0的数组 
  105.  
  106. for i in range(0,dt.shape[0]): 
  107.     if (dt['总金额'].iloc[i]-dt['买家实际支付金额'].iloc[i]) == dt['退款金额'].iloc[i]: 
  108.         d3[i] = 1                                     # 生成一个新变量(类别变量),当买家有支付(无论退不退款)时为1,没有支付时为0(无支付时上述等式不成立,实际支付金额和退款金额均为0),表明支付的情况 
  109.  
  110. dt_use = np.vstack((d1,d2,d3)).T                      # 生成用于建模分析的数据集,np.vstack用于数组的垂直连接    
  111.  
  112. # 数据集划分 
  113.  
  114. x_train,x_test, y_train, y_test = train_test_split(dt_use[:,0:2],dt_use[:,2:3],test_size=0.25, random_state=0)     # 使用从sklearn.model_selection中import的train_test_split函数进行训练集、测试集的划分 
  115.  
  116. print('训练集的自变量数据的维度',x_train.shape) 
  117. print('训练集的因变量量数据的维度',x_test.shape) 
  118. print('测试集的自变量数据的维度',y_train.shape)           
  119. print('测试集的因变量数据的维度',y_test.shape)          # 查看数据集划分后的维度情况 
  120.  
  121.  
  122.  
  123. ### 数据建模 ### 
  124.  
  125. # 初始模型构建 
  126.  
  127. models = {}                                           # 构建一个models集合 
  128.  
  129. models['SVM'] = svm.SVC()                             # 支持向量机模型 
  130.  
  131. models['LDA'] = LinearDiscriminantAnalysis()          # LDA判别模型 
  132.  
  133. models['NB'] = MultinomialNB()                        # 朴素贝叶斯模型 
  134.  
  135. models['KNN'] = KNeighborsClassifier()                # KNN判别模型 
  136.  
  137. models['Detree'] = DecisionTreeClassifier()           # 决策树模型 
  138.  
  139. models['Network'] = MLPClassifier()                   # 神经网络模型 
  140.  
  141. # 模型训练与分析 
  142.  
  143. target_names = ['有支付','没有支付']                   # 生成类别的名称 
  144.  
  145. for key in models: 
  146.     models[key].fit(x_train,y_train)                  # 模型训练 
  147.     display(confusion_matrix(y_test,models[key].predict(x_test)))                                               # 对y_test进行预测,输出混淆矩阵 
  148.     print(classification_report(y_test,models[key].predict(x_test),target_names=target_names))                  # 对y_test进行预测,输出预测的分类评价 
  149.     print('\n'
  150.      
  151. # 模型调参(NB模型) 
  152.  
  153. param_grid_nb = {'alpha':[0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]}    # 设定贝叶斯模型中不同alpha值 
  154.  
  155. model_nb_ty = MultinomialNB()                          # 设定贝叶斯的模型 
  156.  
  157. kfold = KFold(10, 6)                                   # 采用10折交叉验证,初始随机起点为6 
  158.  
  159. grid = GridSearchCV(estimator=model_nb_ty,  
  160.                     param_grid=param_grid_nb, scoring='neg_mean_squared_error', cv=kfold)         # 设置网格搜索的模型 
  161.  
  162. grid_result = grid.fit(x_train, y_train)               # 利用构建好的模型对数据集进行训练,搜索最优的k值 
  163.  
  164. print('最优:%s 使用%s' % (grid_result.best_score_, grid_result.best_params_))                     # 输出最优的参数情况 
  165.  
  166. nb_model = MultinomialNB(alpha=0)                      # 根据模型调参的结果,重新设定朴素贝叶斯模型 
  167.  
  168. nb_model.fit(x_train,y_train)                          # 模型训练 
  169.  
  170. display(confusion_matrix(y_test,nb_model.predict(x_test)))                                        # 对y_test进行预测,输出混淆矩阵 
  171.  
  172. print(classification_report(y_test,nb_model.predict(x_test),target_names=target_names))           # 对y_test进行预测,输出预测的分类评价,发现并没有什么改进 

【编辑推荐】

  1. 盲目追“数据中台”,迟早药丸!
  2. 数据科学的现在与未来
  3. BI工具足以打造数据驱动型文化吗?
  4. 年中盘点:2020年炙手可热的10家数据科学和机器学习初创公司
  5. 调查发现商业智能和数据分析的应用在疫情期间发挥了重要作用
【责任编辑:未丽燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

实操案例:Jenkins持续交付和持续部署

实操案例:Jenkins持续交付和持续部署

微服务架构下的自动化部署
共18章 | freshman411

169人订阅学习

思科交换网络安全指南

思科交换网络安全指南

安全才能无忧
共5章 | 思科小牛

101人订阅学习

云计算从入门到上瘾

云计算从入门到上瘾

传统IT工程师的转型
共26章 | 51CTO阿森

256人订阅学习

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微