对于习惯IDE的Programmer来说 底层实际上是非常陌生的领域 然而下探到C++编译机制，对于一个合格的工程师又是非常有必要掌握的技术因此 本篇文章将讲解利用MakeFile 来实现Python C++混编的目的

首先不同平台的编译，存在着显著的差别：

Linux/UnixLike平台的动态链接库一般为.so为结尾（shared object）

Windows平台的动态链接库一般为.dll为结尾（Dynamic Link Library ）

Linux Part：

编译器

在Linux中 主流编译器为Clang以及GNU（GCC，G++）
GCC中支持的语言常用的有
C、C++、Java、Object-C
结构类似于一个标准Unix编译器

而Clang是支持C++，CObject-C，Object-C++语言的编译器前端
其底层采用了LLVM底层虚拟机，在编译Object-C时对比GCC快三倍

总体上：

• GCC特性：

除支持C/C++/ Objective-C/Objective-C++语言外，还是支持Java/Ada/Fortran/Go等；当前的Clang的C++支持落后于GCC；支持更多平台；更流行，广泛使用，支持完备。

• Clang特性：

编译速度快；内存占用小；兼容GCC；设计清晰简单、容易理解，易于扩展增强；基于库的模块化设计，易于IDE集成；出错提示更友好

我们先以GCC为例讲解以下一个典型的C++编译指令是如何工作的

一个典型的Unix like平台的 C++程序编译要经过哪些步骤？

(更详细的解释参照C++编译过程 ，不再赘述)

而一个 gcc –h显示的帮助信息最常用的部分如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

-B <directory>           Add <directory> to the compiler's search paths
#添加编译器的搜索路径（例如头文件等）
-v                       Display the programs invoked by the compiler
#显示被编译器调用的程序
-###                     Like -v but options quoted and commands not executed
-E                       Preprocess only; do not compile, assemble or link
#只预处理不编译汇编或者链接
-S                       Compile only; do not assemble or link
#只编译不汇编和链接
-c                       Compile and assemble, but do not link
#编译和汇编，不连接
-o <file>                Place the output into <file>
#输出到文件
-pie                     Create a position independent executable
#创建与位置无关的可执行文件
-shared                  Create a shared library
#创建一个共享库

我们来尝试编译一个helloworld

main.cpp

1
2
3
4
5
6

#include<iostream>
using namespace std;
int main(){
    cout<<"c++ is best language"<<endl;
    return 0
}

对于这样一个非常基础的没有额外依赖的cpp文件来说，编译过程当然也相当简单。

1
2

g++ -c main.cpp
#只编译和汇编main.cpp不链接生成main.o的目标代码文件

如果我们还想执行这个代码就要生成可执行文件

1
2
3
4
5
6

g++ -o main.out main.o
#输出到.out可执行文件

#也可以合并执行
g++ -o hello.out hello.cpp
#直接编译并输出到可执行文件

则./xx.out 就可以运行编译完成的可执行文件了
但是这个并不是典型的应用场景 我们用下面的三个代码来模拟日常更常用的C++工作模式

head.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#ifndef HEAD_H
#define HEAD_H
#include "head.h"
#include <iostream>
using namespace std;
class Human
{
private:
    /* data */
public:
void Say();
void SaywithPython();
};
#endif

function.cpp

1
2
3
4
5
6
7
8
9

#include "head.h"

void Human::Say(){
    cout<<"Im Human ,You are shit"<<endl;
}
void Human::SaywithPython(){
    cout<<"Python is best language"<<endl;
}

main.cpp

1
2
3
4
5
6
7
8
9
10
11

#include <iostream>
#include "head.h"
using namespace std;

int main(){
    cout <<"C++ is best language"<<endl;
    Human Jarvis;
    Jarvis.Say();
    return 0;

}

这一小段程序包含了非常多的技巧

首先定义了head以及function本地头文件和实现，在cpp文件中实现了
两个公开的方法

在main中又调用了实例化对象中的该方法

由于涉及了多个文件因此我们必须有一种方法来指定编译器的行为——MakeFile

1
2
3
4
5
6
7
8
9
10

build : main.o function.o
g++ -o build main.o function.o
main.o : main.cpp head.h
g++ -g -c main.cpp
function.o : head.h function.cpp
g++ -g -c function.cpp
clean :
rm main.o function.o build
#pylib : function.cpp
#g++ -o pylib.so -shared -fPIC function.cpp

其中整个的格式为：

1
2

target ... : prerequisites ...
　　command    #tab

• target为目标文件

• prerequisites为生成目标文件所需的文件

• command为编译该目标文件所需的指令

所以目前我们可以按照之前的C++编译流程图 整理出的依赖顺序为：
1.编译function.cpp依赖于head.h 生成function.o 即：

1
2

function.o : head.h function.cpp
g++ -g -c function.cpp

2.编译main.cpp依赖于head.h 生成 main.o 即：

1
2

main.o : main.cpp head.h
g++ -g -c main.cpp

3.编译可执行文件依赖于main.o function.o 生成指定的可执行文件（build）即：

1
2

build : main.o function.o
g++ -o build main.o function.o

具体在执行过程中则遵循依赖，书写则从可执行文件开始（如果确实要生成可执行文件的话）

至此命令行中输入

1

make

就可以进行编译啦

1
2
3
4

#结果如同
g++ -g -c main.cpp
g++ -g -c function.cpp
g++ -o build main.o function.o

生成了build可执行文件
结果：

1
2
3

c++ is best language

Im Human ,You are shit

通过这一步我们解决了C++编译的问题，那我们怎么解决Python和C++的混编呢？

重新编写

function.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include "head.h"

void Human::Say(){
    cout<<"Im Human ,You are shit"<<endl;
}
void Human::SaywithPython(){
    cout<<"Python is best language"<<endl;

}

extern "C"{
    Human pythonman;
    void SaywithPython(){
        pythonman.SaywithPython();
        cout<<"C++ IS SHIT!!"<<endl;
    }
}

