拉格朗日函数Python 拉格朗日函数什么时候学

python实现资产配置(1)----Markowitz 投资组合模型

现假设有A, B, C, D, E五只股票的收益率数据((第二日收盘价-第一日收盘价)/第一日收盘价)), 如果投资人的目标是达到20%的年收益率,那么该如何进行资产配置,才能使得投资的风险最低?

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站建设、网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的镇平网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

更一般的问题,假设现有x 1 ,x 2 ,...,x n , n支风险资产,且收益率已知,如果投资人的预期收益为goalRet,那么该如何进行资产配置,才能使得投资的风险最低?

1952年，芝加哥大学的Markowitz提出现代资产组合理论(Modern Portfolio Theory，简称MPT)，为现代西方证券投资理论奠定了基础。其基本思想是，证券投资的风险在于证券投资收益的不确定性。如果将收益率视为一个数学上的随机变量的话，证券的期望收益是该随机变量的数学期望（均值），而风险可以用该随机变量的方差来表示。

对于投资组合而言，如何分配各种证券上的投资比例，从而使风险最小而收益最大？

答案是将投资比例设定为变量，通过数学规划，对每一固定收益率求最小方差，对每一个固定的方差求最大收益率，这个多元方程的解可以决定一条曲线，这条曲线上的每一个点都对应着最优投资组合，即在给定风险水平下，收益率最大，这条曲线称作“有效前沿” (Efficient Frontier)。

对投资者而言，不存在比有效前沿更优的投资组合，只需要根据自己的风险偏好在有效前沿上寻找最优策略。

简化后的公式为:

其中 p 为投资人的投资目标,即投资人期待的投资组合的期望值. 目标函数说明投资人资产分配的原则是在达成投资目标 p 的前提下,要将资产组合的风险最小化,这个公式就是Markowitz在1952年发表的'Portfolio Selection'一文的精髓,该文奠定了现代投资组合理论的基础,也为Markowitz赢得了1990年的诺贝尔经济学奖. 公式(1)中的决策变量为w i , i = 1,...,N, 整个数学形式是二次规划(Quadratic Programming)问题,在允许卖空的情况下(即w i 可以为负,只有等式约束)时,可以用拉格朗日(Lagrange)方法求解。

有效前缘曲线如下图:

我们考虑如下的二次规划问题

运用拉格朗日方法求解,可以得到

再看公式(1),则将目标函数由 min W T W 调整为 min 1/2(W T W), 两问题等价,写出的求解矩阵为:

工具包: CVXOPT python凸优化包

函数原型: CVXOPT.solvers.qp(P,q,G,h,A,b)

求解时,将对应的P,q,G,h,A,b写出,带入求解函数即可.值得注意的是输入的矩阵必须使用CVXOPT 中的matrix函数转化,输出的结果要使用 print(CVXOPT.solvers.qp(P,q,G,h,A,b)['x']) 函数才能输出。

这里选取五支股票2014-01-01到2015-01-01的收益率数据进行分析.

选取的五支股票分别为: 白云机场, 华夏银行, 浙能电力, 福建高速, 生益科技

先大体了解一下五支股票的收益率情况:

看来，20%的预期收益是达不到了。

接下来,我们来看五支股票的相关系数矩阵：

可以看出，白云机场和福建高速的相关性较高，因为二者同属于交通版块。在资产配置时，不利于降低非系统性风险。

接下来编写一个MeanVariance类，对于传入的收益率数据，可以进行给定预期收益的最佳持仓配比求解以及有效前缘曲线的绘制。

绘制的有效前缘曲线为：

将数据分为训练集和测试集，并将随机模拟的资产配比求得的累计收益与测试集的数据进行对比，得到：

可以看出，在前半段大部分时间用Markowitz模型计算出的收益率要高于随机模拟的组合，然而在后半段却不如随机模拟的数据，可能是训练的数据不够或者没有动态调仓造成的，在后面写策略的时候，我会加入动态调仓的部分。

股票分析部分：

Markowitz 投资组合模型求解

