The Evolution of Neural Network-Based Chart Patterns: A Preliminary Study

TL;DR

This paper introduces a HyperNEAT-based framework for discovering neural network-based chart patterns in stock markets, demonstrating its effectiveness and potential over existing search methods.

Contribution

It formulates a general search problem for neural network chart patterns and applies a novel HyperNEAT framework to improve pattern discovery in financial data.

Findings

Successfully identified attractive patterns in the Korean stock market

The proposed method outperforms other search schemes in robustness and speed

Demonstrates potential for cross-representational quantitative comparison

Abstract

A neural network-based chart pattern represents adaptive parametric features, including non-linear transformations, and a template that can be applied in the feature space. The search of neural network-based chart patterns has been unexplored despite its potential expressiveness. In this paper, we formulate a general chart pattern search problem to enable cross-representational quantitative comparison of various search schemes. We suggest a HyperNEAT framework applying state-of-the-art deep neural network techniques to find attractive neural network-based chart patterns; These techniques enable a fast evaluation and search of robust patterns, as well as bringing a performance gain. The proposed framework successfully found attractive patterns on the Korean stock market. We compared newly found patterns with those found by different search schemes, showing the proposed approach has potential.

Tables

Table 1. Table 1 . Comparative results ( × 10 − 2 absent superscript 10 2 \times 10^{-2} )

		$k=20$			$k=50$			$k=100$
Approach	Pattern name	Training	Validation	Test	Training	Validation	Test	Training	Validation	Test
	doubleB	-0.4135	0.1745	-0.713	0.0299	3.001	-0.1425	0.8759	6.3533	1.3904
	doubleT	-0.1833	0.0892	0.0562	0.1842	1.5489	0.6741	1.4297	4.4436	2.5205
	triangleA	0.0077	-0.0138	-0.0361	0.0007	0.0201	0.0162	0.0222	0.0442	0.0502
	triangleD	0.0142	-0.0079	-0.0296	0.0418	0.0937	-0.0818	0.0287	0.1796	-0.0414
	triangleSB	0.0168	0.0154	0.0134	0.0411	0.0637	0.0051	0.0385	0.1354	0.1185
	triangleST	-0.0104	0.002	-0.0643	0.0284	0.0684	-0.019	0.0434	0.093	-0.0056
	tripleB	-0.1011	0.0444	-0.1613	-0.0113	0.8624	0.0138	0.2487	2.3948	0.903
	tripleT	-0.0262	-0.0075	-0.0375	-0.0349	0.1079	0.0674	0.1352	0.2817	-0.0999
	threeFP	-0.0139	0.5688	0.1183	1.5674	3.6929	0.8612	3.9923	8.997	2.439
	threeRV	-0.2771	0.2085	-0.8037	-0.1859	2.2642	-0.2382	0.2884	4.1644	1.2385
	HnSB	-0.0028	-0.0013	-0.0065	-0.0018	0.0276	-0.0203	0.0614	0.0612	0.0229
Manually designed	HnST	-0.0042	0.0102	-0.0249	0.0165	-0.0077	-0.0384	0.0248	0.1369	-0.0625
well-known	broadenB	-0.0068	0.0008	-0.0135	-0.0111	0.0142	-0.01	-0.0029	0.0006	-0.0071
stock chart patterns	broadenT	0.0055	0.0022	-0.0059	0.0102	-0.0043	-0.0025	0.012	-0.0132	0.0044
	broadenFA	0.0023	-0.0011	0.0031	0.0197	0.0233	-0.0069	0.1019	0.0968	0.0554
	broadenFD	-0.0051	0.005	-0.0117	-0.0073	0.0192	-0.0046	-0.0003	0.0567	-0.0081
	broadenWA	-0.0665	-0.0397	-0.0978	-0.0362	0.0819	-0.0696	0.0459	0.5141	0.1591
	broadenWD	0.0358	0.1306	0.0189	0.2502	0.4267	0.1748	0.5445	0.9414	0.7562
	rectB	-0.002	-0.0159	-0.0071	-0.0043	0.0016	-0.0252	-0.0042	0.0034	-0.0206
	rectT	-0.0024	-0.0172	-0.0024	-0.0091	0.0098	-0.0116	-0.0063	0.0067	-0.0142
	BnRB	0.0313	0.1773	0.0135	0.2508	0.6398	0.2824	0.6682	1.1413	0.9724
	BnRT	-0.0892	-0.0475	-0.1095	-0.0415	0.0705	-0.0556	0.079	0.2984	0.225
	DHnSB	-0.0011	-0.0006	0.0014	-0.0071	-0.006	-0.0175	-0.0015	0	-0.0223
	DHnST	0.0006	0.0033	0.0011	0.0013	0.013	0	0.0004	0.018	0
	diaB	-0.0002	0.0042	-0.0046	0.0264	0.0145	0.0028	0.0146	0.0086	0.0153
	diaT	-0.0105	0.0123	0.0022	-0.0021	0.0236	0.0121	-0.006	0.0167	0.0195
	HnDSB	-0.0012	0	0	-0.0034	0	0	-0.0001	0	0
	rp_20_50(Ha et al., 2016)	-0.1657	0.6548	-0.8153	1.4888	6.4532	0.0863	3.2787	12.2918	1.9913
