促销敏感度模型
 
1.对于租凭公司平台而言，全范围的促销投放和对所有用户发放优惠券之类的，的确可以得到不错的效果，比如2019年的春节，公司通过对所有老用户发放优惠券，成功争取到了1000多订单。但是如果想进一步提高销售额的话，就需要公司对消费者进行更精细化的运营，对不同促销敏感度的用户，进行精确的营销，差别化发放优惠券，促销效果必然会事半功倍。就像公司里，春节时期，即使都是处于满租情况，但是如果精确话营销的话，销售额会提升很多。
 
2.数据准备
 
衡量电商的消费者是否对促销敏感，主要是通过他的历史订单里促销优惠的比例来判断。一般我们认为，用户的含促销订单比例越高，敏感度越高；促销金额比例越大，敏感度越高。
 
a.时间范围：查询每个消费者的1年内的数据，敏感度具有时效性，随着年龄和收入的增长，敏感度也会发生变化，以一年为临界点更具代表性。
 
b.订单单量数据：提取用户订单数据，计算一年内的订单总数和用户参与优惠的订单数。这里的优惠可以是满减，满赠或者使用优惠券的订单。
 
c.订单价格数据：汇总用户所有订单未优惠前总价格，汇总用户所有订单参与优惠的总金额，价格数据可以用np.log()将其偏态分布转为比较标准的正态分布
 
3.处理好的数据字段
 
       a.优惠订单占比
 
       b.平均每单优惠金额占比
 
       c.优惠金额与总金额占比
 
4.模型
 
通用型：将敏感度，划分6个等级。极度敏感，较敏感，一般敏感，较不敏感，极度不敏感。然后使用k-mean聚类将其分成6个类别。此敏感度模型输入，其相似点是优惠订单占比，统计三个数据字段的指标之和。三者之和越小，代表价格敏感度越低。然后根据每个用户的订单数据情况，每个指标我们都会得到一个预测值，这个值在你标准化后的值之间，当预测值未负的时候，我们可以理解为对价格不敏感。然后我们就得到了以下的数据。
 
 
然后可以根据业务需求，去定敏感度划分，例如可以把小于0的定位不敏感，在0和1之间的为一般敏感，大于1的为敏感用户。
 
购买力模型
 
1.消费者购买力，是指消费者购买商品的能力。在一定时期内，能够反映他的消费水平和消费层级。购买力模型属于用户画像的一部分，是区分人群和定义用户身份的其中一项标签。模型具有实效性，数据是动态变化的。
 
2.数据和模型
 
衡量一个用户购买力高低需要在不同类别商品下进行分析的。例如：一个用户在服装上花费很少，购买的衣着大都是平民价位的商品，但是在摄影和相机方面上花费甚高。针对这问题，可以建立不同商品的购买力模型。比如衣着-购买力模型，化妆品-消费模型之类的。或者也可以针对不同类目进行权重分配，然后统计总的用户购买力模型。
 
a.用户的订单数据
 
                  消费者在不同种类商品下购买的商品价格，反应了在此品类下的消费能力和水平。统计用户购买同一类商品（例如：化妆品）高中低各价格段的比列，生成三个数据字段（根据业务要求进行价格区间的划分）。可以直接根据这些数据字段进行一个聚类（k-mean或dbscan）来划分用户在这类商品的购买力。
 
3.实践
 
本身在租凭行业，产品比较单一，因此只需要考虑同一种类商品就行。在特征工程上，先将商品根据业务要求进行了价格划分，分别计算了其不同程度的占比（比例情况）。再此基础上，我加了一个数据字段--adr（日订单均价），然后用k-mean进行了聚类。得出的模型结果，可以根据业务要求进行调整，或者根据实际的分类结果进一步优化。
 
购物决策模型
 
1.此模型所依赖的衡量标准是用户购买商品或者下单过程产生的行为来刻画的。可以根据业务需要，将用户购买商品的决策划分为购物冲动型、海淘犹豫型和理想比较型等。此模型标签作用：统计不同购物人群的比列，用于营销活动的设计或者产品的设计。
 
2.数据和模型
 