蔡立专：量化投资——以python为工具. 电子工业出版社

python 拉格朗日插值 不能超过多少个值

拉格朗日插值Python代码实现

1. 数学原理

对某个多项式函数有已知的k+1个点，假设任意两个不同的都互不相同，那么应用拉格朗日插值公式所得到的拉格朗日插值多项式为：

其中每个lj(x)为拉格朗日基本多项式（或称插值基函数），其表达式为：

2. 轻量级实现

利用

直接编写程序，可以直接插值，并且得到对应的函数值。但是不能得到系数，也不能对其进行各项运算。

123456789101112

def h(x,y,a):    ans=0.0    for i in range(len(y)):        t=y[i]        for j in range(len(y)):            if i !=j:                t*=(a-x[j])/(x[i]-x[j])        ans +=t    return ansx=[1,0]y=[0,2]print(h(x,y,2))

上述代码中，h(x,y,a)就是插值函数，直接调用就行。参数说明如下：

x,y分别是对应点的x值和y值。具体详解下解释。

a为想要取得的函数的值。

事实上，最简单的拉格朗日插值就是两点式得到的一条直线。

例如：

p点(1,0)q点(0,2)

这两个点决定了一条直线，所以当x=2的时候，y应该是-2

该代码就是利用这两个点插值，然后a作为x=2调用函数验证的。

3. 引用库

3.1 库的安装

主要依赖与 scipy。官方网站见：

安装的方法很简单，就是使用pip install scipy 如果失败，则将whl文件下载到本地再利用命令进行安装。

可能如果没有安装numpy

3.2 库的使用

from scipy.interplotate import lagrange

直接调用lagrange(x,y)这个函数即可，返回 一个对象。

参数x,y分别是对应各个点的x值和y值。

例如：(1,2) (3,5) (5,9)这三个点，作为函数输入应该这么写：

x＝[1,3,5]

y =[2, 5, 9]

a=lagrange(x,y)

直接输出该对象，就能看到插值的函数。

利用该对象，能得到很多特性。具体参见：

a.order得到阶

a[]得到系数

a()得到对应函数值

此外可以对其进行加减乘除运算

3.3 代码实现

1234567   from scipy.interpolate import lagrangex=[1,2,3,4,7]y=[5,7,10,3,9]a=lagrange(x,y)print(a)print(a(1),a(2),a(3))print(a[0],a[2],a[3])   

结果是：

class 'numpy.lib.polynomial.poly1d' 4

4            3              2

0.5472 x - 7.306 x + 30.65 x - 47.03 x + 28.13

5.0 7.0 10.0

28.1333333333 30.6527777778 -7.30555555556

解释：

class 'numpy.lib.polynomial.poly1d' 4

这一行是输出a的类型，以及最高次幂。

4            3              2

0.5472 x - 7.306 x + 30.65 x - 47.03 x + 28.13

第二行和第三行就是插值的结果，显示出的函数。

第二行的数字是对应下午的x的幂，如果对应不齐，则是排版问题。

5.0 7.0 10.0

第四行是代入的x值，得到的结果。

也就是说，用小括号f(x)的这种形式，可以直接得到计算结果。

28.1333333333 30.6527777778 -7.30555555556

支持向量机—从推导到python手写

笔者比较懒能截图的地方都截图了。

支持向量机分为三类：

（1）线性可分支持向量机，样本线性可分，可通过硬间隔最大化训练一个分类器。

（2）线性支持向量机，样本基本线性可分，可通过软间隔最大化训练一个分类器。

（3）非线性支持向量机，样本线性不可分，可通过核函数和软间隔最大化训练一个分类器。

上面最不好理解的恐怕就是硬间隔和软间隔了，

说白了硬间隔就是说存在这么一个平面，可以把样本完全正确无误的分开，当然这是一种极理想的情况，现实中不存在，所以就有了软间隔。