Rule-based	rp_100(Ha et al., 2016)	-0.1127	0.5155	-0.5296	0.3814	2.2943	-0.3843	1.0427	4.9562	0.7167
stock chart patterns	rp_example(Ha et al., 2016)	-0.2185	0.4883	-0.8412	0.9535	4.7315	-0.6867	2.3514	9.7325	0.9351
found by GA	rp2_20	0.2112	1.4374	-0.3566	3.0874	6.1921	-0.4915	5.2878	9.9223	0.5566
	rp2_50	0.3646	1.3335	-0.2888	3.2314	6.5954	-0.1334	6.5452	15.4184	2.3219
	rp2_100	0.3277	0.0994	-0.4351	1.5327	4.6352	-0.0762	5.8328	16.3815	2.6038
Template-based	tp_20	9.9308	4.151	2.2809	6.8905	2.6877	0.4456	4.7645	4.1592	-4.5077
stock chart patterns	tp_50	14.8681	8.0650	6.1008	11.9267	7.2954	5.338	9.302	9.8671	-0.0063
found by HyperNEAT	tp_100	-1.7451	0.8408	2.9105	0.9945	5.0631	7.0560	4.4891	15.8227	4.3086
Neural network-based	nnp_20	14.9717	8.0733	$[$6.1778$]$	12.0797	7.0082	5.2648	9.5376	9.5248	-0.1256
stock chart patterns	nnp_50	0.3281	1.2617	2.9870	3.5819	5.6478	7.1354	5.8694	14.5219	4.8035
found by HyperNEAT	nnp_100	-0.6693	1.2977	3.002	2.0989	5.2279	$[$7.3442$]$	5.5765	15.4207	$[$5.5817$]$

Equations

