精华内容
下载资源
问答
  • 选择性搜索和多深度学习模型融合的目标跟踪.pdf
  • 深度学习模型融合正则化方法在高维数据特征筛选中的应用研究.pdf
  • 深度学习模型融合stacking

    千次阅读 2019-03-19 11:03:00
    当你的深度学习模型变得很多时,选一个确定的模型也是一个头痛的问题。或者你可以把他们都用起来,就进行模型融合。我主要使用stacking和blend方法。先把代码贴出来,大家可以看一下。 1 import numpy as np 2...

    当你的深度学习模型变得很多时,选一个确定的模型也是一个头痛的问题。或者你可以把他们都用起来,就进行模型融合。我主要使用stacking和blend方法。先把代码贴出来,大家可以看一下。

      1 import numpy as np
      2 import pandas as pd
      3 import matplotlib.pyplot as plt
      4 from sklearn.metrics import roc_curve
      5 
      6 SEED = 222
      7 np.random.seed(SEED)
      8 from sklearn.model_selection import train_test_split
      9 
     10 from sklearn.metrics import roc_auc_score
     11 from sklearn.svm import SVC,LinearSVC
     12 from sklearn.naive_bayes import GaussianNB
     13 from sklearn.ensemble import RandomForestClassifier,GradientBoostingClassifier
     14 from sklearn.linear_model import LogisticRegression
     15 from sklearn.neighbors import KNeighborsClassifier
     16 from sklearn.neural_network import MLPClassifier
     17 
     18 df = pd.read_csv('input.csv')
     19 
     20 def get_train_test():   # 数据处理
     21 
     22     y = 1 * (df.cand_pty_affiliation == "REP")
     23     x = df.drop(['cand_pty_affiliation'],axis=1)
     24     x = pd.get_dummies(x,sparse=True)
     25     x.drop(x.columns[x.std()==0],axis=1,inplace=True)
     26     return train_test_split(x,y,test_size=0.95,random_state=SEED)
     27 
     28 def get_models():   # 模型定义
     29     nb = GaussianNB()
     30     svc = SVC(C=100,probability=True)
     31     knn = KNeighborsClassifier(n_neighbors=3)
     32     lr = LogisticRegression(C=100,random_state=SEED)
     33     nn = MLPClassifier((80, 10), early_stopping=False, random_state=SEED)
     34     gb = GradientBoostingClassifier(n_estimators =100, random_state = SEED)
     35     rf = RandomForestClassifier(n_estimators=1,max_depth=3,random_state=SEED)
     36 
     37     models = {'svm':svc,
     38               'knn':knn,
     39               'naive bayes':nb,
     40               'mlp-nn':nn,
     41               'random forest':rf,
     42               'gbm':gb,
     43               'logistic':lr,
     44               }
     45     return models
     46 
     47 def train_base_learnres(base_learners,inp,out,verbose=True):    # 训练基本模型
     48     if verbose:print("fitting models.")
     49     for i,(name,m) in enumerate(base_learners.items()):
     50         if verbose:print("%s..." % name,end=" ",flush=False)
     51         m.fit(inp,out)
     52         if verbose:print("done")
     53 
     54 def predict_base_learners(pred_base_learners,inp,verbose=True): # 把基本学习器的输出作为融合学习的特征,这里计算特征
     55     p = np.zeros((inp.shape[0],len(pred_base_learners)))
     56     if verbose:print("Generating base learner predictions.")
     57     for i,(name,m) in enumerate(pred_base_learners.items()):
     58         if verbose:print("%s..." % name,end=" ",flush=False)
     59         p_ = m.predict_proba(inp)
     60         p[:,i] = p_[:,1]
     61         if verbose:print("done")
     62     return p
     63 
     64 def ensemble_predict(base_learners,meta_learner,inp,verbose=True):  # 融合学习进行预测
     65     p_pred = predict_base_learners(base_learners,inp,verbose=verbose)    # 测试数据必须先经过基本学习器计算特征
     66     return p_pred,meta_learner.predict_proba(p_pred)[:,1]
     67 
     68 def ensenmble_by_blend():   # blend融合
     69     xtrain_base, xpred_base, ytrain_base, ypred_base = train_test_split(
     70         xtrain, ytrain, test_size=0.5, random_state=SEED
     71     )   # 把数据切分成两部分
     72 
     73     train_base_learnres(base_learners, xtrain_base, ytrain_base)  # 训练基本模型
     74 
     75     p_base = predict_base_learners(base_learners, xpred_base) # 把基本学习器的输出作为融合学习的特征,这里计算特征
     76     meta_learner.fit(p_base, ypred_base)    # 融合学习器的训练
     77     p_pred, p = ensemble_predict(base_learners, meta_learner, xtest)  # 融合学习进行预测
     78     print("\nEnsemble ROC-AUC score: %.3f" % roc_auc_score(ytest, p))
     79 
     80 
     81 from sklearn.base import clone
     82 def stacking(base_learners,meta_learner,X,y,generator): # stacking进行融合
     83     print("Fitting final base learners...",end="")
     84     train_base_learnres(base_learners,X,y,verbose=False)
     85     print("done")
     86 
     87     print("Generating cross-validated predictions...")
     88     cv_preds,cv_y = [],[]
     89     for i,(train_inx,test_idx) in enumerate(generator.split(X)):
     90         fold_xtrain,fold_ytrain = X[train_inx,:],y[train_inx]
     91         fold_xtest,fold_ytest = X[test_idx,:],y[test_idx]
     92 
     93         fold_base_learners = {name:clone(model)
     94                               for name,model in base_learners.items()}
     95         train_base_learnres(fold_base_learners,fold_xtrain,fold_ytrain,verbose=False)
     96         fold_P_base = predict_base_learners(fold_base_learners,fold_xtest,verbose=False)
     97 
     98         cv_preds.append(fold_P_base)
     99         cv_y.append(fold_ytest)
    100 
    101         print("Fold %i done" %(i+1))
    102     print("CV-predictions done")
    103     cv_preds = np.vstack(cv_preds)
    104     cv_y = np.hstack(cv_y)
    105 
    106     print("Fitting meta learner...",end="")
    107     meta_learner.fit(cv_preds,cv_y)
    108     print("done")
    109 
    110     return base_learners,meta_learner
    111 
    112 def ensemble_by_stack():
    113     from sklearn.model_selection import KFold
    114     cv_base_learners,cv_meta_learner = stacking(
    115         get_models(),clone(meta_learner),xtrain.values,ytrain.values,KFold(2))
    116     P_pred,p = ensemble_predict(cv_base_learners,cv_meta_learner,xtest,verbose=False)
    117     print("\nEnsemble ROC-AUC score: %.3f" %roc_auc_score(ytest,p))
    118 
    119 def plot_roc_curve(ytest,p_base_learners,p_ensemble,labels,ens_label):
    120     plt.figure(figsize=(10,8))
    121     plt.plot([0,1],[0,1],'k--')
    122     cm = [plt.cm.rainbow(i)
    123         for i in np.linspace(0,1.0, p_base_learners.shape[1] +1)]
    124     for i in range(p_base_learners.shape[1]):
    125         p = p_base_learners[:,i]
    126         fpr,tpr,_ = roc_curve(ytest,p)
    127         plt.plot(fpr,tpr,label = labels[i],c=cm[i+1])
    128     fpr, tpr, _ = roc_curve(ytest, p_ensemble)
    129     plt.plot(fpr, tpr, label=ens_label, c=cm[0])
    130     plt.xlabel('False positive rate')
    131     plt.ylabel('True positive rate')
    132     plt.title('ROC curve')
    133     plt.legend(frameon=False)
    134     plt.show()
    135 
    136 from mlens.ensemble import SuperLearner
    137 def use_pack():
    138     sl =SuperLearner(
    139         folds=10,random_state=SEED,verbose=2,
    140         # backend="multiprocessing"
    141     )
    142     # Add the base learners and the meta learner
    143     sl.add(list(base_learners.values()),proba=True)
    144     sl.add_meta(meta_learner,proba=True)
    145     # Train the ensemble
    146     sl.fit(xtrain,ytrain)
    147     # Predict the test set
    148     p_sl=sl.predict_proba(xtest)
    149 
    150     print("\nSuper Learner ROC-AUC score: %.3f" % roc_auc_score(ytest,p_sl[:,1]))
    151 
    152 if __name__ == "__main__":
    153     xtrain, xtest, ytrain, ytest = get_train_test()
    154     base_learners = get_models()
    155 
    156     meta_learner = GradientBoostingClassifier(
    157         n_estimators=1000,
    158         loss="exponential",
    159         max_depth=4,
    160         subsample=0.5,
    161         learning_rate=0.005,
    162         random_state=SEED
    163     )
    164 
    165     # ensenmble_by_blend() # blend进行融合
    166     # ensemble_by_stack()   # stack进行融合
    167     use_pack()  # 调用包进行融合

     

    转载于:https://www.cnblogs.com/demo-deng/p/10557267.html

    展开全文
  • 写在前面的话:文章内容来源于但不限于网络、书籍、个人心得... 基于深度学习模型融合的工业产品(零部件)工艺缺陷检测算法简述 1、序言 随着信息与智能化社会的到来,工业产品生产逐渐走向智能化生产,极大地提...

    写在前面的话:文章内容来源于但不限于网络、书籍、个人心得体会等,意在总结和方便各位同行快速参考,共同学习进步,记录自己的问题。错误在所难免,有请各位批评斧正如有侵权,烦请第一时间通知,我会立即删除相关内容,万分感谢!

                     基于深度学习模型融合的工业产品(零部件)工艺缺陷检测算法简述

    1、序言

    随着信息与智能化社会的到来,工业产品生产逐渐走向智能化生产,极大地提高了生产力。但是随着工人大规模解放,产品或零部件的缺陷检测,一直不能实现自动检测。深度学习技术的出现,为这一领域带来了曙光,其高精度、高效率、升级维护简单等特点,使之在这一领域应用越来越广。

    说明:由于工作原因,不能开放相关源码。实际情况是,大部分源码都是修改而来,功底好一些的同学,可以自行实现。我讲的很清楚了,希望自己实现,拿来主义永远学不会。最后,文中参考了很多文章和论文,甚至有些大家都知道的话,直接粘贴复制的,因为那些仅仅是介绍单个模型,并不是本文核心内容,谢谢理解。加油,大家。

    2、数据集整理

    一般情况下,工业产品或零部件所获得的数据不是太多,因为大多数缺陷特征都极其微小,数据采集存在极大问题。在高分辨率相机帮助下盲拍,短时间可以获得大量图片,但是数据筛选存在极大问题。人工筛选,浪费时间和效率,但是有不可避免的进行清洗。况且,工业界高清缺陷数据集,也极其稀少。

    几百张的数据对深度卷积网络来说是远远不够的,而且数据分布是极不对称的。而且对特征是否明显来说,缺陷特征是最不明显的,在训练的时候更要进行格外关注。

    最后,数据采集的硬件设备,对检测结果也影响巨大。例如,相机的分辨率、补光设备等等。这里,不是咱们讨论的范围,假设已经取得了小部分缺陷图像。

    3、图像增强扩充

    上述现象不可避免,需要对每类特征图像进行原始增强,使其最低扩充到1000幅左右。比如常用的ImageDataGenerator工具,当然也可以自行编写脚本,请自行百度,资料众多。主要包括图像的旋转、平移、错切、旋转、拉伸、明暗度变化等等。

    拍摄图像的过程中,不可避免的出现整个场景图像过于巨大,那么就会导致缺陷特征局部化,也就是所占整幅图像比例较小,不利于特征提取。这种情况下,对图像进行卷积操作后,缺陷特征基本上不会检测提取到或者提取到的特征并不明显。解决办法之一是将场景图像进行有规则的切分,比如一个场景图像被切分成六份,可以横向或纵向或者对角线切分,或者切分成四份均可,依照实际情况进行。然后需要自己去做数据,赋以标签,当然Labelimg这个开源工具可以帮助你。

    在预测的时候,只要场景图像的四个或者六个子图像有一个是缺陷图像,就认为其是缺陷图像。这样做的好处是,在一定程度上避免了特征过于局部化。这是我能想到的方法之一,当然业界可能有很多方法,这个比较简单粗暴。但是实际效果还不错。

    4、融合模型架构

    采用的架构如下:

                                                                                           图1 模型融合架构

    对上图进行解释。数据层当然就是整理后的数据集,数据集的质量决定了后面的所有事情,所在制作的时候一定要认真,废话不多说。分发层,只是原来单个网络的输入层。这一层的目的,就是为了向各个单个网络输入数据。因为每个网络对数据输入要求是不一样的,这一层就干了这一件事情。接下来就是“隐藏”网络层,这一层就是“并行”连接了网络,分而治之。尺寸统一层,就是将各个网络输出的特征图进行修饰,主要是尺寸上进行修改。空白层,这一层的目的是进一步梳理特征信号,进一步处理,比如添加合适的比例放大特征图等等,当然,这只是初步的想法,还没有实际去做。不可否定的是,工业与学术界肯定有更好的方法,这是以后的工作优化内容。特征相加层,就是将得到的统一的特征“点加”,增强特征的表现形式,处理微小特征的方法。最后是全连接层,用于分类与回归,最后是输出结果。当然,中间的损失层之类的没有说,但是并不代表不存在,钻牛角尖得人退避。

    对工业缺陷零件来说,缺陷特征非常细微或者说不明显,通常仅仅一小块区域存在特征,而且高度相似。对于“隐藏层”选择的相关网络,首先,是专注于特征提取,因为特征提取是整个网络的关键所在,其次,要考虑把浅层特征和深度特征进行融合,这样的话结合图像切分,就不会造成主要特征丢失,或者说尽量降低特征的内部损耗。常见的特征提取网络有VGG16、ResNet、DenseNet、Inception-ResNet-V2等等这些,但是笔者复现过得网络只有VGG与ResNet,经过论文以及相关资料,DenseNet效果可能要更好些,留作近期工作内容。

    5、融合模型训练

    选取不同的缺陷数据,数据尽量不要完全相同,这样可以增加模型的丰富度,更有利于提取相关特征。与“隐藏层”相对应训练几个不同的模型,比如训练出四个模型分别对应于ResNet、DenseNet、Inception-ResNet-V2、VGG四个网络。当然,根据你选择的模型进行对应即可,灵活度极高。

    训练完成后,把这四个模型输入层与全连接层去除,仅仅使用这四个模型的相关卷积层进行特征提取,然后利用特征相加层进行特征拼接。拼接的时候注意,在channel方向上保持相同,也就是特征图的w和h必须相同。这是关键中的关键,也是特征统一层存在的意义,否则,特征非但没有增强,反而因为尺寸的问题导致精度下降,得不偿失。

    在对应位置上进行特征相加(点加),然后把这些特征进行汇总,重新建立四个网络,每个网络模型分别对应训练好的四个模型,提取训练好模型的参数,赋给新的模型,然后建立全连接层,这个时候只有一个全连接层。在训练的时候,新的网络只用来做特征提取,卷积层的参数不做训练,把这些网络参数冻结,只更新全连接层。

    对于上述中的特征融合,还有一种方法就是:用三个训练好的模型进行特征提取,然后建立一个MLP多层感知机类型的网络。训练好的模型去掉全连接层,只保存卷积层,做特征提取,并把产生的特征进行拼接,训练时只对全连接层进行更新。

    6、单个网络要点解析

    Inception-ResNet-V2的结构如下,细节请看参考文献,这里只是简单说一下。Inception-ResNet-v2,更加昂贵的混合Inception版本,同明显改善了识别性能。

     

                                                          图2 InceptionResNetV2整体架构(图片来源于网络)

    其中的stem部分网络结构如下,inception设计,并且conv也使用了7*1+1*7这种优化形式:

     

                                                                      图3 stem部分网络结构(图片来源于网络)

    inception-resnet-A部分设计,inception结构相当于加宽网络,也就是并行思想,这是本文灵感来源一。inception+残差设计为:

     

                                                                          图4 inception-resnet-A设计(图片来源于网络)

    通过将不同尺度的feature map进行融合,通过1*n卷积与n*1卷积来替代n*n卷积,从而有效地降低计算量,通过使用多个3x3卷积来代替5x5卷积和7x7卷积来降低计算量。另外在inception resnet v2中将resnet与inception 的网络结构来进行融合,从而进一步提升在 imagenet上的accuracy。咱们文章的灵感来源二也来源于此,特征融合,只是咱们融合了模型以及特征图。说一句没必要的废话,slim库中已经实现的inception-resnet-v2网络,所以以后网络应用更加简单了。

    VGG16网络,我接触的比较早了,研究生期间就使用了。读研的时候做了基于Faster R-CNN的高铁定位器识别,当初就是用的VGG网络而不是ZF网络。VGG16相比前辈AlexNet网络做了诸多改进,其中比较主要的是采用连续的几个3x3的卷积核代替AlexNet中的较大卷积核(11x11,7x7,5x5),对于给定的感受野(与输出有关的输入图片的局部大小),采用堆积的小卷积核是优于采用大的卷积核,因为多层非线性层可以增加网络深度来保证学习更复杂的模式,而且代价还比较小,参数更少,节省算力。

    简单来说,在VGG中,使用了3个3x3卷积核来代替7x7卷积核,使用了2个3x3卷积核来代替5*5卷积核,这样做的主要目的是在保证具有相同感知野的条件下,提升了网络的深度,在一定程度上提升了神经网络的效果。话题拉回来,本文灵感来源三就是VGG训练过程,VGG有六种结构或者说有六个阶段的训练过程。分别是A、A-LRN、B、C、D、E六种,训练时,逐层递归训练,由浅入深,思路清晰。训练的方式也对本文产生了影响,冻结卷积层参数,只更新全连接层参数。最后,经过证明D、E两个模型融合,效果最佳。

     

                                                                          图5 VGG16结构图(图片来源于网络)

     ResNet(Residual Neural Network)由微软研究院的Kaiming He等四名华人提出,通过使用ResNet Unit成功训练出了152层的神经网络,并在ILSVRC2015比赛中取得冠军,在top5上的错误率为3.57%,同时参数量比VGGNet低,效果非常突出。ResNet的结构可以极快的加速神经网络的训练,模型的准确率也有比较大的提升。同时ResNet的推广性非常好,甚至可以直接用到InceptionNet网络中。

    ResNet的主要思想是在网络中增加了直连通道,即Highway Network的思想。此前的网络结构是性能输入做一个非线性变换,而Highway Network则允许保留之前网络层的一定比例的输出。ResNet的思想和Highway Network的思想也非常类似,允许原始输入信息直接传到后面的层中,如下图7所示。

    CNN能够提取low/mid/high-level的特征,网络的层数越多,意味着能够提取到不同level的特征越丰富。并且,越深的网络提取的特征越抽象,越具有语义信息。既然这样,为什么不能简单地堆叠网络层呢?因为存在梯度弥散或梯度爆炸。有没有解决方法呢?有,正则化初始化和中间的正则化层(Batch Normalization),但是,这样的话也仅仅可以训练几十层的网络。虽然通过上述方法能够训练了,但是又会出现另一个问题,就是退化问题,网络层数增加,但是在训练集上的准确率却饱和甚至下降了。这个不能解释为overfitting,因为overfit应该表现为在训练集上表现更好才对。退化问题说明了深度网络不能很简单地被很好地优化。

     

                                                                                  图6 ResNet结构(图片来源于网络)

     

                                                                               图7 不同的残差单元(图片来源于网络)

    DenseNet结构如下:

     

                                                                                图8  DenseNet结构(图片来源于网络)

    DenseNet脱离了加深网络层数(ResNet)和加宽网络结构(Inception)来提升网络性能的定式思维,从特征的角度考虑,通过特征重用和旁路(Bypass)设置,既大幅度减少了网络的参数量,又在一定程度上缓解了gradient vanishing问题的产生.结合信息流和特征复用的假设,是该网络新颖的地方

    对于本文四种网络,后续会根据实际测试情况,进行模型的更换与删减,具体情况只有实际测试才能知晓。

    7、融合损失函数

    Focal loss主要是为了解决one-stage目标检测中正负样本比例严重失衡的问题。该损失函数降低了大量简单负样本在训练中所占的权重,也可理解为一种困难样本挖掘。

    首先,二分类交叉上损失公式:

     

    可见普通的交叉熵对于正样本而言,输出概率越大损失越小。对于负样本而言,输出概率越小则损失越小。此时的损失函数在大量简单样本的迭代过程中比较缓慢且可能无法优化至最优。Focal loss的改进高明之处是:

     

    首先在原有的基础上加了一个因子,其中gamma>0使得减少易分类样本的损失。使得更关注于困难的、错分的样本。

    此外,平衡因子alpha的加入,用来平衡正负样本本身的比例不均:

     

    只添加alpha虽然可以平衡正负样本的重要性,但是无法解决简单与困难样本的问题。lambda调节简单样本权重降低的速率,当lambda为0时即为交叉熵损失函数,当lambda增加时,调整因子的影响也在增加。

    8、期望与问题

    关于融合模型的一些思考,欢迎大家讨论。其中的一些问题已经解决,说实话,每一点都可以形成一篇论文,大家参考。

    1. 分发层,内部机制是什么?统一分发,还是通道形式?是否需要放大?
    2. 网络“隐藏”层,模型间进行“某种连接”,是不是会产生特殊火花?
    3. 网络“隐藏”层,哪几种模型融合效果最好,增加,删减效果怎么样?
    4. 尺寸统一层,统一的方式,除了简单“比例拉扯”,有没有更好的方式?
    5. 特征相加层,点加最好?加上比例放大?比例多少?能学习吗?
    6. 模型融合,目标检测模型融合会更好吗?NLP是否有相关的研究?
    7. YOLOv3号称检测小目标(细微特征相对应)能力出色,是否相关思想可以借鉴?

    模型的融合并不是简单地堆叠,而是根据特征图尺寸这一核心思想进行重新设计计算。对单个模型的参数进行适当的修改,前提是架构不改变。充分利用每个模型的优点,摒弃缺点。其中最重要的就是砍掉了每个模型的全连接层,极大地降低了参数的数量。

    9、参考文献连接

    https://my.oschina.net/gyspace/blog/893788

    https://github.com/tzutalin/labelImg

    https://arxiv.org/abs/1602.07261

    https://arxiv.org/abs/1512.03385

    https://blog.csdn.net/u013709270/article/details/78838875

    https://www.cnblogs.com/skyfsm/p/8451834.html

    https://arxiv.org/pdf/1708.02002.pdf

    https://blog.csdn.net/amusi1994/article/details/81461968

    https://www.cnblogs.com/alanma/p/6877166.html

    https://blog.csdn.net/u013181595/article/details/80990930

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 深度学习模型决策融合的滚动轴承故障诊断.pdf
  • 融合浅层学习和深度学习模型的语音情感识别.pdf
  • 一种基于深度学习模型的数据融合处理算法.pdf
  • 基于Stacking融合深度学习模型和传统机器学习模型的短文本情感分类研究.pdf
  • 融合先验知识的深度学习模型快速训练方法.pdf
  • 深度学习融合不同模型的小样本表情识别深度学习融合不同模型的小样本表情识别深度学习融合不同模型的小样本表情识别深度学习融合不同模型的小样本表情识别深度学习融合不同模型的小样本表情识别
  • 基于深度学习模型的无线传感器网络数据融合算法.pdf
  • 基于融合深度学习模型的长鳍金枪鱼渔情预测研究.pdf
  • 一种基于Lasso回归与SVD融合深度学习模型压缩方法.pdf
  • 提出一种基于集成深度学习模型的情感状态检测方法.首先从脑电信号的时域、频域和时频域中提取4种表征情绪状态显著信息的初始特征;然后使用胶质细胞链改进的深度信念网络分别提取这些特征的高层抽象表示;最后利用判别...
  • 在分析传统文本内容安全识别方法的基础上,提出了利用深度学习的融合识别模型以及模型融合算法流程。深入介绍了基于利用深度学习的融合识别模型的文本内容安全识别系统,并进行了实验验证。结果表明,所提模型可以...
  • 模拟电路故障的深度学习融合模型诊断方法.pdf
  • 深度学习融合模型在机械故障诊断中的应用.pdf
  • 利用深度学习融合模型提升文本内容安全的研究.pdf
  • 图谱数据深度学习融合模型及焊缝缺陷识别方法.pdf
  • 可穿戴传感步态模式深度学习融合判别模型.pdf
  • 【keras】深度学习多输入模型融合

    千次阅读 热门讨论 2019-06-01 22:27:38
    最近想将多个模型训练不同特征,想看看是否能提高训练准确率,想要多模型融合,建议构建模型的方式用函数式 API的形式进行构建,即使用keras的Model() . 我的数据集形式是这样的:一行代表一个样本,每个样本有4个...

    最近想将多个模型训练不同特征,想看看是否能提高训练准确率,想要多模型融合,建议构建模型的方式用函数式 API的形式进行构建,即使用keras的Model() .
    我的数据集形式是这样的:一行代表一个样本,每个样本有4个特征,每个特征包含6000个数据,这样就是每行有24000个数据,其中0到5999是特征一的数据,6000到11999是特征二的数据,12000到17999是特征三的数据,18000到23999是特征三的数据。
    我预想的模型是这样的,特征一的数据输入到模型一中,特征二的数据输入到模型二中,特征三和特征四的数据输入到模型三中。总的结构图大致如下:
    在这里插入图片描述
    各个模型如下:
    模型一:

    first_inp=Input(shape=(100, 60, 1), name='md_1')
    base_model = VGG16(include_top=False, weights=None)(first_inp)
    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    x = Dense(1024, activation='relu')(x)
    x = Dense(3, activation='softmax')(x)
    

    模型二:

    second_inp=Input(shape=(6000, 1), name='md_2')
    l1=LSTM(32, return_sequences=True)(second_inp)
    l2=LSTM(32, return_sequences=True)(l1)
    l3=LSTM(32)(l2)
    d=Dense(3, activation='softmax')(l3)
    

    模型三:

    third_inp=Input(shape=(6000, 2), name='md_3')
    c1=Convolution1D(256, 5, activation='relu', input_shape=(6000,4))( third_inp)
    c2=Convolution1D(128, 5, activation='relu')(c1)
    p1=MaxPooling1D(3)(c2)
    c3=Convolution1D(128, 5, activation='relu')(p1)
    c4=Convolution1D(64, 5, activation='relu')(c3)
    p2=GlobalAveragePooling1D()(c4)
    d1=Dropout(0.5)(p2)
    d2=Dense(3, activation='softmax')(d1)
    

    这里,三个模型的输出分别是x,d1,d2 , 现在使用
    keras.layers.concatenate()方法进行融合:

    merger=concatenate([x, d, d2])
    

    我想再在后面加个全连接层:

    op=Dense(3, activation='softmax')(merger)
    

    最后,使用Model()函数生成一个完整的模型:

    model=Model(inputs=[first_inp, second_inp, third_inp], outputs=op)
    

    然后下面的部分就和普通的模型一样了:

    sgd=SGD(lr=0.001, nesterov=True, decay=1e-6, momentum=0.9)
    model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
    model.summary()
    nb_epoch=25
    model.fit([train1, train2, train3], y_train, nb_epoch=nb_epoch, validation_data=([valid1, valid2, valid3], y_valid), batch_size=256)
    

    弄的过程中,可能会遇到shape不对应的问题,那就需要多调试。

    【参考】

    1. https://stackoverflow.com/questions/43196636/how-to-concatenate-two-layers-in-keras/43196972
    2. https://blog.csdn.net/brucewong0516/article/details/79042292
    展开全文
  • 深度学习模型部署技术方案

    千次阅读 2020-07-12 17:13:55
    深度学习模型部署技术方案训练好的深度学习模型如何进行部署的相关技术方案1 什么是模型部署?2 数据科学项目整个开发流程3 使用flask 将 Keras深度学习模型部署为Web应用程序 训练好的深度学习模型如何进行部署的...

    训练好的深度学习模型如何进行部署的相关技术方案

    1 什么是模型部署?

    在典型的机器学习和深度学习项目中,我们通常从定义问题陈述开始,然后是数据收集和准备、数据理解和模型构建,对吧?
    但是,最后,我们希望我们的模型能够提供给最终用户,以便他们能够利用它。模型部署是任何机器学习项目的最后阶段之一,可能有点棘手。如何将机器学习模型传递给客户/利益相关者?模型的部署大致分为以下三个步骤:

    1. 模型持久化
      持久化,通俗得讲,就是临时数据(比如内存中的数据,是不能永久保存的)持久化为持久数据(比如持久化至数据库中,能够长久保存)。那我们训练好的模型一般都是存储在内存中,这个时候就需要用到持久化方式,在 Python 中,常用的模型持久化方式一般都是以文件的方式持久化。

    2. 选择适合的服务器加载已经持久化的模型

    3. 提高服务接口,拉通前后端数据交流

    2 数据科学项目整个开发流程

    在这里插入图片描述
    图的过程是一个数据科学项目所要经历的典型的过程。从数据采集开始,经历数据分析,数据变形,数据验证,数据拆分,训练,模型创建,模型验证,大规模训练,模型发布,到提供服务,监控和日志。诸多的机器学习工具如Scikt-Learn,Spark, Tensorflow, MXnet, PyTorch提供给数据科学家们不同的选择,同时也给模型的部署带来了不同的挑战。利用不同的开源框架进行构建训练的模型在部署时有着不同的方式。

    3 使用flask 将 Keras深度学习模型部署为Web应用程序

    在这里插入图片描述
    组成部分
    客户端: 工作流中的客户端可以是任何设备或第三方应用,用于向托管用于模型预测的架构的服务器发送请求。比如:Facebook 会在新上传的图像中尝试标记出你的脸部。
    负载均衡器: 负载均衡器用于通过集群中的多个服务器或实例将工作负载(请求)进行分布,目的是避免任何单一资源发生过载,进而将响应时间最小化、程序吞吐量最大化。在上图中,负载均衡器是面向公众的实体,会将来自客户端的所有请求分布到集群中的多台 Ubuntu 服务器上。
    Nginx: Nginx 是一个开源网络服务器,但也可以用作负载均衡器,其以高性能和很小的内存占用而著称。它可以大量生成工作进程,每个进程能处理数千个网络连接,因而在极重的网络负载下也能高效工作。在上图中,Nginx 是某个服务器或实例的本地均衡器,用于处理来自公共负载均衡器的所有请求。我们也可以用 Apache HTTP Server 代替 Nginx。
    Gunicorn: 这是一个 Python WSGI HTTP 服务器,移植自 Ruby 的 Unicorn 项目。它是 pre-fork worker 模式,意味着一个主线程会创建多个称为 worker 的子进程来处理请求。由于 Python 并非多线程,所以我们尝试创建多个 gunicorn worker,它们为单独进程且有各自的内存配置,以此来实现并行处理请求。Gunicorn 适用多种 Python 框架,我们也可以用 uWSGI 代替它。
    Flask: 一款用 Python 编写的微型 web 框架,可以帮我们开发响应请求的 API 或 web 应用。Flask 也是一个 Python 编写的 Web 微框架,可以让我们使用 Python 语言快速实现一个网站或 Web 服务。并使用方式和 Bottle 相似,Flask 依赖 Jinja2 模板和 Werkzeug WSGI 服务。Werkzeug 本质是 Socket 服务端,其用于接收 HTTP 请求并对请求进行预处理,然后触发 Flask 框架,开发人员基于 Flask 框架提供的功能对请求进行相应的处理,并返回给用户,如果返回给用户的内容比较复杂时,需要借助 Jinja2 模板来实现对模板的处理,即将模板和数据进行渲染,将渲染后的字符串返回给用户浏览器。
    Keras: 由 Python 编写的开源神经网络库,能够在 TensorFlow、CNTK 或 MXNet 上运行。Keras 也有一些替代选择:TensorFlow、Caffe、CNTK、PyTorch、MXNet、Chainer 和 Theano。

    参考实例:
    1 https://www.liangzl.com/get-article-detail-194875.html
    2 https://www.jianshu.com/p/fb4c56cec3d6
    3 http://www.atyun.com/32862.html
    4 https://zhuanlan.zhihu.com/p/34610834、
    实例代码:
    https://github.com/mtobeiyf/keras-flask-deploy-webapp

    RNN实例代码:https://github.com/WillKoehrsen/recurrent-neural-networks

    优点:部署简单,可以快速上手,适用于demo展示

    缺点:需要在服务器端安装所有依赖,多条并发请求需要启动做个线程推进,不同的模型需要启动不同的服务。

    4 TensorFlow Serving + Docker + Tornado机器学习模型生产级快速部署

    在这里插入图片描述
    一、简介
    当我们训练完一个tensorflow(或keras)模型后,需要把它做成一个服务,让使用者通过某种方式来调用你的模型,而不是直接运行你的代码(因为你的使用者不一定懂怎样安装),这个过程需要把模型部署到服务器上。常用的做法如使用flask、Django、tornado等web框架创建一个服务器app,这个app在启动后就会一直挂在后台,然后等待用户使用客户端POST一个请求上来(例如上传了一张图片的url),app检测到有请求,就会下载这个url的图片,接着调用你的模型,得到推理结果后以json的格式把结果返回给用户。
    这个做法对于简单部署来说代码量不多,对于不熟悉web框架的朋友来说随便套用一个模板就能写出来,但是也会有一些明显的缺点:

    1. 需要在服务器上重新安装项目所需的所有依赖。
    2. 当接收到并发请求的时候,服务器可能要后台启动多个进程进行推理,造成资源紧缺。
    3. 不同的模型需要启动不同的服务

    而为了解决第一个问题,Docker是最好的方案。这里举一个不是十分准确但是能帮助理解的例子:Docker在直觉上可以理解成为码头上的“集装箱”,我们把计算机系统比喻成码头,把应用程序比喻成码头上的货物,当集装箱还未被发明的时候,货物在码头上到处乱放,当要挑选某些货物的时候(执行程序),工人们到处乱找彼此干扰(依赖冲突),影响效率。如果把货物装在一个个集装箱里面,那么每个集装箱里面的货物整理就不会影响到其它集装箱。
    在这里插入图片描述
    Docker有两个重要概念,分别是image(镜像)和container(容器)。image可以理解成python中的类,container就是类的一个instance(实例)。我们把image pull到本地后,在这个image中启动一个container,然后我们就可以进入这个container里面做我们想做的事,例如配置环境,存放文件等等,这个过程可以形象地理解成我们买了一台新电脑,然后打开电脑装软件。
    在这里插入图片描述
    针对第二个问题,对于使用tensorflow、keras框架进行算法开发的用户来说,TensorFlow Serving能够很简单的
    把你的模型挂在服务器后台
    ,然后你只需要写一个客户端把请求发过去,它就会把运算后的结果返回给你。而TensorFlow Serving的最佳使用方式就是使用一个已经编译好TensorFlow Serving功能的docker,你所要做的只是简单的运行这个docker即可。(具体含义就是将模型以及模型的依赖环境都封装到一个docker之中)

    TensorFlow Serving还支持同时挂载多个模型或者多个版本的模型,只需简单地指定模型名称即可调用相应的模型,无需多写几份代码、运行多个后台服务。因此优势在于:

    1. 自动刷新使用新版本模型,无需重启服务。

    2. 无需写任何部署代码。

    3. 可以同时挂载多个模型。

    二、导出你的模型
    TensorFlow Serving只需要一个导出的tensorflow或keras模型文件,这个模型文件定义了整个模型的计算图,因此我们首先把一个训练好的模型进行导出。

    如果模型的输出还不是最终的结果,需要进行其它运算,请尽可能把后处理的操作都用tf或者keras的API写进计算图的节点里面,尽量使模型的预测结果就是最终的结果,否则需要在web的代码中对返回的结果进行其它处理。

    可以看到,TensorFlow Serving不需要其它环境依赖,只要tensorflow版本对了,导出的模型就能直接在TensorFlow Serving上使用,接收输入,返回输出,无需写任何部署代码。

    三、Docker
    1.安装docker
    TensorFlow Serving的安装推荐使用docker,所以必须先安装docker。
    2.安装nvidia-docker
    3.拉取TensorFlow Serving镜像

    四、运行TensorFlow Serving Docker
    五、Client客户端
    TensorFlow Serving启动后,我们需要用一个客户端来发送预测请求,跟以往请求不同的是,TensorFlow Serving使用的是gRPC协议,我们的客户端需要安装使用gRPC的API,以特定的方式进行请求以及接收结果。
    六、Tornado Web服务
    TensorFlow模型的计算图,一般输入的类型都是张量,你需要提前把你的图像、文本或者其它数据先进行预处理,转换成张量才能输入到模型当中。而一般来说,这个数据预处理过程不会写进计算图里面,因此当你想使用TensorFlow Serving的时候,需要在客户端上写一大堆数据预处理代码,然后把张量通过gRPC发送到serving,最后接收结果。现实情况是你不可能要求每一个用户都要写一大堆预处理和后处理代码,用户只需使用简单POST一个请求,然后接收最终结果即可。因此,这些预处理和后处理代码必须由一个“中间人”来处理,这个“中间人”就是Web服务。
    在这里插入图片描述
    我们使用Tornado框架来搭建我们的Web服务,Tornado是一个支持异步非阻塞的高性能Web框架,可以接收多个用户的并发请求,然后向TensorFlow Serving并发请求结果,并在其中承担所有的数据预处理、后处理任务。

    详细的教程信息见:https://zhuanlan.zhihu.com/p/52096200

    5 使用tensorflow serving部署keras模型(tensorflow 2.0.0)

    1 导出Keras模型
    keras模型训练完毕后,一般我们都会使用model.save(filepath)储存为h5文件,包含模型的结构和参数,而我们需要把这个h5文件导出为tensorflow serving所需要的模型格式:

    from keras import backend as K
    from keras.models import load_model
    import tensorflow as tf
    
    # 首先使用tf.keras的load_model来导入模型h5文件
    model_path = 'v7_resnet50_19-0.9068-0.8000.h5'
    model = tf.keras.models.load_model(model_path, custom_objects=dependencies)
    model.save('models/resnet/', save_format='tf')  # 导出tf格式的模型文件
    

    注意,这里要使用tf.keras.models.load_model来导入模型,不能使用keras.models.load_model,只有tf.keras.models.load_model能导出成tfs所需的模型文件。
    2 Docker部署模型
    一律使用docker来部署你的模型,如果还不知道docker是什么,不知道怎么用docker来拉取tfs的镜像,请查阅这篇文章:
    https://zhuanlan.zhihu.com/p/52096200
    这里默认你已经会拉取tfs模型到本地,现在执行以下容器启动命令:

    sudo nvidia-docker run -p 8500:8500 \
      -v /home/projects/resnet/weights/:/models \
      --name resnet50 \
      -itd --entrypoint=tensorflow_model_server tensorflow/serving:2.0.0-gpu \
      --port=8500 --per_process_gpu_memory_fraction=0.5 \
      --enable_batching=true --model_name=resnet --model_base_path=/models/season &
    

    3 请求客户端
    模型部署起来后,我们要写一个grpc客户端来请求模型,代码参考:

    from tensorflow_serving.apis import predict_pb2
    from tensorflow_serving.apis import prediction_service_pb2_grpc
    import grpc
    
    def request_server(img_resized, server_url):
        '''
        用于向TensorFlow Serving服务请求推理结果的函数。
        :param img_resized: 经过预处理的待推理图片数组,numpy array,shape:(h, w, 3)
        :param server_url: TensorFlow Serving的地址加端口,str,如:'0.0.0.0:8500' 
        :return: 模型返回的结果数组,numpy array
        '''
        # Request.
        channel = grpc.insecure_channel(server_url)
        stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
        request = predict_pb2.PredictRequest()
        request.model_spec.name = "resnet"  # 模型名称,启动容器命令的model_name参数
        request.model_spec.signature_name = "serving_default"  # 签名名称,刚才叫你记下来的
        # "input_1"是你导出模型时设置的输入名称,刚才叫你记下来的
        request.inputs["input_1"].CopyFrom(
            tf.make_tensor_proto(img_resized, shape=[1, ] + list(img_resized.shape)))
        response = stub.Predict(request, 5.0)  # 5 secs timeout
        return np.asarray(response.outputs["fc2"].float_val) # fc2为输出名称,刚才叫你记下来的
    

    tensorflow 2.0.0请使用以上这段代码,之前那篇tfs的部署文章里面的api已经变了。

    我们测试一下,读取一张图片,发送请求到tfs:

    from PIL import Image
    import numpy as np
    
    imgpath = '20171101110450_48901.jpg'
    x = Image.open(imgpath)
    x = np.array(x).astype('float32')
    x = (x - 128.) / 128.
    
    # grpc地址及端口,为你容器所在机器的ip + 容器启动命令里面设置的port
    server_url = '0.0.0.0:8500'  
    request_server(x, server_url)
    

    我们将会得到(我这里的resnet只输出4类多标签结果):

    array([0.58116215, 0.04240507, 0.74790353, 0.1388033 ])
    

    详细的文章内容:https://zhuanlan.zhihu.com/p/96917543

    6 Nvidia的TensorRT Inference Server

    如果你使用的是其它神经网络框架,例如caffe、pytorch,我会推荐Nvidia的TensorRT Inference Server,它支持所有模型的部署,包括TF系、ONNX系、mxnet等等,TRT会先对你的网络进行融合,合并可以同步计算的层,然后量化计算子图,让你的模型以float16、int8等精度进行推理,大大加速推理速度,而你只需要增加几行简单的代码就能实现。而且TRT Inference Server能够处理负载均衡,让你的GPU保持高利用率。
    在这里插入图片描述

    7 Clipper的架构

    在这里插入图片描述

    8 tensorflow serving 服务部署与访问(Python + Java)

    我的目标是使用tensorflow serving 用docker部署模型后,将服务暴露出来,分别在Python和Java中对模型进行访问。
    Tensorflow Serving 服务部署
    我直接用tensorflow serving docker部署的,直接按照官方的文档即可,唯一可能不同的是国内的网络问题,可以将下载和安装的步骤从dockerfile里面转移到登陆docker container去手动做。
    我的总体环境:
    tensorflow 1.3.0
    python 3.5
    java 1.8
    Tensorflow Serving 服务编写
    这里我训练了一个分类器,主要有三个分类,主要代码如下:

    #设置导出时的目录特征名
    export_time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))
    #为了接收平铺开的图片数组(Java处理比较麻烦) 150528 = 224*224*3
    x = tf.placeholder(tf.float32, [None, 150528])
    x2 = tf.reshape(x, [-1, 224, 224, 3])
    #我自己的网络预测
    prob = net.network(x2)
    
    sess = tf.Session()
    #恢复模型参数
    saver = tf.train.Saver()
    module_file = tf.train.latest_checkpoint(weights_path)
    saver.restore(sess, module_file)
    #获取top 1预测
    values, indices = tf.nn.top_k(prob, 1)
    #创建模型输出builder
    builder = tf.saved_model.builder.SavedModelBuilder(exporter_path + export_time)
    #转化tensor到模型支持的格式tensor_info,下面的reshape是因为只想输出单个结果数组,否则是二维的
    tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
    tensor_info_pro = tf.saved_model.utils.build_tensor_info(tf.reshape(values, [1]))
    tensor_info_classify = tf.saved_model.utils.build_tensor_info(tf.reshape(indices, [1]))
    #定义方法名和输入输出
    signature_def_map = {
            "predict_image": tf.saved_model.signature_def_utils.build_signature_def(
                inputs={"image": tensor_info_x},
                outputs={
                    "pro": tensor_info_pro,
                    "classify": tensor_info_classify
                },
                method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME
            )}
    builder.add_meta_graph_and_variables(sess,
                                          [tf.saved_model.tag_constants.SERVING],
                                             signature_def_map=signature_def_map)
    builder.save()
    

    可以使用python命令生成模型文件夹,里面包含了saved_model.pb文件和variables文件夹
    接着在container中可以新建一个文件夹,如serving-models,在文件夹下新建该模型文件夹classify_data,用来存放的模型文件夹,使用docker拷贝的命令拷贝模型到模型文件夹中:

    docker cp 本机模型文件夹 containerId:/serving-models/classify_data/模型版本号
    

    启动模型服务,监听9000端口:

    bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server --port=9000 --model_name=classify_data --model_base_path=/serving-models/classify_data/
    

    Python 客户端调用tensorflow serving 中的服务
    而是用pip install tensorflow-serving-client安装了一个第三方提供的库来访问tensorflow serving服务,python代码如下:

    import sys
    sys.path.insert(0, "./")
    from tensorflow_serving_client.protos import predict_pb2, prediction_service_pb2
    import cv2
    from grpc.beta import implementations
    import tensorflow as tf
    from tensorflow.python.framework import dtypes
    import time
    
    #注意,如果在windows下测试,文件名可能需要写成:im_name = r"测试文件目录\文件名"
    im_name = "测试文件目录/文件名"
    if __name__ == '__main__':
        #文件读取和处理
        im = cv2.imread(im_name)
        re_im = cv2.resize(im, (224, 224), interpolation=cv2.INTER_CUBIC)
        #记个时
        start_time = time.time()
        #建立连接
        channel = implementations.insecure_channel("你的ip", 9000)
        stub = prediction_service_pb2.beta_create_PredictionService_stub(channel)
        request = predict_pb2.PredictRequest()
        #这里由保存和运行时定义,第一个是运行时配置的模型名,第二个是保存时输入的方法名
        request.model_spec.name = "classify_data"
        #入参参照入参定义
        request.inputs["image"].ParseFromString(tf.contrib.util.make_tensor_proto(re_im, dtype=dtypes.float32, shape=[1, 224, 224, 3]).SerializeToString())
        #第二个参数是最大等待时间,因为这里是block模式访问的
        response = stub.Predict(request, 10.0)
        results = {}
        for key in response.outputs:
            tensor_proto = response.outputs[key]
            nd_array = tf.contrib.util.make_ndarray(tensor_proto)
            results[key] = nd_array
        print("cost %ss to predict: " % (time.time() - start_time))
        print(results["pro"])
        print(results["classify"])
    

    最终输出,例如:

    cost 5.115269899368286s to predict: 
    [ 1.]
    [2]
    

    Java 访问tensorflow中的服务
    像我一样用第三方库,我是用的是这个http://mvnrepository.com/artifact/com.yesup.oss/tensorflow-client/1.4-2
    在pom.xml下加入依赖:

            <dependency>
                <groupId>com.yesup.oss</groupId>
                <artifactId>tensorflow-client</artifactId>
                <version>1.4-2</version>
            </dependency>
            <!-- 这个库是做图像处理的 -->
            <dependency>
                <groupId>net.coobird</groupId>
                <artifactId>thumbnailator</artifactId>
                <version>0.4.8</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-netty</artifactId>
                <version>1.7.0</version>
            </dependency>
            <dependency>
                <groupId>io.netty</groupId>
                <artifactId>netty-tcnative-boringssl-static</artifactId>
                <version>2.0.7.Final</version>
            </dependency>
    

    Java代码:

    String file = "文件地址"
    //读取文件,强制修改图片大小,设置输出文件格式bmp(模型定义时输入数据是无编码的)
    BufferedImage im = Thumbnails.of(file).forceSize(224, 224).outputFormat("bmp").asBufferedImage();
    //转换图片到图片数组,匹配输入数据类型为Float
    Raster raster = im.getData();
    List<Float> floatList = new ArrayList<>();
    float [] temp = new float[raster.getWidth() * raster.getHeight() * raster.getNumBands()];
    float [] pixels  = raster.getPixels(0,0,raster.getWidth(),raster.getHeight(),temp);
    for(float pixel: pixels) {
        floatList.add(pixel);
    }
    
    #记个时
    long t = System.currentTimeMillis();
    #创建连接,注意usePlaintext设置为true表示用非SSL连接
    ManagedChannel channel = ManagedChannelBuilder.forAddress("192.168.2.24", 9000).usePlaintext(true).build();
    //这里还是先用block模式
    PredictionServiceGrpc.PredictionServiceBlockingStub stub = PredictionServiceGrpc.newBlockingStub(channel);
    //创建请求
    Predict.PredictRequest.Builder predictRequestBuilder = Predict.PredictRequest.newBuilder();
    //模型名称和模型方法名预设
    Model.ModelSpec.Builder modelSpecBuilder = Model.ModelSpec.newBuilder();
    modelSpecBuilder.setName("classify_data");
    modelSpecBuilder.setSignatureName("predict_image");
    predictRequestBuilder.setModelSpec(modelSpecBuilder);
    //设置入参,访问默认是最新版本,如果需要特定版本可以使用tensorProtoBuilder.setVersionNumber方法
    TensorProto.Builder tensorProtoBuilder = TensorProto.newBuilder();
    tensorProtoBuilder.setDtype(DataType.DT_FLOAT);
    TensorShapeProto.Builder tensorShapeBuilder = TensorShapeProto.newBuilder();
    tensorShapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(1));
    #150528 = 224 * 224 * 3
    tensorShapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(150528));
    tensorProtoBuilder.setTensorShape(tensorShapeBuilder.build());
    tensorProtoBuilder.addAllFloatVal(floatList);
    predictRequestBuilder.putInputs("image", tensorProtoBuilder.build());
    //访问并获取结果
    Predict.PredictResponse predictResponse = stub.predict(predictRequestBuilder.build());
    System.out.println("classify is: " + predictResponse.getOutputsOrThrow("classify").getIntVal(0));
    System.out.println("prob is: " + predictResponse.getOutputsOrThrow("pro").getFloatVal(0));
    System.out.println("cost time: " + (System.currentTimeMillis() - t));
    

    结果打印如下:

    classify is: 2
    prob is: 1.0
    cost time: 6911
    

    具体详细内容:https://blog.csdn.net/shin627077/article/details/78592729
    https://blog.csdn.net/luoyexuge/article/details/79826141?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-2
    https://blog.csdn.net/qq_41375318/article/details/107253654

    其他企业级AI开发平台

    1. 腾讯 Angel平台
    2. 华为Mindspore
    3. 海康威视 Hikflow
    4. 用于Java的DeepLearning4j
    5. 知乎的Jeeves
    展开全文
  • 深度学习中关于模型融合问题

    千次阅读 2019-10-08 16:44:45
    模型融合即Ensemble Generation,指的是将多个不同的Base Model组合成一个Ensemble Model的方法。它可以同时降低最终模型的bias和Variance。从而在提高分数的同时又降低过拟合的风险。 常见的Ensemble方法有以下几...
  • 一篇很不错的关于如何调整深度学习模型参数的博客
  • 点云数据由无序的数据点构成的一个集合;...点云数据处理方式,通常有:将点云数据投影到二维平面(多视图法)、将点云数据划分到有空间依赖关系的voxel(体素法)、直接在点云数据上应用深度学习模型(点云法)。
  • 随着人工智能和物联网的快速发展与融合, 智能物联网AIoT 正成长为一个极具前景的新兴前 沿领域, 其中深度学习模型的终端运行是其主要特征之一。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,763
精华内容 21,505
关键字:

深度学习模型融合