怎么计算隐含波动率

1. 怎么计算隐含波动率

将标的股价、执行价格、利率、到期时间代入定价公式，就可以从中解出惟一的未知量，其大小就是隐含波动率。
由于期权定价模型(如BS模型)给出了期权价格与五个基本参数(标的股价、执行价格、利率、到期时间、波动率)之间的定量关系，只要将其中前4个基本参数及期权的实际市场价格作为已知量代入定价公式，就可以从中解出惟一的未知量，其大小就是隐含波动率。

扩展资料
历史波动率反映标的股价在过去一段时间的波动幅度，权证发行商与投资者在权证发行初期只能利用历史波动率作参考。
一般来说，权证的隐含波动率越高，其隐含的风险也就越大。权证投资者除了可以利用权证的正股价格变化方向来买卖权证外，还可以从股价的波动幅度的变化中获利。波动率并不是可以无限上涨或下跌，而是在一个区间内来回震荡，认购权证波动率小时买入，认沽权证波动率大时卖出。
隐含波动率是把权证的价格代入BS模型中反算出来的，它反映了投资者对未来标的证券波动率的预期。目前市场上没有其他的国电电力权证，所以得不到国电电力未来波动率预期的参考数据，那么投资者在计算国电权证的理论价值时，可以参考历史波动率（观察样本可以是最近一年）。
参考资料来源：百度百科-隐含波动率

2. 如何用python实现Markowitz投资组合优化

0.导入需要的包import pandas as pd
import numpy as np
import statsmodels.api as sm #统计运算
import scipy.stats as scs #科学计算
import matplotlib.pyplot as plt #绘图

1.选取几只感兴趣的股票
000413 东旭光电，000063 中兴通讯，002007 华兰生物，000001 平安银行，000002 万科A
并比较一下数据（2015-01-01至2015-12-31）
In[1]:
stock_set = ['000413.XSHE','000063.XSHE','002007.XSHE','000001.XSHE','000002.XSHE']
noa = len(stock_set)
df = get_price(stock_set, start_date = '2015-01-01', end_date ='2015-12-31', 'daily', ['close'])
data = df['close']
#规范化后时序数据
(data/data.ix[0]*100).plot(figsize = (8,5))
Out[1]:

2.计算不同证券的均值、协方差
每年252个交易日，用每日收益得到年化收益。计算投资资产的协方差是构建资产组合过程的核心部分。运用pandas内置方法生产协方差矩阵。
In [2]:
returns = np.log(data / data.shift(1))
returns.mean()*252
Out[2]:

000413.XSHE    0.184516
000063.XSHE    0.176790
002007.XSHE    0.309077
000001.XSHE   -0.102059
000002.XSHE    0.547441

In [3]:
returns.cov()*252
Out[3]:

3.给不同资产随机分配初始权重
由于A股不允许建立空头头寸，所有的权重系数均在0-1之间
In [4]:
weights = np.random.random(noa)
weights /= np.sum(weights)
weights
Out[4]:

array([ 0.37505798,  0.21652754,  0.31590981,  0.06087709,  0.03162758])

4.计算预期组合年化收益、组合方差和组合标准差
In [5]:
np.sum(returns.mean()*weights)*252
Out[5]:

0.21622558669017816

In [6]:
np.dot(weights.T, np.dot(returns.cov()*252,weights))
Out[6]:

0.23595133640121463

In [7]:
np.sqrt(np.dot(weights.T, np.dot(returns.cov()* 252,weights)))
Out[7]:

0.4857482232609962

5.用蒙特卡洛模拟产生大量随机组合
进行到此，我们最想知道的是给定的一个股票池（证券组合）如何找到风险和收益平衡的位置。
下面通过一次蒙特卡洛模拟，产生大量随机的权重向量，并记录随机组合的预期收益和方差。
In [8]:
port_returns = []
port_variance = []
for p in range(4000):
  weights = np.random.random(noa)
  weights /=np.sum(weights)
  port_returns.append(np.sum(returns.mean()*252*weights))
  port_variance.append(np.sqrt(np.dot(weights.T, np.dot(returns.cov()*252, weights))))
port_returns = np.array(port_returns)
port_variance = np.array(port_variance)
#无风险利率设定为4%
risk_free = 0.04
plt.figure(figsize = (8,4))
plt.scatter(port_variance, port_returns, c=(port_returns-risk_free)/port_variance, marker = 'o')
plt.grid(True)
plt.xlabel('excepted volatility')
plt.ylabel('expected return')
plt.colorbar(label = 'Sharpe ratio')
Out[8]:

6.投资组合优化1——sharpe最大
建立statistics函数来记录重要的投资组合统计数据（收益，方差和夏普比）
通过对约束最优问题的求解，得到最优解。其中约束是权重总和为1。
In [9]:
def statistics(weights):
   weights = np.array(weights)
   port_returns = np.sum(returns.mean()*weights)*252
   port_variance = np.sqrt(np.dot(weights.T, np.dot(returns.cov()*252,weights)))
   return np.array([port_returns, port_variance, port_returns/port_variance])
#最优化投资组合的推导是一个约束最优化问题
import scipy.optimize as sco
#最小化夏普指数的负值
def min_sharpe(weights):
  return -statistics(weights)[2]
#约束是所有参数(权重)的总和为1。这可以用minimize函数的约定表达如下
cons = ({'type':'eq', 'fun':lambda x: np.sum(x)-1})
#我们还将参数值(权重)限制在0和1之间。这些值以多个元组组成的一个元组形式提供给最小化函数
bnds = tuple((0,1) for x in range(noa))
#优化函数调用中忽略的唯一输入是起始参数列表(对权重的初始猜测)。我们简单的使用平均分布。
opts = sco.minimize(min_sharpe, noa*[1./noa,], method = 'SLSQP', bounds = bnds, constraints = cons)
opts
Out[9]:
status: 0
success: True
njev: 4
nfev: 28
fun: -1.1623048291871221
x: array([ -3.60840218e-16,   2.24626781e-16,   1.63619563e-01,        -2.27085639e-16,   8.36380437e-01])
message: 'Optimization terminated successfully.'
jac: array([  1.81575805e-01,   5.40387481e-01,   8.18073750e-05,         1.03137662e+00,  -1.60038471e-05,   0.00000000e+00])
nit: 4

得到的最优组合权重向量为：
In [10]:
opts['x'].round(3)
Out[10]:
array([-0.   ,  0.   ,  0.164, -0.   ,  0.836])

sharpe最大的组合3个统计数据分别为：
In [11]:
#预期收益率、预期波动率、最优夏普指数
statistics(opts['x']).round(3)
Out[11]:

array([ 0.508,  0.437,  1.162])

7.投资组合优化2——方差最小
接下来，我们通过方差最小来选出最优投资组合。
In [12]:
#但是我们定义一个函数对 方差进行最小化
def min_variance(weights):
   return statistics(weights)[1]
optv = sco.minimize(min_variance, noa*[1./noa,],method = 'SLSQP', bounds = bnds, constraints = cons)
optv
Out[12]:
status: 0
success: True
njev: 7
nfev: 50
fun: 0.38542969450547221
x: array([  1.14787640e-01,   3.28089742e-17,   2.09584008e-01,         3.53487044e-01,   3.22141307e-01])
message: 'Optimization terminated successfully.'
jac: array([ 0.3851725 ,  0.43591119,  0.3861807 ,  0.3849672 ,  0.38553924,  0.        ])
nit: 7

方差最小的最优组合权重向量及组合的统计数据分别为：
In [13]:
optv['x'].round(3)
Out[13]:
array([ 0.115,  0.   ,  0.21 ,  0.353,  0.322])

In [14]:
#得到的预期收益率、波动率和夏普指数
statistics(optv['x']).round(3)
Out[14]:
array([ 0.226,  0.385,  0.587])

8.组合的有效前沿
有效前沿有既定的目标收益率下方差最小的投资组合构成。
在最优化时采用两个约束，1.给定目标收益率，2.投资组合权重和为1。
In [15]:
def min_variance(weights):
   return statistics(weights)[1]
#在不同目标收益率水平（target_returns）循环时，最小化的一个约束条件会变化。
target_returns = np.linspace(0.0,0.5,50)
target_variance = []
for tar in target_returns:
  cons = ({'type':'eq','fun':lambda x:statistics(x)[0]-tar},{'type':'eq','fun':lambda x:np.sum(x)-1})
  res = sco.minimize(min_variance, noa*[1./noa,],method = 'SLSQP', bounds = bnds, constraints = cons)
  target_variance.append(res['fun'])
target_variance = np.array(target_variance)

