├── eurusd_backtest.png ├── requirements.txt ├── LICENSE └── README.md /eurusd_backtest.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/impulsecorp/livealgos/HEAD/eurusd_backtest.png -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | pandas==0.24.2 2 | matplotlib==3.0.3 3 | scikit-learn==0.20.3 4 | tqdm==4.31.1 5 | bs4==0.0.1 6 | statsmodels==0.9.0 7 | scipy==1.2.1 8 | lxml==4.3.3 9 | python-dotenv==0.10.1 10 | pyyaml==5.1.1 11 | tabulate==0.8.2 12 | requests==2.20.0 13 | ujson==1.35 14 | v20==3.0.25.0 15 | telegram-send==0.20 16 | imgkit==1.0.1 17 | wkhtmltopdf==0.2 18 | pandas-market-calendars==1.1 19 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU LESSER GENERAL PUBLIC LICENSE 2 | Version 3, 29 June 2007 3 | 4 | Copyright (C) 2007 Free Software Foundation, Inc. 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | 9 | This version of the GNU Lesser General Public License incorporates 10 | the terms and conditions of version 3 of the GNU General Public 11 | License, supplemented by the additional permissions listed below. 12 | 13 | 0. Additional Definitions. 14 | 15 | As used herein, "this License" refers to version 3 of the GNU Lesser 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU 17 | General Public License. 18 | 19 | "The Library" refers to a covered work governed by this License, 20 | other than an Application or a Combined Work as defined below. 21 | 22 | An "Application" is any work that makes use of an interface provided 23 | by the Library, but which is not otherwise based on the Library. 24 | Defining a subclass of a class defined by the Library is deemed a mode 25 | of using an interface provided by the Library. 26 | 27 | A "Combined Work" is a work produced by combining or linking an 28 | Application with the Library. The particular version of the Library 29 | with which the Combined Work was made is also called the "Linked 30 | Version". 31 | 32 | The "Minimal Corresponding Source" for a Combined Work means the 33 | Corresponding Source for the Combined Work, excluding any source code 34 | for portions of the Combined Work that, considered in isolation, are 35 | based on the Application, and not on the Linked Version. 36 | 37 | The "Corresponding Application Code" for a Combined Work means the 38 | object code and/or source code for the Application, including any data 39 | and utility programs needed for reproducing the Combined Work from the 40 | Application, but excluding the System Libraries of the Combined Work. 41 | 42 | 1. Exception to Section 3 of the GNU GPL. 43 | 44 | You may convey a covered work under sections 3 and 4 of this License 45 | without being bound by section 3 of the GNU GPL. 46 | 47 | 2. Conveying Modified Versions. 48 | 49 | If you modify a copy of the Library, and, in your modifications, a 50 | facility refers to a function or data to be supplied by an Application 51 | that uses the facility (other than as an argument passed when the 52 | facility is invoked), then you may convey a copy of the modified 53 | version: 54 | 55 | a) under this License, provided that you make a good faith effort to 56 | ensure that, in the event an Application does not supply the 57 | function or data, the facility still operates, and performs 58 | whatever part of its purpose remains meaningful, or 59 | 60 | b) under the GNU GPL, with none of the additional permissions of 61 | this License applicable to that copy. 62 | 63 | 3. Object Code Incorporating Material from Library Header Files. 64 | 65 | The object code form of an Application may incorporate material from 66 | a header file that is part of the Library. You may convey such object 67 | code under terms of your choice, provided that, if the incorporated 68 | material is not limited to numerical parameters, data structure 69 | layouts and accessors, or small macros, inline functions and templates 70 | (ten or fewer lines in length), you do both of the following: 71 | 72 | a) Give prominent notice with each copy of the object code that the 73 | Library is used in it and that the Library and its use are 74 | covered by this License. 75 | 76 | b) Accompany the object code with a copy of the GNU GPL and this license 77 | document. 78 | 79 | 4. Combined Works. 80 | 81 | You may convey a Combined Work under terms of your choice that, 82 | taken together, effectively do not restrict modification of the 83 | portions of the Library contained in the Combined Work and reverse 84 | engineering for debugging such modifications, if you also do each of 85 | the following: 86 | 87 | a) Give prominent notice with each copy of the Combined Work that 88 | the Library is used in it and that the Library and its use are 89 | covered by this License. 90 | 91 | b) Accompany the Combined Work with a copy of the GNU GPL and this license 92 | document. 93 | 94 | c) For a Combined Work that displays copyright notices during 95 | execution, include the copyright notice for the Library among 96 | these notices, as well as a reference directing the user to the 97 | copies of the GNU GPL and this license document. 98 | 99 | d) Do one of the following: 100 | 101 | 0) Convey the Minimal Corresponding Source under the terms of this 102 | License, and the Corresponding Application Code in a form 103 | suitable for, and under terms that permit, the user to 104 | recombine or relink the Application with a modified version of 105 | the Linked Version to produce a modified Combined Work, in the 106 | manner specified by section 6 of the GNU GPL for conveying 107 | Corresponding Source. 108 | 109 | 1) Use a suitable shared library mechanism for linking with the 110 | Library. A suitable mechanism is one that (a) uses at run time 111 | a copy of the Library already present on the user's computer 112 | system, and (b) will operate properly with a modified version 113 | of the Library that is interface-compatible with the Linked 114 | Version. 115 | 116 | e) Provide Installation Information, but only if you would otherwise 117 | be required to provide such information under section 6 of the 118 | GNU GPL, and only to the extent that such information is 119 | necessary to install and execute a modified version of the 120 | Combined Work produced by recombining or relinking the 121 | Application with a modified version of the Linked Version. (If 122 | you use option 4d0, the Installation Information must accompany 123 | the Minimal Corresponding Source and Corresponding Application 124 | Code. If you use option 4d1, you must provide the Installation 125 | Information in the manner specified by section 6 of the GNU GPL 126 | for conveying Corresponding Source.) 127 | 128 | 5. Combined Libraries. 129 | 130 | You may place library facilities that are a work based on the 131 | Library side by side in a single library together with other library 132 | facilities that are not Applications and are not covered by this 133 | License, and convey such a combined library under terms of your 134 | choice, if you do both of the following: 135 | 136 | a) Accompany the combined library with a copy of the same work based 137 | on the Library, uncombined with any other library facilities, 138 | conveyed under the terms of this License. 139 | 140 | b) Give prominent notice with the combined library that part of it 141 | is a work based on the Library, and explaining where to find the 142 | accompanying uncombined form of the same work. 143 | 144 | 6. Revised Versions of the GNU Lesser General Public License. 145 | 146 | The Free Software Foundation may publish revised and/or new versions 147 | of the GNU Lesser General Public License from time to time. Such new 148 | versions will be similar in spirit to the present version, but may 149 | differ in detail to address new problems or concerns. 150 | 151 | Each version is given a distinguishing version number. If the 152 | Library as you received it specifies that a certain numbered version 153 | of the GNU Lesser General Public License "or any later version" 154 | applies to it, you have the option of following the terms and 155 | conditions either of that published version or of any later version 156 | published by the Free Software Foundation. If the Library as you 157 | received it does not specify a version number of the GNU Lesser 158 | General Public License, you may choose any version of the GNU Lesser 159 | General Public License ever published by the Free Software Foundation. 160 | 161 | If the Library as you received it specifies that a proxy can decide 162 | whether future versions of the GNU Lesser General Public License shall 163 | apply, that proxy's public statement of acceptance of any version is 164 | permanent authorization for you to choose that version for the 165 | Library. 166 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