通常来说，在模块的头文件中对本模块提供给其他模块引用的函数和全局变量以关键字extern声明。

Tips:

• extern是C/C++语言中表明函数和全局变量的作用范围的关键字，该关键字告诉编译器，其申明的函数和变量可以在本模块或其他模块中使用。

• 被extern “C”修饰的变量和函数是按照C语言方式进行编译和链接的

• extern int a; 仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出错。

• extern对应的关键字是static，static表明变量或者函数只能在本模块中使用，因此，被static修饰的变量或者函数不可能被extern C修饰。

这一步的目的是通过MakeFile生成动态链接库，在Unix like系统中一般为.so文件：

1
2
3
4
5
6
7
8
9
10
11
12

build : main.o function.o
g++ -o build main.o function.o
main.o : main.cpp head.h
g++ -g -c main.cpp
function.o : head.h function.cpp
g++ -g -c function.cpp
clean :
rm main.o function.o build

pylib : function.cpp
g++ -o pylib.so -shared -fPIC function.cpp
#通过 -shared 生成 .so文件

通过

1

make pylib

就可以生成pylib.so文件
此时我们开始建立python脚本

main.py

1
2
3
4
5
6

import ctypes
ll=ctypes.cdll.LoadLibrary
#载入动态链接库
lib=ll('/home/winshare/Leetcode/MakeFileTutorial/pylib.so')
#ll('动态链接库文件的地址')
lib.SaywithPython()

输出：

1
2

Python is best language
C++ IS SHIT!!

至此 我们完成了Python调用C++的实践

Massive earthquakes in mountainous regions often lead to numerous landslides endangering human lives. Whether and where landslides can occur is a mystery. We wonder whether it is possible to single out mountainous sites prone to landslides around major fault lines, and subsequently warn off habitation and development there.
To do that, we propose the deep learning of terrain structure around the 2008 Wenchuan earthquake. We convert this terrain challenge to literally an MNIST challenge familiar to most data miners. Results show that landslide area can be predicted up to ~93% accuracy when the location and depth of the quake epicenter is known, or to ~78% accuracy with unknown epicenter location and depth. These accuracy numbers are imperfect but already useful for disaster prevention and relief work. We are releasing this dataset to the community for further experiments. In the future, deep learning of landslides from all major earthquakes around the world may lead to much more accurate predictions.

Predict performance

Without auxiliary feature vector input, the model trains to 78% binary classification accuracy. When we incorporate auxiliary feature input, the classification accuracy rises sharply to 93%.

Network Structure & Data Process

We synchronized both the landslide dataset and the elevation dataset to the same ground resolution of 30 meters. Then we randomly subset both datasets to 33-by-33-pixel images. This translates to a square-kilometer region on the ground. In total we have 160,000 square kilometers in this study. 60% of the data is used for training, and 40% for validation.
We chose EfficientNet-B0 due to its small size and excellent results.

The auxiliary input data is a 4x1 vector feature :

• the distance to epicenter
• longitudinal and latitudinal angles towards epicenter(two cord values)
• the local quake intensity

In Mercalli scale. We conducted two training-testing runs in total. The first training run does not incorporate the auxiliary input data feed, while the second run incorporates it. Their results will be compared and discussed in later sections.

The Integrated SRTM Data at epicenter, Wenchuan 2018：

• SRTM data & Fault lines

• label data in the whole Wenchuan area.

Predicition & Result

The prediction visualization in the gis softwear.

Original prediction data

We use two different way to generate prediction data.

• Random sample
• Sliding window sample

The first way like monte carlo simulation that random generate a cordinate of point in the whole area and add prediction to sample position on the background zero-matrix.(see iamge below)

The second way like convolution operation.The sample process like sliding window in original STRM data map, you can set different stride to make result perfect.
(see image below)

As comparison, the first way has more information about possibility of landslide,the secound way just faster and generate binary classification result to help people make a strategic decision directly.

Train & Run

Clone Project:

1

git@github.com:OOXXXXOO/Efficient-landslide.git

Environment requirement：

• Anaconda
  (China Option)
• Pytorch 1.1/1.2
  (China Channel Option)

In order to simplify configuration process. you could install requirement from yml file.

1

conda env create -f environment.yml

Then

1
2

source activate torchbeta
python predict_vector_intensity.py #train_vector_intensity.py

Data:

Original Data is

• SRTM map : download link
• Intensity map : download link
• The Wenchuan Epicenter longitude and latitude (31.0°N,103.4°E)

Preprocessed Data :

OneDrive Link ( China.Hongkong Data Center )

Tips:
The $10^{6}$ small files I/O has been a bottleneck in training process，append all sample data to a npy file is a greate training strategy for save you time.

It is true that our study is based on the dataset from just one major earthquake and thus can be quite limited in power. Overfitting is a serious concern. However, if geologists from quake-prone countries could share landslide cataloging data after major quakes, then it is possible to train deep learning models for the whole planet. More data leads to more reliable predictions. As a baby step, we are sharing the Wenchuan landslide dataset with the research community.
We invite everyone to try it and come up with insights.

Reference:

• [1] C. Xu et al., Three (nearly) complete inventories of landslides triggered by the May 12, 2008 Wenchuan Mw 7.9 earthquake of China and their spatial distribution statistical analysis. Landslides (2014) 11: 441
• [2] C. Xu et al., “Revisions of the M 8.0 Wenchuan earthquake seismic intensity map based on co-seismic landslide abundance”, Natural Hazards 69(3) · December 2013
• [3] Jet Propulsion Laboratory, NASA. “U.S. Releases Enhanced Shuttle Land Elevation Data”, , https://www2.jpl.nasa.gov/srtm/index.html as accessed in July 2019
• [4] M. Tan, Q. V. Le, EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks, ICML2019
• [5] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. “Gradient-based learning applied to document recognition.” Proceedings of the IEEE, 86(11):2278-2324, November 1998
• [6] A. Holcombe, “Farewell authors, hello contributors”, Nature 571, 147 (2019)