$$f(\mathbf{x})=\{\begin{array}{ll}1,& \text{ if }{w}_0+w_1{x}_1+...+w_D{x}_D>0\\ 0,& \text{ otherwise}.\end{array}$$

$$g(f,\bm{X})=\exp\Big{(}-\frac{6}{\alpha}\sum_{\bm{x}\in\bm{X}}{f(\bm{x})}\Big{)},\\$$

$$Chart\_Pattern\_Search(k,\bm{X})=\underset{f}{\arg\max}\Big{(}\frac{\sum_{\bm{x}\in\bm{X}}r(\bm{x},k)f(\bm{x})}{\sum_{\bm{x}\in\bm{X}}f(\bm{x})}g(f,\bm{X})\Big{)},$$

Full text

In this paper, we formulate a general chart pattern search problem to enable cross-representational quantitative comparison of various search schemes. We suggest a HyperNEAT framework applying state-of-the-art deep neural network techniques to find attractive neural network-based chart patterns; These techniques enable a fast evaluation and search of robust patterns, as well as bringing a performance gain. The proposed framework successfully found attractive patterns on the Korean stock market. We compared newly found patterns with those found by different search schemes, showing the proposed approach has potential.

chart pattern, HyperNEAT, neural network

††copyright: rightsretained††doi: 10.475/123_4††isbn: 123-4567-24-567/08/06††journalyear: 2017††copyright: acmcopyright††conference: GECCO ’17; July 15-19, 2017; Berlin, Germany††price: 15.00††doi: http://dx.doi.org/10.1145/3071178.3071192††isbn: 978-1-4503-4920-8/17/07††ccs: Computing methodologies Neural networks††ccs: Computing methodologies Generative and developmental approaches

1. Introduction

According to the famous EMH (efficient market hypothesis (Fama, 1970)), all relevant information is fully reflected in asset prices and the assets are traded at fair values. It asserts that no one can consistently beat the market, so any effort to find such a strategy is worthless. As refutations of this, a considerable amount of empirical studies have been conducted (Banz, 1981; Keim, 1983). In particular, technical analysis focuses mostly on the historical record of price movement, assuming that the fluctuations of asset prices have useful information for investment.

This preliminary paper focuses on chart patterns in technical analysis. The significance of the analysis is that patterns often play a key role in building a trading strategy.111Triggering actions using chart patterns is a common approach for trading strategy in practice. Since the study of strategy is beyond the scope of our research, it is not covered in this paper. A templated-based chart pattern matching is an approach to determine whether a reference chart matches to a template (Bo et al., 2005; Cervelló-Royo et al., 2015; Leigh et al., 2008; Leigh et al., 2002b; Wang and Chan, 2007, 2009; Leigh et al., 2002a). This approach has a strong limitation to detecting highly abstracted features. On the other hand, a rule-based approach enables one to design patterns with abstracted features, yet it has the disadvantage that experts must manually define syntactic elements and their structures (Bandara et al., 2015; Fu et al., 2007; Lee et al., 2006; Lo et al., 2000; Zapranis and Tsinaslanidis, 2012; Zhang et al., 2010; Ha et al., 2016). Kamijo and Tanigawa (Kamijo and Tanigawa, 1990) attempted to recognize the triangle chart pattern with a recurrent neural network as a precedent study of a neural network-based matching. Guo et al. (Guo et al., 2007) used a rival penalized competitive learning (RPCL) neural network for clustering stock chart patterns. Unlike stock chart pattern analysis, the use of a neural network for the control chart pattern recognition has been actively studied in the field of statistical process control (SPC) (Addeh et al., 2011; Barghash and Santarisi, 2004; Leger et al., 1998; Cheng, 1997).

Prior chart pattern studies have focused mostly on how to discriminate whether a chart matches to a chart pattern. They blindly used well-known patterns, such as the head-and-shoulder, without sufficient consideration on how to design a profitable chart pattern. The well-known patterns are likely to have been generated by inefficient searches on very limited regions of the pattern space since they were designed by human intuition. Ha et al. (Ha et al., 2016) posed this problem and applied a genetic algorithm (GA) to find rule-based chart patterns automatically.

In this paper, we formulate a chart pattern search problem independent of how chart patterns are designed. We propose a search framework using Hypercube-based NeuroEvolution of Augmented Topologies (HyperNEAT; (Gauci and Stanley, 2010; Stanley et al., 2009)) for template-based and neural network-based chart pattern searches, which have not been studied in the past. Neural networks are advantageous to approximate a function in theoretical reason (see Section 2.1). On the other hand, a chart pattern is a discriminant function itself that takes a chart as input and outputs a match (see Section 2.2). Therefore, a neural network is a suitable candidate to represent the chart pattern. Since typical gradient-based learning techniques are not applicable for the neural network-based chart pattern search, we solve it using the NeuroEvolution framework. We implement the proposed framework applying the state-of-the-art deep neural network techniques:

a) the use of GPGPU allows handling the tremendous cost of a stock chart pattern search;

b) a simple but powerful regularizer, dropout (Srivastava et al., 2014), helps find general patterns;

c) the use of the Rectified Linear Unit (ReLU; (Nair and Hinton, 2010)) brings performance gain, as well as enabling fast operation, compared to the conventional activation function, sigmoid. However, ReLU should be used with caution because the variance of activations of a layer can be amplified or attenuated over layers. Weight initialization tricks (Glorot and Bengio, 2010; He et al., 2015b) for gradient-based learning provides insight for weight scaling of a phenotype network using ReLU, allowing an efficient exploration of deeper networks without suffering such a problem.