The World's First Live Open-Source Trading Algorithm
2 | [Note: This Site Is Not Functional Yet]

3 | 4 |

5 | LiveAlgos.com Logo 6 |

7 |

8 | Use our money to test your automated stock/FX/crypto trading strategies. All changes users make to our Python GitHub code are added to the repo, and then reflected in the live trading account that goes with it. You can also use that same code to trade with your own money. We have spent over 10 years developing automated trading strategies, and are open sourcing all of our programming (meaning it is free for anybody to use) in the hopes that users will help improve it. Here is some of what we have learned so far from doing automated trading: 9 |

10 | 11 | 19 | 20 | 21 | There are 2 main ways to improve our existing ML trading algorithm: 22 | 23 |
    24 |
  1. Increase the accuracy by trying new machine learning methods. For example, there are always new types of neural networks that could be tested, or new time series prediction libraries that could be used. That similar to how they do it in the contest at Numerai, but the problem with Numerai is that all of the data is anonymous and encrypted. You have no idea what financial instruments and indicators/features you are working with. So if you come up with something good, there is no easy way to apply it to real trading for yourself.
    2. 25 |
  2. Add new features to help the ML model learn better. Features can be new technical indicators or a complete strategy that gives buy and sell signals. The ML combines these new indicators and strategies with all of the existing ones, to improve on the model it already has. This is similar to the contests at Kaggle.com, but Kaggle rarely deals with stocks, and when they do it, it is still hard to apply the results to real trading.
    3. 26 |
27 | 28 |

What We Have Working So Far

29 |
30 | 43 | 44 | Below are the accuracy results (classification) on unseen test data using 4 years of hourly EURUSD data, with a 75%/25% train/test split:
45 | [coming soon]
46 | And here's the backtest results (exit trade at the end of each 1 hour bar, no commissions/slippage) on the unseen test set, using XGBoost:
47 |

48 | [coming soon] 49 |