下面是最优化结果的展示。
叉号：构成的曲线是有效前沿（目标收益率下最优的投资组合）
红星：sharpe最大的投资组合
黄星：方差最小的投资组合
In [16]:
plt.figure(figsize = (8,4))
#圆圈：蒙特卡洛随机产生的组合分布
plt.scatter(port_variance, port_returns, c = port_returns/port_variance,marker = 'o')
#叉号：有效前沿
plt.scatter(target_variance,target_returns, c = target_returns/target_variance, marker = 'x')
#红星：标记最高sharpe组合
plt.plot(statistics(opts['x'])[1], statistics(opts['x'])[0], 'r*', markersize = 15.0)
#黄星：标记最小方差组合
plt.plot(statistics(optv['x'])[1], statistics(optv['x'])[0], 'y*', markersize = 15.0)
plt.grid(True)
plt.xlabel('expected volatility')
plt.ylabel('expected return')
plt.colorbar(label = 'Sharpe ratio')

3. python确定一个数是不是完全平方数

1. 与依赖于任何浮动的问题（math.sqrt(x)或x**0.5）是你不能真正确定它的准确（对充分大的整数x，它不会是，甚至有可能溢出）。幸运的（如果是不急于;-)有很多纯整数的方法，如下面的...：
def is_square(apositiveint):
 x = apositiveint // 2
 seen = set([x])
 while x * x != apositiveint:
 x = (x + (apositiveint // x)) // 2
 if x in seen: return False
 seen.add(x)
 return True
for i in range(110, 130):
 print i, is_square(i)
提示：它是基于“巴比伦算法”的平方根，请参阅维基百科。它适用于任何正数，而您有继续 编辑：让我们看一个例子...
x = 12345678987654321234567 ** 2
for i in range(x, x+2):
 print i, is_square(i)
这种版画，根据需要（和太;-)一个合理的金额：
152415789666209426002111556165263283035677489 True
152415789666209426002111556165263283035677490 False
请您提出了一种基于浮点结果的解决方案之前 CodeGo.net，确保他们正确地工作在这个简单的例子-它不是那么难（你只需要一些额外的检查，以防是有点过），只是需要多一点的关怀。 然后尝试用x**7并找到解决您会得到这个问题巧妙的方式，
OverflowError: long int too large to convert to float
你必须得到越来越多的聪明的数量不断增加，当然。 如果我很着急，当然，我gmpy-但后来，我明显偏向;-)。
>>> import gmpy
>>> gmpy.is_square(x**7)
1
>>> gmpy.is_square(x**7 + 1)
0
是啊，我知道，这只是很容易感觉像作弊（有点我总体感觉对Python的;-)的方式-没有聪明可言，只是完美的直接和简单（和，在gmpy，绝对速度的情况下;-) ...
2. 用牛顿的快速零最接近的整数的平方根，那么它平方，看看它是否是你的号码。见isqrt。
3. 因为你永远无法靠当浮动（如计算平方根的这些方式），一个不易出错将是对处理
import math
def is_square(integer):
 root = math.sqrt(integer)
 if int(root + 0.5) ** 2 == integer: 
  return True
 else:
  return False
想像integer是9。math.sqrt(9)可能是3.0的，但它也可以是像2.99999或3.00001，因此现蕾结果马上是不可靠的。知道int取整数值，通过增加浮点值0.5我们会得到我们要找的，如果我们是在一个范围内的值，其中float仍然有足够细的分辨率来表示附近的一个为我们所期待的数字。
4. 我是新来的堆栈溢出，并做了一个快速脱脂找到解决的办法。我只是张贴在另一个线程（寻找完美的正方形）上的例子，一个细微的变化上面，我想我会包括什么，我贴在这里有一个细微的变化（使用nsqrt作为一个临时变量），如果它的利益/使用：
import math
def is_perfect_square(n):
 if not ( ( isinstance(n, int) or isinstance(n, long) ) and ( n >= 0 ) ):
 return False 
 else:
 nsqrt = math.sqrt(n)
 return nsqrt == math.trunc(nsqrt)