We found some attractive stock chart patterns in the Korean market with the framework. The suggested framework found some profitable patterns, outperformed the other patterns.

The remainder of this paper is organized as follows. In Section 2, we introduce various chart pattern matchings and formulate a chart pattern search problem. Section 3 describes the HyperNEAT framework for neural network-based chart pattern search and its implementation with state-of-the-art deep neural network techniques. Section 4 presents the preprocess and the experimental setup. In Section 5, we demonstrate the performance of the proposed approach with the results and show the advantages of applied neural network techniques. Finally, we draw conclusions in the last section.

2. Chart Pattern Search

Section 2.1 provides an overview of various chart pattern matching techniques. In Section 2.2, we formulate the chart pattern search problem independent of a matching, which establishes a basis to compare patterns represented by different matching techniques.

2.1. Chart Pattern Matching

In the applications of chart pattern analysis, a raw time series can be preprocessed to either a one-dimensional sequence or a two-dimensional image. Since either of them can be vectorized, a chart can be written in the form of $\bm{x}=(x_{1},x_{2},...,x_{D})^{T}$.

A template-based matching uses a template $\bm{w}=(w_{0},w_{1},...,w_{D})^{T}$ to discriminate whether a chart matches by the sign of a linear combination with the chart. The discriminant function $f$ can be written as follows:

[TABLE]

We say that $\bm{x}$ matches to the corresponding chart pattern when the value of $f(\bm{x})$ is $1$. A template-based pattern forms a linearly separated area in the input space; the matched input lies in this area. This linear model not only limits the representation of the chart pattern, but also has a high bias. Nonetheless, it has the advantage in the field of finance due to the robustness from low variances.

A feature-based matching, on the other hand, discriminates a chart through a linear combination of fixed nonlinear functions that extract features from input. The nonlinear feature extraction function maps the input to the feature space. Thus, the feature extraction function is called the basis function because it generates the basis of the feature space. Feature-based matching has a limitation that feature extraction functions must be pre-defined by an expert. However, there are few known features in the chart pattern analysis that induce profitability.

An alternative is to introduce adaptive parameters to the basis function so that the parameter can be adapted while searching chart patterns. The neural network is one of the most widely studied models to handle adaptive parametric basis functions. Theoretically, a two-layer neural network containing a sufficient finite number of hidden nodes can approximate a continuous function defined on a compact domain (Cybenko, 1989; Hornik, 1991), therefore, the neural network-based chart pattern representation using adaptive parametric feature have potential expressiveness. We use a neural network to represent a chart pattern. Furthermore, a template-based chart pattern can be represented by a neural network with no hidden neurons.

In rule-based chart pattern analysis, a rule indicates the order relation of extrema extracted from a smoothen time series. A rule-based chart pattern consists of a set of rules. If the chart satisfies all the rules of the rule-based chart pattern, it is said to match. Most manually designed well-known patterns are rule-based. The head-and-shoulder, for example, is expressed in the order relations of the extrema, the head, the two shoulders, and the two necks.

2.2. Problem Formulation

A chart pattern itself can be considered to be a function, which discriminates whether a chart matches to the chart pattern. The chart pattern matching describes how a discriminant function is represented. The feasible functions from a chart pattern matching span a discriminant function space. The chart pattern search is to find an attractive chart pattern on the chart pattern space defined by a matching. Equivalently, it is a problem of finding an attractive discriminant function in the function space.

We define the profitability of a pattern by an expected value of log returns222The losses and profits are likely to be distributed fairly evenly. In practice, losses lie in the interval of $(-1,0)$ and profits in the interval of $(0,\infty)$, which makes their distribution skewed severely to the profit side. Thus, we use the log returns that are more sensitive to losses. after $k$ days for all charts matched to the pattern. We define a chart pattern search as a problem of finding a discriminant function $f$ of a pattern such that it maximizes the profitability of the chart pattern. If the number of matches of a chart pattern is too small, the pattern is not general enough as well as it is hard to be used in the field. Thus, a penalty related to the number of matches is applied. The penalty function $g$ is defined as follows:

[TABLE]