主要的数据类型：用户完成订单前的浏览时间、浏览SKU数量（SKU就是相当于一款商品，但是例如同款多色的话，SKU是不同）、订单是否取消、订单付款时间和下单时间的差值等有关的特征进行聚类。
 
PS:因为用户的购物决策是有时效性的，在取数据时，根据行业和业务需求，取最近一年或相关时间的数据。
 
品类综合偏好度
 
1.品类偏好度是用户通过搜索、浏览、关注、购买品类商品的次数、频率这些特征，来计算对品类的权重，最后用户与用户会有个纵向比较。例如：计算某款车型的偏好。取最近一段时间订单里该款车型的占比，再与其他用户进行纵向比较。
 
2.数据和模型
 
偏好度不需要一些机器学习的知识，只要简单的统计次数占比，再进行一个纵向比较，即可完成用户对某款商品的偏好度。
 
用户价值模型
 
1.一个很经典的RFM模型，根据在某一段时间内，用户最近的消费间隔，消费次数和消费金额，再根据k-mean结合，对用户价值的一个划分。每个数据字段划分高、低的话，共分8类用户，如下图所示：
 
 
2.注意一点，不仅仅可以局限于这三个数据字段，可以根据业务需求，加入某些字段，进行调整模型。
 
用户活跃度模型
 
1.跟RFM模型很相似的RFE模型，是根据最近一次访问时间R（ Recency）、访问频率 F（Frequency）和页面互动度 E（Engagements），在根据k-mean，进行划分的的一种模型。
 
              a.最近一次访问时间 R（ Recency）： 会员最近一次访问或到达网站的时间。 
 
              b.访问频率 F（ Frequency）：用户在特定时间周期内访问或到达的频率。
 
              c.页面互动度 E（ Engagements）：互动度的定义可以根据不同企业或行业的交互情况而定，例如可以定义为页面 浏览时间、浏览商品数量等。 
 
             PS：在RFE模型中， 由于不要求用户发生交易， 因此可以做未发生登录、 注册等匿名用户的行为价值分析， 也可以做 实名用户分析。 该模型常用来做用户活跃分群或价值区分。

最近一段时间都在学习深度学习，想着在用户画像标签模型中看能不能用上，终于，用了一个多月的时间，结合实际的场景和数据，搭建了一套“孕妇标签”的深度学习模型。这篇文章重点介绍了在用户画像标签模型中运用深度学习建模的过程中，我们遇到的一些问题，以及其中的一些体会和思考，对于深度学习的一些基础概念和模型，文章没有过多的介绍。另外，自己也属于深度学习的入门阶段，若有理解有误的地方，欢迎大家指正。
什么是用户画像标签



 
基于用户事实数据，进行一定抽象后的用户特征表示

拿电商为例，用户的购物性别，年龄，消费能力等都是用户画像的标签。这些标签能帮助我们理解用户，将用户进行归类，进一步进行个性化运营，例如针对高消费人群，那我们可以展示比较有品味的服装给用户。
标签建模的方法


标签建模有什么方法？可分为两大类:
人工建模
凭借经验，对标签定义一个数据描述口径，通过大数据ETL跑出标签结果，再逐步通过调整口径达到运营可接受的模型。
机器建模
通过机器对标签样本数据的多维度学习，建立机器自学习的标签模型，可通过对样本数据的调整以及模型结构及参数的调整来逐步优化模型。
两种建模方式各有优缺点，这里介绍如何运用深度学习进行机器建模。
下面以“孕妇标签”为例(电商场景下)，我们是怎样一步步完成深度学习建模的。
简陋的模型


一开始思路很简单，将用户的各个品类购买行为做为模型训练的特征，并通过对品类划分中挑出和孕妇明显相关的品类(例如孕期护理，孕妇装，高跟鞋，彩妆等)，通过某些品类的购买行为筛选出训练正负样本，例如按一年统计用户对各个品类的购买次数，若孕妇相关品类购买次数超过5次，则标识为正样本，若高跟鞋，彩妆类购买次数超过5次，则标识为负样本。
正负样本，模型训练需要的特征数据都有了，最简单的就是构造一个浅层神经网络模型，将数据丢给模型，看看模型能否自我训练学习，这就是模型最初的样子：