软间隔说的是，不存在一个平面可以把样本完全正确无误的分开，因此呢允许一些样本被分错，怎么做呢就是加入松弛变量，因为希望分错的样本越小越好，因此松弛变量也有约束条件。加入松弛变量后，问题就变为线性可分了，因为是每一个样本都线性可分，因此松弛变量是针对样本的，每一个样本都对应一个不同的松弛变量。

其实感知机说白了就是找到一条直线把样本点分开，就是上方都是一类，下方是另一类。当然完全分开是好事，往往是不能完全分开的，因此就存在一个损失函数，就是误分类点到这个平面的距离最短：

这里啰嗦一句，误分类点y*(wx+b)0，所以加个负号在前边。

一般情况下||w||都是可以缩放，那么我们把它缩放到1，最后的目标函数就变成了

间隔就是距离，我们假设分离超平面为 ，那么样本点到这个平面的距离可以记为 。我们都知道通过感知机划分的点，超平面上方的点 ，下方的点 ，然后通过判断 的值与y的符号是否一致来判断分类是否正确。根据这个思路函数间隔定义为：

支持向量的定义来源于几何间隔，几何间隔最直接的解释是离分隔超平面最近点的距离，其他任何点到平面的距离都大于这个值，所以几何间隔就是支持向量。然后呢同样道理，w和b是可以缩放的，所以定义支持向量满足如下条件：

再通俗一点说，支持向量是一些点，这些点到分隔平面的距离最近，为了便于表示，把他们进行一下缩放计算，让他们满足了wx+b=+-1.

核函数是支持向量机的核心概念之一，它存在的目的就是将维度转换之后的计算简化，达到减少计算量的目的。我们都知道支持向量机求的是间距最大化，通常情况下我们求得的alpha都等于0，因此支持向量决定了间距最大化程度。

核函数的形式是这样的

其中x(i)和x(j)都是向量，他们两个相乘就是向量内积，相乘得到一个数。刚才说了目标函数一般只和支持向量有关，因此在做核函数计算之前，实际就是选择的支持向量进行计算。

这个写完下面得再补充

我们知道了支持向量的概念，那么支持向量机的目标函数是要使这两个支持向量之间的距离尽可能的远，因为这样才能更好地把样本点分开，当然支持向量也要满足最基本的约束条件，那就是分类正确，还有就是其他点到分隔平面的距离要大于等于支持向量到分隔平面的距离。

这种凸优化问题都可以通过拉格朗日算子进行优化，就是把约束条件通过拉格朗日系数放到目标函数上。这部分基础知识，就是拉格朗日算法可以将等式约束和不等式约束都加到目标函数上，完成求解问题的转换，但是要满足一些约束条件，也就是我们后边要说的kkt条件。

这里有个细节就是转换时候的加减号问题，这个和目标函数还有约束的正负号有关。一般这么理解，就是求最小化问题时候，如果约束是大于0的，那么拉个朗日算子可以减到这一部分，这样一来目标函数只能越来越小，最优解就是约束为0的时候，这个时候和没有约束的等价，再求最小就是原问题了。

这里是最小化问题，直接减掉这部分约束，然后后半部分永远大于等于0所以这个式子的值是要小于原来目标函数值的。我们知道当x满足原问题的约束条件的时候，最大化L就等于那个原目标函数。所以我们可以把这个问题转化为：

把它带回去原来的目标函数中，整理一下。

这个时候只要求最优的α，就可以求出w和b了。我们上边做了那么一堆转换，这个过程要满足一个叫做kkt条件的东西，其实这个东西就是把一堆约束条件整理到一起。

（1）原有问题的可行性，即h(x )=0,g(x )0

放到这里就是：

SMO算法的核心思想是求出最优化的α，然后根据之前推导得到的w,b,α之间的关系计算得到w和b，最后的计算公式是：

现在的问题就是怎么求α了。

SMO算法总共分两部分，一部分是求解两个α的二次规划算法，另一部分是选择两个α的启发式算法。

先说这个选择α的启发式算法部分：大神可以证明优先优化违反kkt条件的α可以最快获得最优解，至于咋证明的，就先不看了。