50 |
51 | Program Requirements:
52 | Linux Server (we use Ubuntu 16.04)
53 | Python 3.6
54 | There are many other smaller packages that you will need also, see the requirements.txt file.
55 |
56 | Our Programs Consists of 4 Main Python Notebooks:
57 |
58 | Data Handling and Feature Generation - datamodel_dev.ipynb - Loads the raw price data, preprocesses it (drop NANs, normalization, etc.), balances the dataset (equal number of ups and downs), and adds new features (such as moving average, Bollinger Bands, time lags etc.).
59 |
60 | Feature Selection - Uses dimensionality reduction (such as PCA) to find the most useful of the 11000+ features from the data file. This helps the ML learn better by letting it focus on what is really important, instead of distracting it with useless noise. And, it makes everything run much faster to use less data. We run over 20 different feature selection programs and then use XGBoost on the datasets they generate, to see which has the highest accuracy. This narrows it down from using over 11,000 features to only the top 100.
61 |
62 | Algorithm Selection - Test 60 different ML algorithms on the data to see which one gives the highest accuracy.
63 |
64 | HPO and Ensembles - Optimizes the parameters of the ML model (such as XGBoost) to increase accuracy. It then runs it 100 times to create an ensemble model, giving it more stability.
65 |
66 | Note: The RL programming was done by Peter Chervenski (https://www.facebook.com/l.s.d.records), with assistance from Eric Borgos. The "Roadmap For The Future" part below is by Eric Borgos. 67 | 68 |

Roadmap For The Future

69 |
70 | Suggested improvements for users to try:

71 |
    72 |
  1. Use these programs to get new features:
    73 | TSFresh: https://github.com/blue-yonder/tsfresh
    74 | Cesium: https://github.com/cesium-ml/cesium
    75 | PyAF: https://github.com/antoinecarme/pyaf
    76 | TSLearn - https://github.com/rtavenar/tslearn
    77 | pyts: https://github.com/johannfaouzi/pyts
    78 | Time Series Feature Extraction Library: https://github.com/fraunhoferportugal/tsfel
    79 | Khiva: https://github.com/shapelets/khiva (C++) or https://github.com/shapelets/khiva-python (python bindings)
    80 | PyFTS: https://github.com/PYFTS/pyFTS
    81 | Genetic Discovert of Shapelets: https://github.com/IBCNServices/GENDIS
    82 | PyFlux: https://github.com/RJT1990/pyflux
    83 | Deep Learning for Time Series Classification: https://github.com/cauchyturing/UCR_Time_Series_Classification_Deep_Learning_Baseline
    84 | PMDARIMA: https://github.com/tgsmith61591/pmdarima
    85 | Stumpy: https://github.com/TDAmeritrade/stumpy
    86 | Feets: https://github.com/carpyncho/feets
    87 | Thalesians' Time Series Analysis (TSA) - https://github.com/thalesians/tsa (notebooks at https://github.com/thalesians/tsa/tree/master/src/jupyter/python) - Made specifically for stock time series analysis.
    88 | SLearn: https://github.com/mzoll/slearn
    89 | TimeNet: https://github.com/kirarenctaon/timenet
    90 | Signature Transforms: https://github.com/patrick-kidger/signatory
    91 | 92 | Also:
    93 | A) There is good code/info for ARCH, GARCH, and EGARCH: https://0xboz.github.io/blog/understand-and-model-cryptocurrencies-volatility-using-garch-variants/
    94 | B) If you need a faster version of Fourier Transform, see https://github.com/ShihuaHuang/Fast-Fourier-Transform
    95 | C) If you have not already used Dynamic Time Warping (DTW), here's info for it:
    96 | TSLearn - https://github.com/rtavenar/tslearn
    97 | pyts: https://github.com/johannfaouzi/pyts
    98 | See these articles about how it can be used in a nearest neighbors sort of way to find stock price patterns that are similar to the current one: https://systematicinvestor.wordpress.com/2012/01/20/time-series-matching-with-dynamic-time-warping/ and https://systematicinvestor.wordpress.com/2012/01/13/time-series-matching/ ).
    99 | Other DTW programs:
    100 | https://github.com/wannesm/dtaidistance
    101 | https://github.com/markdregan/K-Nearest-Neighbors-with-Dynamic-Time-Warping
    102 | https://github.com/pierre-rouanet/dtw
    103 | https://github.com/fpetitjean/DBA
    104 |
    2. 105 |
    106 |
  2. Try these probabilistic modeling programs:
    107 | A) https://github.com/tensorflow/probability (Includes Edward)
    108 | B) http://pyro.ai/ (From Uber Labs)
    109 | C) https://brancher.org (see their time series module)
    110 | D) Pomegranate - https://github.com/jmschrei/pomegranate
    111 |
    3. 112 |
    113 |
  3. More programs to get features/predictions from:
    114 | 1. SKTime:
    115 | https://github.com/alan-turing-institute/sktime/blob/master/examples/time_series_classification.ipynb
    116 | https://github.com/alan-turing-institute/sktime/blob/master/examples/forecasting.ipynb
    117 | https://github.com/alan-turing-institute/sktime/blob/master/examples/shapelet_transform.ipynb
    118 | 1.5 Skits - https://github.com/EthanRosenthal/skits - Scikit-inspired time series.
    119 | 2. Stock Prediction AI - https://github.com/borisbanushev/stockpredictionai
    120 | 3. Facebook Prophet at https://facebook.github.io/prophet/ . Also see https://github.com/CollinRooney12/htsprophet and https://github.com/advaitsave/Introduction-to-Time-Series-forecasting-Python/blob/master/Time%20Series%20in%20Python.ipynb .
    121 | 4. Statsmodels: Try all the methods at https://github.com/statsmodels/statsmodels
    122 | 5. Shapelets (MLP): https://github.com/mohaseeb/shaplets-python
    123 | 6. 11 methods from https://machinelearningmastery.com/time-series-forecasting-methods-in-python-cheat-sheet/
    124 | 7. Deep Learning for Time Series Classification: https://github.com/hfawaz/dl-4-tsc - Various methods in Keras
    125 | 8. ES-RNN - https://github.com/damitkwr/ESRNN-GPU (also maybe at https://github.com/M4Competition/M4-methods/tree/master/118%20-%20slaweks17 )
    126 | 9. Keras: https://github.com/jaungiers/LSTM-Neural-Network-for-Time-Series-Prediction
    127 | 10. Keras: https://github.com/BenjiKCF/Neural-Net-with-Financial-Time-Series-Data
    128 | 11. Keras LSTM Fully Convolutional Networks for Time Series Classification : https://github.com/titu1994/LSTM-FCN
    129 | 11.5 https://github.com/titu1994/MLSTM-FCN
    130 | 12. HMM-LSTM: https://github.com/JINGEWU/Stock-Market-Trend-Analysis-Using-HMM-LSTM
    131 | 13. https://teddykoker.com/2019/06/trading-with-reinforcement-learning-in-python-part-ii-application/
    132 | 14. https://www.reddit.com/r/algotrading/comments/bwmji0/stockmlcloud_ready_trading_toolbot_for/
    133 | 15. OgmaNEO2: https://ogma.ai/2019/06/ogmaneo2-and-reinforcement-learning/
    134 | 16. See all the methods listed in this blog posting - Using the latest advancements in deep learning to predict stock price movements - https://towardsdatascience.com/aifortrading-2edd6fac689d
    135 | There are some new indicators you can use (use any TA-Lib does not already have) at:
    136 | 17. R-Transformer RNN: https://github.com/DSE-MSU/R-transformer
    137 | 18. Temporal CNN: https://github.com/uchidalab/dtw-features-cnn
    138 | 19. Temporal Causal Discovery Framework: https://github.com/M-Nauta/TCDF
    139 | 20. Echo state networks:
    140 | https://github.com/lucapedrelli/DeepESN
    141 | https://github.com/kalekiu/easyesn
    142 | https://github.com/ahmedmdl/Dynamic_reservoir_keras (Keras version)
    143 | https://github.com/FilippoMB/Reservoir-Computing-framework-for-multivariate-time-series-classification
    144 | 21. Time series models in Keras: https://github.com/vlawhern/arl-eegmodels
    145 | 22. Unsupervised Time Series Method: https://github.com/White-Link/UnsupervisedScalableRepresentationLearningTimeSeries
    146 | 23. Time series classification and clustering: https://github.com/alexminnaar/time-series-classification-and-clustering
    147 | 24. Time series data augmentation: https://github.com/hfawaz/aaltd18 (Keras)
    148 | 25. Time series anomaly detection: https://github.com/chickenbestlover/RNN-Time-series-Anomaly-Detection
    149 | 26. Time series deep learning baseline: https://github.com/cauchyturing/UCR_Time_Series_Classification_Deep_Learning_Baseline
    150 | 27. RNN autoencoder: https://github.com/RobRomijnders/AE_ts
    151 | 28. GuonTS - https://github.com/awslabs/gluon-ts
    152 | 29. Deep Time Series (Keras) - https://github.com/pipidog/DeepTimeSeries - RNN2Dense, Seq2Seq, Attention-Based, etc.
    153 | 30. Dilated CNN with WaveNet - https://github.com/kristpapadopoulos/seriesnet
    154 | 31. Keras Time Series Models: https://github.com/zhangxu0307/time-series-forecasting-keras - LSTM, GRU, RNN, MLP, SVR, ARIMA, time series decomposition
    155 | 32. Pytorch time series models: https://github.com/zhangxu0307/time_series_forecasting_pytorch
    156 | 33. SegLearn - https://github.com/dmbee/seglearn
    157 | 34. Deep Learning Time Series - https://github.com/mb4310/Time-Series
    158 | 35. Variational Autoencoder for Dimensionality Reduction of Time-Series - https://github.com/msmbuilder/vde
    159 | 36. Singular Spectrum Analysis - https://github.com/kieferk/pymssa
    160 | 37. Temporal Pattern Attention for Multivariate Time Series Forecasting - https://github.com/gantheory/TPA-LSTM
    161 | 38. Dual-Stage Attention-Based Recurrent Neural Net for Time Series Prediction - https://github.com/Seanny123/da-rnn (blog posting about it at https://chandlerzuo.github.io/blog/2017/11/darnn )
    162 | 39. Piecewise regression: https://github.com/DataDog/piecewise
    163 | 40. Probabilistic Inference on Noisy Time Series (PINTS): https://github.com/pints-team/pints
    164 | 41. Multivariate Anomaly Detection for Time Series Data with GANs - https://github.com/LiDan456/MAD-GANs
    165 | 42. Wotan - https://github.com/hippke/wotan - Automagically remove trends from time-series data.
    166 | 43. Nonlinear measures for dynamical systems (based on one-dimensional time series) - https://github.com/CSchoel/nolds
    167 | 44. NOnLinear measures for Dynamical Systems (nolds) - https://github.com/CSchoel/nolds
    168 | 45. LSTNet - https://github.com/Vsooong/pattern_recognize - Long- and Short-term Time-series network. Uses the Convolution Neural Network (CNN) and the Recurrent Neural Network (RNN) to extract short-term local dependency patterns among variables and to discover long-term patterns for time series trends.
    169 | 46. Indicators to add, if they are not already in TA-Lib:
    170 | A) https://github.com/joosthoeks/jhTAlib/tree/master/jhtalib
    171 | B) https://github.com/peerchemist/finta (use code at https://github.com/peerchemist/finta/blob/master/finta/finta.py)
    172 | C) https://tulipindicators.org/benchmark (use the Python bindings at https://github.com/cirla/tulipy or "Tulip Indicators works well with C++. Just compile the C code; you shouldn't have any problems." )
    173 | D) https://github.com/kylejusticemagnuson/pyti
    174 | 47. Programs Like Skope (https://github.com/scikit-learn-contrib/skope-rules):
    175 | https://github.com/meelgroup/MLIC
    176 | https://github.com/christophM/rulefit - Regression only, but we could still use that.
    177 | https://github.com/alienJohny/Rules-Extraction-from-sklearn-DecisionTreeClassifier (C++)
    178 | 48. Deep Anomaly Detection: https://github.com/KDD-OpenSource/DeepADoTS
    179 | 49. Deep4Cast: https://github.com/MSRDL/Deep4Cast - WaveNet based.
    180 | 50. LSTM Variational autoencoder: https://github.com/Danyleb/Variational-Lstm-Autoencoder
    181 | 51. Deep Neural Network Ensembles for Time Series Classification - https://github.com/hfawaz/ijcnn19ensemble
    182 | 52. RobustSTL: https://github.com/LeeDoYup/RobustSTL - A Robust Seasonal-Trend Decomposition Algorithm for Long Time Series
    183 | 53. AntiCipy: https://github.com/sky-uk/anticipy
    184 | 54. Autoencoders: https://github.com/hamaadshah/autoencoders_keras/blob/master/Python/autoencoders.ipynb (use the various autoencoders on the 2nd half of the page)
    185 | 55. Use automatic feature engineering using GANs: https://github.com/hamaadshah/gan_public/blob/master/Python/gan.ipynb
    186 | 56. Feature Engineering Wrapper (Few): https://github.com/lacava/few
    187 | 57. LibFM (in Keras) - https://github.com/jfpuget/LibFM_in_Keras - He used this to generate new features in a Kaggle compeition.
    188 | 58. Metric Learning - https://github.com/scikit-learn-contrib/metric-learn. Metric Learning is explained at http://metric-learn.github.io/metric-learn/introduction.html . Also, the code for many more advanced methods are listed at https://github.com/kdhht2334/Survey_of_Deep_Metric_Learning .
    189 | 59. knnFeat - https://github.com/upura/knnFeat and https://github.com/momijiame/gokinjo - Knn feature extraction.
    190 | 60. Surrogate Assisted Feature Extraction (SAFE) - https://github.com/ModelOriented/SAFE
    191 | 61. Feature Stuff: https://github.com/hiflyin/Feature-Stuff
    192 | 62. GAN-Keras: https://github.com/hamaadshah/gan_keras - Automatic feature engineering using Generative Adversarial Networks.
    193 | 63. AutoFeat: https://github.com/cod3licious/autofeat - Linear Regression Model with Automated Feature Engineering and Selection Capabilities.
    194 | 64. Various Keras NNs for stocks: https://github.com/rosdyana/Going-Deeper-with-Convolutional-Neural-Network-for-Stock-Market-Prediction
    195 | 65. Temporal Pattern Attention for Multivariate Time Series Forecasting - https://github.com/gantheory/TPA-LSTM 196 | 66. WATTNet: https://github.com/Zymrael/wattnet-fx-trading - Learning to Trade FX with Hierarchical Spatio-Temporal Representations of Highly Multivariate Time Series
    197 | 67. TabNet: https://github.com/titu1994/tf-TabNet
    198 | 199 |
    200 | Also, see this big study which shows the simple models such as ARIMA are better than NNs for time series prediction: https://machinelearningmastery.com/findings-comparing-classical-and-machine-learning-methods-for-time-series-forecasting/
    201 |
    4. 202 |
    203 |
  4. Some strategies to consider adding, as features:
    204 | A) The ML version of their crypto strategy at https://github.com/achmand/ari5123_assignment/blob/master/src/algo_trading.ipynb shows big profits: https://github.com/achmand/ari5123_assignment/blob/master/src/algo_trading.ipynb 205 | What is most interesting is that in their backtests, using XGBoost with 7 features (such as moving average) did much better than using the typical strategy of trading each of those indicators individually. ML was able to take a group of not too profitable indicators, and use them in a smart way to make money.
    206 | B) RL Bitcoin trading with a profit - https://github.com/teddykoker/blog/blob/master/notebooks/trading-with-reinforcement-learning-in-python-part-two-application.ipynb 207 | Also read the first part of his article, about "gradient ascent", at https://github.com/teddykoker/blog/blob/master/notebooks/trading-with-reinforcement-learning-in-python-part-one-gradient-ascent.ipynb
    208 | C) Ernie Chan's Mean Reversion - https://github.com/teddykoker/blog/blob/master/notebooks/cross-sectional-mean-reversion-strategy-in-python-with-backtrader.ipynb
    209 | D) Andrew Clenow's Momentum - https://github.com/teddykoker/blog/blob/master/notebooks/momentum-strategy-from-stocks-on-the-move-in-python.ipynb
    210 | E) B and C above could also be tested with shorter bars.
    211 | F) Futures Momentum Investing - https://www.linkedin.com/pulse/implement-cta-less-than-10-lines-code-thomas-schmelzer/ - I assume this could apply to stocks/fx/crypto
    212 | G) Seahorse: https://github.com/fwu03/ML_Stock_Trading-Seahorse
    213 | H) Here's a pair trading strategy in Java: https://github.com/lukstei/trading-backtest
    214 | I) Another pair trading strategy: https://github.com/oskarringstrom/StatArbProject
    215 | J) There is a profitable RL strategy at https://github.com/sachink2010/AutomatedStockTrading-DeepQ-Learning/blob/master/Trading.ipynb
    216 | K) RL Trading Bot: https://github.com/ai-portfolio/deep_reinforcement_learning_stock_trading_bot/blob/master/deep_reinforcement_learning_stock_trading_bot.ipynb
    217 | L) RL Portfolio Management - https://github.com/ZhengyaoJiang/PGPortfolio - The paper they reference is really good.
    218 | M) Deep RL Trading - https://github.com/golsun/deep-RL-trading - The paper that goes with this has some great info about using a CNN vs RNN.
    219 | N) RL Options Trading - https://github.com/randli/Optimal-Trading-Price - They did not upload their code, but their 1 page PDF summary paper is interesting.
    220 | O) Personae: https://github.com/Ceruleanacg/Personae 221 | P) Free-Lunch Saliency via Attention in Atari Agents - https://github.com/dniku/free-lunch-saliency 222 | Q) RL Algos - https://github.com/xlnwel/model-free-algorithms 223 |
    224 |
    5. 225 |
    226 |
  5. Add all the indicators from these libraries that we don't already have from TA-Lib:
    227 | https://github.com/peerchemist/finta (use code at https://github.com/peerchemist/finta/blob/master/finta/finta.py)
    228 | https://tulipindicators.org/benchmark (use the Python bindings at https://github.com/cirla/tulipy or "Tulip Indicators works well with C++. Just compile the C code; you shouldn't have any problems." )
    229 | https://github.com/kylejusticemagnuson/pyti
    230 |
    6. 231 |
    232 |
  6. Use Featuretools.com to generate new features:
    233 | FeatureTools Methods see https://github.com/Featuretools/featuretools and https://www.kdnuggets.com/2018/02/deep-feature-synthesis-automated-feature-engineering.html):
    234 | Create Entities: https://docs.featuretools.com/loading_data/using_entitysets.html - A parent identity made from the relationship between child identities.
    235 | Feature Primatives: TimeSincePrevious, Mean, Max, Min, Std, Skew
    236 | Aggregation primitives: These primitives take related instances as an input and output a single value. They are applied across a parent-child relationship in an entity set. E.g: Count, Sum, AvgTimeBetween
    237 | Transform primitives: These primitives take one or more variables from an entity as an input and output a new variable for that entity. They are applied to a single entity. E.g: Hour, TimeSincePrevious, Absolute.
    238 | Deep Feature Synthesis: https://docs.featuretools.com/automated_feature_engineering/afe.html - Stacking features to create new features.
    239 | To parallize featuretools, see https://medium.com/feature-labs-engineering/scaling-featuretools-with-dask-ce46f9774c7d and https://docs.featuretools.com/guides/parallel.html
    240 |
    7. 241 |
    242 |
  7. Unsupervised Feature Extraction and Reduction:
    243 | PyDeep (https://github.com/MelJan/PyDeep - A machine learning / deep learning library with focus on unsupervised learning. Has 25 different methods (PCA, ICA, etc.),)
    244 | Fastknn - https://github.com/davpinto/fastknn - Unlike normal knn, this has a command knnExtract() that extracts features from the data, Kaggle style.
    245 | Scikit-Learn Unsupervised: http://scikit-learn.org/stable/unsupervised_learning.html - Gaussian mixture models, manifold learning, clustering, and decomposing signals in components (matrix factorization problems)
    246 | Ladder Networks: http://bair.berkeley.edu/blog/2018/01/23/kernels/ Code: https://github.com/search?l=Python&q=ladder+network&type=Repositories&utf8=%E2%9C%93
    247 | Robust Continuous Clustering - https://github.com/yhenon/pyrcc
    248 | SOINN(Self-Organizing Incremental Neural Network) - https://github.com/fukatani/soinn
    249 | Self Organizing Maps - https://github.com/search?p=1&q=%22Self+Organizing+Map%22&type=Repositories&utf8=%E2%9C%93
    250 | Paysage - https://github.com/drckf/paysage - A library for unsuperised learning and probabilistic generative models. Bernoulli Restricted Boltzmann Machines, Gaussian Restricted Boltzmann Machines, Hopfield Models. Using advanced mean field and Markov Chain Monte Carlo methods.
    251 | Parametric t-SNE: https://github.com/search?utf8=%E2%9C%93&q=Parametric+t-SNE&type=
    252 | Largevis: https://github.com/ml4me/largevis
    253 | Feature Extraction: https://github.com/search?l=Python&q="feature+extraction"&type=Repositories&utf8=? 254 | Unsupervised Learning by Predicting Noise - https://arxiv.org/abs/1704.05310 Code: https://github.com/search?l=Python&q=%22Unsupervised+Learning+by+Predicting+Noise%22&type=Repositories&utf8=%E2%9C%93
    255 | Clustering Algorithms - https://github.com/search?l=Python&q=%22clustering+algorithms%22&type=Repositories&utf8=%E2%9C%93
    256 | Gap Statistic: https://github.com/milesgranger/gap_statistic
    257 | Neural Clustering: Concatenating Layers for Better Projections - https://openreview.net/forum?id=r1PyAP4Yl
    258 | Unsupervised Learning on Neural Network Outputs - https://github.com/yaolubrain/ULNNO
    259 | K-medoids clustering algorithm with NEAT: http://blog.otoro.net/2015/08/23/k-medoids-clustering-algorithm/ Code: https://github.com/search?l=Python&q=k-medoids&type=Repositories&utf8=%E2%9C%93
    260 | Autoencoder Trees: Paper: https://www.cmpe.boun.edu.tr/~ethem/files/papers/Ozan_Neurocomp.pdf Code: https://github.com/gionuno/autoencoder_trees
    261 | Denoising Autoencoder: https://github.com/AdilBaaj/unsupervised-image-retrieval
    262 | Stacked Denoising Autoencoder: https://www.researchgate.net/publication/285392625_Stacked_Denoise_Autoencoder_Based_Feature_Extraction_and_Classification_for_Hyperspectral_Images Keras Code: https://github.com/madhumita-git/SDAE
    263 | Non-negative Matrix Factorization: https://github.com/search?l=Python&q=%22non-negative+matrix+factorization%22&type=Repositories&utf8=%E2%9C%93
    264 | Group Factor Analysis: https://github.com/mladv15/gfa-python
    265 | SVDD: https://github.com/sdvermillion/pySVDD and https://github.com/search?l=Python&q=SVDD&type=Repositories&utf8=%E2%9C%93
    266 | Kinetic PCA: https://github.com/alexandrudaia/NumeraiExperiments/blob/master/kineticPcaNumerai.ipynb
    267 | TFeat - https://github.com/vbalnt/tfeat (based on http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf )
    268 | UMap: https://github.com/lmcinnes/umap
    269 |
    8. 270 |
    271 | 272 |
  8. More Feature Exctraction Methods:
    273 | Interaction Features: http://www.ultravioletanalytics.com/blog/kaggle-titantic-competition-part-v-interaction-variables - Adding/multiplying/dividing/subtracting each of the existing features with each other. Scikit-learn has this ability with "PolynomialFeatures", see https://chrisalbon.com/machine_learning/linear_regression/create_interaction_features/ .
    274 | Derived Variables: http://www.ultravioletanalytics.com/blog/kaggle-titanic-competition-part-iv-derived-variables - Based on Name, Cabin, Ticket #.
    275 | Variable Transformations - http://www.ultravioletanalytics.com/blog/kaggle-titanic-competition-part-iii-variable-transformations - Dummy Variables, Factorizing, Scaling, Binning
    276 | NN Feature Extraction - https://github.com/tomrunia/TF_FeatureExtraction - Gets features from VGG, ResNet, Inception.
    277 | Feature Engineering - Use all the methods in Scikit-Learn's preprocessing module at http://scikit-learn.org/stable/modules/preprocessing.html and also at https://www.slideshare.net/gabrielspmoreira/feature-engineering-getting-most-out-of-data-for-predictive-models) - Binarizing, Rounding, Binning, Quantiles, Log Transform, Scaling (Min-Max, Standard Z), Normalization, Rounding, Polynomial Features, Feature Hashing, Bin-counting, LabelCount Encoding, Category Embedding, etc. A good explanation of it all is also at https://github.com/bobbbbbi/Machine-learning-Feature-engineering-techniques/blob/master/python%20feature%20engineering.pdf .
    278 | XAM: https://github.com/MaxHalford/xam - Binning, Combining features, Groupby transformer, Likelihood encoding, Resampling, etc.
    279 | Exponential Moving Average of the Weights (in Keras): https://gist.github.com/soheilb/c5bf0ba7197caa095acfcb69744df756
    280 | Categorical Interaction Features -http://blog.kaggle.com/2017/02/27/allstate-claims-severity-competition-2nd-place-winners-interview-alexey-noskov/ - "...the last trick I used was forming categorical interaction features, applying lexical encoding to them. These combinations may be easily extracted from XGBoost models by just trying the most important categorical features, or better, analysing the model dump with the excellent Xgbfi tool."
    281 | FeatureFu (https://github.com/linkedin/FeatureFu) does thing like Feature normalization, Feature combination, Nonlinear featurization, Cascading modeling, Model combination
    282 | CopperSmith: https://github.com/CommBank/coppersmith
    283 | Feng: https://github.com/mewwts/feng
    284 | Faegen: https://github.com/ianlini/feagen
    285 | Ratios of one feature to another, like at https://www.kaggle.com/sudalairajkumar/feature-engineering-validation-strategy
    286 | Locally weighted bagging: https://maxhalford.github.io/blog/locally-weighted-bagging/
    287 | Prince: https://github.com/MaxHalford/prince - Does PCA, Correspondance Analysis (CA), Multiple Correspondance Analysis (MCA)
    288 | Self-Normalizing Neural Networks: https://github.com/atulshanbhag/Self-Normalizing-Neural-Networks-SNN-
    289 | Create new features like at https://www.datacamp.com/community/tutorials/feature-engineering-kaggle
    290 | Pairwise Interactions: https://medium.com/jim-fleming/notes-on-the-numerai-ml-competition-14e3d42c19f3 (code at https://github.com/jimfleming/numerai ) - 'given features from two samples predict which of the two had a greater probability of being classified as '1'.'
    291 | t-SNE Multiple Runs - https://medium.com/jim-fleming/notes-on-the-numerai-ml-competition-14e3d42c19f3 (code at https://github.com/jimfleming/numerai ) - 'Since t-SNE is stochastic, multiple runs will produce different embeddings. To exploit this I will run t-SNE 5 or 6 times at different perplexities and dimensions (2D and 3D) then incorporate these extra features. Now the validation loss is 0.68839 (-0.65% from baseline).'
    292 |
    9. 293 |
    294 | 295 |
  9. More Autoencoders to try:
    296 | See https://towardsdatascience.com/autoencoders-for-the-compression-of-stock-market-data-28e8c1a2da3e
    297 | also Try Wavenet:
    298 | https://github.com/PhilippeNguyen/keras_wavenet
    299 | https://github.com/PyWavelets/pywt
    300 | https://github.com/kykosic/WaveNet-BTC
    301 |
    10. 302 |
    303 | 304 | 305 |
  10. Things To Try In Keras:
    306 | 1) LearningRateScheduler with step decay schedule: https://gist.github.com/jeremyjordan/86398d7c05c02396c24661baa4c88165
    307 | 2) Cyclical Learning Rate - https://github.com/leaprovenzano/cyclical_lr_keras
    308 | 3) AdamW - http://34.230.249.160:8888/notebooks/new/automl/gsketch-resnet50-128x128-AdamW.ipynb (using the code from AdamW: https://github.com/GLambard/AdamW_Keras)
    309 | 4) SGDR - http://34.230.249.160:8888/notebooks/new/automl/gsketch-kerasnn-sgdr-128x128.ipynb or http://34.230.249.160:8888/notebooks/deepneat/reptile-test-SGDR.ipynb
    310 | 5) One Cycle Learning Rate Policy for Keras - https://github.com/titu1994/keras-one-cycle
    311 | 6) Optimal Learning Rate Finder: https://gist.github.com/jeremyjordan/ac0229abd4b2b7000aca1643e88e0f02 and https://github.com/metachi/fastaiv2keras (from https://towardsdatascience.com/estimating-optimal-learning-rate-for-a-deep-neural-network-ce32f2556ce0).
    312 | 7) Add Gradient Noise - https://github.com/cpury/keras_gradient_noise
    313 | 8) Stochastic Weight Averaging - https://github.com/kristpapadopoulos/keras_callbacks
    314 | 9) Variants of RMSProp and Adagrad - https://github.com/mmahesh/variants_of_rmsprop_and_adagrad . Also Nadamax, Radamax, AdamDelta: https://github.co
    315 | 10) Pyramid Pooling Layers: https://github.com/yhenon/keras-spp
    316 | 11) One Hundred Layers Tiramisu - https://github.com/0bserver07/One-Hundred-Layers-Tiramisu and https://github.com/junjungoal/Tiramisu-keras
    317 | 12) Neural Tensor Layer - https://github.com/dapurv5/keras-neural-tensor-layer
    318 | 13) Coordconv - https://github.com/titu1994/keras-coordconv
    319 | 14) RBF Layer - https://github.com/PetraVidnerova/rbf_keras
    320 | 15) Mixture Network Desnity Layer: https://github.com/cpmpercussion/keras-mdn-layer
    321 | 16) Position Embedding Layers: https://github.com/CyberZHG/keras-pos-embd
    322 | 17) Mixture of Experts: https://github.com/eminorhan/mixture-of-experts
    323 | 18) Multi Head - https://github.com/CyberZHG/keras-multi-head
    324 | 19) Spectral Normalization: https://github.com/IShengFang/SpectralNormalizationKeras
    325 | 20) Gradient Reversal: https://github.com/michetonu/gradient_reversal_keras_tf
    326 | 21) Keras learning rate callbacks: https://github.com/Drxan/DNN_Learning_Rate/blob/master/lr_callbacks.py
    327 |
    11. 328 |
    329 |
  11. Dynamic Ensemble Selection (DES)
    330 | I tried it for stocks data once and it did not give good results but maybe somebody else will can have better luck with it. I have it working at http://34.230.249.160:8888/notebooks/DESlib/examples/Notebooks_examples/Example_Eric-Copy1.ipynb and also using multiple base classifiers at http://34.230.249.160:8888/notebooks/DESlib/examples/Notebooks_examples/Example_Eric-Copy2.ipynb but there are other ways doing it at http://34.230.249.160:8888/tree/DESlib/examples/Notebooks_examples
    331 |
    332 | DES Code: https://github.com/Menelau/DESlib
    333 | DES Papers:
    334 | https://arxiv.org/abs/1802.04967
    335 | https://arxiv.org/pdf/1509.00825.pdf
    336 | https://arxiv.org/abs/1804.07882
    337 | DES Manual: https://deslib.readthedocs.io/en/latest/
    338 |
    339 | How they deal with splitting the data is explained well at https://arxiv.org/pdf/1509.00825.pdf
    340 |
    341 | DES does not use diverse ensembles like voting and stacking, because the goal is to have each classifier be an expert at different parts of the dataset, so using an ensemble of diverse classifiers would defeat that purpose. It does use bagging as explained at https://arxiv.org/abs/1804.07882
    342 |
    12. 343 |
    344 |
  12. More Genetic Programming (GP) programs to try:
    345 | 1. Finish Vita - https://github.com/morinim/vita/wiki/features (http://34.230.249.160:8888/tree/new/automl/earthquakes2019/testvita)
    346 | Also, see the info about running Vita in parallel: https://github.com/morinim/vita/issues/21
    347 | C++ 14 can run multicore natively (see https://www.bfilipek.com/2014/01/tasks-with-stdfuture-and-stdasync.html), or you could use easyLambda: https://github.com/haptork/easyLambda
    348 | Plus Vita has around 15 algorithms, so those (and multiple trials) could be run multicore instead of parallelizing Vita directly.
    349 |
    350 | 2. Glyph: And there is also this, from https://github.com/Ambrosys/glyph/blob/master/glyph/gp/algorithms.py )/ 351 | def make_unique_version(obj):
    352 | Takes an algorithm class and creates a sublcass with a modified evolve method.
    353 | The modified version will ensures uniqueness of individuals.
    354 | If it gives good results, later we can parallelize it:
    355 | Dask example: https://github.com/Ambrosys/glyph/blob/master/examples/control/dask_app.py
    356 | and also at https://github.com/Ambrosys/glyph/blob/master/examples/control/joblib_app.py
    357 |
    358 | 3. Cartesian Generic Programming: https://github.com/shinjikato/cartesian_genetic_programming
    359 |
    360 | 4. Multiple Regression GP: Code: https://github.com/prasanna-rn/multiRegresssionGP Explanation: https://flexgp.github.io/gp-learners/mrgp.html
    361 | In a paper I read compring various GP methods (not the one that goes with this code), this method won. "Improves the program evaluation process by performing multiple regression on subexpressions of the solution functions. Instead of evaluating the fitness of each individual solution as a whole, MRGP decouples its mathematical expression tree into subtrees. The fitness of the solution is evaluated based on the best linear combination of these subtree structures."
    362 |
    363 | 5. A Greedy Search Tree Heuristic for Symbolic Regression - Python Code: https://github.com/folivetti/ITSR Paper: https://arxiv.org/abs/1801.01807
    364 |
    365 | 6. Geometric Semantic Genetic Programming - Paper: https://arxiv.org/abs/1804.06808 366 | Code: https://github.com/laic-ufmg/GSGP-Red (Java) plus also https://github.com/search?q=Geometric+Semantic+Genetic+Programming
    367 | it says "Advances in Geometric Semantic Genetic Programming (GSGP) have shown that this variant of Genetic Programming (GP) reaches better results than its predecessor for supervised machine learning problems, particularly in the task of symbolic regression. However, by construction, the geometric semantic crossover operator generates individuals that grow exponentially with the number of generations, resulting in solutions with limited use. This paper presents a new method for individual simplification named GSGP with Reduced trees (GSGP-Red)."
    368 |
    369 | 7. Differential Evolution - Vita and XGP already have this
    370 | XGP is at https://maxhalford.github.io/xgp/ and is powered by https://github.com/MaxHalford/eaopt . I already have XGP working at http://34.230.249.160:8888/notebooks/new/automl/earthquakes2019/earthquakes-eric.ipynb ). For info about DE see https://nathanrooy.github.io/posts/2017-08-27/simple-differential-evolution-with-python/
    371 | Code: https://github.com/nathanrooy/differential-evolution-optimization-with-python and https://github.com/search?l=Python&q=Differential++evolution&type=Repositories
    372 | More DE Info: http://107.167.189.191/~piak/teaching/ec/ec2012/das-de-sota-2011.pdf
    373 | Also see this related NAS paper: A Hybrid Differential Evolution Approach toDesigning Deep Convolutional Neural Networks for Image Classification - https://arxiv.org/pdf/1808.06661.pdf
    374 |
    375 | 8. Self-adaptation of Genetic Operators Through Genetic Programming Techniques
    376 | Paper: https://arxiv.org/abs/1712.06070
    377 | Code: https://github.com/afcruzs/AOEA
    378 |
    379 | 9. Grammar Variational Autoencoder: https://github.com/search?q=Grammar+Variational+Autoencoder
    380 |
    381 | 10. Mixed-Integer Non-Linear Programming - Code: https://github.com/minotaur-solver/minotaur Paper: https://arxiv.org/pdf/1710.10720.pdf
    382 |
    383 | 11. P-Tree Programming - Code: https://github.com/coesch/ptree Paper: https://arxiv.org/pdf/1707.03744.pdf
    384 |
    385 | 12. Strongly Typed GP: https://deap.readthedocs.io/en/master/examples/gp_spambase.html (see explanation at https://deap.readthedocs.io/en/master/tutorials/advanced/gp.html#strongly-typed-gp).
    386 |
    387 | 13. https://github.com/Decadz/Genetic-Programming-for-Symbolic-Regression - This work uses the Rademacher complexity and incorporates it into the fitness function of GP, utilizing it as a means of controlling the functional complexity of GP individuals.
    388 |
    389 | 14. Take a quick look at these GP programs, in case they do something the others we already have do not do:
    390 | https://github.com/marcovirgolin/GP-GOMEA
    391 | https://github.com/Ambrosys/gpcxx (see the symbolic regression example at http://gpcxx.com/doc/gpcxx/tutorial.html#gpcxx.tutorial.symbolic_regression )
    392 | https://github.com/LLNL/SoRa
    393 | https://github.com/marcovirgolin/GP-GOMEA
    394 | https://github.com/degski/CGPPP
    395 | https://github.com/gchoinka/gpm
    396 | https://github.com/kpot/cartgp
    397 | https://github.com/AndrewJamesTurner/CGP-Library
    398 | https://github.com/kstaats/karoo_gp
    399 | https://github.com/ViktorWase/Cgpy
    400 | https://github.com/Jarino/cgp-wrapper
    401 |
    13. 402 |
    403 |
  13. Stacking/Ensemble Programs To Try:
    404 | StackNet - https://github.com/h2oai/pystacknet
    405 | Random Rotation Ensembles: https://github.com/tmadl/sklearn-random-rotation-ensembles
    406 | Simple and Scalable Predictive Uncertainty estimation using Deep Ensembles: https://github.com/vvanirudh/deep-ensembles-uncertainty
    407 | Coupled Ensembles of Neural Networks: https://github.com/vabh/coupled_ensembles
    408 | Deep Incremental Boosting: https://arxiv.org/pdf/1708.03704.pdf Code is part of https://github.com/nitbix/toupee (a Keras ensembler)
    409 | Stack Keras on top of scikit learn model: https://hergott.github.io/deep-learning-model-augmentation/
    410 |
    14. 411 |
    412 |
  14. New types of neural networks and algorithms to try:
    413 | List of Keras Classification Models: https://github.com/titu1994/Keras-Classification-Models 414 | Capsule Networks: https://github.com/XifengGuo/CapsNet-Fashion-MNIST and and https://github.com/shinseung428/CapsNet_Tensorflow and https://github.com/naturomics/CapsNet-Tensorflow and https://github.com/Sarasra/models/tree/master/research/capsules (https://arxiv.org/abs/1710.09829)
    415 | DenseNet: https://github.com/titu1994/DenseNet (https://arxiv.org/pdf/1608.06993v3.pdf)
    416 | Highway Networks: https://github.com/trangptm/HighwayNetwork (https://arxiv.org/abs/1505.00387)
    417 | CliqueNet: https://github.com/iboing/CliqueNet (https://arxiv.org/abs/1802.10419)
    418 | Equilibrium Propagation: https://github.com/StephanGrzelkowski/EquilibriumPropagation (https://www.frontiersin.org/articles/10.3389/fncom.2017.00024/full)
    419 | Session-based Recommendations With Recurrent Neural Networks (GRU4Rec): https://github.com/hidasib/GRU4Rec or this improved PyTorch version: https://github.com/yhs-968/pyGRU4REC (https://arxiv.org/pdf/1511.06939.pdf)
    420 | Siamese Networks: https://github.com/sorenbouma/keras-oneshot (https://www.cs.cmu.edu/%7Ersalakhu/papers/oneshot1.pdf)
    421 | Nested LSTMs: https://github.com/titu1994/Nested-LSTM (https://arxiv.org/abs/1801.10308)
    422 | E-=Swish activation function: https://github.com/EricAlcaide/E-swish (https://arxiv.org/abs/1801.07145v1)
    423 | Energy Prederving Neural Networks: https://github.com/akanimax/energy-preserving-neural-network (https://github.com/akanimax/energy-preserving-neural-network)
    424 | Training Neural Networks Without Gradients: A Scalable ADMM Approach - https://github.com/dongzhuoyao/admm_nn (https://arxiv.org/abs/1605.02026)
    425 | Inverse Compositional Spatial Transformer Networks: https://github.com/chenhsuanlin/inverse-compositional-STN
    426 | Ladder Networks: http://bair.berkeley.edu/blog/2018/01/23/kernels/ Code: https://github.com/search?l=Python&q=ladder+network&type=Repositories&utf8=%E2%9C%93
    427 | RWA: https://gist.github.com/shamatar/55b804cf62b8ee0fa23efdb3ea5a4701 - Machine Learning on Sequential Data Using a Recurrent Weighted Average - https://arxiv.org/abs/1703.01253
    428 | Neural Turing Machines - Now officially part of Tensorflow, see https://www.scss.tcd.ie/joeran.beel/blog/2019/05/25/google-integrates-our-neural-turing-machine-implementation-in-tensorflow/
    429 | ELM: https://github.com/dclambert/Python-ELM
    430 | PyDLM Bayesian dynamic linear model: https://github.com/wwrechard/pydlm - A python library for Bayesian dynamic linear models for time series data.
    431 | Symbolic Aggregate Approximation - https://github.com/nphoff/saxpy - See stock trading paper at at https://www.researchgate.net/publication/275235449_A_Stock_Trading_Recommender_System_Based_on_Temporal_Association_Rule_Mining
    432 | Hidden Markov Models: https://github.com/hmmlearn/hmmlearn (see stock example at http://hmmlearn.readthedocs.io/en/latest/auto_examples/plot_hmm_stock_analysis.html#sphx-glr-auto-examples-plot-hmm-stock-analysis-py ). Also see https://github.com/larsmans/seqlearn
    433 | Neural Decision Forests: https://github.com/jingxil/Neural-Decision-Forests
    434 | Deep Generative Models: https://github.com/AtreyaSh/deep-generative-models
    435 | PyGAM: https://github.com/dswah/pyGAM - Generalized Additive Models in Python.
    436 | ANFIS - https://github.com/twmeggs/anfis - Adaptive neuro fuzzy inference system
    437 | Particle Swarm Optimization: https://github.com/ljvmiranda921/pyswarms
    438 |
    439 | Various Keras NNs for stocks:
    440 | Deep CNN: https://github.com/rosdyana/Going-Deeper-with-Convolutional-Neural-Network-for-Stock-Market-Prediction
    441 | Meta learning - https://github.com/seba-1511/pytorch-hacks - MAML, FOMAML, MetaSGD
    442 | Contextual Bandits - https://devpost.com/software/unsupervised-representation-learning-for-contextual-bandits
    443 | TorchBrain - https://github.com/shoaibahmed/torchbrain - Spiking Neural Networks.
    444 |
    445 | Continual Learning: https://github.com/GMvandeVen/continual-learning
    446 |
    15. 447 |
    448 |
  15. Try one or both of these 2 programs for dealing with outliers/anomalies:
    449 | Try one or both of these 2 programs for dealing with outliers/anomalies:
    450 | https://github.com/yzhao062/pyod
    451 | https://github.com/hendrycks/outlier-exposure
    452 |
    16. 453 |
    454 |
  16. Order Book Imbalances:
    455 | There is good potential to make money from order book imbalances, in both Bitcoin and stocks/FX. See this Github program, which is old but uses no nns, only sklearn, so the age should not matter much:
    456 | https://github.com/rorysroes/SGX-Full-OrderBook-Tick-Data-Trading-Strategy
    457 | Also, Alpaca (https://alpaca.markets/), the commission free stock trading brokerage/API, has demo code for something similar for stocks at https://github.com/alpacahq/example-hftish , using only Numpy and Pandas. Their link to the paper they based it on is broken, but you can read that paper at https://www.palmislandtraders.com/econ136/hftois.pdf. And there are other similar papers on this topic such as:
    458 | https://arxiv.org/pdf/1809.01506.pdf
    459 | https://core.ac.uk/download/pdf/146502703.pdf
    460 | http://www.smallake.kr/wp-content/uploads/2015/11/SSRN-id2668277.pdf
    461 |
    462 | There are also these programs for it:
    463 | https://github.com/durdenclub/Algorithmic-Trading
    464 | https://github.com/timothyyu/gdax-orderbook-ml
    465 |
    17. 466 |
    467 |
  17. News Trading - Sentiment Analysis:
    468 | Kaggle Two Sigma: https://github.com/silvernine209/stock_price_prediction
    469 | Sentiment Analysis for Event-Driven Stock Prediction - https://github.com/WayneDW/Sentiment-Analysis-in-Event-Driven-Stock-Price-Movement-Prediction
    470 | Stocksight - https://github.com/shirosaidev/stocksight
    471 | https://github.com/Avhirup/Stock-Market-Prediction-Challenge/blob/master/Predicting%20Stock%20Prices%20Challenge.ipynb
    472 | https://www.dlology.com/blog/simple-stock-sentiment-analysis-with-news-data-in-keras/
    473 | https://github.com/jasonyip184/StockSentimentTrading/blob/master/Stock%20Sentiment%20Algo%20Trading.ipynb
    474 | https://github.com/Sadden/PredictStock/blob/master/PredictBasedOnNews.ipynb
    475 | Bert for Sentiment analysis: https://github.com/search?q=bert+sentiment+analysis&type=Repositories
    476 | ERNIE: https://github.com/PaddlePaddle/ERNIE
    477 | XLNet: https://github.com/zihangdai/xlnet
    478 |
    479 | Sources of news and sentiment:
    480 | https://api.tiingo.com/about/pricing
    481 | https://newsapi.org
    482 | https://rapidapi.com/Nuzzel/api/news-search/pricing
    483 | https://cloud.benzinga.com/cloud-product/bz-newswires/
    484 | https://www.decisionforest.com
    485 | http://sentdex.com
    486 | https://psychsignal.com/
    487 |
    18. 488 |
    489 |
  18. Reinforcement Learning (RL):
    490 | TensorTrade: https://github.com/notadamking/tensortrade
    491 | RL Trading - https://www.reddit.com/r/algotrading/comments/cjuzh7/how_to_create_a_concurrent_stochastic/and more comments at 492 | https://www.reddit.com/r/reinforcementlearning/comments/cjutsr/how_to_create_a_concurrent_stochastic/
    493 | RL Trading with Ray: https://github.com/Draichi/cryptocurrency_algotrading
    494 | Additional Frameworks To Add (we are already using Stable Baselines at https://github.com/hill-a/stable-baselines):
    495 | Coach: https://github.com/NervanaSystems/coach
    496 | Ray: https://ray.readthedocs.io/en/latest/rllib-algorithms.html
    497 | RL Kit: https://github.com/vitchyr/rlkit
    498 | MediPixel: https://github.com/medipixel/rl_algorithms - For TD3 and Rainbow IQN
    499 | PARL: https://github.com/PaddlePaddle/PARL - Parallel versions of algos
    500 |
    501 | Meta Learning for RL:
    502 | https://github.com/tristandeleu/pytorch-maml-rl
    503 | https://github.com/navneet-nmk/Hierarchical-Meta-Reinforcement-Learning
    504 | https://github.com/quantumiracle/Benchmark-Efficient-Reinforcement-Learning-with-Demonstrations/tree/master/MAML
    505 | Reptile for RL (maybe?): https://github.com/alok/rl_implementations/tree/master/reptile
    506 |
    507 | Evolution-Guided Policy Gradient in Reinforcement Learning: Code: https://github.com/ShawK91/erl_paper_nips18 Paper: https://arxiv.org/abs/1805.07917
    508 | Tsallis: Code: https://github.com/kyungjaelee/tsallis_actor_critic_mujoco Paper: https://arxiv.org/abs/1902.00137
    509 |
    510 | Some unusual RL Algos:
    511 | https://github.com/WilsonWangTHU/mbbl
    512 | and
    513 | https://github.com/dennybritz/reinforcement-learning
    514 |
    515 | Has good Tensorflow versions of RL agents: https://github.com/tensorflow/agents
    516 | Uber Research Programs: https://github.com/uber-research
    517 | Selective memory: https://github.com/FitMachineLearning/FitML/tree/master/SelectiveMemory
    518 | Random Network Distillation: https://github.com/search?q=Random+Network+Distillation
    519 | RL Graph (uses Ray): https://github.com/rlgraph/rlgraph
    520 | Huskarl: https://github.com/danaugrs/huskarl
    521 |
    522 | Also see these RL trading frameworks:
    523 | https://github.com/notadamking/tensortrade
    524 | https://medium.com/@kevinhill_96608/how-to-create-a-concurrent-and-parallel-stochastic-reinforcement-learning-environment-for-crypto-3756d78b7a8e
    525 | https://github.com/Kismuz/btgym
    526 |
    19. 527 |
    528 |
  19. Misc.:
    529 | AdaBound (PyTorch) optimizer - Like Adam
    530 | Daily Forex Patterns
    531 | Neuro-Evolution Trading Bot (in Keras)
    532 | Gluon Time Series
    533 | NeuroEvolution Trader (Tensorflow)
    534 | Somebody in the RL Trader discussion group suggested using https://github.com/vaexio/vaex 535 | Also, there is this:  Pystore - Fast Data Store for Pandas Time-Series Data - https://medium.com/@aroussi/fast-data-store-for-pandas-time-series-data-using-pystore-89d9caeef4e2
    536 | EA Trader: https://github.com/EA31337/EA31337 - Open source FX trading robot for MT4/MT5
    537 | 538 |
    20. 539 |
    540 | 541 |
542 | 543 | 544 | 545 | 546 | 547 | 548 |
549 |

Click Here to see what we offer on GitHub.

550 |

If you have any questions, email eric@impulsecorp

551 | 552 | 553 | 554 | --------------------------------------------------------------------------------