这个版本的模型直接用Keras构造，非常简单，也可以直接看到实时训练的情况。准备了5万的样本训练数据，大概几分钟就可以发现模型的Training accuracy和Validate accuracy都达到了0.9以上，可以试试模型的效果，但要再找出一批已知是否孕妇的数据，是个大难题，所以比较直接的就是找了几个(女)同事的帐号，虽然测试数量少，但比较有代表性，很容易发现模型的问题: 对于几个月前是孕妇，现在已经是妈妈的情况，没有准确的识别出来。想想，因为模型输入的数据是过去一年的购买记录，模型无法感知数据在时间维度上的变化。
时序模型


由于孕妇标签的时间敏感性，模型中需要考虑时间维度，比如6个月前有购买过孕妇类，最近2个月已经不再买了，而是开始买婴幼品类的商品，这个说明现在已经不再是孕妇了，应该打上新生妈妈的标签了。
因此，首先在模型的特征维度上需要将一年的购买行为按时间间隔(月)拆开，同时将用户的购买行为数据放在一个时间轴上，这样可以提供更立体的特征数据给模型训练，于是我们选用了可以感知时序数据的RNN模型，对用户某段短时间内的购买行为综合分析学习，这样模型更容易准确地判断出孕妇标签。
比如，用户购买平底鞋这个行为，一般情况下，对孕妇标签的判断没有太大的作用，但如果用户购买平底鞋的时候，还买了孕妇裤，这就不同了，购买平底鞋这个行为就变得和孕妇行为相关了，和标签结果就有一定的相关性。就是因为加上用户前后购买行为这个Context，而让数据更立体，更丰富，模型对标签的判断也就更准确。

模型的特征是用户每个月对各个品类的购买次数，比如我们对最近18个月的，2000个品类进行统计，得到18*2000的矩阵，作为一个用户的特征表示，所以模型的inputs维度是：user_num * months * categorys (e.g. 10000 * 18 * 2000)，output targets维度是：user_num * 1 (e.g. 10000 * 1)
模型采用LSTM，对LSTM的最后一个output通过sigmoid映射到[0,1]后和target对比，计算得出cost函数。
模型训练完后，再用测试数据校验了下，已经可以准确区分出新生妈妈和孕妇了。
但这个模型的输入特征不够丰富，用户的行为除了购买之外，点击行为也是放进来，让学习维度更加丰富。
多时序模型


从用户的浏览->点击->购买这个转化漏斗可以知道，用户的点击行为远比购买行为更频繁。以月为单位，一个用户在某个品类的购买次数一般为1次，很少超过10次。但点击不同，如果以月为单位统计，点击的数量会很大，这样会有什么问题？
假设按自然月统计，如果一个用户在1号那天就对某个品类点击次数达到10次，我们知道用户对这个品类是有偏好的，但如果放到1个月统计这个维度，10次可能还没达到模型认为有强相关的程度。换句话说，就是模型无法实时感知到用户的偏好变化。
所以，针对点击行为，我们得采用以天为单位统计用户在各个品类下的点击次数，作为模型的输入。这样就出现了购买行为和点击行为的两套时序模型，他们的时间维度不同，不能放在一套LSTM模型里，只能分开两套，再通过一层fully connected layer，将两套LSTM的输出作为这层的输入，得到最终的模型结果。

模型调优


结合点击和购买时序行为的模型，使用样本的筛选规则得到的数据，都可以准确的识别出结果，但模型的泛化能力如何，会不会overfit，由于缺乏更丰富的数据样本，并不好验证这点。
所以，对于模型的评估，我们采取人工伪造数据的方式来校验，比如将训练样本中的购买数据全部抹掉，这样用一份只有点击的数据来校验模型对点击行为的学习能力；再比如将训练样本中强孕妇相关品类的购买，点击数据抹掉，来验证模型对其他“潜在”的相关维度的学习能力。
值得一提的是，模型的训练样本是按照一定的规则进行人工筛选标注完成的，而筛选的条件同时也是模型的学习维度中的一部分，这意味着模型很容易学习到这些“人工设定”的规则，而忽略那些“潜在”的维度和结果之间的相关性。模型容易出现“Memorize more than Learning”，也就是缺失泛化能力。
如何提高模型的泛化能力：
减少Hidden Size，降低模型记忆单元数
增加Dropout，通过随机抹掉部分hidden layer的节点，类似通过让模型变得简单，同时通过将多个简单的模型的结果综合起来，达到提高泛化能力的目的
采用L2 Regularizer，通过对权重的惩罚，来提高模型泛化能力
提供更丰富的训练样本，让模型接触更多不一样的数据
体会和思考