在讲支持向量机的求解算法时候，直接给出了核函数K，那么怎么去理解核函数呢。核函数的作用是解决样本点在高维空间的内积运算问题，怎么理解呢，通常的分类问题都是有很多个特征的，然后为了达到现线性可分，又会从低维映射到高维，样本量再一多计算量非常大，因此先通过函数进行一个转换，减少乘法的计算量。

要理解核函数，先理解内积运算，内积运算实际是两个向量，对应位置相乘加和，比如我有x1 = [v1,v2], x2=[w1,w2]，那么x1和x2的内积计算方法就是：v1w1+v2w2。

如果上面那种情况线性不可分，需要到高维进行映射，让数据变得线性可分，然后数据变为五维的，即v1 2+v2 2+v1+v2+v1v2，然后再进行一次内积计算，数据变为 。

稍作变换，可以变为 ，形式展开和上边那个长式子差不多，然后其实可以映射内积相乘的情况，所以可以进行核函数的变化。

问题在于，当你需要显式的写出来映射形式的时候，在维度很高的时候，需要计算的量太大，比如x1有三个维度，再进行映射就有19维度了，计算很复杂。如果用核函数，还是在原来低维度进行运算，既有相似的效果（映射到高维），又低运算量，这就是核函数的作用了。

核函数的种类：

这部分的核心在于SMO算法的编写。有待补充。

谁有拉格朗日插值法的python代码啊！急用啊！谢谢啦！

您好，#includestdio.h

#includestdlib.h

#includeiostream.h

typedef struct data

{

float x;

float y;

}Data;//变量x和函数值y的结构

Data d[20];//最多二十组数据

float f(int s,int t)//牛顿插值法，用以返回插商

{

if(t==s+1)

return (d[t].y-d[s].y)/(d[t].x-d[s].x);

else

return (f(s+1,t)-f(s,t-1))/(d[t].x-d[s].x);

}

float Newton(float x,int count)

{

int n;

while(1)

{

cout"请输入n值(即n次插值):";//获得插值次数

cinn;

if(n=count-1)// 插值次数不得大于count－1次

break;

else

system("cls");

}

//初始化t，y，yt。

float t=1.0;

float y=d[0].y;

float yt=0.0;

//计算y值

for(int j=1;j=n;j++)

{

t=(x-d[j-1].x)*t;

yt=f(0,j)*t;

//coutf(0,j)endl;

y=y+yt;

}

return y;

}

float lagrange(float x,int count)

{

float y=0.0;

for(int k=0;kcount;k++)//这儿默认为count－1次插值

{

float p=1.0;//初始化p

for(int j=0;jcount;j++)

{//计算p的值

if(k==j)continue;//判断是否为同一个数

p=p*(x-d[j].x)/(d[k].x-d[j].x);

}

y=y+p*d[k].y;//求和

}

return y;//返回y的值

}

void main()

{

float x,y;

int count;

while(1)

{

cout"请输入x[i],y[i]的组数，不得超过20组:";//要求用户输入数据组数

cincount;

if(count=20)

break;//检查输入的是否合法

system("cls");

}

//获得各组数据

for(int i=0;icount;i++)

{

cout"请输入第"i+1"组x的值:";

cind[i].x;

cout"请输入第"i+1"组y的值:";

cind[i].y;

system("cls");

}

cout"请输入x的值:";//获得变量x的值

cinx;

while(1)

{

int choice=3;

cout"请您选择使用哪种插值法计算："endl;

cout" (0):退出"endl;

cout" (1):Lagrange"endl;

cout" (2):Newton"endl;

cout"输入你的选择：";

cinchoice;//取得用户的选择项

if(choice==2)

{

cout"你选择了牛顿插值计算方法，其结果为：";

y=Newton(x,count);break;//调用相应的处理函数

}

if(choice==1)

{

cout"你选择了拉格朗日插值计算方法，其结果为：";

y=lagrange(x,count);break;//调用相应的处理函数

}

if(choice==0)

break;

system("cls");

cout"输入错误!!!!"endl;

}

coutx" , "yendl;//输出最终结果

}