where $\bm{X}$ is the set of all given charts, $\sum_{\bm{x}\in\bm{X}}{f(\bm{x})}$ is the number of matches, and $\alpha$ is a hyperparameter that determines the degree of penalty. When the number of matches is greater than $\alpha$, the panalty value is small enough to be ignored. For a given set of charts, the chart pattern search problem can be represented by the following optimization problem:

[TABLE]

where $r(\bm{x},k)$ is the $k$-day log return after the last day of $\bm{x}$. The chart pattern search problem is defined independently of what representation is used.

3. HyperNEAT for chart pattern search

The discriminant function of a chart pattern can be expressed as a neural network. This section describes how to generate neural networks to represent a chart pattern. HyperNEAT is designed to encode neural connectivity patterns with regularities such as symmetry, repetition, and deformation of neural networks. In particular, these patterns arranged on the substrate are geometrically interpreted and indirectly encoded by a Compositional Pattern Producing Network (CPPN) (Stanley, 2007, 2006). A CPPN receives a pair of coordinates of two neurons in a phenotype neural network as inputs and outputs their connection weight, or takes one neuron’s coordinate with a zero-filled null coordinate to determine the bias through a separate output node. In addition, a CPPN recieves constant one as bias of genotype network in our implementation. This approach permits a relatively small genotype network to effectively describe neural connectivity patterns of a much larger phenotype network. The extension of HyperNEAT, called HyperNEAT with Link Expression Output (HyperNEAT-LEO), was introduced to limit connectivity with a bias towards modularity (Verbancsics and Stanley, 2011). This creates a separate output called LEO as well as the weight and bias output of the genotype CPPN. LEO determines the expression of the link in the phenotype network. HyperNEAT has shown to be effective for a variety of problems (Clune et al., 2009; D’Ambrosio et al., 2010; Gauci and Stanley, 2010; Verbancsics and Stanley, 2010). Nevertheless, to the best of our knowledge, no research exists to find a stock chart pattern with HyperNEAT. We present the HyperNEAT framework for the stock chart pattern search. We use the HyperNEAT-LEO version except for a few modifications. We adopt a multi-layer perceptron (MLP) architecture for a discriminant function of the chart pattern. After preprocessing, a chart input is represented by a $32\times 2$ real-value matrix. The substrate configuration of MLP for a template-based chart pattern is composed of a $32\times 2$ input layer and a $1\times 1$ output layer, and the one for a neural network-based chart pattern is composed of $16\times 12$ and $8\times 6$ hidden layers between the input and output layers. To encode the phenotype indirectly, the geometric layout of MLP needs to be determined in advance. Figure 1 shows the actual configuration of the neural network-based chart pattern. The $x$, $y$, and $z$ denote the time axis of input, the input channel axis, and the layer axis, respectively. The layers are arranged equally dividing the interval $[-1.0,1.0]$ and the endpoints. The nodes are placed in the coordinates equally dividing the interval $[-1.0,1.0]$ for each of $x$ and $y$ axes. When the value of the LEO output is not greater than zero, the connection is not expressed, thereby the weight of connection is set to zero. The MLP receives a chart and outputs 0 or 1 to determine chart matching. After obtaining candidate matches of a pattern, it is evaluated based on the expected profitability.

We adopt the state-of-the-art deep neural network technique for computationally efficient and effective implementation of a phenotype neural network of HyperNEAT.

GPGPU for fast evaluation

We use about one million input charts of the training set for the experiments (see Section 4). Therefore, a phenotype network should evaluate over one million charts to evaluate one organism. Because these operations require significant computational resources, efficient computational design will determine the possibility of practical experiment.

In recent deep neural network studies, the use of GPGPU for deep and complex neural networks using considerable amounts of data has been applied to various problems and shows excellent performance (Krizhevsky et al., 2012; He et al., 2015a). We use GPGPU for fast evaluation of phenotype networks. The feedforward operation of the MLP structure is composed of simple matrix computation such as multiplication and summation so that the gain of GPGPU can be fully exploited. TensorFlow is a library for numerical computation using stateful data flow graphs (Abadi et al., 2015). It allows flexible CPU or GPU selection for numerical computation without consideration of low-level implementation. We use TensorFlow to take advantage of GPGPU from fast phenotype network operations.