The Satellite Imagery DataSet Toolkit

Useage:

• Guide to Start
• Document

The Satellite Imagery DataSet is an important part to train, validate the deep learning model of different missions in modern GIS science.

This toolkit work for download different data sources and use specific layer (class) in OSM Vector Data (or other vector file) to generate dataset for train or validation model.

Install

Requirement:

Install GDAL by Anaconda/MiniConda not pip

1

conda install gdal

install package

1

pip install d-arth

Additional: Huawei OBS Server Package (Optional)

After version 0.0.3, the process will install OBS package automatically. The Azure & Amazon Service will support in beta version, if it is necessary. So we don’t need to install related package manually.

Support Vector Datasource type:

• MBTiles
• Shapefile
• Pbf
• Geojson

First of all , the layer name & class should be know as prior knowledge that mean the same class maybe has different keyword in OSM data and definition. like ‘water’ as a classname, but same classname in OSM data will be ‘waterway’,’water’,’lake’…

Support Raster Dataset key:

• Google
• Google China,
• Google Maps,
• Google Satellite,
• Google Terrain,
• Google Terrain Hybrid,
• Google Satellite Hybrid
• Stamen Terrain
• Stamen Toner
• Stamen Toner Light
• Stamen Watercolor
• Wikimedia Map
• Wikimedia Hike Bike Map
• Esri Boundaries Places
• Esri Gray (dark)
• Esri Gray (light)
• Esri National Geographic
• Esri Ocean,
• Esri Satellite,
• Esri Standard,
• Esri Terrain,
• Esri Transportation,
• Esri Topo World,
• OpenStreetMap Standard,
• OpenStreetMap H.O.T.,
• OpenStreetMap Monochrome,
• OpenTopoMap,
• Strava All,
• Strava Run,
• Open Weather Map Temperature,
• Open Weather Map Clouds,
• Open Weather Map Wind Speed,
• CartoDb Dark Matter,
• CartoDb Positron,
• Bing VirtualEarth

Tutorial:

Step 1:

Download the tile file is the first step. But the almost data resources supporter didn’t write the projection information to tile file. So the compute tile projection infomation & write to file is most import part in process of download flow.

Optional :

1
2

from darth.downloader import downloader
Google=downloader("Google Satellite",thread_count=8)

Ues the 8 thread(if you have more thread could set more) to process download that will speed up whole flow of step1.

1
2

from darth.downloader import downloader
Google=downloader("Google Satellite")

# ---------------------------------------------------------------------------- ##                            MAP Production Toolkit                            ## ---------------------------------------------------------------------------- ## ---------------------- MAP Serverv Init Successful by ---------------------- ## ---------------------- Google Satellite ------------------------------------ #

Demo:

We could choose a position like the Saltlake city, Utah states.

Salt Lake City is located in United States country, in North America continent (or region). DMS latitude longitude coordinates for Salt Lake City are:

40°45’38.81”N, 111°53’27.78”W.

• Latitude position:
  Equator ⇐ 4532km (2816mi) ⇐ Salt Lake City ⇒ 5475km (3402mi) ⇒ North pole.
• Longitude position: Salt Lake City ⇐ 8644km (5371mi) ⇐ Prime meridian. GMT: -6h.
• Local time in Salt Lake City: Friday 1:35 am, May 22, 2020. [*time info]

We need plan a area that describe by WGS84 lonlat,like:

• Cord1=(-111.89105,40.76078) # Left Top Lonlat

• Cord2=(-111.8,40.7)# Right Bottom Lonlat

In addition, we need set the zoom level that mean resolution of each map tile. Relative info:

The data will generate as tiles (256*256 pixel image), you also could use DOWNLOADER_INSTANCE.merge() to merge all the tiles to whole tiff file.

addcord() as a function ,input is WGS cord of left-top point & right-bottom point x1,y1,x2,y2,additional zoom level that mean different level density of data grid.

left, top : left-top coordinate, for example (100.361,38.866)right, bottom : right-bottom coordinatez : zoomfilePath : File path for storing results, TIFF format

1
2
3

Google.add_cord(116.3, 39.9, 116.6, 39.7, 13)# WGS Lonlat Form
Google.download()
#Google.merge()#Merge to one tif file 

# -----WGS BoundingBox: (116.27325422704708, 39.90850398784923, 116.62506415757257, 39.67233079805734)# -----Mercator BoudingBox: (12943479.451629978, 4852655.222148937, 12982642.753946641, 4818439.909406773)# -----Total tiles number：8 X 7  0%|          | 0/56 [00:00<?, ?it/s]# -----Url Queue size: 56 88%|████████▊ | 49/56 [00:00<00:00, 30.20it/s]100%|██████████| 56/56 [00:00<00:00, 93877.31it/s]100%|██████████| 56/56 [00:00<00:00, 57.96it/s]# ===== Decode Downloading...# ------------------------------- Download Done ------------------------------ ## ===== Save description done Google China-Sun Jun 28 10:51:01 2020-(116.3, 39.9, 116.6, 39.7)-13.json

Cord System

TMS Global Mercator Profile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Functions necessary for generation of tiles in Spherical Mercator projection,
EPSG:900913 (EPSG:gOOglE, Google Maps Global Mercator), EPSG:3785, OSGEO:41001.

Such tiles are compatible with Google Maps, Microsoft Virtual Earth, Yahoo Maps,
UK Ordnance Survey OpenSpace API, ...
and you can overlay them on top of base maps of those web mapping applications.

Pixel and tile coordinates are in TMS notation (origin [0,0] in bottom-left).

What coordinate conversions do we need for TMS Global Mercator tiles::

     LatLon      <->       Meters      <->     Pixels    <->       Tile     

 WGS84 coordinates   Spherical Mercator  Pixels in pyramid  Tiles in pyramid
     lat/lon            XY in metres     XY pixels Z zoom      XYZ from TMS 
    EPSG:4326           EPSG:900913                                         
     .----.              ---------               --                TMS      
    /      \     <->     |       |     <->     /----/    <->      Google    
    \      /             |       |           /--------/          QuadTree   
     -----               ---------         /------------/                   
   KML, public         WebMapService         Web Clients      TileMapService