深度学习模型更像一个黑盒子，无法通过因果关系进行逻辑推导，而只能通过不同的数据不断从外部试探，理解模型
人的很多特征都是会随着时间变化的，用户画像的标签建模是需要考虑好时间维度的数据
用户画像标签模型的数据样本获取成本大，通过规则筛选的数据，不够丰富，容易导致模型泛化能力差

这篇主要讲一下模型预测控制，如果对PID控制了解的同学，那效果更好。如果不了解PID控制，还是熟悉下比较好。
 
模型预测控制，顾名思义，基于模型，预测未来，进行控制。这个控制是基于模型的，也就是model-based。
 
有人会问，我这个系统的模型怎么来呢？我想到两点解决方法：
 
1. 文献上去找别人已经建好的，公认的模型；
 
2. 首先进行系统辨识，再进行建模。（难度太大，不建议）
 
下面给上经典的MPC控制流程图：
 
 
模型预测控制是一种基于模型的闭环优化控制策略。
 
预测控制算法的三要素：内部（预测）模型、参考轨迹、控制算法。现在一般则更清楚地表述为内部（预测）模型、滚动优化、反馈控制。 
 大量的预测控制权威性文献都无一例外地指出, 预测控制最大的吸引力在于它具有显式处理约束的能力, 这种能力来自其基于模型对系统未来动态行为的预测, 通过把约束加到未来的输入、输出或状态变量上, 可以把约束显式表示在一个在线求解的二次规划或非线性规划问题中. 
 模型预测控制具有控制效果好、鲁棒性强等优点，可有效地克服过程的不确定性、非线性和并联性，并能方便的处理过程被控变量和操纵变量中的各种约束。[1]
 
在线性模型预测控制（Linear Model Predictive Control, LMPC）的基础上，发展了非线性模型预测控制（Non-linear Model Predictive Control, NMPC），显示模型预测控制（Explicit Model Predictive Control, EMPC）和 鲁棒模型预测控制（Robust Model Predictive Control）
 
首先，我们定义一个模型来描述我们的车辆。[2]
 
 
这是自行车模型，运动学上面经常使用。
 
（x, y）是车辆的质心，ψ是当前车身的角度，v是当前车辆的速度，lf是当前车辆质心到原点的距离， β是速度和车身的角度。在我们的例子中，我们假设β为零，也就是没有侧滑。
 
在我们的模型中，我们可以通过控制前轮的转角δf 以及车辆的加速度a来控制车辆轨迹。简单起见，我们只考虑前轮驱动的车辆，并且将δf记作δ。
 
  模型预测控制的细节
 
每个控制周期，我们都从传感器读取数据并得到车辆状态量：
 
 
车辆的位置（x，y）
 
 
速度v
 
 
车身角度 ψ
 
 
转向角（舵角） δ
 
 
加速度a
 
轨迹模型：
 
我们的道路检测系统应该能够为我们规划好路线，比如，以接下来6个航点的坐标的形式。在我们的例子中，我们使用6个航点去逼近一个3阶多项式函数。我们用这个模型去计算y坐标和相对于x轴的车身角度ψ。
 
 
轨迹模型一般有规划模块给出，在这里就不做深入的研究。
 
动态模型：
 
接下来，我们要创建动态模型利用t时刻的状态去预测在t+1拍时刻的车辆状态。利用动力学模型，我们可以轻易地从最新时刻地采样推导出下一时刻的位置，车身角度和速度。
 
 
我们可以在添加另外2个状态去衡量轨迹跟踪误差和车身角度误差ψ：
 
 
损失函数：
 
