Python for Finance on Yuunagi Library

前言

Mon, 01 Jan 0001 00:00:00 +0000

掌握数据驱动金融（Mastering Data-Driven Finance）

Python金融应用（Python for Finance）#

Python已成为数据驱动和AI优先金融（AI-first Finance）领域的首选编程语言。一些大型投资银行和对冲基金现在使用Python及其生态系统来构建核心交易和风险管理系统。在本指南的第二版中，Yves Hilpisch向开发者与量化分析师展示了如何使用Python包和工具进行金融数据科学（Financial Data Science）、算法交易（Algorithmic Trading）和计算金融（Computational Finance）。

本书已针对Python 3进行更新，大部分代码以Jupyter Notebook形式提供，让你可以执行和交互式地运行书中几乎所有示例。全书共五部分，你将了解Python及其生态系统如何为金融领域的公司和个体提供技术框架：

第一部分：Python与金融 —— 入门Python交互式金融分析与应用开发

第二部分：掌握基础 —— 学习Python数据类型与结构、NumPy、pandas及其DataFrame类、面向对象编程

第三部分：金融数据科学 —— 探索Python在金融时间序列数据、I/O操作、随机过程和机器学习方面的技术与包

第四部分：算法交易 —— 使用Python回测和部署自动化算法交易策略

第五部分：衍生品分析 —— 开发灵活而强大的Python期权与衍生品定价及风险管理包

Yves J. Hilpisch博士是The Python Quants的创始人兼管理合伙人，该公司专注于利用开源技术进行金融数据科学、人工智能、算法交易和计算金融。他还是The AI Machine的创始人兼CEO，该公司致力于通过专有策略执行平台利用AI为算法交易赋能。Yves是首个在线培训项目的负责人，该项目可颁发Python算法交易大学证书。

前言#

如今，Python无疑是金融行业的主要战略性技术平台之一。2013年开始撰写本书第一版时，我仍然需要在许多谈话和演示中不懈地论证Python在金融领域相比其他语言和平台的竞争优势。到2018年底，这已不再是问题：世界各地的金融机构都在尽力利用Python及其强大的数据分析、可视化和机器学习包生态。

在金融领域之外，Python也常常是编程入门课程的首选语言，例如计算机科学项目。除了其可读性强的语法和多范式方法之外，一个主要原因是Python已成为人工智能（Artificial Intelligence, AI）、机器学习（Machine Learning, ML）和深度学习（Deep Learning, DL）领域的一流语言。许多流行包和库要么直接用Python编写（如用于ML的scikit-learn），要么提供Python封装（如用于DL的TensorFlow）。

金融本身正在进入一个新时代，两大力量正在推动这一演变。第一是几乎所有金融数据都可以通过编程方式获取——通常实时进行，这导致了数据驱动金融（Data-Driven Finance）。几十年前，大多数交易或投资决策依赖于交易员和投资组合经理在报纸上读到或通过私人谈话了解的信息。后来，终端通过计算机和电子通信将金融数据实时带到交易员和投资组合经理的办公桌上。如今，个体（或团队）再也无法跟上哪怕一分钟内产生的海量金融数据。只有机器，凭借其不断提升的处理速度和计算能力，才能跟上金融数据的体量和速度。这意味着，当今全球大部分股票交易量是由算法和计算机驱动的，而非人类交易员。

第二个主要力量是AI在金融领域日益增长的重要性。越来越多的金融机构试图利用ML和DL算法来改善运营和交易投资绩效。2018年初，第一本关于"金融机器学习"的专著出版，突显了这一趋势。毫无疑问，更多的书还在后面。这导致了所谓的AI优先金融（AI-first Finance），灵活、可参数化的ML和DL算法取代了传统的金融理论——那些理论可能优雅，但在数据驱动、AI优先金融的新时代已不再那么有用。

Python是应对这个金融时代挑战的正确编程语言和生态系统。虽然本书涵盖了用于无监督和监督学习的基本ML算法（以及深度神经网络等），但重点是Python的数据处理和分析能力。要全面说明AI在金融中——现在和未来——的重要性，需要另外一本书的篇幅。然而，大多数AI、ML和DL技术需要大量数据，因此掌握数据驱动金融应该是第一步。

《Python for Finance》第二版与其说是更新，不如说是升级。例如，它增加了关于算法交易的完整部分（第四部分）。这个话题最近在金融行业变得相当重要，在零售交易者中也很受欢迎。它还增加了更偏入门的第二部分，介绍基础Python编程和数据分析主题，之后在后续部分中加以应用。另一方面，第一版中的一些章节已被完全删除。例如，关于Web技术和包（如Flask）的章节被删除了，因为如今已有更专门、更聚焦的书籍介绍这类主题。

在第二版中，我试图覆盖更多与金融相关的主题，并聚焦于对金融数据科学、算法交易和计算金融特别有用的Python技术。和第一版一样，方法仍然是实践导向的：实现和示例先于理论细节，我通常关注大局而不是某个类、方法或函数最晦涩的参数化选项。

在描述了第二版的基本方法之后，值得强调的是，本书既不是Python编程入门，也不是金融学导论。这两方面都有大量优秀资源可用。本书位于这两个激动人心领域的交汇点，假定读者具有一定的编程背景（不一定是Python）和金融背景。这样的读者将学到如何将Python及其生态系统应用于金融领域。

本书附带的Jupyter Notebook和代码可以通过我们的Quant Platform访问和执行。你可以在 http://py4fi.pqp.io 免费注册。

我和我的公司（The Python Quants）提供了更多资源，帮助你掌握Python在金融数据科学、人工智能、算法交易和计算金融方面的应用。你可以从以下网站开始：

• 我们公司网站 • 我的个人网站 • 我们的Python书籍网站 • 我们的在线培训网站 • 证书项目网站

第一部分 · Python与金融

Mon, 01 Jan 0001 00:00:00 +0000

Part 1

Python与金融

Python在金融中的角色——为什么选择Python、基础设施搭建。

本部分章节#

第1章为什么用Python做金融 — Python编程语言、生态系统、金融中的数据驱动与AI优先。

第2章 Python基础设施 — conda包管理、Docker容器、云实例、Jupyter Notebook配置。

第1章 · 为什么用Python做金融

Mon, 01 Jan 0001 00:00:00 +0000

银行本质上是科技公司。 —Hugo Banziger

Python编程语言#

Python是一种高级、多用途编程语言，广泛应用于各种领域和技术领域。在Python官网上，你可以找到以下概要：

Python是一种解释型、面向对象、高级编程语言，具有动态语义。其高级内置数据结构，结合动态类型和动态绑定，使其非常适合快速应用开发（Rapid Application Development），也适用于作为脚本或胶水语言（glue language）来连接现有组件。Python简单易学的语法强调可读性，因此降低了程序维护成本。Python支持模块和包，促进了程序模块化和代码复用。Python解释器和扩展的标准库以源代码或二进制形式免费提供，支持所有主要平台，并且可以自由分发。

这很好地描述了为何Python已成为当今主要编程语言之一。如今，从初级程序员到高级专家开发者，从学校、大学到网络公司、大企业和金融机构，以及任何科学领域，都在使用Python。

Python的特点包括：#

开源（Open source） Python及大多数支持的库和工具都是开源的，通常具有相当灵活和开放的许可证。

解释型（Interpreted） 参考CPython实现是该语言的解释器，在运行时将Python代码翻译为可执行的字节码（byte code）。

多范式（Multiparadigm） Python支持不同的编程和实现范式，如面向对象、命令式、函数式和过程式编程。

多用途（Multipurpose） Python既可用于快速交互式代码开发，也可用于构建大型应用；既可用于底层系统操作，也可用于高级分析任务。

跨平台（Cross-platform） Python适用于最重要的操作系统，如Windows、Linux和macOS。它可用于构建桌面和Web应用，既可在大型集群和最强大的服务器上运行，也可在Raspberry Pi等小型设备上使用。

动态类型（Dynamically typed） Python的类型通常在运行时推断，而非像大多数编译语言那样静态声明。

缩进感知（Indentation aware） 与大多数其他编程语言不同，Python使用缩进来标记代码块，而非圆括号、方括号或分号。

垃圾回收（Garbage collecting） Python具有自动垃圾回收机制，无需程序员管理内存。

谈到Python语法和Python的核心理念，Python Enhancement Proposal 20——即所谓的"Python之禅"（Zen of Python）——提供了主要指导原则。它可以通过每个交互式shell中的命令 import this 来访问：

In [1]: import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.

面对歧义，拒绝猜测的诱惑。应该有一种——最好只有一种——明显的做法。虽然那种方式一开始可能并不明显，除非你是荷兰人。做比不做好。虽然"立刻"做通常不如"现在"做。如果实现难以解释，那是个坏主意。如果实现容易解释，那可能是个好主意。命名空间（Namespaces）是一个绝妙的理念——让我们多做些吧！

第2章 · Python基础设施

Mon, 01 Jan 0001 00:00:00 +0000

建房首先要选好木材。木匠必须携带好用的工具，并在有空时磨利这些工具。 —宫本武藏（《五轮书》）

对于Python新手来说，Python部署可能看起来并不简单。大量可选安装的库和包也是如此。首先，Python不止一种。Python有多种不同的风格，如CPython、Jython、IronPython和PyPy。还有Python 2.7与3.x世界之间的分歧。¹

即使你决定了版本，部署仍然因其他一些原因而变得困难：

• 解释器（标准CPython安装）仅附带所谓的标准库（例如涵盖典型数学函数） • 可选的Python包需要单独安装——而且有成百上千个 • 由于依赖关系和特定操作系统的要求，自行编译/构建这些非标准包可能很棘手 • 处理这些依赖关系和随时间保持版本一致性（即维护）通常是繁琐和耗时的 • 某些包的更新或升级可能需要重新编译许多其他包 • 更改或替换一个包可能导致（许多）其他地方的麻烦

幸运的是，有一些可用的工具和策略可以提供帮助。本章涵盖以下有助于Python部署的技术类型：

包管理器（Package managers） 像pip和conda这样的包管理器有助于安装、更新和移除Python包；它们还有助于保持不同包的版本一致性。

虚拟环境管理器（Virtual environment managers） 像virtualenv或conda这样的虚拟环境管理器允许你并行管理多个Python安装（例如，在单台机器上同时拥有Python 2.7和3.7安装，或测试某个新奇Python包的最新开发版本而无风险）。²