The new version of data toolkit will have dict to save info during process.
format:

1
2
3
4
5
6
7
8
9
10

tileinfo={
    "time":str(time.asctime(time.localtime(time.time()))),
    "left":self.left,
    "top":self.top,
    "right":self.right,
    "bottom":self.bottom,
    "zoom":self.zoom,
    "server":self.server,
    "data":self.result
    }

The each downloaded item will has a self description key like:

1
2
3
4
5
6
7

{
    'server': 'Google Satellite', 
    'info': [6743, 3104, 13], 
    'url': 'https://mt1.google.com/vt/lyrs=s&x=6743&y=3104&z=13', 
    'path': './images/Google Satellite-6743-3104-13.tif'
}

1

tiles=[i["path"] for i in Google.result]

The Vector & Raster Class could do some I/O, transform object to raster or vector object.

For instance, we use a shapefile that downloads from https://gis.utah.gov/ as the label to generate ground-truth.

If the timestamp of two data sources (vector & raster) is almost the same, you could get a high-quality dataset.

Additionally, https://www.openstreetmap.org/ has global vector product as below:

1
2

from darth.vector import Vector
Building=Vector('/home/winshare/Downloads/2017-07-03_asia_china.mbtiles')# 3.7GB SQLiteBased-MBTiles . The China Main Class Vector Object.

# ---------------------------------------------------------------------------- ##                                Vector Toolkit                                ## ---------------------------------------------------------------------------- ## ---------------------------------------------------------------------------- ##                            TIFF process Toolkit                              ## ---------------------------------------------------------------------------- ## -----Class TIF init without filename# -----Valid vector format : mbtiles# ----------------------------- Meta Information ----------------------------- ## -----ZOOM_LEVEL : 14                                                         ## -----attribution : <a href="http://www.openmaptiles.org/" target="_blank">&co## -----center : 116.4025,39.92,14                                              ## -----description : Extract from https://openmaptiles.org                     ## -----maxzoom : 14                                                            ## -----minzoom : 0                                                             ## -----name : OpenMapTiles                                                     ## -----pixel_scale : 256                                                       ## -----mtime : 1499626373833                                                   ## -----format : pbf                                                            ## -----id : openmaptiles                                                       ## -----version : 3.6.1                                                         ## -----maskLevel : 5                                                           ## -----bounds : 115.686,39.414,117.119,40.426                                  ## -----planettime : 1499040000000                                              ## -----basename : china_beijing.mbtiles                                        ## ----------------------------- Meta Information ----------------------------- ## -----Description :  /workspace/osm-2017-07-03-v3.6.1-china_beijing.mbtiles# -----LayerCount: 15# -----Layer : 0  LayerName :  water # -----Layer : 1  LayerName :  waterway # -----Layer : 2  LayerName :  landcover # -----Layer : 3  LayerName :  landuse # -----Layer : 4  LayerName :  mountain_peak # -----Layer : 5  LayerName :  park # -----Layer : 6  LayerName :  boundary # -----Layer : 7  LayerName :  aeroway # -----Layer : 8  LayerName :  transportation # -----Layer : 9  LayerName :  building # -----Layer : 10  LayerName :  water_name 

The most of SQLite based mbtiles vector database will have multi-layer, but wkt based shapefile & geojson almost have single layer.
Normally , Name of layer is class name that must set as default layer by getDefaultLayerbyName function. So we need choose a default layer by LayerName that will generate binary label for deep learning training.

• Of course , the function of multi-layer will update in next version.

1

Building.getDefaultLayerbyName("building")

----- Set Default Layer  building  :  <osgeo.ogr.Layer; proxy of <Swig Object of type 'OGRLayerShadow *' at 0x7fd4b2566660> ><osgeo.ogr.Layer; proxy of <Swig Object of type 'OGRLayerShadow *' at 0x7fd4b2566660> >

Step 2:

If the data used for model training, we should have a label that could be generated by the rasterize vector file. Normally, the data will label by artificial work. But human resources have limit in huge object labels with high-resolution imagery. The OSM Vector data has a worldwide version that saves in sqlite based mbtiles file system that could be decode by GDAL library.

The Class Vector and Raster is an important part of data I/O. Rasterisation is the task of taking an image described in a vector graphics format (shapes) and converting it into a raster image (a series of pixels, dots, or lines, which, when displayed together, create the image which was represented via shapes).[1][2] The rasterized image may then be displayed on a computer display, video display or printer, or stored in a bitmap file format. Rasterisation may refer to the technique of drawing 3D models, or the conversion of 2D rendering primitives such as polygons, line segments into a rasterized format.

The map data has better relative accuracy than temporary human label work that means the vector map has the potential to be ground-truth. So, transform the existing vector to raster data that is an indispensable method for generating training data in deep-learning-based computer vision mission.
Rasterize:

Notes:

If the vector layers have a huge geography space and enormous amount of data item that will cause the indexing process will extremely inefficient in rasterize process.

We set a rect size like a bounding box of Beijing city from the geographic area of CHINA. Then, we set the same area as filters in the whole space.

That could show the speed of the same mission on with filter and without a filter.

Although I already boost the rasterize flow, but that still runs on a single process, I still want to find a way that runs GDAL rasterize on python multiprocessing.

1
2

Building.crop_default_layer_by_rect(Google.mercator_cord)#FILTER to speed up
label=Building.generate(tiles)

  0%|          | 0/56 [00:00<?, ?it/s]-----Set filter Rect: (12944152.11792486, 4852834.051769256, 12983287.876406869, 4818590.263097501)-----Start Generate.....100%|██████████| 56/56 [00:18<00:00,  2.99it/s]

If we write the ‘image’ & ‘label’ to csv / json that could be a great dataset for deep learning training workflow.

And we have finished that on the Process workflow.
We could show the label&image like that.

1
2
3
4
5
6