在模型预测控制中，我们需要定义损失函数来优化路径。如果模型不能保持目标速度，那么我们就要惩罚模型。如果可能的话，我们并不想要突然的加减速或者突然的转向。但是既然这些实际上是不可避免的，我们可以尽可能地抑制加减速和转向地变化率。这减轻了晕车同时更加省油（也省人民币）。模型的损失函数应当包含
 
 
跟踪误差
 
 
转向误差
 
 
速度损失函数项（尽量保持在100英里每小时）
 
 
转向损失函数项（尽量避免转向）
 
 
加速度损失函数项（尽量保持0加速度）
 
 
转向变化率（越小越好）
 
 
加速度变化率（越小越好）
 
因为这些目标也许会相互冲突，我们需要给这些损失项定义权重以体现优先级。损失函数如下：
 
 
总而言之：
 
我们需要用模型预测控制来寻找最优路径，那么就需要动力学模型来预测下一拍的状态，以下是动力学模型和系统约束：
 
 
这是下面GitHub链接里，别人给的权重。
 
    const int cte_cost_weight = 2000;
    const int epsi_cost_weight = 2000;
    const int v_cost_weight = 1;
    const int delta_cost_weight = 10;
    const int a_cost_weight = 10;
    const int delta_change_cost_weight = 100;
    const int a_change_cost_weight = 10;
 
 
 
优化模型预测控制
 
我们通过解决一个约束条件下优化损失函数的问题来解决了控制问题。这些约束条件包括油门和转向的控制。
 
 
从道路中检测下6个航点，并且计算3次插值的来建立行驶轨迹
 
 
从传感器读取当前速度v,  方向ψ,  转向角 δ 以及加速度  a
 
 
使用传感器读取的数据和动力学模型计算出第一个车辆状态
 
 
根据1秒内的车辆状态响应优化控制动作，控制的周期为100ms，所以1s内有10个周期
 
 
模型预测控制的两个变量（也是控制量）：加速度（油门对应正加速度，刹车对应负加速度）和转向角
 
 
给出加速度和转向角的约束范围
 
 
我们将动态模型计算9次，得到未来9个时间拍的系统状态
 
 
给出每个采样计算周期的损失函数
 
 
用1个优化器解算出在约束定义下周期1到周期9的最小总损失（注意，在我们的定义中，时间周期并不从0开始，而是从1开始到10）
 
 
我们仅仅选择周期1给出的控制量
 
 
但是，我们延时100ms后再将控制量给模拟器。这样能够模拟现实世界，毕竟处理计算（读取传感器）和执行都需要时间。
 
 
从步骤1开始重复，寻找下一个最优控制量。
 
 
 
可调性：
 
在我们的例子中，我们计算了1秒中内的最优解，这个参数是可以调节的。长时间窗口的优化会给控制器的动作漂亮的曲线，但是也会积累过多的误差。实际上，如果这个优化时间窗口太大，汽车反而会脱离期望轨迹。
 
上面的文章内容都来自于链接[2]中，但是很多人对MPC还是有点不明白。模型也建立好了，约束我也会给，那怎么求解呢？求的解怎么利用呢？
 
现在我们看第一个问题：
 
1. 如何求解
 
上面的文章其实来自于Udacity的自动驾驶的一个课程。
 
大家可以去GitHub上下载下来，自己跑一下上面的代码。链接是这个https://github.com/mvirgo/MPC-Project，里面是一位博主写好的代码。大家配置好环境后可以直接跑起来的，然后有个可视化软件，可以看到3D引擎看到动画。
 
比如像这样的：https://github.com/mvirgo/MPC-Project/blob/master/MPC_vid.mov。
 
这个代码尽量在Ubuntu上去跑，因为装的东西比较多，给的教程关于LInux的。教程还是看Udacity给的模板比较好，但是代码不要下这个网址的，当时我环境配置好了之后还是有报错，我还以为是我环境配置的有问题。https://github.com/udacity/CarND-MPC-Project
 
这个代码是C++写的。
 