容器（Containers） Docker容器代表完整的文件系统，包含运行特定软件所需的所有系统组件，如代码、运行时或系统工具。例如，你可以在运行macOS或Windows 10的机器上托管的Docker容器中，运行带有Python 3.7安装和相应Python代码的Ubuntu 18.04操作系统。

云实例（Cloud instances） 部署用于金融应用的Python代码通常需要高可用性、安全性和性能；这些要求通常只能通过使用专业的计算和存储基础设施来满足，而如今这些基础设施以从相当小到真正大而强大的云实例的形式，以优惠的条件提供。与长期租用的专用服务器相比，云实例的一个好处是用户通常只按实际使用的小时数付费；另一个优势是，如果需要，这类云实例实际上在一两分钟内就可以启动，这有助于敏捷开发和可扩展性。

本章的结构如下：

conda作为包管理器 本节介绍conda作为Python包管理器的用法。

conda作为虚拟环境管理器 本节重点介绍conda作为虚拟环境管理器的能力。

使用Docker容器 本节简要概述Docker作为容器化技术，并重点介绍构建基于Ubuntu的、包含Python 3.7安装的容器。

使用云实例 本节展示如何在云端部署Python和Jupyter Notebook——一套强大的、基于浏览器的Python开发工具套件。

本章的目标是在专业基础设施上建立正确的Python安装，配备最重要的工具以及数值、数据分析和可视化包。这样的组合将作为后续章节中实现和部署Python代码的骨干——无论是交互式金融分析代码，还是脚本和模块形式的代码。

conda作为包管理器#

虽然conda可以独立安装，但一种高效的方式是通过Miniconda，它是一个最小的Python发行版，包含conda作为包和虚拟环境管理器。

安装Miniconda#

Miniconda适用于Windows、macOS和Linux。你可以从Miniconda网页下载不同版本。以下假设使用Python 3.7 64位版本。本节的主要示例是在基于Ubuntu的Docker容器中进行会话，通过wget下载Linux 64位安装程序，然后安装Miniconda。所展示的代码应该适用于任何其他基于Linux或macOS的机器（可能只需稍作修改）：

$ docker run -ti -h py4fi -p 11111:11111 ubuntu:latest /bin/bash

root@py4fi:/# apt-get update; apt-get upgrade -y
...
root@py4fi:/# apt-get install -y bzip2 gcc wget
...
root@py4fi:/# cd root
root@py4fi:~# wget \
> https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh \
> -0 miniconda.sh
...
HTTP request sent, awaiting response... 200 OK
Length: 62574861 (60M) [application/x-sh]
Saving to: 'miniconda.sh'

miniconda.sh 100%[=================>] 59.68M 5.97MB/s in 11s

2018-09-1509:44:28 (5.42 MB/s) - 'miniconda.sh' saved [62574861/62574861]

root@py4fi:~# bash miniconda.sh

第二部分 · 掌握基础

Mon, 01 Jan 0001 00:00:00 +0000

Part 2

掌握基础

Python数据类型、NumPy、pandas、面向对象编程——金融计算的核心基础。

本部分章节#

第3章数据类型与结构 — 基本数据类型、元组、列表、字典、集合、控制结构与函数式编程。

第4章 NumPy数值计算 — 数组操作、向量化、结构化数组、内存布局与性能比较。

第5章 pandas数据分析 — DataFrame基础操作、GroupBy聚合、合并连接、性能考量。

第6章面向对象编程 — Python对象模型、类基础、数据模型、自定义向量类。

第3章 · 数据类型与结构

Mon, 01 Jan 0001 00:00:00 +0000

数据类型与结构#

糟糕的程序员关心代码，优秀的程序员关心数据结构及其关系。

—Linus Torvalds

本章介绍Python的基本数据类型（Data Types）与数据结构（Data Structures），组织如下：

"基本数据类型" on page 62

第一部分介绍基本数据类型，如 int、float、bool 和 str。

"基本数据结构" on page 75

第二部分介绍Python的基本数据结构（如列表对象），并展示控制结构、函数式编程方法和匿名函数等内容。

本章旨在对Python在数据类型与结构方面的特性进行通用介绍。具备其他编程语言（如C或Matlab）背景的读者，应当能够轻松掌握Python使用所可能带来的差异。这里介绍的主题和惯用法对后续章节至关重要。

本章涵盖以下数据类型与结构：

对象类型	含义	用途
int	整数值	自然数
float	浮点数	实数
bool	布尔值	真或假
str	字符串对象	字符、词语、文本
tuple	不可变容器	固定对象集合、记录
list	可变容器	可变对象集合
dict	可变容器	键值存储
set	可变容器	唯一对象的集合

基本数据类型#

Python是一种动态类型语言（Dynamically Typed Language），这意味着Python解释器在运行时推断对象的类型。相比之下，C等编译语言通常是静态类型语言（Statically Typed Language），对象的类型必须在编译前指定。¹

整数#

最基本的数据类型之一是整数（Integer, int）：

In [1]: a = 10
type(a)
Out[1]: int

内置函数 type 提供所有对象的类型信息，包括标准类型、内置类型，以及新创建的类和对象。对于后者，所提供的信息取决于程序员在类中存储的描述。有一种说法是"Python中一切都是对象"，这意味着即使是像刚才定义的 int 对象这样的简单对象，也具有内置的方法。例如，可以通过调用 bit_length() 方法获取在内存中表示该 int 对象所需的位数：

In [2]: a.bit_length()
Out[2]: 4

所需的位数随着赋给对象的整数值增大而增加：

In [3]: a = 100000
a.bit_length()
Out[3]: 17

一般来说，方法非常多，以至于很难记住所有类和对象的所有方法。像IPython这样的高级Python环境提供了Tab补全功能，可以显示对象的所有方法。只需输入对象名后跟一个点（如 a.），然后按Tab键，就会显示可以在该对象上调用的方法集合。另外，Python内置函数 dir 可以列出任何对象的所有属性和方法。

Python的一个特性是整数可以任意大。例如，考虑古戈尔数 10¹⁰⁰。Python处理如此大的数毫无问题：

In [4]: googol = 10 ** 100
 googol

Out[4]: 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

In [5]: googol.bit_length()
Out[5]: 333

第4章 · NumPy数值计算

Mon, 01 Jan 0001 00:00:00 +0000

NumPy数值计算#

计算机毫无用处，它们只能给出答案。

—Pablo Picasso

虽然Python解释器本身已经提供了丰富的数据结构，但NumPy和其他库以有价值的方式进一步扩展了这些数据结构。本章聚焦于NumPy，它提供了多维数组对象（Multidimensional Array）来存储同质或异质数据数组，并支持代码的向量化。

本章涵盖以下数据结构：

对象类型	含义	用途
ndarray（常规）	n维数组对象	大型数值数据数组
ndarray（记录）	二维数组对象	按列组织的表格数据

本章组织如下：

"数据数组" on page 86

本节讨论使用纯Python代码处理数据数组。

"常规NumPy数组" on page 90

这是关于常规NumPy ndarray类的核心部分，是所有涉及数值数据的数据密集型Python用例的主力工具。

"结构化NumPy数组" on page 105

本小节简要介绍用于处理带列名的表格数据的结构化（或记录）ndarray对象。

"代码向量化" on page 106

本节讨论代码向量化及其优势；还讨论了某些场景下内存布局的重要性。

数据数组#

前一章展示了Python提供了一些相当有用和灵活的通用数据结构。特别是，列表对象可以被视为具有许多便利特性和应用领域的真正主力。使用这种灵活（可变）的数据结构是有代价的，表现为相对较高的内存使用、较慢的性能，或两者兼有。然而，科学和金融应用通常需要在特殊数据结构上进行高性能操作。在这方面最重要的数据结构之一就是数组（Array）。数组通常将相同数据类型的其他（基本）对象按行和列组织起来。

暂时假设只有数字是相关的，尽管这个概念也可以推广到其他类型的数据。在最简单的情况下，一维数组在数学上表示一个向量，通常由浮点数对象在内部表示的真实数组成。它仅由单行或单列元素组成。在更常见的情况下，数组表示一个 i × j 的元素矩阵。这个概念可以推广到三维中的 i × j × k 立方体元素，以及一般的 n 维数组，其形状为 $i \times j \times k \times l \times$

线性代数和向量空间理论等数学学科表明，这种数学结构在许多科学学科和领域中具有高度重要性。因此，拥有一个专门设计用于方便高效处理数组的数据结构类是富有成效的。这正是Python库NumPy及其强大的 ndarray 类的用武之地。在下一节介绍这个类之前，本节将说明处理数组的两种替代方案。

使用Python列表的数组#

可以使用前一章介绍的内置数据结构来构建数组。list 对象特别适合完成此任务。一个简单的列表已经可以被视为一维数组：

In [1]: v = [0.5, 0.75, 1.0, 1.5, 2.0]

包含数字的列表对象。

由于列表对象可以包含任意其他对象，它们也可以包含其他列表对象。通过这种方式，可以通过嵌套列表对象轻松构造二维和更高维的数组：

第5章 · pandas数据分析

Mon, 01 Jan 0001 00:00:00 +0000

pandas数据分析#

数据！数据！数据！没有黏土，我无法造砖！

—Sherlock Holmes

本章介绍 pandas，一个专注于表格数据的数据分析库。pandas 是一个强大的工具，不仅提供了许多有用的类和函数，还出色地封装了其他包的功能。其结果是提供了一个用户界面，使数据分析，特别是金融分析，变得更加便捷高效。

本章涵盖以下基本数据结构：

对象类型	含义	用途
DataFrame	带索引的二维数据对象	按列组织的表格数据
Series	带索引的一维数据对象	单个（时间）数据序列

本章组织如下：

"DataFrame类" on page 114

本节首先通过简单的小数据集探索 pandas 的 DataFrame 类的基本特性和功能；然后展示如何将 NumPy 的 ndarray 对象转换为 DataFrame 对象。

"基本分析" on page 123 和 "基本可视化" on page 126

这些部分介绍了基本的分析和可视化功能（后续章节会更深入探讨这些主题）。

"Series类" on page 128