import tifffile as tif 
import matplotlib.pyplot as plt
image=tif.imread(tiles[1])
label=tif.imread(label[1])
plt.imshow(image),plt.show()
plt.imshow(label),plt.show()

update log：

• Version 0.1.0 change the CLI UI & cancle the opencv requirement to simplify the install operation.

• Version 0.0.9 Fix HTTP header bug for request url of Google mt1-mt6 resources.

• Version 0.0.7 GDAL version limit is not friendly for user ,so i cancel the GDAL version require

• Version 0.0.6 fix license problem & call problem the root call function has been turn back to low case

• Version 0.0.3 Test Sucessful & Package Could be download & install huawei obs server automatically

Neural Network for GIS , let’s fuck!

Copyright 2020 Tom Winshare

Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

All philosophy is a critique of language - Wittgenstein

Strategy Instructions

The components of strategy instructions are: conditions (signals) and actions. The core idea of strategy is “condition => action”. Set any condition, and once it is met, trigger the trading action.

Common conditions include: price, assets, and time. Common actions include: buying and selling. With just these few elements, very rich trading strategies can be constructed. Whether good trigger conditions can be found, whether good actions can be taken under established conditions, and whether this process can continue to cycle and continue to profit - this is the embodiment of trading will in a quantified system. When people talk about quantification, they usually think of strategy first. It is the soul of the quantification system.

A basic prototype of a quant trading system should include:

• Strategy system
• Trading system
• Intelligence system
• Real-time data
• Historical data

The intelligence system includes trading data, factor data crawling, interface acquisition, and various alternative data factors, together forming the system’s data pool. From the perspective of Python, the data acquisition interface simply includes the following types.

Relationship between Data and Instructions

After obtaining the data and initial factor metadata in the previous step, they are usually highly structured and cannot be directly used for strategies. Functions and models for filtering, searching, aggregation, statistics, and other data processing exist, which have clear input, processing logic, and output. The corresponding relationships between these clear, specialized processing instructions and natural language are relatively simple and fixed.

For example:

1
2
3
4

data = sum(d0, d1, d2, d3)
data = d0 + d1 + d2 + d3

And similar expressions such as “get the sum of d0 to d3”, “sum up d0 to d3”, and “add d0 to d3” all have high semantic similarity. Therefore, the difficulty lies in the rules and generation of input and processing logic. The highest difficulty lies in the correspondence between natural language models and mathematical expressions, as well as logical expressions (which can be understood as pseudocode with fixed rules and templates). It is extremely difficult to generate and accumulate such data. Therefore, the design of this mathematical expression and logical expression system is the most fundamental and challenging work. On this basis, we need to introduce many concepts.

First-Order Logic

• George Boole

First-order logic (FOL), also known as first-order predicate calculus, allows for quantification of statements and is a formal system used in mathematics, philosophy, linguistics, and computer science. FOL is a mathematical logic that distinguishes itself from higher-order logic by not allowing quantification over properties. Properties are characteristics of an object; therefore, a red object would be described as having the property of being red.

The language of logical programs is a subset of FOL because it is useful for many tasks. FOL can be viewed as a language for logical programs that can add disjunctions and explicit quantification. FOL is first-order because it allows for quantification over individuals in a domain. FOL neither allows for predicates to be variables nor allows for quantification over predicates.

Second-order logic allows for quantification over first-order relations and predicates whose arguments are first-order relations. These are all second-order relations. For example, the second-order logic formula

defines symmetry for second-order relations, and if its argument is a symmetric relation, it is true. FOL is recursively enumerable, which means that there is a complete proof procedure in which every true statement can be proven using a proof program on a Turing machine. Second-order logic is not recursively enumerable, so there is no complete proof procedure that can be implemented on a Turing machine.

Propositional logic deals only with simple propositional statements, while FOL also includes assertions and quantification.

An assertion is like a function that returns true or false. Consider the following sentences: “Socrates is a philosopher” and “Plato is a philosopher”. In propositional logic, the two sentences are considered as two unrelated propositions, simply labeled as p and q. However, in FOL, the two sentences can be represented using assertions in a more similar way. The assertion is Phil(a), which means a is a philosopher. Therefore, if a represents Socrates, Phil(a) is the first proposition - p; if a represents Plato, Phil(a) is the second proposition - q. A key point of FOL can be seen here: the string “Phil” is a grammatical entity, and its semantics are assigned by assigning it to be true when a is a philosopher. The assignment of a semantics is called an interpretation.

FOL allows for the use of variables to infer properties shared by many components. For example, let Phil(a) represent a philosopher, and let Schol(a) represent a scholar. Then, the formula represents that if a is a philosopher, then a is a scholar. The symbol is used to mark a conditional statement. The left side is the hypothesis, and the right side is the conclusion. The truth value of this formula depends on the element labeled as a and the interpretation of “Phil” and “Schol”.

For each a, assertions of the form “if a is a philosopher, then a is a scholar” require the use of variables and quantification. Once again, let Phil(a) represent a philosopher, and let Schol(a) represent a scholar. The FOL statement

represents that regardless of what a represents, if a is a philosopher, then a is a scholar. The universal quantifier represents a claim for “all” choices of a, and the statement in parentheses is an idea that is true.

To demonstrate that the assertion “if it is a philosopher, then it is a scholar” is false, it can be shown that there are philosophers who are not scholars. This can be

expressed using existential quantification. For example:

• ¬(∀x)(Phil(x) → Schol(x))
• ¬(∀x)(Phil(x) ∧ ¬Schol(x))

The negation operator ¬ is true if and only if the statement is false; in other words, if and only if a is not a scholar.
The conjunction operator ∧ indicates that a is a philosopher and not a scholar.

Assertions Phil(a) and Schol(a) both have only one argument. However, FOL can also represent assertions with more than one argument. For example, “There exist people who can be fooled at any time” can be represented as