主函数中的调用
 
 /*
          * Calculate steering angle and throttle using MPC.
          * Both are in between [-1, 1].
          * Simulator has 100ms latency, so will predict state at that point in time.
          * This will help the car react to where it is actually at by the point of actuation.
          */
          
          // Fits a 3rd-order polynomial to the above x and y coordinates
          auto coeffs = polyfit(ptsx_car, ptsy_car, 3);
          
          // Calculates the cross track error
          // Because points were transformed to vehicle coordinates, x & y equal 0 below.
          // 'y' would otherwise be subtracted from the polyeval value
          double cte = polyeval(coeffs, 0);
          
          // Calculate the orientation error
          // Derivative of the polyfit goes in atan() below
          // Because x = 0 in the vehicle coordinates, the higher orders are zero
          // Leaves only coeffs[1]
          double epsi = -atan(coeffs[1]);
          
          // Center of gravity needed related to psi and epsi
          const double Lf = 2.67;
          
          // Latency for predicting time at actuation
          const double dt = 0.1;
          
          // Predict state after latency
          // x, y and psi are all zero after transformation above
          double pred_px = 0.0 + v * dt; // Since psi is zero, cos(0) = 1, can leave out
          const double pred_py = 0.0; // Since sin(0) = 0, y stays as 0 (y + v * 0 * dt)
          double pred_psi = 0.0 + v * -delta / Lf * dt;
          double pred_v = v + a * dt;
          double pred_cte = cte + v * sin(epsi) * dt;
          double pred_epsi = epsi + v * -delta / Lf * dt;
          
          // Feed in the predicted state values
          Eigen::VectorXd state(6);
          state << pred_px, pred_py, pred_psi, pred_v, pred_cte, pred_epsi;
          
          // Solve for new actuations (and to show predicted x and y in the future)
          auto vars = mpc.Solve(state, coeffs);
          
          // Calculate steering and throttle
          // Steering must be divided by deg2rad(25) to normalize within [-1, 1].
          // Multiplying by Lf takes into account vehicle's turning ability
          double steer_value = vars[0] / (deg2rad(25) * Lf);
          double throttle_value = vars[1];
 
MPC函数的实现
 
// MPC class definition implementation.
//
MPC::MPC() {}
MPC::~MPC() {}