这一小节介绍 pandas 的 Series 类，它在某种意义上代表了 DataFrame 类的一种特殊情况，仅包含单列数据。

"GroupBy操作" on page 130

DataFrame 类的优势之一在于能够根据单个或多个列对数据进行分组。本节探讨 pandas 的分组功能。

"复杂选择" on page 132

本节说明如何使用（复杂）条件从 DataFrame 对象中轻松选择数据。

"连接、拼接与合并" on page 135

将不同数据集合并为一个是数据分析中的重要操作。pandas 提供了不同的选项来完成此任务，如本节所述。

"性能方面" on page 141

第6章 · 面向对象编程

Mon, 01 Jan 0001 00:00:00 +0000

面向对象编程#

软件工程的目标是控制复杂性，而不是制造复杂性。

—Pamela Zave

面向对象编程（Object-Oriented Programming, OOP）是当今最流行的编程范式之一。如果使用得当，它与过程式编程（Procedural Programming）相比具有许多优势。在许多情况下，OOP 似乎特别适合金融建模和实现金融算法。然而，也有许多批评者对其中的某些方面甚至整个范式持怀疑态度。本章采取中立立场，将 OOP 视为一种重要工具，它可能不是解决每个问题的最佳方法，但应该是从事金融工作的程序员和宽客（Quants）应该掌握的工具。

使用 OOP 会带来一些新的语言术语。就本书和本章而言，最重要的术语如下（更多内容将在后面介绍）：

类（Class）#

某种类型对象的抽象定义。例如，人类。

对象（Object）

类的一个实例。例如，Sandra。

属性（Attribute）#

类的一个特征（类属性）或类实例的特征（实例属性）。例如，属于哺乳动物、男性或女性，或眼睛的颜色。

方法（Method）#

类或其实例可以实现的操作。例如，行走。

参数（Parameter）#

方法接受的输入，用于影响其行为。例如，三步。

实例化（Instantiation）

基于抽象类创建特定对象的过程。

转换成 Python 代码，实现人类示例的简单类可能如下所示：

In [1]: class HumanBeing(object):
 def__init__(self, first_name, eye_color):
 self.first_name = first_name
 self.eye_color = eye_color
 self.position = 0
 def walk_steps(self, steps):
 self.position += steps

类定义语句；self 引用当前类的实例。

实例化期间调用的特殊方法。

用参数值初始化的名字属性。

用参数值初始化的眼睛颜色属性。

初始化为 0 的位置属性。

定义行走的方法，steps 为参数。

根据 steps 值改变位置的代码。

基于类定义，可以实例化并使用新的 Python 对象：

In [2]: Sandra = HumanBeing('Sandra', 'blue')
In [3]: Sandra.first_name
Out[3]: 'Sandra'
In [4]: Sandra.position
Out[4]: 0
In [5]: Sandra.walk_steps(5)
In [6]: Sandra.position
Out[6]: 5

实例化。

访问属性值。

调用方法。

访问更新后的位置值。

支持使用 OOP 的若干人为因素：

自然思维方式#

人类思维通常围绕现实世界或抽象对象展开，如汽车或金融工具。OOP 适合用其特征来建模此类对象。

降低复杂性#

通过不同的方法，OOP 有助于降低问题或算法的复杂性，并逐步建立模型。

第三部分 · 金融数据科学

Mon, 01 Jan 0001 00:00:00 +0000

Part 3

金融数据科学

数据可视化、时间序列分析、I/O操作、性能优化、数学工具、随机过程、统计学。

本部分章节#

第7章数据可视化 — 2D/3D静态绘图、交互式2D绘图、金融图表与自定义样式。

第8章金融时间序列 — 数据导入、变化分析、滚动统计、相关性分析与高频数据。

第9章输入/输出操作 — Python I/O、SQL数据库、CSV/Excel、PyTables与TsTables。

第10章 Python性能优化 — 循环优化、NumPy/Numba/Cython加速、蒙特卡洛模拟与多进程。

第11章数学工具 — 逼近、回归、插值、凸优化、积分、符号计算与微分。

第12章随机过程 — 随机数生成、模拟、随机过程、方差缩减、风险度量与估值。

第13章统计学 — 正态性检验、投资组合优化、贝叶斯统计与机器学习应用。

第7章 · 数据可视化

Mon, 01 Jan 0001 00:00:00 +0000

数据可视化#

一图胜千言。 —Arthur Brisbane (1911)

本章介绍 matplotlib 和 plotly 包的基本可视化功能。

虽然有更多的可视化包可用，但 matplotlib 已确立了自己作为基准和——在许多情况下——一种稳健可靠的可视化工具的地位。它既易于用于标准绘图，在处理更复杂的绘图和自定义时也非常灵活。此外，它与 NumPy 和 pandas 及其提供的数据结构紧密集成。

matplotlib 只能生成位图形式的图表（例如 PNG 或 JPG 格式）。另一方面，现代 Web 技术——例如基于数据驱动文档（Data-Driven Documents, D3.js）标准的技术——允许创建漂亮的交互式且可嵌入的图表（交互式的意思是，例如，可以放大查看特定区域的更多细节）。plotly 是一个可以方便地用 Python 创建此类 D3.js 图表的包。一个名为 Cufflinks 的小型附加库将 plotly 与 pandas DataFrame 对象紧密集成，并允许创建流行的金融图表（如蜡烛图（candlestick chart））。

本章主要涵盖以下主题：

"静态二维绘图" on page 168

本节介绍 matplotlib，并展示一系列典型的二维绘图，从最简单的到一些更高级的——带有双刻度或不同子图的绘图。

"静态三维绘图" on page 191

基于 matplotlib，本节展示了一些对某些金融应用有用的三维绘图。

"交互式二维绘图" on page 195

本节介绍 plotly 和 Cufflinks 以创建交互式二维绘图。利用 Cufflinks 的 QuantFigure 功能，本节还介绍了技术分析中使用的典型金融图表。

本章无法全面介绍 Python、matplotlib 或 plotly 的数据可视化功能，但提供了一些示例，展示了这些包在金融领域的基本和重要功能。其他示例也出现在后续章节中。例如，第8章更深入地展示了如何使用 pandas 库可视化金融时间序列数据。

第8章 · 金融时间序列

Mon, 01 Jan 0001 00:00:00 +0000

金融时间序列#

时间让一切不会同时发生。 —Ray Cummings

金融时间序列数据（financial time series data）是金融领域中最重要的数据类型之一。这是按日期和/或时间索引的数据。例如，股票价格随时间的变化就代表了金融时间序列数据。类似地，欧元/美元汇率随时间变化也代表金融时间序列；汇率以短时间间隔报价，这些报价的集合就构成了汇率的时间序列。

没有一个金融学科不考虑时间这个重要因素。这基本上与物理学和其他科学相同。处理时间序列数据的主要 Python 工具是 pandas。Wes McKinney——pandas 的原作者和主要作者——在 AQR Capital Management（一家大型对冲基金）担任分析师时开始开发这个库。可以肯定地说，pandas 从头开始就被设计为处理金融时间序列数据。

本章主要基于两个金融时间序列数据集，格式为逗号分隔值（comma-separated values, CSV）文件。内容结构如下：

金融数据

本节介绍使用 pandas 处理金融时间序列数据的基础知识：数据导入、导出汇总统计、计算随时间的变化以及重采样。

滚动统计

在金融分析中，滚动统计（rolling statistics）扮演着重要角色。这些统计量通常在一个固定的时间区间上计算，并在整个数据集中向前滚动。一个流行的例子是简单移动平均线（simple moving averages）。本节说明 pandas 如何支持此类统计量的计算。

相关性分析

本节基于标准普尔500指数（S&P 500）和 VIX 波动率指数（VIX volatility index）的金融时间序列数据提供一个案例研究。它为两个指数呈负相关这一程式化（实证）事实提供了一些支持。

高频数据

本节处理高频数据（high-frequency data），或称逐笔数据（tick data），这在金融领域已变得非常普遍。pandas 再次证明了其在处理此类数据集方面的强大能力。

金融数据#

本节使用一个本地存储的 CSV 格式金融数据集。从技术上讲，此类文件是简单的文本文件，具有以逗号分隔单个值的数据行结构。在导入数据之前，先进行一些包导入和自定义设置：

In [1]: import numpy as np
import pandas as pd
from pylab import mpl, plt
plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
%matplotlib inline

数据导入#

pandas 提供了许多不同的函数和 DataFrame 方法来导入不同格式（CSV、SQL、Excel 等）存储的数据，并导出为不同格式（参见第9章了解更多细节）。以下代码使用 pd.read_csv() 函数从 CSV 文件导入时间序列数据集：¹