Dropout

Dropout (Srivastava et al., 2014) is a regularization technique to prevent coadaptation of feature detectors by randomly and temporarily omitting nodes of a neural network. We use it to prevent a neural network from overfitting to training set. The probability of retaining a neuron is set to 0.8 for evaluation using training set.

Rectified Linear Unit and weight scaling

ReLU (Nair and Hinton, 2010) is an activation function defined by $h(a)=max(0,a)$ where $a$ is a preactivation of neuron. It is known to be a practical solution of the vanishing or exploding gradient problems of gradient-based learning, but it also has the effect of reducing the computational cost compared to the traditional activation function, i.e., sigmoid. We use ReLU as an activation function in our experiments, which is more cost-effective and provides a performance improvement. Because the ReLU propagates the variance of positive valued activation to the next layer, the variance can be amplified or attenuated over layers. Careful weight initialization techniques (Glorot and Bengio, 2010; He et al., 2015b) for deep learning were introduced to prevent this problem, so it became a key factor for designing deep architectures. They carefully scale randomly selected weights so that the variances of activation over layer are kept constant. We scale the CPPN’s weight outputs from the same insight. We refer to He et al.’s work (He et al., 2015b) and scale the phenotype neuron’s weight to $\sqrt{(2.0/N_{in})}$ times where $N_{in}$ is the number of connected neurons from the preceding layer.

HyperNEAT evolves connective CPPN through NeuroEvolution of Augmenting Topologies (NEAT) (Stanley and Miikkulainen, 2002). NEAT is a genetic algorithm allowing the evolution of neural networks. A neural network has a permutation problem which makes difficult to define crossover, but it overcomes the problem by using historical markers. Beginning with a population of small and simple neural networks, this algorithm makes them increasingly complex. It exploits and explores with evolutionary tinkerings, such as adding new nodes and connections to a neural network. In addition, to preserve the topological innovation, speciation is applied by sharing fitness among similar individuals. We set the population size to 1000; it is carried out until reaching the 200th generation. A decay factor of 0.999 is introduced to decrease the mutation rates gradually over generations. In addition, when the compatibility threshold is fixed, the population speciate too much. Since it cannot take advantage of niching, we raised the threshold to the rate of 1.001 per generation. For the same reason, if the number of species exceeded 100, the degree of speciation is adjusted by raising the threshold by 1.1 times. We do not allow for a genotype CPPN to contain any recursive connection since charts are assumed to be independent and identically distributed in chart pattern analysis.

4. Experimental Setup

This section describes preprocessing and experiments for the chart pattern search problem.

4.1. Preprocessing

Figure 2 shows the preprocessing for the chart pattern analysis used in this study. In the chart pattern analysis, smoothing techniques such as moving average, linear Kalman filter, and kernel regression are used (Bandara et al., 2015) because raw financial time series data tend to have unstable fluctuations in short term. We smoothed the time series using a 24-day moving average as shown in Figure 2a. The sliding window is shifted by one day in each time series and emits a sliced time series. If a sliding window of size $s$ is used in $l$-length time series, then $l-s+1$ sliced time series are obtained. We used 128 days for window size. Each sliced time series was processed into two channels of chart as shown in Figure 2b:

(1) the logarithmic rate of daily price change;

(2) the logarithmic rate of price change of a day to the last day.

We took logarithm to resolve the skewedness. In addition, the preprocessed data were downsampled by a factor of 4 to reduce the size of the preprocessed data as shown in Figure 2c. Finally, we reduced the magnitude of the second channel by a factor of $1/32$ to match the one of the first channel. Apart from this, we computed the $k$-day return rate of the day after the last day of the preprocessed data. In a template-based chart pattern analysis, two-dimensional chart images are popularly used as input. However, the height of the two-dimensional chart is determined in advance, so the magnitude of the price or the change rate is adjusted according to the height. We use the one-dimensional real-valued input to maintain magnitude information.

4.2. Experimental Setup and Parameters

We seek attractive patterns that operate on the stock market, rather than on a particular stock or indicator. Therefore, we used the daily closing prices of all stocks ever-listed in the Korean stock market from January 2012 to December 2016. We divided the dataset into three groups:

• •

training set: January 2012 through December 2014,

• •

validation set: January 2015 through December 2015,

• •

test set: January 2016 through December 2016.

The numbers of samples were 1018045, 294586, and 292141 for training, validation, and test sets, respectively. The training set is used for optimizing chart patterns, the validation set for model selection, and the test set for assessment of the approach. We refined the datasets by excluding both preferred and fund stocks on the stock market. Unlike the US stock market, the Korean stock market has both upper and lower limits of daily price movement. If the price of the item reaches the daily upper limit, it is extremely hard to buy the item. Therefore, it is assumed that the chart is not matched in that case.

We experimented the $Chart\_Pattern\_Search(k,\bm{X})$ of genetic frameworks for the various representations for quantitative comparisons. Template-based and neural network-based chart pattern searches were conducted with the proposed HyperNEAT framework. In addition, we re-implemented the GA (Ha et al., 2016) to search rule-based chart patterns for the given datasets. The hyperparameter $\alpha$ was set to 100000. We tuned solutions for each objective function by varying the parameter $k$ in three ways: 20, 50, and 100. Our implementation of Python and TensorFlow took about 33 hours to run on an i7-4770 CPU @ 3.40GHz machine with a GeForce GTX 980 GPU card.

5. Experimental Results

This section provides a comparative analysis of the patterns found and the benefits of the key technologies applied for a neural network.

5.1. The Chart Patterns Found

We conducted a full-scale examination of well-known patterns333Manually designed well-known 26 patterns are the following: double-bottom, double-top, triangle-ascending, triangle-descending, triangle-symmetric-bottom, triangle-symmetric-top, triple-bottom, triple-top, three-falling-peak, three-rising-valley, head-and-shoulder-bottom, head-and-shoulder-top, broaden-bottom, broaden-top, broaden-formation-ascending, broaden-formation-descending, broaden-wedge-ascending, broaden-wedge-descending, rectangle-bottom, rectangle-top, bump-and-run-reversal-bottom, bump-and-run-reversal-top, double-head-and-shoulder-bottom, double-head-and-shoulder-top, diamond-bottom, diamond-top, head-and-double-shoulder-bottom, and head-and-double-shoulder-top. and the found patterns using genetic frameworks for the various matchings. All the well-known patterns were provided in a rule-based representation (Ha et al., 2016). We used GA (Ha et al., 2016) to find the profitable patterns for rule-based representation. The patterns found in the previous study are rp_20_50, rp_100, and rp_example, and the patterns found in the updated dataset in this paper were rp2_20, rp2_50 and rp2_100. We used the HyperNEAT framework proposed in this paper to find attractive template-based and neural network-based chart patterns. The names of the patterns found for each $k$ are: tp_20, tp_50, and tp_100 for template-based representation and nnp_20, nnp_50, and nnp_100 for neural network-based representation.

Table 1 shows the performance of each pattern. The columns represent each dataset for each $k$ value, and the rows represent patterns. If no chart matches to a pattern, the fitness of the pattern is marked as zero. Bold figures indicate the best column values for a given $k$ for each cluster of patterns. The values enclosed in square brackets are the best patterns out of all the patterns for a given $k$ in terms of test sets. When $k$ is 20, nnp_20 was the best, and when $k$ is 50 or 100, nnp_100 was the best. Overall, we observed that neural network-based chart patterns outperformed the other clusters. In particular, they showed consistently high profitability with an acceptable variance over all datasets. Templated-based patterns followed neural network-based patterns in a comparable range. For the rule-based patterns, it seems to be more difficult to find a general pattern with $k=20$, the lowest.

We visualized the chart patterns found for a closer look at. Figure 3 shows superimposed charts that match to the each found patterns to see the actual images as well as the characteristics of the patterns. Each of the two images of an input channel is separately piled up. The logarithmic rate of daily price change is on the left side and the logarithmic rate of price change of a day to the last day is on the right side. The more overlay, the darker colored. The horizontal axis indicates the day and the vertical axis indicates the magnitude.