vector<double> MPC::Solve(Eigen::VectorXd state, Eigen::VectorXd coeffs) {
  bool ok = true;
  typedef CPPAD_TESTVECTOR(double) Dvector;
  
  // State vector holds all current values neede for vars below
  double x = state[0];
  double y = state[1];
  double psi = state[2];
  double v = state[3];
  double cte = state[4];
  double epsi = state[5];

  // Setting the number of model variables (includes both states and inputs).
  // N * state vector size + (N - 1) * 2 actuators (For steering & acceleration)
  size_t n_vars = N * 6 + (N - 1) * 2;
  // Setting the number of constraints
  size_t n_constraints = N * 6;

  // Initial value of the independent variables.
  // SHOULD BE 0 besides initial state.
  Dvector vars(n_vars);
  for (int i = 0; i < n_vars; i++) {
    vars[i] = 0.0;
  }

  Dvector vars_lowerbound(n_vars);
  Dvector vars_upperbound(n_vars);
  // Sets lower and upper limits for variables.
  // Set all non-actuators upper and lowerlimits
  // to the max negative and positive values.
  for (int i = 0; i < delta_start; i++) {
    vars_lowerbound[i] = -1.0e19;
    vars_upperbound[i] = 1.0e19;
  }
  
  // The upper and lower limits of delta are set to -25 and 25
  // degrees (values in radians).
  for (int i = delta_start; i < a_start; i++) {
    vars_lowerbound[i] = -0.436332;
    vars_upperbound[i] = 0.436332;
  }
  
  // Acceleration/decceleration upper and lower limits.
  for (int i = a_start; i < n_vars; i++) {
    vars_lowerbound[i] = -1.0;
    vars_upperbound[i] = 1.0;
  }

  // Lower and upper limits for the constraints
  // Should be 0 besides initial state.
  Dvector constraints_lowerbound(n_constraints);
  Dvector constraints_upperbound(n_constraints);
  for (int i = 0; i < n_constraints; i++) {
    constraints_lowerbound[i] = 0;
    constraints_upperbound[i] = 0;
  }
  
  // Start lower and upper limits at current values
  constraints_lowerbound[x_start] = x;
  constraints_lowerbound[y_start] = y;
  constraints_lowerbound[psi_start] = psi;
  constraints_lowerbound[v_start] = v;
  constraints_lowerbound[cte_start] = cte;
  constraints_lowerbound[epsi_start] = epsi;
  
  constraints_upperbound[x_start] = x;
  constraints_upperbound[y_start] = y;
  constraints_upperbound[psi_start] = psi;
  constraints_upperbound[v_start] = v;
  constraints_upperbound[cte_start] = cte;
  constraints_upperbound[epsi_start] = epsi;

  // object that computes objective and constraints
  FG_eval fg_eval(coeffs);

  //
  // NOTE: You don't have to worry about these options
  //
  // options for IPOPT solver
  std::string options;
  // Uncomment this if you'd like more print information
  options += "Integer print_level  0\n";
  // NOTE: Setting sparse to true allows the solver to take advantage
  // of sparse routines, this makes the computation MUCH FASTER. If you
  // can uncomment 1 of these and see if it makes a difference or not but
  // if you uncomment both the computation time should go up in orders of
  // magnitude.
  options += "Sparse  true        forward\n";
  options += "Sparse  true        reverse\n";
  // NOTE: Currently the solver has a maximum time limit of 0.5 seconds.
  // Change this as you see fit.
  options += "Numeric max_cpu_time          0.5\n";

  // place to return solution
  CppAD::ipopt::solve_result<Dvector> solution;

  // solve the problem
  CppAD::ipopt::solve<Dvector, FG_eval>(
      options, vars, vars_lowerbound, vars_upperbound, constraints_lowerbound,
      constraints_upperbound, fg_eval, solution);

  // Check some of the solution values
  ok &= solution.status == CppAD::ipopt::solve_result<Dvector>::success;

  // Cost
  auto cost = solution.obj_value;
  std::cout << "Cost " << cost << std::endl;

  // Return the first actuator values, along with predicted x and y values to plot in the simulator.
  vector<double> solved;
  solved.push_back(solution.x[delta_start]);
  solved.push_back(solution.x[a_start]);
  for (int i = 0; i < N; ++i) {
    solved.push_back(solution.x[x_start + i]);
    solved.push_back(solution.x[y_start + i]);
  }
  
  return solved;

}
 
 具体源码大家还是去直接下载代码看看看。跑下看看效果。然后可以改下预测步长N和采样周期t。这里给的N=10，t=0.1s。
 
大家有什么问题，我们可以一起交流下，相互促进，共同进步。我C++一般，是硬伤，Linux也是用了没多久，就为了跑这个工程。
 
如何求解的问题已经解决。
 
2. 如何利用
 
如何利用比求解简单多了啊，看代码：
 
// Send values to the simulator
          json msgJson;
          msgJson["steering_angle"] = steer_value;
          msgJson["throttle"] = throttle_value;

          // Display the MPC predicted trajectory
          vector<double> mpc_x_vals = {state[0]};
          vector<double> mpc_y_vals = {state[1]};

          // add (x,y) points to list here, points are in reference to the vehicle's coordinate system
          // the points in the simulator are connected by a Green line
          
          for (int i = 2; i < vars.size(); i+=2) {
            mpc_x_vals.push_back(vars[i]);
            mpc_y_vals.push_back(vars[i+1]);
          }

          msgJson["mpc_x"] = mpc_x_vals;
          msgJson["mpc_y"] = mpc_y_vals;

          // Display the waypoints/reference line
          vector<double> next_x_vals;
          vector<double> next_y_vals;

          // add (x,y) points to list here, points are in reference to the vehicle's coordinate system
          // the points in the simulator are connected by a Yellow line
          double poly_inc = 2.5;
          int num_points = 25;
          
          for (int i = 1; i < num_points; i++) {
            next_x_vals.push_back(poly_inc * i);
            next_y_vals.push_back(polyeval(coeffs, poly_inc * i));
          }
          
          msgJson["next_x"] = next_x_vals;
          msgJson["next_y"] = next_y_vals;

          auto msg = "42[\"steer\"," + msgJson.dump() + "]";
          std::cout << msg << std::endl;
          // Latency
          // The purpose is to mimic real driving conditions where
          // the car doesn't actuate the commands instantly.
          this_thread::sleep_for(chrono::milliseconds(100));
          ws.send(msg.data(), msg.length(), uWS::OpCode::TEXT);
        }
      } else {
        // Manual driving
        std::string msg = "42[\"manual\",{}]";
        ws.send(msg.data(), msg.length(), uWS::OpCode::TEXT);
      }
 
 主要看前两句，就是把计算好的发送到模拟器，实际的话应该是发信号给方向盘和脚踏板。还有预测的轨迹点也输出到模拟器。
 