5. 你可以二进制搜索的圆形平方根。平方的结果，以确定它的原始值相匹配。 你可能会更好过与FogleBirds回答-虽然小心，因为浮点数是近似的，它可以抛出这种方法了。你可以在原则上得到一个假阳性从一个大的整数，较完美的正方形，例如，由于丢失精度1以上。
6.
>>> def f(x):
...  x = x ** 0.5
...  return int(x) == x
...
>>> for i in range(10):
...  print i, f(i)
...
0 True
1 True
2 False
3 False
4 True
5 False
6 False
7 False
8 False
9 True
7. 决定多久的数量就越大。 采取增量0.000000000000 ....... 000001 见，如果（SQRT（X））^ 2-x是大于/等于/大于δ较小并且基于增量误差决定。
8. 我不知道Python的，但你可以不喜欢：
function isSquare(x) = x == floor(sqrt(x) + 0.5)^2
也就是说，拿一个数，求平方根，四舍五入到最接近的整数，它平方，并测试它是作为原来的号码。 （floor并加入0.5做是为了防止类似案件sqrt(4)回国1.9999999...由于浮点运算，麦克grahams指出。） 如果你有兴趣，曾经有一个很好的判断以最快的方式，如果一个整数的平方根是一个整数。 编辑澄清。
9. 该回复不属于你的declarative的问题，而是一个隐含的问题，我在您发布的代码中看到，即“如何检查是否是整数？” 优先个回答你通常得到这个问题是“不要！”并且这是真的，在Python，类型检查不应该做的事情。 对于那些极少数的异常，不过，不是寻找数字的字符串表示小数点，那东西做isinstance函数：
>>> isinstance(5,int)
True
>>> isinstance(5.0,int)
False
当然适用于变量，而不是一个值。如果我想确定该值是否是一个整数，我会做到这一点：
>>> x=5.0
>>> round(x) == x
True
但正如其他人已经详细介绍，也有这种事情的大多数非玩具的例子来加以考虑浮点问题。
10. 我有轻微的原始巴比伦的方法。取而代之的是一套以存储每个生成的近似，只是最近的两个近似的存储和核对电流近似。这保存了大量的通过整套的近似值的浪费检查。我的java，而不是python和BigInteger类，而不是一个正常的原始整数。
 BigInteger S = BigInteger.ZERO; 
 BigInteger x = BigInteger.ZERO;
 BigInteger prev1 = BigInteger.ZERO;
 BigInteger prev2 = BigInteger.ZERO;
 Boolean isInt = null;
 x = S.divide(BigInteger.valueOf(2));
 while (true) {
  x = x.add(preA.divide(x)).divide(BigInteger.valueOf(2));
  if (x.pow(2).equals(S)) { 
   isInt = true;
   break;
  }
  if (prev1.equals(x) || prev2.equals(x)) {
   isInt = false; 
   break;
  }
  prev2 = prev1;
  prev1 = x;
 }

4. 如何用 Python 构建神经网络择时模型