Here, Person(x) is interpreted as x is a person, Time(y) is interpreted as y is a period of time, and Canfool(x,y) is interpreted as person x can be fooled at time y. Clearly, the statement represents that at least one person can be fooled at any time, which is stronger than the statement “At any time, there exists at least one person who can be fooled.” The latter does not imply that the person being fooled is always the same.

The scope of quantification is determined by the set of objects that can be used to satisfy quantification (in some of the informal examples in this section, the scope of quantification is not specified). In addition to specifying the meaning of assertion symbols such as Person and Time, an interpretation must also specify a non-empty set called the domain, which serves as the scope of quantification. Therefore, a statement of the form in a specific interpretation is true if there exist objects in the domain that can be used to assign meanings to the symbols Phil and Schol.

Formation Rules

Formation rules define the terms and formulas of first-order logic, which can be used to write a formal grammar for terms and formulas, because they are represented as sequences of symbols. These rules are usually context-free (the result of the rule has only a single symbol on the left-hand side), unless infinite sequences of symbols are allowed and there are many starting symbols, such as variables in terms.

• Terms

Terms can be recursively defined according to the following rules:

1. Variables. Every variable is a term.
2. Functions. Every expression f(t1, …, tn) with n parameters, where each ti is a term and f is a function symbol with n parameters, is a term. In addition, constant symbols are function symbols with 0 parameters, and therefore they are also terms.

Only those expressions that can be obtained by applying the above rules a finite number of times are terms. For example, there are no terms containing predicate symbols.

• Formulas

Formulas (or well-formed formulas) can be recursively defined according to the following rules:

1. Predicate Symbols. If P is an nary predicate symbol and t1, …, tn are terms, then P(t1, …, tn) is a formula.
2. Equality. If the equality symbol is part of the logic and t1 and t2 are terms, then t1 = t2 is a formula.
3. Negation. If φ is a formula, then ┐φ is a formula.
4. Binary Connectives. If φ and ψ are formulas, then (φ ψ) is a formula. Other binary logical connectives can be defined similarly.
5. Quantification. If φ is a formula and x is a variable, then and are formulas.

Only those expressions that can be obtained by applying the above rules a finite number of times are formulas. Formulas obtained from the first two rules are called atomic formulas.

For example,

is a formula, where f is a unary function symbol, P is a unary predicate symbol, and Q is a ternary predicate symbol. On the other hand, is not a formula, although it is a string of symbols from the vocabulary.

The parentheses in the definition are used to ensure that any formula can only be obtained by recursively defining it in a single way (in other words, each formula has a unique parse tree). This property is called the unique readability of formulas. There are many conventions regarding where to use parentheses in formulas. For example, some authors use colons or dots instead of parentheses, or change the position of the parentheses. However, every author’s definition must be shown to satisfy unique readability.

The rules for defining formulas cannot define the “if-then-else” function ite(c, a, b), where c is a condition represented by a formula, and ite(c, a, b) returns a if c is true and b if c is false. This is because both predicates and functions can only accept terms as their arguments, but the first argument of this function is a formula. Some languages built on top of first-order logic, such as SMT-LIB 2.0, allow such constructs.

SMT-LIB is an international initiative aimed at facilitating research and development in Satisfiability Modulo Theories  (SMT). Since its inception in 2003, the initiative has pursued these aims by focusing on the following concrete goals.

• Provide standard rigorous descriptions of background theories used in SMT systems.
• Develop and promote common input and output languages for SMT solvers .
• Connect developers, researchers and users of SMT, and develop a community around it.
• Establish and make available to the research community a large library of benchmarks for SMT solvers.
• Collect and promote software tools useful to the SMT community.

This website provides access to the following main artifacts of the initiative.

• Documents describing the SMT-LIB input/output language for SMT solvers and its semantics;
• Specifications of background theories and logics;
• A large library of input problems, or benchmarks, written in the SMT-LIB language.
• Links to SMT solvers and related tools and utilities.

Programming Z3

The Z3 engine is an efficient symbolic reasoning tool that was initially used for theorem proving and symbolic verification. However, its powerful features are now being applied in various fields.

To learn Z3, one first needs to understand how it does theorem proving (its original purpose), and then see how it can be applied to other fields.

In 1990, Halpern, J. Y. proposed two methods for solving probabilistic first-order logic. In 1998, Chiara Ghidini also proposed Distributed First Order Logic for use in distributed knowledge representation and reasoning systems (DKRS). In 2002, Anand Ranganathan Æ Roy H. Campbell used first-order logic for background-aware systems to represent information that cannot be quantified. In 2012, Fitting, M. applied first-order logic to automatic theorem proving.

With the help of the tools mentioned above, definitions, and formulas, we can say that as long as we have first-order logic, the results obtained, and the set of composite logics can convert structured (low degrees of freedom) natural language into corresponding data processing logic and executable strategies within a limited scope, which is no longer impossible to achieve.

Natural Language Modeling

In reality, a natural language model that can completely replace human communication and semantic parsing has not yet been developed. Therefore, it is unnecessary to pursue the ability to process relatively contextually dependent and complex languages. Through large-scale language corpus training, the model can achieve natural language semantic parsing and convert it into a set of first-order logic in a relatively structured (lower degree of freedom) natural language environment.

We often say “don’t speak incoherently, be coherent and cohesive,” meaning that the context of the vocabulary should have semantic coherence. Based on the coherence of natural language, the language model predicts the next word based on the previous words. If the parameters of the language model are correct and the word vectors of each word are set correctly, the language model’s predictions should be relatively accurate. With countless articles in the world, training data is endless. However, context dependency means that you cannot obtain enough information from just one sentence. So, what is this information?

For example, when we use a regular voice assistant to say “call my wife,” “call my mother,” “call my father,” the predicate “call(x)” is first parsed as an item (function). The term “wife,” “mother,” “father,” and so on are then parsed as items (variables). As previously mentioned, items and formulas are represented as a string of symbols, and these rules can be used to write a formal grammar for items and formulas. These rules are usually context-free. Otherwise, there will be an infinite number of symbols.