现在大家再看看链接[2]中的这段话，是不是有点感觉：
 
自动驾驶的3大核心科技是定位（在哪里），感知（周围是啥）以及控制（咋开车呢）。通过车道检测，我们可以对车的行进路线进行路径规划。本篇文章主要通过一个自行车的动力学模型讨论车辆的加速、刹车和转向的模型预测控制。目的不仅在于尽可能地控制车辆轨迹，同时也还要尽可能使速度平滑以避免晕车和频繁的刹车。
 
模型预测控制主要在约束条件下使损失函数最小。例如，我们想要以100ms的周期调整转向和速度，在转向角度不能超过25°的约束下，最小化以规划的路径和实际路径之间的误差。我们通过传感器获取车辆的状态，比如速度，而我们的动作基于传感器读数以一个短的周期执行（例如1s）。例如，我们顺时针转向20°，然后每100ms周期减小1°。加入这些动作可以1秒钟之后的损失函数最小，我们将会采用第一个动作：顺时针转动20°，但是却并不执行后续的动作，而是在100ms后，重复优化过程。100ms后，有了新的读数，我们就重新计算下一个最优动作。模型预测控制通过预测接下来一段较长时间（1s）的损失函数，来计算选择出下一个较短周期（100ms）的最优动作。相比于短视的贪心算法，模型预测控制具有鲁棒性，因此能够控制得更好。
 
给出一张图，大家可能看的更明白了。
 
 
这是维基百科上的图[3]。 
 
这一篇就到这里吧，写的也不够深入，下一篇我会讲MATLAB中的实现。感谢下以下三个链接的作者。
 
 [1] https://www.cnblogs.com/kui-sd具体u/p/9026796.html
 
 [2] https://www.leiphone.com/news/201812/3iia3PiNHnHiUFMb.html(中文翻译)
 
     https://medium.com/@jonathan_hui/lane-keeping-in-autonomous-driving-with-model-predictive-control-50f06e989bc9（英文原版，视频需翻墙）
 
 [3] https://zh.wikipedia.org/wiki/%E6%A8%A1%E5%9E%8B%E9%A0%90%E6%B8%AC%E6%8E%A7%E5%88%B6

 
 
灰色预测的主要特点是模型使用的不是原始数据序列，而是生成的数据序列。其核心体系是灰色模型（Grey Model，简称GM），即对原始数据作累加生成（或其他方法生成）得到近似的指数规律再进行建模的方法。
 
 
优点是不需要很多的数据，一般只需要4个数据就够。缺点是只适合于中短期的预测，只适合指数增长的预测。
 
 
GM(1,1)预测模型1阶微分方程，只含1个变量
 
 
GM(1,1)模型预测步骤
 1.数据的检验与处理
 2.建立模型
 3.检验预测值
 （1）残差检验
 （2）级比偏差检验
 4.预测数据
 
 
灰色预测模型使用条件：
 
1.已知数据[x,y]的组合大于4组，小于10组。（已知的样本数据过小或过大可选择其他的方法预测）
 
2.在实际应用中，数据通常是以年份度量的非负数据（如果是月份或季度数据可用时间序列模型）
 
3.数据能经过准指数规律的检验（除了前两期外，后面至少90%的期数的光滑比要低于0.5&#x