import math
import random
random.seed(0)
def rand(a,b): #随机函数
return (b-a)*random.random()+a
def make_matrix(m,n,fill=0.0):#创建一个指定大小的矩阵
mat = []
for i in range(m):
mat.append([fill]*n)
return mat
#定义sigmoid函数和它的导数
def sigmoid(x):
return 1.0/(1.0+math.exp(-x))
def sigmoid_derivate(x):
return x*(1-x) #sigmoid函数的导数
class BPNeuralNetwork:
def __init__(self):#初始化变量
self.input_n = 0
self.hidden_n = 0
self.output_n = 0
self.input_cells = []
self.hidden_cells = []
self.output_cells = []
self.input_weights = []
self.output_weights = []
self.input_correction = []
self.output_correction = []
#三个列表维护：输入层，隐含层，输出层神经元
def setup(self,ni,nh,no):
self.input_n = ni+1 #输入层+偏置项
self.hidden_n = nh  #隐含层
self.output_n = no  #输出层
#初始化神经元
self.input_cells = [1.0]*self.input_n
self.hidden_cells= [1.0]*self.hidden_n
self.output_cells= [1.0]*self.output_n
#初始化连接边的边权
self.input_weights = make_matrix(self.input_n,self.hidden_n) #邻接矩阵存边权：输入层->隐藏层
self.output_weights = make_matrix(self.hidden_n,self.output_n) #邻接矩阵存边权：隐藏层->输出层
#随机初始化边权：为了反向传导做准备--->随机初始化的目的是使对称失效
for i in range(self.input_n):
for h in range(self.hidden_n):
self.input_weights[i][h] = rand(-0.2 , 0.2) #由输入层第i个元素到隐藏层第j个元素的边权为随机值
for h in range(self.hidden_n):
for o in range(self.output_n):
self.output_weights[h][o] = rand(-2.0, 2.0) #由隐藏层第i个元素到输出层第j个元素的边权为随机值
#保存校正矩阵，为了以后误差做调整
self.input_correction = make_matrix(self.input_n , self.hidden_n)
self.output_correction = make_matrix(self.hidden_n,self.output_n)
#输出预测值
def predict(self,inputs):
#对输入层进行操作转化样本
for i in range(self.input_n-1):
self.input_cells[i] = inputs[i] #n个样本从0~n-1
#计算隐藏层的输出，每个节点最终的输出值就是权值*节点值的加权和
for j in range(self.hidden_n):
total = 0.0
for i in range(self.input_n):
total+=self.input_cells[i]*self.input_weights[i][j]
# 此处为何是先i再j，以隐含层节点做大循环，输入样本为小循环，是为了每一个隐藏节点计算一个输出值，传输到下一层
self.hidden_cells[j] = sigmoid(total) #此节点的输出是前一层所有输入点和到该点之间的权值加权和
for k in range(self.output_n):
total = 0.0
for j in range(self.hidden_n):
total+=self.hidden_cells[j]*self.output_weights[j][k]
self.output_cells[k] = sigmoid(total) #获取输出层每个元素的值
return self.output_cells[:]  #最后输出层的结果返回
#反向传播算法：调用预测函数，根据反向传播获取权重后前向预测，将结果与实际结果返回比较误差
def back_propagate(self,case,label,learn,correct):
#对输入样本做预测
self.predict(case) #对实例进行预测
output_deltas = [0.0]*self.output_n #初始化矩阵
for o in range(self.output_n):
error = label[o] - self.output_cells[o] #正确结果和预测结果的误差：0,1，-1
output_deltas[o]= sigmoid_derivate(self.output_cells[o])*error#误差稳定在0~1内
#隐含层误差
hidden_deltas = [0.0]*self.hidden_n
for h in range(self.hidden_n):
error = 0.0
for o in range(self.output_n):
error+=output_deltas[o]*self.output_weights[h][o]
hidden_deltas[h] = sigmoid_derivate(self.hidden_cells[h])*error
#反向传播算法求W
#更新隐藏层->输出权重
for h in range(self.hidden_n):
for o in range(self.output_n):
change = output_deltas[o]*self.hidden_cells[h]
#调整权重：上一层每个节点的权重学习*变化+矫正率
self.output_weights[h][o] += learn*change + correct*self.output_correction[h][o]
#更新输入->隐藏层的权重
for i in range(self.input_n):
for h in range(self.hidden_n):
change = hidden_deltas[h]*self.input_cells[i]
self.input_weights[i][h] += learn*change + correct*self.input_correction[i][h]
self.input_correction[i][h] =  change
#获取全局误差
error = 0.0
for o in range(len(label)):
error = 0.5*(label[o]-self.output_cells[o])**2 #平方误差函数
return error
def train(self,cases,labels,limit=10000,learn=0.05,correct=0.1):
for i in range(limit): #设置迭代次数
error = 0.0
for j in range(len(cases)):#对输入层进行访问
label = labels[j]
case = cases[j]
error+=self.back_propagate(case,label,learn,correct) #样例，标签，学习率，正确阈值
def test(self): #学习异或
cases = [
[0, 0],
[0, 1],
[1, 0],
[1, 1],
] #测试样例
labels = [[0], [1], [1], [0]] #标签
self.setup(2,5,1) #初始化神经网络：输入层，隐藏层，输出层元素个数
self.train(cases,labels,10000,0.05,0.1) #可以更改
for case in  cases:
print(self.predict(case))
if __name__ == '__main__':
nn = BPNeuralNetwork()
nn.test()

5. 如何用python计算隐含波动率

用BS model计算欧式call option的implied volatility。
稍微修改一下也可以算put option。计算结果可以和期权计算器上的结果对比。

6. python怎么做快速图像分割算法

时间序列模型最常用最强大的的工具就是递归神经网络（recurrent neural network, RNN）。相比与普通神经网络的各计算结果之间相互独立的特点，RNN的每一次隐含层的计算结果都与当前输入以及上一次的隐含层结果相关。
通过这种方法，RNN的计算结果便具备了记忆之前几次结果的特点。

7. 如何用Python画实时更新的波动率曲线图

用python做是不是有些太重了，python只需要负责给前端返回格式化的数据就好啦，这种图片的事情让这种专业的工具去做岂不更好
实时刷新的曲线图 | Highcharts
需要一点点js知识和最简单的flask知识，但是时间成本和效果表现肯定要优于python GUI

8. python除法计算出来的都是float

在python3中所有除法结果都是float
如果你想执行象C语言那样的整数除法，必须使用//这个操作符
4//2 #结果是2
type(4//2)