Therefore, we begin to compare symbols with existing symbols. For example, the function call() needs to know the phone number property of the input item, so it is reasonable to use “wife,” “mother” to refer to items in the symbol library. Thus, the matching is completed. The entire chain also works. We can also understand that if we use “Zhang San” or “Li Si” to refer to the item designated for dad, it will be impossible to complete the matching work without context (and there should be no context). This is the great difficulty of modern NLP compared to humans. Every normal person’s brain has a very large, fully trained context-dependent symbol system, and it is extremely difficult for a computer based on von Neumann architecture to have the same symbol system. This is also why modern language models like GPT-3 have already reached a parameter volume that home computers cannot handle. The larger the symbol system, the more connections between symbols, and the better the model’s performance. Therefore, after BERT, almost all models use pre-training. These pre-training models basically represent a basic symbol system. Based on this complete and massive symbol system, the learning difficulty and computational complexity of building larger symbol systems will be greatly reduced.

Therefore, once we have a clear understanding, we can find that by specifying the grammar rules on the input end and having a well-designed code (functions and symbol system) on the execution end, processing rule-based natural language into a string of executable functions is achievable.

So, HOW?

Translation Model OR Generation Model

We should be clear that the few-shot learning capability of GPT-3 is not universal. Although the model has impressed people with its learning of complex tasks and patterns, it can still fail. For example, even after seeing 10,000 examples, it cannot solve a simple task like reversing a string. It is essentially a network of nodes connected in a high-dimensional word embedding space. GPT-3 transforms the input words into high-dimensional space nodes in the network as a starting point and continuously searches for shortcuts to reach the next node, which is its perceptual world. In fact, it is only trying to understand the language dimension of humans and cannot understand the perceptual cognitive dimension of humans. This is the limitation of GPT-3 that cannot be broken no matter how much the model is expanded.

However, we should also know that our needs do not actually require the model to be intelligent to any extent.

From the conventional perspective, we have two seemingly feasible technical routes:

• NLP translation model

GitHub - huggingface/transformers: 🤗 Transformers: State-of-the-art Natural Language Processing for Pytorch, TensorFlow, and JAX.

• NLU/NLG generation model

GitHub - charlesXu86/Chatbot_CN: A chatbot based on finance-judiciary domain (with casual chat nature), whose main modules include information extraction, NLU, NLG, knowledge graph, etc., and integrated frontend display with Django. It has currently encapsulated nlp and kg’s restful interfaces.

However, generally speaking, translation models have a higher probability of failure in grammar and logic after translation, and due to the much lower fault tolerance of first-order logic than natural language, the drawbacks of translation models in this task are obvious. For example, “I don’t want to eat apples.” and “I don’t eat apples.” The subtle semantic differences between these two sentences can be ignored in daily conversations, but from the perspective of logic, the semantic differences between “not,” “cannot,” and “do not want” are significant and require three separate functions to describe. The input and matching confusion in this process makes the requirement for humans very high after translation and the usability of the entire process very low.

Thus, we can understand that the core of the entire process becomes a dialogue system based on NLU, NLG, and an application layer composed of symbolic system sets. As we gradually clarify this technical solution, we can provide the following basic system structure:

1. Data Layer: Dialogue business data, open-source multi-turn dialogue data, etc.

2. Algorithm Layer: Syntactic analysis, fine-grained analysis, entity extraction, query error correction, etc.

3. Capability Layer: Natural Language Understanding, Dialogue Management, Dialogue Strategy, Strategy Optimization, Dialogue Factory

4. Application Layer: Real-time/historical data aggregation, statistics, analysis, visualization, backtesting, live trading

In the data layer and application layer, the financial data, factor library data, and the system’s own database are used as support.

New Chapter - GPT4

The publish of chatgpt is new phase of artificial intelligence, and GPT4 bring multi-modal capability in dialogue system. It have potential to revolute whole finance system.

GPT series’ capabilities are mainly reflected in the following aspects:

1. After performing Preprompt preprocessing, GPT can have a primary logical reasoning ability that meets requirements. Although this ability is unstable, when combined with frameworks like Wolfram, its reasoning and scientific computing capabilities will be greatly expanded.
2. In dealing with unstructured natural language data problems, GPT has excellent analysis and restructuring abilities, enabling a vast amount of human data to be used. It can effectively transform multimodal data into structured semantics.
3. When faced with multi-stage problems, GPT can effectively handle task scheduling and sequencing to help design an instruction architecture that meets system requirements. Many projects have begun to demonstrate their capabilities in this area.

For example:

AutoGPT:

https://github.com/Significant-Gravitas/Auto-GPT

Microsoft Jarvis:

https://github.com/microsoft/JARVIS

These two projects have extensively explored the potential of LLM Server as the core of a task system. For example, in the Jarvis project:

We introduce a collaborative system that consists of an LLM as the controller and numerous expert models as collaborative executors (from HuggingFace Hub). The workflow of our system consists of four stages:

• Task Planning: Using ChatGPT to analyze the requests of users to understand their intention, and disassemble them into possible solvable tasks.
• Model Selection: To solve the planned tasks, ChatGPT selects expert models hosted on Hugging Face based on their descriptions.
• Task Execution: Invokes and executes each selected model, and return the results to ChatGPT.
• Response Generation: Finally, using ChatGPT to integrate the prediction of all models, and generate responses.

Resources:

GitHub - tokenmill/awesome-nlg: A curated list of resources dedicated to Natural Language Generation (NLG)

GitHub - keon/awesome-nlp: A curated list of resources dedicated to Natural Language Processing (NLP)

Reference：