In [2]: filename = '.././source/tr_eikon_eod_data.csv'
In [3]: f = open(filename, 'r') ②
f.readlines()[:5] ②
Out[3]: ['Date,AAPL.0,MSFT.0,INTC.0,AMZN.0,GS.N,SPY,.SPX,.VIX,EUR=,XAU=,GDX, ,GLD\n',
'2010-01-01,,,,,,,1.4323,1096.35,,\n',
'2010-01-04,30.57282657,30.95,20.88,133.9,173.08,113.33,1132.99,20.04,
,1.4411,1120.0,47.71,109.8\n',
'2010-01-05,30.625683660000004,30.96,20.87,134.69,176.14,113.63,1136.52,
,19.35,1.4368,1118.65,48.17,109.7\n',
'2010-01-06,30.138541290000003,30.77,20.8,132.25,174.26,113.71,1137.14,
,19.16,1.4412,1138.5,49.34,111.51\n']

In [4]: data = pd.read_csv(filename, index_col=0, parse_dates=True)
In [5]: data.info() 6
<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: 2216 entries, 2010-01-01 to 2018-06-29
Data columns (total 12 columns):
AAPL.02138 non-null float64
MSFT.02138 non-null float64
INTC.02138 non-null float64
AMZN.02138 non-null float64
GS.N 2138 non-null float64
SPY 2138 non-null float64
.SPX 2138 non-null float64
.VIX 2138 non-null float64
EUR= 2216 non-null float64
XAU= 2211 non-null float64
GDX 2138 non-null float64
GLD 2138 non-null float64
dtypes: float64(12)
memory usage: 225.1 KB

① 指定路径和文件名。

第9章 · 输入/输出操作

Mon, 01 Jan 0001 00:00:00 +0000

输入/输出操作#

在没有数据之前就提出理论是一个致命的错误。 —Sherlock Holmes

作为一般规则，大多数数据——无论是在金融领域还是任何其他应用领域——都存储在硬盘驱动器（hard disk drives, HDDs）或其他某种永久存储设备上，如固态硬盘（solid state disks, SSDs）或混合硬盘驱动器。多年来，存储容量稳步增长，而每存储单元（例如每兆字节）的成本则稳步下降。

与此同时，存储的数据量增长速度远远超过即使是最大型机器上可用的典型随机存取存储器（random access memory, RAM）的增长速度。这使得不仅需要将数据存储到磁盘以实现永久存储，还需要通过将数据从 RAM 交换到磁盘及反向操作来弥补 RAM 不足的问题。

因此，输入/输出（I/O）操作在金融应用和数据密集型应用中是一项重要任务。它们通常代表了性能关键型计算的瓶颈，因为 I/O 操作通常无法足够快地将数据传送到 RAM¹ 或从 RAM 传送到磁盘。从某种意义上说，CPU 常常因慢速的 I/O 操作而"饥饿"。

尽管当今大多数金融和企业分析工作都面临大数据（例如 PB 级规模），但单个分析任务通常使用属于"中等"数据范畴的数据子集。微软研究院的一项研究指出：

我们的测量以及其他近期工作表明，大多数真实世界的分析任务处理的数据量不到 100 GB，但 Hadoop/MapReduce 等流行基础设施最初是为 PB 级处理设计的。 —Appuswamy et al. (2013)

就频率而言，单个金融分析任务通常处理不超过几 GB 的数据——而这正是 Python 及其科学栈库（如 NumPy、pandas 和 PyTables）的最佳适用点。这种大小的数据集也可以在内存中进行分析，利用当今的 CPU 和 GPU 通常能实现高速处理。然而，数据必须读入 RAM，结果必须写入磁盘，同时确保满足当今的性能要求。

本章涉及以下主题：

"Python 基本 I/O" on page 232#

Python 有内置函数来序列化并将任何对象存储到磁盘，以及从磁盘将其读入 RAM；除此之外，Python 在处理文本文件和 SQL 数据库方面也很强大。NumPy 也提供了专门的函数用于 ndarray 对象的快速二进制存储和检索。

第10章 · Python性能优化

Mon, 01 Jan 0001 00:00:00 +0000

Python性能优化#

不要降低你的期望去适应你的表现。提升你的表现去达到你的期望。 —Ralph Marston

长期以来存在一种偏见，认为Python本身是一种相对较慢的编程语言，不适合实现金融中的计算密集型任务。除了Python是一种解释型语言这一事实外，推理通常沿着以下思路进行：Python在处理循环时很慢；而实现金融算法通常需要循环；因此Python对于金融算法实现来说太慢了。另一种推理思路是：其他（编译型）编程语言（如C或C++）在执行循环时很快；而金融算法通常需要循环；因此这些（编译型）编程语言非常适合金融和金融算法实现。

诚然，确实可以编写执行相当缓慢的Python代码——对于许多应用领域来说可能太慢了。本章介绍如何加速金融环境中常见的典型任务和算法。它表明，通过明智地使用数据结构、选择正确的实现惯用法和范式，以及使用正确的性能包，Python甚至能够与编译型编程语言竞争。这其中的原因之一就是Python本身也可以被编译。

为此，本章介绍了加速代码的不同方法：

向量化#

利用Python的向量化（vectorization）能力是前面章节中已经广泛使用的一种方法。

动态编译（Dynamic compiling）使用Numba包可以通过LLVM技术动态编译纯Python代码。

Cython 不仅是一个Python包，更是一种混合了Python和C的语言；例如，它允许使用静态类型声明并静态编译此类调整后的代码。

多进程处理（Multiprocessing） Python的multiprocessing模块可以轻松实现代码执行的并行化。

本章涉及以下主题：

"循环"一节本节讨论Python循环以及如何加速它们。

"算法"一节本节关注常用于性能基准测试的标准数学算法，如斐波那契数列生成。

"二叉树模型"一节二叉树期权定价模型是一种广泛使用的金融模型，为更复杂的金融算法提供了一个有趣的案例研究。

"蒙特卡洛模拟"一节同样，蒙特卡洛模拟在金融实践中广泛用于定价和风险管理。它的计算需求很高，长期以来被认为是C或C++等语言的领域。

本节讨论基于金融时间序列数据的递归算法的加速。特别是，它介绍了计算指数加权移动平均（EWMA, Exponentially Weighted Moving Average）的不同实现。

循环#

本节解决Python循环问题。任务相当简单：编写一个函数，抽取一定"大"数量的随机数并返回这些值的平均值。执行时间是关注的重点，可以通过魔法函数%time和%timeit来估计。

Python#

让我们开始"慢速"进行——请原谅这个双关语。在纯Python中，这样的函数可能看起来像average_py()：

In [1]: import random

In [2]: def average_py(n):
 s = 0 ①
 for i in range(n):
 s += random.random() ②
 return s / n ③

In [3]: n = 10000000 ④

In [4]: %time average_py(n) ⑤
 CPU times: user 1.82 s, sys: 10.4 ms, total: 1.83 s
 Wall time: 1.93 s

Out[4]: 0.5000590124747943

In [5]: %timeit average_py(n) ⑥
 1.31 s ± 159 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [6]: %time sum([random.random() for_ in range(n)]) / n ⑦
 CPU times: user 1.55 s, sys: 188 ms, total: 1.74 s
 Wall time: 1.74 s

Out[6]: 0.49987031710661173

① 初始化变量s的值。

第11章 · 数学工具

Mon, 01 Jan 0001 00:00:00 +0000

数学工具#

数学家是现代世界的祭司。 —Bill Gaede

自20世纪80年代和90年代所谓的"火箭科学家"（Rocket Scientists）进入华尔街以来，金融学已发展为一门应用数学学科。早期的金融研究论文包含大量文本和少量数学表达式与方程，而当前的研究论文则主要由数学表达式和方程组成，周围辅以一些解释性文本。

本章介绍一些对金融有用的数学工具，但不对每一种工具提供详细的背景知识。关于这个主题有许多有用的书籍，因此本章重点介绍如何使用Python来应用这些工具和技术。具体而言，它涵盖：

"近似"一节

回归（regression）和插值（interpolation）是金融中最常用的数值技术之一。

"凸优化"一节

许多金融学科需要凸优化（convex optimization）工具（例如，在模型校准时的衍生品分析）。

"积分"一节特别是金融（衍生）资产的估值通常归结为积分的计算。

"符号计算"一节 Python通过SymPy提供了一个强大的符号数学包，例如，用于求解（方程组）。

近似#

首先，进行通常的导入：

In [1]: import numpy as np from pylab import plt, mpl

In [2]: plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
%matplotlib inline

在本节中，主要的示例函数如下，它由一个三角项和一个线性项组成：

In [3]: def f(x):
 return np.sin(x) + 0.5 * x

主要关注点在给定区间上通过回归（regression）和插值（interpolation）技术对该函数进行近似。首先，绘制函数图像以更好地了解近似要达到什么效果。感兴趣的区间应为[–2π, 2π]。图11-1显示了通过np.linspace()函数定义的固定区间上的函数。函数create_plot()是一个辅助函数，用于创建本章中多次需要的相同类型的图：

In [4]: def create_plot(x, y, styles, labels, axlabels):
 plt.figure(figsize=(10, 6))
 for i in range(len(x)):
 plt.plot(x[i], y[i], styles[i], label=labels[i])
 plt.xlabel(axlabels[0])
 plt.ylabel(axlabels[1])
 plt.legend(loc=0)

In [5]: x = np.linspace(-2 * np.pi, 2 * np.pi, 50)

In [6]: create_plot([x], [f(x)], ['b'], ['f(x)'], ['x', 'f(x)'])

① 用于绘图和计算的x值。

图11-1 示例函数图

回归#

回归（regression）在函数近似方面是一种相当高效的工具。它不仅适用于一维函数的近似，在高维问题上也表现出色。得到回归结果所需的数值技术易于实现且执行迅速。基本上，给定一组所谓的基函数（basis functions）b_d, d ∈ {1, ..., D}，回归的任务是根据方程11-1找到最优参数α₁*, ..., α_D*，其中y_i ≡ f(x_i)，i ∈ {1, ..., I}为观测点。x_i被视为独立观测值，y_i为因变量观测值（在函数或统计意义上）。

方程11-1. 回归的最小化问题

$$ \min_{\alpha_{1}, \dots , \alpha_{D}} \frac{1}{I} \sum_{i = 1} ^{I} \left(y_{i} - \sum_{d = 1} ^{D} \alpha_{d} \cdot b_{d} (x_{i})\right) ^{2} $$

以单项式为基函数#

最简单的情况之一是使用单项式（monomials）作为基函数——即b₁ = 1, b₂ = x, b₃ = x², b₄ = x³, ...。在这种情况下，NumPy具有内置函数，既可用于确定最优参数（即np.polyfit()），也可用于在给定一组输入值时评估近似结果（即np.polyval()）。

第12章 · 随机过程

Mon, 01 Jan 0001 00:00:00 +0000

随机过程#

可预测性不是事情将会如何发展，而是事情可能如何发展。 —Raheel Farooq

如今，随机过程（Stochastics）是金融学中最重要的数学与数值学科之一。在现代金融学早期，主要是20世纪70年代和80年代，金融研究的主要目标是为特定金融模型下的期权定价等问题寻找闭式解。近年来，需求已发生巨大变化——金融市场参与者不仅需要正确估值单个金融工具，还需要对整本衍生品账簿等进行一致估值。同样，要在整个金融机构范围内得出一致的风险度量指标（如风险价值（Value-at-Risk, VaR）和信用估值调整（Credit Valuation Adjustment, CVA）），必须考虑机构的所有账簿及其所有交易对手。这些艰巨的任务只能依靠灵活高效的数值方法来解决。因此，随机过程一般方法以及蒙特卡洛模拟（Monte Carlo Simulation）这一特定方法在金融领域日益重要。

本章从 Python 角度介绍以下主题：

"随机数" 见第346页

一切始于伪随机数（Pseudo-Random Numbers），它们构成了所有模拟工作的基础；尽管拟随机数（Quasi-Random Numbers，例如基于 Sobol 序列）在金融领域已获得一定认可，但伪随机数似乎仍是基准方法。

"模拟" 见第352页

在金融中，两项模拟任务尤为重要：随机变量（Random Variables）的模拟和随机过程（Stochastic Processes）的模拟。

In [3]: npr.seed(100) ①
np.set_printoptions(precision=4) ①

In [4]: npr.rand(10) ②
Out[4]: array([0.5434, 0.2784, 0.4245, 0.8448, 0.0047, 0.1216, 0.6707, 0.8259, 0.1367, 0.5751])

In [5]: npr.rand(5, 5) ③
Out[5]: array([[0.8913, 0.2092, 0.1853, 0.1084, 0.2197], [0.9786, 0.8117, 0.1719, 0.8162, 0.2741], [0.4317, 0.94, 0.8176, 0.3361, 0.1754], [0.3728, 0.0057, 0.2524, 0.7957, 0.0153],

"估值" 见第375页#

估值（Valuation）的两个主要方向是欧式行权（European exercise，在特定日期行权）和美式行权（American exercise，在特定时间区间内行权）的衍生品估值；此外还有百慕大行权（Bermudan exercise），即在有限个特定日期行权的工具。

"风险度量" 见第383页#

模拟方法非常适合计算风险度量指标，如风险价值（VaR）、信用风险价值（Credit Value-at-Risk, CVaR）和信用估值调整（CVA）。

随机数#

本章使用 numpy.random 子包提供的函数生成随机数：¹

In [1]: import math
import numpy as np
import numpy.random as npr
from pylab import plt, mpl

In [2]: plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
%matplotlib inline

从 NumPy 导入随机数生成子包#

例如，rand() 函数以参数指定的形状返回半开区间 [0,1) 中的随机数。返回对象是一个 ndarray 对象。这些数可以轻松变换到实数轴上的其他区间。例如，如果要生成区间 [a,b)=[5,10) 上的随机数，可以按如下示例变换 npr.rand() 返回的数——由于 NumPy 的广播机制，这在多维下同样适用：

第13章 · 统计学

Mon, 01 Jan 0001 00:00:00 +0000

统计学#

除了真相，我可以用统计数据证明任何事情。 —George Canning

统计学（Statistics）是一个广阔的领域，但它提供的工具和结果已成为金融领域不可或缺的部分。这解释了为什么 R 等特定领域语言在金融行业中如此流行。统计模型越精细复杂，拥有易用且高性能的计算解决方案就越重要。

一本像这样的书中的单一章节无法全面展现统计学的丰富性和深度。因此，与许多其他章节一样，本章的方法是聚焦于精选的主题，这些主题看似重要，或者为使用 Python 处理特定任务提供了良好的起点。本章有四个重点：

"正态性检验" 见第398页

大量重要的金融模型，如现代投资组合理论（Modern Portfolio Theory, MPT，即均值-方差投资组合理论）和资本资产定价模型（Capital Asset Pricing Model, CAPM），都依赖于证券收益率呈正态分布的假设。因此，本章介绍了检验给定时间序列收益率正态性的方法。

"投资组合优化" 见第415页

MPT 可被视为统计学在金融领域最成功的应用之一。从20世纪50年代初先驱 Harry Markowitz 的工作开始，这一理论开始用严谨的数学和统计方法取代人们在金融市场投资中对判断和经验的依赖。在这个意义上，它或许是金融领域第一个真正的量化模型和方法。

"贝叶斯统计学" 见第429页#

在概念层面上，贝叶斯统计学（Bayesian Statistics）引入了代理信念（Beliefs）和信念更新的概念。在线性回归中，这可能表现为回归参数具有统计分布而非单一点估计（例如回归线的截距和斜率）。如今，贝叶斯方法在金融领域被广泛使用，因此本节通过一些示例来说明贝叶斯方法。

"机器学习" 见第444页#

机器学习（Machine Learning，或称统计学习）基于先进的统计方法，被认为是人工智能（AI）的子学科。与统计学本身一样，机器学习提供了丰富的方法和模型来从数据集中学习，并根据所学内容进行预测。区分了不同的学习算法，如监督学习（Supervised Learning）或无监督学习（Unsupervised Learning）。算法解决的问题类型也有所不同，如估计或分类。本章中的示例属于分类的监督学习范畴。

本章的许多方面涉及日期和/或时间信息。请参阅附录A，了解如何使用 Python、NumPy 和 pandas 处理此类数据。

正态性检验#

正态分布（Normal Distribution）可以被认为是金融中最重要的分布，也是金融理论的主要统计基石之一。以下金融理论的基石在很大程度上依赖于金融工具收益率呈正态分布的假设：¹

投资组合理论#

当股票收益率呈正态分布时，最优投资组合选择可以转化为一个框架，其中只有（期望）平均收益率、收益率方差（或波动率）以及不同股票之间的协方差与投资决策（即最优投资组合构成）相关。

资本资产定价模型#

同样，当股票收益率呈正态分布时，单只股票的价格可以优雅地表示为与广泛市场指数的线性关系；这种关系通常通过衡量单只股票与市场指数共同运动的指标——贝塔（Beta 或 β）来表示。

有效市场假说#

有效市场（Efficient Market）是指价格反映所有可用信息的市场，其中"所有"可以狭义或广义地定义（例如，"所有公开可用"信息 vs. 也包括"仅私下可用"信息）。如果该假说成立，那么股票价格随机波动，收益率呈正态分布。

期权定价理论#

布朗运动是建模金融工具随机价格运动的基准模型；著名的 Black-Scholes-Merton 期权定价公式使用几何布朗运动作为股票随时间随机价格波动的模型，导致价格呈对数正态分布，收益率呈正态分布。

这个远非详尽无遗的列表凸显了正态性假设在金融中的重要性。

基准案例#

为了为进一步分析奠定基础，首先从几何布朗运动开始——它是金融建模中的典型随机过程之一。关于几何布朗运动 S 的路径特征，可以得出以下结论：

正态对数收益率#

在时间 0 < s < t 之间的对数收益率 log $\begin{array} {r} {\frac{\boldsymbol{S} _{t}} {\boldsymbol{S} _{s}} = \log \boldsymbol{S} _{t} - \log \boldsymbol{S} _{s}} \end{array}$ 呈正态分布。

第四部分 · 算法交易

Mon, 01 Jan 0001 00:00:00 +0000

Part 4

算法交易

FXCM交易平台、交易策略回测与优化、自动化交易系统部署。

本部分章节#

第14章 FXCM交易平台 — 数据获取、API使用、订单下达与账户信息管理。

第15章交易策略 — 简单移动平均、OLS回归、聚类分类与深度神经网络。

第16章自动化交易 — 资本管理、Kelly准则、ML交易策略与线上部署。

第14章 · FXCM交易平台

Mon, 01 Jan 0001 00:00:00 +0000

FXCM 交易平台#

金融机构喜欢将自己做的事情称为"交易"。但说实话，这不是交易，这是赌博。 —Graydon Carter

本章介绍FXCM集团（以下简称"FXCM"）的交易平台，包括其RESTful和流式应用程序接口（API），以及Python封装包fxcmpy。FXCM为零售和机构交易者提供了多种金融产品，这些产品既可以通过传统交易应用程序进行交易，也可以通过API以编程方式进行交易。产品重点在于货币对以及主要股票指数和大宗商品等的差价合约（Contract for Difference, CFD）。

风险免责声明#

以保证金交易外汇/差价合约具有较高的风险水平，可能不适合所有投资者，因为您可能遭受超过本金的损失。杠杆可能对您不利。这些产品面向零售和专业客户。由于当地法律法规的特定限制，德国居民零售客户可能遭受存入资金的全部损失，但无需承担超出存入资金的后续付款义务。请了解并充分理解与市场和交易相关的所有风险。在交易任何产品之前，请仔细考虑您的财务状况和经验水平。任何意见、新闻、研究、分析、价格或其他信息均作为一般市场评论提供，不构成投资建议。市场评论并非按照旨在促进投资研究独立性的法律要求编制，因此不受任何禁止抢先传播的限制。FXCM和作者不对因使用或依赖此类信息而直接或间接产生的任何损失或损害（包括但不限于利润损失）承担责任。

FXCM的交易平台使即使是资金规模较小的个人交易者也能实施和部署算法交易策略。

本章涵盖使用FXCM交易API和fxcmpy Python包实现自动化算法交易策略所需的基本功能。内容结构如下：

"入门指南" 第469页#

本节展示如何设置一切以使用FXCM REST API进行算法交易。

"获取数据" 第469页#

本节展示如何获取和处理金融数据（精确到刻级别）。

"使用API" 第474页#

本节说明使用REST API实现的典型任务，如获取历史数据和流数据、下单以及查询账户信息。

入门指南#

FXCM API的详细文档请访问 https://fxcm.github.io/rest-apidocs。要安装Python封装包fxcmpy，在终端中执行以下命令：

pip install fxcmpy

fxcmpy包的文档请访问 http://fxcmpy.tpq.io。

要开始使用FXCM交易API和fxcmpy包，拥有一个免费的FXCM模拟账户即可。¹ 下一步是在模拟账户中创建一个唯一的API令牌——例如 YOUR_FXCM_API_TOKEN。然后通过以下方式打开与API的连接：

import fxcmpy
api = fxcmpy.fxcmpy(access_token=YOUR_FXCM_API_TOKEN, log_level='error')

或者，也可以使用配置文件（例如 fxcm.cfg）来连接API。该文件的内容应如下所示：

[FXCM]
log_level = error
log_file = PATH_TO_AND_NAME_OF_LOG_FILE
access_token = YOUR_FXCM_API_TOKEN

然后可以通过以下方式进行连接：

import fxcmpy
api = fxcmpy.fxcmpy(config_file='fxcm.cfg')

默认情况下，fxcmpy类连接到模拟服务器。但通过使用server参数，可以连接到真实交易服务器（如果存在此类账户）：

api = fxcmpy.fxcmpy(config_file='fxcm.cfg', server='demo')
api = fxcmpy.fxcmpy(config_file='fxcm.cfg', server='real')

连接到模拟服务器。

连接到真实交易服务器。

获取数据#

FXCM以预打包形式提供历史市场价格数据集，例如刻成交数据。这意味着可以从FXCM服务器检索包含2018年第26周EUR/USD汇率刻成交数据的压缩文件，如下一小节所述。通过API获取历史K线数据将在后续小节中说明。

获取刻成交数据#

对于多种货币对，FXCM提供历史刻成交数据。fxcmpy包使得检索和处理此类刻成交数据变得便捷。首先，导入必要的库：

In [1]: import time
import numpy as np
import pandas as pd
import datetime as dt
from pylab import mpl, plt

In [2]: plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
%matplotlib inline

其次，查看可用的刻成交数据交易品种（货币对）：

第15章 · 交易策略

Mon, 01 Jan 0001 00:00:00 +0000

交易策略#

[T]他们愚蠢到认为可以通过观察过去来预测未来。 —The Economist¹

本章介绍算法交易策略的向量化回测。术语"算法交易策略"（algorithmic trading strategy）用于描述任何基于算法的金融交易策略，该算法旨在自主地（无需人工干预）对金融工具建立多头、空头或中性头寸。一个简单的算法，如"每五分钟在苹果公司股票的多头和中性头寸之间切换"，就符合这一定义。从更技术的角度来说，本章中，算法交易策略由一段Python代码表示，该代码在新数据可用时，决定买入或卖出某种金融工具，以对其建立多头、空头或中性头寸。

本章不提供算法交易策略的全面概述（关于算法交易策略的详细参考资料，请参见第519页的"延伸资源"）。而是重点介绍几种精选策略的向量化回测（vectorized backtesting）技术方面。在这种方法中，被测试策略所基于的金融数据通常整体上进行操作，对存储金融数据的NumPy ndarray和pandas DataFrame对象应用向量化操作。²

本章的另一个重点是应用机器学习和深度学习算法来制定算法交易策略。为此，在历史数据上训练分类算法，以预测未来的方向性市场运动。这通常需要将金融数据从实际值转换为相对较少的分类值。³ 这使我们能够利用此类算法的模式识别能力。

本章分为以下几个部分：

"简单移动平均线" 第484页本节重点介绍基于简单移动平均线的算法交易策略以及如何回测此类策略。

"随机游走假说" 第491页本节介绍随机游走假说。

"线性OLS回归" 第494页本节探讨使用OLS回归推导算法交易策略。

"聚类" 第499页在本节中，我们探索使用无监督学习算法推导算法交易策略。

"频率方法" 第501页本节介绍一种用于算法交易的简单频率方法。

"分类" 第504页这里我们探讨机器学习中的分类算法在算法交易中的应用。

"深度神经网络" 第512页本节重点介绍深度神经网络及其在算法交易中的使用方法。

简单移动平均线#

基于简单移动平均线（Simple Moving Average, SMA）进行交易是一种已有数十年历史的交易方法（例如，参见Brock等人(1992)的论文）。虽然许多交易者在自主交易中使用SMA，但它们也可以用来制定简单的算法交易策略。本节使用SMA来介绍算法交易策略的向量化回测，它建立在第8章中的技术分析示例基础之上。

In [1]: import numpy as np
 import pandas as pd
 import datetime as dt
 from pylab import mpl, plt

In [2]: plt.style.use('seaborn')
mpl.rcParams['font.family'] = 'serif'
%matplotlib inline

数据导入#

首先，导入相关库：

其次，读取原始数据并选择单个交易品种——苹果公司股票（AAPL.O）的金融时间序列。本节的分析基于日终数据；日内数据将在后续部分使用：

In [3]: raw = pd.read_csv('../source/tr_eikon_eod_data.csv', index_col=0, parse_dates=True)

In [4]: raw.info()
 <class 'pandas.core.frame.DataFrame'>
 DatetimeIndex: 2216 entries, 2010-01-01 to 2018-06-29
 Data columns (total 12 columns):
 AAPL.O 2138 non-null float64
 MSFT.O 2138 non-null float64
 INTC.O 2138 non-null float64
 AMZN.O 2138 non-null float64
 GS.N 2138 non-null float64
 SPY 2138 non-null float64
 .SPX 2138 non-null float64
 .VIX 2138 non-null float64
 EUR= 2216 non-null float64
 XAU= 2211 non-null float64
 GDX 2138 non-null float64
 GLD 2138 non-null float64
 dtypes: float64(12)
 memory usage: 225.1 KB

In [5]: symbol = 'AAPL.O'

In [6]: data = (
 pd.DataFrame(raw[symbol])
 .dropna()
)

交易策略#

第三，计算两个不同滚动窗口大小的SMA值。

图15.1

第16章 · 自动化交易

Mon, 01 Jan 0001 00:00:00 +0000

自动化交易#

人们担心计算机会变得太聪明并接管世界，但真正的问题是它们太笨了，而且它们已经接管了世界。 —Pedro Domingos

"现在该怎么办？"你可能会想。我们有了一个交易平台，可以检索历史数据和流数据、下达买入和卖出订单、检查账户状态。我们还介绍了多种通过预测市场价格运动方向来推导算法交易策略的方法。如何将这一切整合在一起以自动化方式工作？这个问题无法一概而论。然而，本章讨论在此背景下重要的若干主题。本章假设仅部署单个自动化算法交易策略。这简化了资金管理和风险管理等方面的问题。

本章涵盖以下主题：

"资金管理" 第522页

如本节所示，根据策略特征和可用交易资金，凯利准则有助于确定交易规模。

"基于机器学习的交易策略" 第532页

为了建立对算法交易策略的信心，需要从业绩和风险特征两方面进行彻底回测；示例策略基于第15章介绍的机器学习分类算法。

"在线算法" 第544页

为了部署算法交易策略进行自动化交易，需要将其转换为一个能够实时处理传入流数据的在线算法。

"基础设施与部署" 第546页

为了稳健可靠地运行自动化算法交易策略，从可用性、性能和安全性角度来看，云端部署是首选方案。

"日志记录与监控" 第547页

为了能够分析部署期间的历史记录和某些事件，日志记录起着重要作用；通过套接字通信进行监控可以（远程）实时观察事件。

资金管理#

算法交易中的一个核心问题是，在给定总可用资金的情况下，应向特定算法交易策略分配多少资金。这个问题的答案取决于通过算法交易试图实现的主要目标。大多数个人和金融机构都会同意，长期财富最大化是一个合理的候选目标。这正是Edward Thorp在推导投资中的凯利准则（Kelly Criterion）时所考虑的，如Rotando和Thorp (1992)的论文所述。

二项式设定中的凯利准则#

介绍凯利准则投资理论的常见方式是基于一个抛硬币游戏，或者更一般地，一个二项式设定（只有两种可能结果）。本节遵循这一思路。假设一个赌徒在与一个资金无限的银行或赌场玩抛硬币游戏。再进一步假设正面朝上的概率为某个值 $\boldsymbol{p}$，满足 $\frac{1} {2} < p < 1$。反面朝上的概率定义为 $q = 1 - p < \frac{1} {2}$。赌徒可以下任意大小的赌注 $b > 0$，如果猜对则赢得相同金额，如果猜错则输掉全部赌注。根据概率假设，赌徒当然希望押注正面。因此，这个赌博游戏 B（即代表该游戏的随机变量）在单次设定下的期望值为：

$$ \mathbf{E} [ B ] = p \cdot b - q \cdot b = (p - q) \cdot b > 0 $$

一个风险中性且资金无限的赌徒希望下尽可能大的赌注，因为这将最大化期望收益。然而，金融市场中的交易通常不是一次性游戏，而是重复进行的。因此，假设 $b_{i}$ 表示第 i 天下注的金额，$c_{0}$ 表示初始资金。第一天结束时的资金 $c_{1}$ 取决于当天的下注结果，可能是 $c_{0} + b_{1}$ 或 $c_{0} - b_{1}$。重复 n 次的赌博的期望值为：

第五部分 · 衍生品分析

Mon, 01 Jan 0001 00:00:00 +0000

Part 5

衍生品分析

估值框架、金融模型模拟、衍生品与投资组合估值、市场校准。

本部分章节#

第17章估值框架 — 资产定价基本定理、风险中性折现与市场环境建模。

第18章金融模型模拟 — 随机数生成、几何布朗运动、跳跃扩散与平方根扩散。

第19章衍生品估值 — 欧式/美式期权估值、最小二乘蒙特卡洛方法。

第20章投资组合估值 — 衍生品持仓与组合建模、估值环境构建。

第21章基于市场的估值 — 期权数据、模型校准与组合估值。

第17章 · 估值框架

Mon, 01 Jan 0001 00:00:00 +0000

估值框架（Valuation Framework）#

复利是有史以来最伟大的数学发现。

—Albert Einstein

本章为开发DX库提供了框架，介绍了此项目所需的最基本概念。它简要回顾了资产定价基本定理（Fundamental Theorem of Asset Pricing），该定理为模拟和估值提供了理论基础。接着讨论了日期处理和风险中性贴现（risk-neutral discounting）的基本概念。本章仅考虑最简单的常数短期利率贴现情况，但更复杂和更现实的模型可以很容易地添加到库中。本章还介绍了市场环境（market environment）的概念——即一系列常数、列表和曲线的集合，后续章节中几乎所有其他类的实例化都需要用到它们。

本章包括以下部分：

"资产定价基本定理" 第558页

本节介绍资产定价基本定理，该定理为待开发的库提供了理论基础。

"风险中性贴现" 第560页

本节开发了一个用于对未来期权及其他衍生品收益进行风险中性贴现的类。

"市场环境" 第565页

本节开发了一个用于管理单个工具及由多个工具组成的投资组合的市场环境的类。

资产定价基本定理（Fundamental Theorem of Asset Pricing）#

资产定价基本定理（Fundamental Theorem of Asset Pricing）是现代金融理论和数学的基石与成功典范之一。¹ 该定理的核心概念是鞅测度（martingale measure），即一种从贴现风险因子（随机过程）中去除漂移项的概率测度。换句话说，在鞅测度下，所有风险因子都以无风险短期利率漂移——而不是以任何包含相对于无风险短期利率的风险溢价的市场利率漂移。

一个简单示例（A Simple Example）#

考虑一个简单经济，包含今天和明天两个时间点，有一种风险资产（"股票"）和一种无风险资产（"债券"）。债券今天价值10美元，明天偿付10美元（零利率）。股票今天价值10美元，明天以60%和40%的概率分别偿付20美元或0美元。债券的无风险收益率为0。股票的预期收益率为 $\frac{0.6 \cdot 20 + 0.4 \cdot 0}{10} - 1 = 0.2$，即20%。这是股票因其风险性而支付的风险溢价。

现在考虑一个行权价为15美元的看涨期权。这样一个或有债权（contingent claim）以60%的概率偿付5美元，否则偿付0美元，其公允价值是多少？一种方法是取期望值，然后将结果贴现回来（此处利率为零）。这种方法得出价值为0.6 × 5 = 3美元，因为当股票价格上涨至20美元时期权偿付5美元，否则为0美元。

然而，还有另一种成功应用于此类期权定价问题的方法：通过交易证券的组合来复制期权的收益。可以很容易地验证，购买0.25股股票可以完美复制期权的收益（在60%的情况下，0.25 × 20 = 5美元）。四分之一股票的成本仅为2.5美元，而非3美元。在真实世界概率测度下取期望会高估期权的价值。

这是为什么？真实世界测度意味着股票有20%的风险溢价，因为股票所涉及的风险（上涨100%或下跌100%）在无法分散或对冲的意义上是"真实的"。另一方面，存在一个可以无风险地复制期权收益的投资组合。这也意味着卖出（出售）此类期权的人可以完全对冲掉任何风险。² 这样一个完全对冲的期权和头寸组合必须产生无风险利率，以避免套利机会（即以正概率从零资金中赚钱的机会）。

能否通过取期望的方法来拯救看涨期权的估值？是的，可以。只需改变概率，使得风险资产（股票）以零无风险短期利率漂移即可。显然，赋予两种情景各50%权重的（鞅）测度可以实现这一点；计算为 $\frac{0.5 \cdot 20 + 0.5 \cdot 0}{10} - 1 = 0$。现在，在新的鞅测度下对期权的收益取期望，得到正确的（无套利）公允价值：$0.5 \cdot 5 + 0.5 \cdot 0 = 2.5$ 美元。

第18章 · 金融模型模拟

Mon, 01 Jan 0001 00:00:00 +0000

金融模型模拟（Simulation of Financial Models）#

科学的目的不是分析或描述，而是建立有用的世界模型。

—Edward de Bono

第12章详细介绍了使用 Python 和 NumPy 对随机过程进行蒙特卡洛模拟的方法。本章将应用那里介绍的基本技术来实现模拟类，作为 DX 包的核心组件。随机过程集合限制为三种广泛使用的过程。具体而言，本章包括以下部分：

"随机数生成" 第572页

本节开发了一个使用方差缩减技术生成标准正态分布随机数的函数。¹

"通用模拟类" 第574页

本节开发了一个通用模拟类，其他特定的模拟类从中继承基本属性和方法。

"几何布朗运动" 第577页

本节讨论几何布朗运动（geometric Brownian motion, GBM），该过程通过 Black 和 Scholes (1973) 及 Merton (1973) 的开创性工作被引入期权定价文献；尽管它存在已知的缺陷且越来越多的实证证据对其不利，但它在本章中多次使用，并仍然是期权和衍生品估值的基准过程。

#
### DX 包
#
### 框架 -- 随机数生成
#
**sn_random_numbers.py**
#


#
import numpy as np

"跳跃扩散" 第582页

由 Merton (1976) 引入金融学的跳跃扩散（jump diffusion），在 GBM 的基础上增加了一个对数正态分布的跳跃分量。这允许考虑如下事实：例如，短期虚值（out-of-the-money, OTM）期权往往似乎已将较大跳跃的可能性定价在内；换句话说，依赖 GBM 作为金融模型往往无法令人满意地解释此类 OTM 期权的市场价值，而跳跃扩散可能能够做到。

"平方根扩散" 第587页#

由 Cox、Ingersoll 和 Ross (1985) 在金融学中推广的平方根扩散（square-root diffusion），用于建模利率和波动率等均值回归量；除了具有均值回归特性外，该过程保持正值，这通常是这些量所期望的特征。

第19章 · 衍生品估值

Mon, 01 Jan 0001 00:00:00 +0000

衍生品估值（Derivatives Valuation）#

衍生品是一个庞大而复杂的问题。

—Judd Gregg

长期以来，期权和衍生品估值一直是华尔街所谓的"火箭科学家"的领域——即拥有物理学或类似高难度学科学位的人。然而，通过蒙特卡洛模拟等数值方法应用模型通常比理论模型本身要简单一些。

对于欧式行权（European exercise）的期权和衍生品估值尤其如此——即只能在某个预定日期行权的情况。而对于美式行权（American exercise）的期权和衍生品，情况则稍微复杂一些，因为允许在预定时间段内的任何时间点行权。本章介绍并使用了最小二乘蒙特卡洛（Least-Squares Monte Carlo, LSM）算法，该算法已成为基于蒙特卡洛模拟的美式期权估值的基准算法。

本章的结构与第18章相似：首先介绍一个通用估值类，然后提供两个专门的估值类，一个用于欧式行权，另一个用于美式行权。通用估值类包含数值估计期权最重要希腊字母（Greeks）的方法：delta 和 vega。因此，估值类不仅对估值目的很重要，对风险管理目的也同样重要。

本章的结构如下：

"通用估值类" 第596页

本节介绍通用估值类，具体的估值类从中继承。

"欧式行权" 第600页

本节介绍用于欧式行权的期权和衍生品估值类。

"美式行权" 第606页

本节介绍用于美式行权的期权和衍生品估值类。

通用估值类（Generic Valuation Class）#

与通用模拟类一样，实例化估值类对象只需提供少量输入（此处为四个）：

name

一个 str 对象，作为模型模拟对象的名称

underlying

一个模拟类的实例，代表标的资产

mar_env

一个 dx.market_environment 类的实例

payoff_func

一个 Python str 对象，包含期权/衍生品的收益函数

通用类有三个方法：

update() 更新选定的估值参数（属性）

delta() 计算期权/衍生品 delta 的数值

vega() 计算期权/衍生品 vega 的数值

有了前几章关于 DX 包的背景知识，这里介绍的通用估值类应该几乎是自解释的；在适当的地方也提供了内联注释。再次，首先完整呈现该类，然后进行更详细的讨论：

#
### DX 包
#
### 估值 -- 基类
#
**valuation_class.py**
#



#
class valuation_class(object):
 ''' 单因子估值的基础类。

 属性（Attributes）
 ========
 name: str
 对象名称
 underlying: instance of simulation class
 对单个风险因子进行建模的对象
 mar_env: instance of market_environment
 用于估值的市场环境数据
 payoff_func: str
 Python 语法的衍生品收益函数
 例如：'np.maximum(maturity_value - 100, 0)'
 其中 maturity_value 是包含标的资产相应值的 NumPy 向量
 例如：'np.maximum(instrument_values - 100, 0)'
 其中 instrument_values 是包含整个时间/路径网格上标的资产值的 NumPy 矩阵

 方法（Methods）
 ========
 update:
 更新选定的估值参数
 delta:
 返回衍生品的 delta
 vega:
 返回衍生品的 vega
 '''

 def __init__(self, name, underlying, mar_env, payoff_func=''):
 self.name = name
 self.pricing_date = mar_env.pricing_date
 try:
 # strike 是可选的
 self.strike = mar_env.get_constant('strike')
 except:
 pass
 self.maturity = mar_env.get_constant('maturity')
 self.currency = mar_env.get_constant('currency')
 # 来自模拟对象的模拟参数和贴现曲线
 self.frequency = underlying.frequency
 self.paths = underlying.paths
 self.discount_curve = underlying.discount_curve
 self.payoff_func = payoff_func
 self.underlying = underlying
 # 向标的对象提供 pricing_date 和 maturity
 self.underlying.special_dates.extend([self.pricing_date, self.maturity])

 def update(self, initial_value=None, volatility=None, strike=None,
 maturity=None):
 if initial_value is not None:
 self.underlying.update(initial_value=initial_value)
 if volatility is not None:
 self.underlying.update(volatility=volatility)
 if strike is not None:
 self.strike = strike
 if maturity is not None:
 self.maturity = maturity
 # 如果 time_grid 中没有新的到期日则添加
 if maturity not in self.underlying.time_grid:
 self.underlying.special_dates.append(maturity)
 self.underlying.instrument_values = None

 def delta(self, interval=None, accuracy=4):
 if interval is None:
 interval = self.underlying.initial_value / 50.
 # 前向差分近似
 # 计算数值 delta 的左值
 value_left = self.present_value(fixed_seed=True)
 # 右值的数值标的资产值
 initial_del = self.underlying.initial_value + interval
 self.underlying.update(initial_value=initial_del)
 # 计算数值 delta 的右值
 value_right = self.present_value(fixed_seed=True)
 # 重置模拟对象的 initial_value
 self.underlying.update(initial_value=initial_del - interval)
 delta = (value_right - value_left) / interval
 # 修正潜在的数值误差
 if delta < -1.0:
 return -1.0
 elif delta > 1.0:
 return 1.0
 else:
 return round(delta, accuracy)

 def vega(self, interval=0.01, accuracy=4):
 if interval < self.underlying.volatility / 50.:
 interval = self.underlying.volatility / 50.
 # 前向差分近似
 # 计算数值 vega 的左值
 value_left = self.present_value(fixed_seed=True)
 # 右值的数值波动率值
 vola_del = self.underlying.volatility + interval
 # 更新模拟对象
 self.underlying.update(volatility=vola_del)
 # 计算数值 vega 的右值
 value_right = self.present_value(fixed_seed=True)
 # 重置模拟对象的波动率值
 self.underlying.update(volatility=vola_del - interval)
 vega = (value_right - value_left) / interval
 return round(vega, accuracy)

通用 dx.valuation_class 类涉及的一个主题是 Greeks 的估计。这值得仔细研究。为此，假设存在一个连续可微函数 $V(S_{0}, \sigma_{0})$ 表示期权的现值。期权的 delta 定义为对标的资产当前值 $S_{0}$ 的一阶偏导数，即 $\Delta = \frac{\partial V(\cdot)}{\partial S_{0}}$。

第20章 · 投资组合估值

Mon, 01 Jan 0001 00:00:00 +0000

投资组合估值（Portfolio Valuation）#

价格是你付出的，价值是你得到的。

—Warren Buffett

到目前为止，构建 DX 衍生品分析包的整体方法——及其相关优势——应该已经清晰了。通过严格依赖蒙特卡洛模拟作为唯一的数值方法，该方法实现了分析包的几乎完全模块化：

贴现（Discounting）#

相关风险中性贴现由 dx.constant_short_rate 类的实例处理。

模拟对象（Simulation objects）#

相关风险因子（标的资产）被建模为三个模拟类之一的实例：

• dx.geometric_brownian_motion

• dx.jump_diffusion

• dx.square_root_diffusion

估值对象（Valuation objects）#

待估值的期权和衍生品被建模为两个估值类之一的实例：

• dx.valuation_mcs_european

• dx.valuation_mcs_american

还缺少最后一步：对可能复杂的期权和衍生品投资组合进行估值。为此，需要满足以下要求：

非冗余性（Nonredundancy）#

每个风险因子（标的资产）仅被建模一次，并可能被多个估值对象使用。

头寸（Positions）#

例如，一个期权头寸由一定数量的期权合约组成。

然而，尽管原则上允许（甚至要求）为模拟和估值对象都提供货币，但以下代码假设投资组合仅以单一货币计价。这显著简化了投资组合内的价值聚合，因为可以抽象掉汇率和货币风险。

本章介绍了两个新类：一个用于建模单个衍生品头寸的简单类，和一个用于建模和估值衍生品投资组合的更复杂类。其结构如下：

"衍生品头寸" 第618页

本节介绍用于建模单个衍生品头寸的类。

"衍生品投资组合" 第622页

本节介绍用于估值可能包含多个衍生品头寸的投资组合的核心类。

衍生品头寸（Derivatives Positions）#

原则上，衍生品头寸不过是一个估值对象和所建模工具的数量（quantity）的组合。

#
### DX 包
#
### 投资组合 -- 衍生品头寸类
#
**derivatives_position.py**
#


#
class derivatives_position(object):
 ''' 对衍生品头寸进行建模的类。

 属性（Attributes）
 ========
 name: str
 对象名称
 quantity: float
 构成该头寸的资产/衍生品数量
 underlying: str
 衍生品标的资产/风险因子的名称
 mar_env: instance of market_environment
 与估值类相关的常数、列表和曲线
 otype: str
 要使用的估值类
 payoff_func: str
 衍生品的收益字符串

 方法（Methods）
 ========
 get_info:
 打印关于衍生品头寸的信息
 '''

 def __init__(self, name, quantity, underlying, mar_env,
 otype, payoff_func):
 self.name = name
 self.quantity = quantity
 self.underlying = underlying
 self.mar_env = mar_env
 self.otype = otype
 self.payoff_func = payoff_func

类（The Class）#

以下代码展示了用于建模衍生品头寸的类。它主要是一个数据和对象的容器。此外，它提供了一个 get_info() 方法，打印存储在类实例中的数据和对象信息：

第21章 · 基于市场的估值

Mon, 01 Jan 0001 00:00:00 +0000

基于市场的估值#

我们正面临极端的波动性。 —Carlos Ghosn

衍生品分析（derivatives analytics）中的一项主要任务是针对流动性不足的期权和衍生品进行基于市场的估值（market-based valuation）。为此，通常需要将定价模型校准（calibration）到流动性期权的市场报价，然后使用校准后的模型对非交易期权进行定价。^1^

本章基于DX包（DX package）展示了一个案例研究，说明前四章逐步开发的该包能够实现基于市场的估值。案例研究基于DAX 30股票指数，这是一个由30家德国主要公司股票组成的蓝筹股市场指数。该指数上有流动性充足的欧式看涨期权（European call option）和看跌期权（European put option）可供交易。

本章分为几个部分，实现以下主要任务：

"期权数据" on page 638

需要两类数据：DAX 30股票指数本身的数据以及该指数上流动性充足的欧式期权数据。

"模型校准" on page 641

为了以市场一致的方式对非交易期权进行估值，通常首先将所选模型校准到报价期权价格，使得基于最优参数的模型尽可能好地复现市场价格。

"投资组合估值" on page 651

拥有数据以及DAX 30股票指数的市场校准模型后，最后任务是建模和估值非交易期权；同时还在头寸和投资组合（portfolio）层面上估计重要的风险度量。

本章使用的指数和期权数据来自Thomson Reuters Eikon Data API（参见"Python代码" on page 654）。

期权数据#

首先，进行所需的导入和自定义设置：

In [1]: import numpy as np
 import pandas as pd
 import datetime as dt

In [2]: from pylab import mpl, plt
 plt.style.use('seaborn')
 mpl.rcParams['font.family'] = 'serif'
 %matplotlib inline

In [3]: import sys
 sys.path.append('../')
 sys.path.append('../dx')

给定"Python代码" on page 654中创建的数据文件，使用pandas读取期权数据，并将日期信息处理为pd.Timestamp对象：

In [4]: dax = pd.read_csv('../source/tr_eikon_option_data.csv', index_col=0)
In [5]: for col in ['CF_DATE', 'EXPIR_DATE']:
 dax[col] = dax[col].apply(lambda date: pd.Timestamp(date))
In [6]: dax.info()
 <class 'pandas.core.frame.DataFrame'>
 Int64Index: 115 entries, 0 to 114
 Data columns (total 7 columns):
 Instrument 115 non-null object
 CF_DATE 115 non-null datetime64[ns]
 EXPIR_DATE 114 non-null datetime64[ns]
 PUTCALLIND 114 non-null object
 STRIKE_PRC 114 non-null float64
 CF_CLOSE 115 non-null float64
 IMP_VOLT 114 non-null float64
 dtypes: datetime64[ns](2), float64(3), object(2)
 memory usage: 7.2+ KB

In [7]: dax.set_index('Instrument').head(7)
Out[7]:

CF_DATE EXPIR_DATE PUTCALLIND STRIKE_PRC CF_CLOSE \

附录A · 日期与时间

Mon, 01 Jan 0001 00:00:00 +0000

日期与时间#

与大多数科学学科一样，日期和时间在金融领域扮演着重要角色。本附录介绍在Python编程中与此主题相关的不同方面。当然，它不可能面面俱到，但它提供了对Python生态系统中支持日期和时间信息建模的主要领域的介绍。

Python#

Python标准库中的datetime模块允许实现大多数重要的日期和时间相关任务：

In [1]: from pylab import mpl, plt
 plt.style.use('seaborn')
 mpl.rcParams['font.family'] = 'serif'
 %matplotlib inline

In [2]: import datetime as dt

In [3]: dt.datetime.now() ①
Out[3]: datetime.datetime(2018, 10, 19, 15, 17, 32, 164295)

In [4]: to = dt.datetime.today() ①
to
Out[4]: datetime.datetime(2018, 10, 19, 15, 17, 32, 177092)

In [5]: type(to)
Out[5]: datetime.datetime

In [6]: dt.datetime.today().weekday() ②
Out[6]: 4

返回当前精确日期和系统时间。

⑥ ... day ...

⑤ ... month ...

以数字形式返回星期几，其中0 = 星期一。

当然，datetime对象可以自由定义：

In [7]: d = dt.datetime(2020, 10, 31, 10, 5, 30, 500000)
d
Out[7]: datetime.datetime(2020, 10, 31, 10, 5, 30, 500000)
In [8]: str(d)
Out[8]: '2020-10-3110:05:30.500000'
In [9]: print(d)
2020-10-3110:05:30.500000
In [10]: d.year
Out[10]: 2020
In [11]: d.month
Out[11]: 10
In [12]: d.day
Out[12]: 31
In [13]: d.hour
Out[13]: 10

自定义datetime对象。

附录B · BSM期权类

Mon, 01 Jan 0001 00:00:00 +0000

BSM期权类#

类定义#

以下给出Black-Scholes-Merton (1973)模型中欧式看涨期权（European call option）的类定义。这种基于类的实现是本章前述基于函数的实现的替代方案：

#
# 在Black-Scholes-Merton模型中估值欧式看涨期权
# 包含vega函数和隐含波动率估计
# -- 基于类的实现
#

from math import log, sqrt, exp
from scipy import stats

class bsm_call_option(object):
 """ BSM模型中欧式看涨期权的类。

 属性
 S0: float 初始股票/指数水平
 K: float 行权价
 T: float 到期时间（以年分数表示）
 r: float 常数无风险短期利率
 sigma: float 扩散项中的波动率因子

 方法
 =====
 value: float
 返回看涨期权的现值
 vega: float
 返回看涨期权的vega
 imp_vol: float
 返回给定期权报价的隐含波动率
 """
 def __init__(self, S0, K, T, r, sigma):
 self.S0 = float(S0)
 self.K = K
 self.T = T
 self.r = r
 self.sigma = sigma

 def value(self):
 ''' 返回期权价值。
 '''
 d1 = ((log(self.S0 / self.K) +
 (self.r + 0.5 * self.sigma ** 2) * self.T) /
 (self.sigma * sqrt(self.T)))
 d2 = ((log(self.S0 / self.K) +
 (self.r - 0.5 * self.sigma ** 2) * self.T) /
 (self.sigma * sqrt(self.T)))
 value = (self.S0 * stats.norm.cdf(d1, 0.0, 1.0) -
 self.K * exp(-self.r * self.T) * stats.norm.cdf(d2, 0.0, 1.0))
 return value

 def vega(self):
 ''' 返回期权的vega。
 '''
 d1 = ((log(self.S0 / self.K) +
 (self.r + 0.5 * self.sigma ** 2) * self.T) /
 (self.sigma * sqrt(self.T)))
 vega = self.S0 * stats.norm.pdf(d1, 0.0, 1.0) * sqrt(self.T)
 return vega

 def imp_vol(self, C0, sigma_est=0.2, it=100): <!-- validate-skip -->
 ''' 返回给定期权价格的隐含波动率（implied volatility）。
 '''
 option = bsm_call_option(self.S0, self.K, self.T, self.r, sigma_est)
 for i in range(it):
 option.sigma -= (option.value() - C0) / option.vega()
 return option.sigma

类的使用#

该类可在交互式Jupyter Notebook会话中使用如下：