As shown in Figure 3, we found similar patterns in template-based and neural network-based chart patterns, which can be roughly classified into two classes. One is a soaring pattern represented by tp_20 (Figure  3(a)), tp_50 (Figure 3(b)), and nnp_20 (Figure 3(d)), and the other is a falling pattern represented by tp_100 (Figure 3(c)), nnp_50 (Figure 3(e)), and nnp_100 (Figure 3(f)). The representative patterns found were rather simple. We suspect that many attractive patterns are hidden in the pattern space, considering our modelling is preliminary.

5.2. Advantages of state-of-the-art neural network techniques

We examined the benefits of each state-of-the-art deep neural network technique.

GPGPU

The computational time reduction for MLP is important given that most of the computational costs arise from the evaluation of phenotype networks. We were able to take advantage of GPGPU for evaluation of MLP. We compared the efficiency of GPGPU with CPU computation on the same TensorFlow implementation of evaluation of nnp_50 100 times for each. It takes about 587 seconds to evaluate by CPU operation, while about 21 seconds by the GPU operation. This results in a computational gain of about 27 times. It allows us to search chart patterns within tolerable amount of time.

Dropout

As shown in Figure 4, we compared the average performance difference according to whether the dropout was applied or not on 5 runs of neural network-based chart pattern search when $k$ is 100. The darker color is used when dropout is applied, and the training set is represented by a dotted line to distinguish from test set. In the case without dropout (dropout rate = 1.0), the average performance in the training converged relatively faster and the final performance is slightly better than the other case. However, the average performance of the test set was not improved after about 20th generation, resulting in overfitting to training set. On the other hand, in the case with dropout (dropout rate = 0.8), the average performance of training set was improved relatively slowly until about 160th generation. Furthermore, the average performance of test set was also improved slowly, so it outperformed the other case from around 80th generations. Therefore, dropout served as a significant regularizer to prevent to overfit to training set.

ReLU and weight scaling

The use of ReLU as an activation function of the phenotype network has a slight benefit in computation time compared to the sigmoid network. However, without properly scaled weights, it is difficult to find attractive patterns using the ReLU network due to the occurrence of amplification or attenuation of the variance of activations over layers. We tested each activation functions with deeper neural networks to observe the amplication or attenuation; The substrate configuration of MLP was composed of a $32\times 2$ input layer, $16\times 12$, $16\times 6$, $8\times 6$, $4\times 6$, and $4\times 3$ hidden layers and $1\times 1$ output layer. The population size was set to 100 and ran 5 times for each. In the early generation of the ReLU networks, the average variance of the weights was about 0.096 over the whole network and the variance of activation was amplified to about $6.2\times 10^{7}$ times from the input to preactivation of output. The CPPN could not successfully suppress this amplification over 200 generations, so it did not significantly improve the performance from the beginning. By introducing a scaling factor, following He et al.’s suggestion (He et al., 2015b), we scaled the weights and managed variances. It enabled us to bound the amplification in a few thousand times, which is a comparable variance level of the sigmoid networks. The best fitness of the ReLU network was 0.051. On the other hand, the amplification problem did not occur when sigmoid was used in phenotype network, so the performance did not deteriorate. Furthermore, we could not observe the performance difference depending on the weight scaling for the sigmoid networks. The best fitness of the sigmoid network was 0.049. The use of ReLU with careful weight scaling provided better record with reduction of the computation time by about 5.421%.

6. Conclusion

Attractive chart patterns can provide crucial information for making trading decisions, but the chart pattern search has been relatively unexplored so far. In this paper, we defined and formulated the problem of chart pattern search which is not limited by matching techniques, and proposed HyperNEAT framework to cope with the problem. We used various deep neural network techniques to overcome problem-specific difficulties. Although the neural network-based patterns were better than the others, they were fairly simple. We think that our model is still not mature enough, hoping to find more complex patterns hidden in the pattern space.

In the future, we expect to increase profitability by injecting contextual information such as time or the stock item into the chart. We also plan to devise a method to speed up the computation of CPPN using GPGPU, and design a new CPPN so that NEAT can adaptively determine the weight scale using information about incoming connections.

Acknowledgement

The authors would like to thank Seung-kyu Lee for constructive discussion and proof reading the article. The Institute of Engineering Research of Seoul National University provided research facilities for this work.