1. Andreas Fröhlich, Armin Biere, Christoph M. Wintersteiger, Youssef Hamadi: Stochastic Local Search for Satisfiability Modulo Theories . AAAI 2015.
2. Nikolaj Bjørner and Anh-Dung Phan and Lars Fleckenstein. nu-Z: An Optimizing SMT Solver . TACAS April 2015.
3. Nikolaj Bjørner and Arie Gurfinkel.Property Directed Polyhedral Abstraction.  VMCAI 2015.
4. Aleksandar Zeljic, Christoph M. Wintersteiger, and Philipp Rümmer. Approximations for Model Construction . IJCAR 2014.
5. Markus N. Rabe, Christoph M. Wintersteiger, Hillel Kugler, Boyan Yordanov, and Youssef Hamadi. Symbolic Approximation of the Bounded Reachability Probability in Large Markov Chains . QEST 2014.
6. Nikolaj Bjørner and Anh-Dung Phan. newZ: Maximal Satisfaction with Z3.  Invited paper, in SCSS 2014 .
7. Josh Berdine and Nikolaj Bjørner. Computing All Implied Equalities via SMT-based Partition Refinement. IJCAR 2014. Technical Report .
8. Margus Veanes, Nikolaj Bjørner, Lev Nachmanson and Sergey Bereg.Monadic Decomposition.  CAV 2014.
9. Shachar Itzhaky, Nikolaj Bjørner, Thomas Reps, Mooly Sagiv, and Aditya Thakur.Property Directed Shape Analysis . CAV 2014.
10. Nuno Lopes, Nikolaj Bjorner, Patrice Godefroid, Karthick Jayaraman, and George Varghese. *Checking beliefs in Dynamic Networks*.  Technical Report. Revised version to appear in NSDI 2015.
11. Thomas Ball, Nikolaj Bjørner, Aaron Gember, Shachar Itzhaky, Aleksandr Karbyshev, Mooly Sagiv, Michael Schapira and Asaf Valadarsky.VeriCon: Towards Verifying Controller Programs in Software-Defined Networks . PLDI 2014
12. Nikolaj Bjørner, Konstantin Korovin, Arie Gurfinkel and Ori Lahav.Instantiations, Zippers and EPR Interpolation . Short paper at LPAR 19 .
13. Josh Berdine, Nikolaj Bjørner, Samin Ishtiaq, Jael E. Kriener, Christoph Wintersteiger.Resourceful Reachability as HORN-LA . LPAR 19.
14. Nikolaj Bjørner, Ken McMillan and Andrey Rybalchenko.Higher-order Program Verification as Satisfiability Modulo Theories with Algebraic Data-types . In informal proceedings of HOPA 2013 (workshop on Higher-Order Program Analysis).
15. Nikolaj Bjørner, Ken McMillan and Andrey Rybalchenko.On Solving Universally Quantified Horn Clauses. SAS 2013
16. Nikolaj Bjørner, Ken McMillan, Andrey Rybalchenko.Program Verification as Satisfiability Modulo Theories . SMT workshop 2012. Slides
17. Nikolaj Bjørner, Vijay Ganesh, Raphael Michel, Margus Veanes. An SMT-liB Format for Sequences and Regular Expressions.  SMT workshop 2012.
18. Leonardo de Moura and Grant Passmore. Computation in real closed infinitesimal and transcendental extensions of the rationals. In Automated Deduction - CADE-24, 24th International Conference on Automated Deduction, Lake Placid, New York, June 9-14, 2013, Proceedings, 2013.
19. Leonardo de Moura and Grant Passmore. The Strategy Challenge in SMT Solving, volume 7788 of Lecture Notes in Artificial Intelligence. Springer, 2013. [.pdf ]
20. Leonardo de Moura and Dejan Jovanović. A model-constructing satisfiability calculus. In 14th International Conference on Verification, Model Checking, and Abstract Interpretation, VMCAI, Rome, Italy, 2013, 2013. [ .pdf  ]
21. Dejan Jovanović and Leonardo de Moura. Solving non-linear arithmetic. In Automated Reasoning - 6th International Joint Conference, IJCAR 2012, Manchester, UK, June 26-29, 2012. Proceedings, volume 7364 of Lecture Notes in Computer Science, pages 339-354. Springer, 2012. [ .pdf  ]
22. Dejan Jovanović and Leonardo de Moura. Solving non-linear arithmetic. Technical Report MSR-TR-2012-20, Microsoft Research, 2012. [ http  ]
23. Nikolaj Bjørner. Taking Satisfiability to the Next Level with Z3. IJCAR 2012.
24. Anh-Dung Phan, Nikolaj Bjørner, David Monniaux. Anatomy of Alternating Quantifier Satisfiability. SMT workshop 2012. [ .pdf  ]
25. Krystof Hoder and Nikolaj Bjørner. Generalized Property Directed Reachability. In SAT 2012. [.pdf ]
26. Christoph Wintersteiger, Youssef Hamadi, and Leonardo de Moura. Efficiently solving quantified bit-vector formulas. Formal Methods in System Design, 2012. [ http  | .pdf  ]
27. Nikolaj Bjørner and Leonardo de Moura. Tractability and Modern Satisfiability Modulo Theories Solvers. In Handbook of Tractability. Cambridge University Press, 2012. [.pdf]
28. Krystof Hoder, Nikolaj Bjørner, and Leonardo de Moura. muZ - an efficient engine for fixed points with constraints. In Computer Aided Verification - 23rd International Conference, CAV 2011, Snowbird, UT, USA, July 14-20, 2011. Proceedings, volume 6806 of Lecture Notes in Computer Science, pages 457-462, 2011. [.pdf ]
29. Leonardo de Moura and Nikolaj Bjørner. Satisfiability modulo theories: introduction and applications. Commun. ACM, 54(9):69-77, 2011. [ http  ]
30. Dejan Jovanović and Leonardo de Moura. Cutting to the chase solving linear integer arithmetic. In Automated Deduction - CADE-23 - 23rd International Conference on Automated Deduction, Wroclaw, Poland, July 31 - August 5, 2011. Proceedings, volume 6803 of Lecture Notes in Computer Science, pages 338-353. Springer, 2011. [ .pdf  ]
31. Maria Paola Bonacina, Christopher Lynch, and Leonardo de Moura. On deciding satisfiability by theorem proving with speculative inferences. J. Autom. Reasoning, 47(2):161-189, 2011. [ .pdf  ]