{% trans "First, enter a username and password. Then, you'll be able to edit more user options." %}
7 | {% else %}
8 |
14 |
15 | {% if app_list %}
16 | {% for app in app_list %}
17 |
18 |
19 |
20 | {{ app.name }}
21 |
22 | {% for model in app.models %}
23 |
24 | {% if model.admin_url %}
25 | | {{ model.name }} |
26 | {% else %}
27 | {{ model.name }} |
28 | {% endif %}
29 |
30 | {% if model.add_url %}
31 | {% trans 'Add' %} |
32 | {% else %}
33 | |
34 | {% endif %}
35 |
36 | {% if model.admin_url %}
37 | {% trans 'Change' %} |
38 | {% else %}
39 | |
40 | {% endif %}
41 |
42 | {% endfor %}
43 |
44 |
45 | {% endfor %}
46 | {% else %}
47 |
{% trans "You don't have permission to edit anything." %}
48 | {% endif %}
49 |
96 |
97 | |
98 | Symbol
99 | |
100 |
101 | Date
102 | |
103 |
104 | Avg Unit Buy Price
105 | |
106 |
107 | Avg Unit Sell
108 | |
109 |
110 | Buy Volume
111 | |
112 |
113 | Sell Volume
114 | |
115 |
116 | Net Volume
117 | |
118 |
119 | Ending Balance
120 | |
121 |
122 | Realized Net Profit / Loss
123 | |
124 |
125 | Unrealized Net Profit / Loss
126 | |
127 |
128 | {% for this in data %}
129 |
130 | |
131 | {{this.symbol}}
132 | |
133 |
134 | {{this.date}}
135 | |
136 |
137 | {{this.buy}}
138 | |
139 |
140 | {{this.sell}}
141 | |
142 |
143 | {{this.buyvol}} {{this.one_symbol}}
144 | |
145 |
146 | {{this.sellvol}} {{this.one_symbol}}
147 | |
148 |
149 | {{this.netvol}} {{this.one_symbol}}
150 | |
151 |
152 | {{this.bal}} {{this.one_symbol}}
153 | |
154 |
155 | {{this.diff}} {{this.one_symbol}}
156 | |
157 |
158 | {% if this.unrealizeddiff and this.date == max_date %}
159 | {{this.unrealizeddiff}} {{this.one_symbol}}
160 | {% endif %}
161 | |
162 |
163 | {% endfor %}
164 |
165 |
166 |
167 |
168 |
169 |
181 |
--------------------------------------------------------------------------------
/history/tests.py:
--------------------------------------------------------------------------------
1 | from django.test import TestCase # noqa
2 |
3 | # Create your tests here.
4 |
--------------------------------------------------------------------------------
/history/tools.py:
--------------------------------------------------------------------------------
1 | import time
2 | import datetime
3 | from django.conf import settings
4 | from django.core.exceptions import ImproperlyConfigured
5 |
6 |
7 | def print_and_log(log_string):
8 | with open(settings.LOG_FILE, "a") as myfile:
9 | myfile.write(log_string + "\n")
10 | print(log_string)
11 |
12 |
13 | def get_utc_unixtime():
14 | import time
15 | import datetime
16 |
17 | d = datetime.datetime.now()
18 | unixtime = time.mktime(d.timetuple())
19 | return int(unixtime)
20 |
21 |
22 | def create_sample_row(data, i, size):
23 | sample = ()
24 | for k in range(0, size):
25 | sample = sample + (data[i + k],)
26 | return sample
27 |
28 |
29 | def normalization(data, new_max=1, new_min=0):
30 | old_max = 0
31 | old_min = 0
32 |
33 | # Finde altes Max- und Minimum
34 | for i in range(len(data)):
35 | if old_max < data[i]:
36 | old_max = data[i]
37 | elif old_min > data[i]:
38 | old_min = data[i]
39 |
40 | old_range = (old_max - old_min)
41 |
42 | for i in range(len(data)):
43 | if old_range == 0:
44 | data[i] = new_min
45 | else:
46 | new_range = (new_max - new_min)
47 | data[i] = (((data[i] - old_min) * new_range) / old_range) + new_min
48 | return data
49 |
50 |
51 | def filter_by_mins(data, mins=5):
52 | new_data = []
53 |
54 | for ele in data:
55 | ele_unixtime = int(time.mktime(ele.created_on.timetuple()))
56 | ele_unixtime_min = int(ele_unixtime / 60)
57 | if ele_unixtime_min % mins == 0:
58 | new_data.append(ele)
59 |
60 | return new_data
61 |
62 |
63 | def median_value(queryset, term):
64 | count = queryset.count()
65 | return queryset.values_list(term, flat=True).order_by(term)[int(round(count / 2))]
66 |
67 |
68 | def get_exchange_rate_to_btc(ticker, d=None):
69 | from history.models import Price
70 |
71 | if d is None:
72 | d = datetime.datetime.now()
73 | if ticker == 'BTC':
74 | return 1
75 |
76 | try:
77 | exchange_pair = 'BTC_' + ticker
78 | latest_price = Price.objects.filter(symbol=exchange_pair, created_on__lt=d).order_by('-created_on').first()
79 | return latest_price.price
80 | except:
81 | exchange_pair = ticker + '_BTC'
82 | latest_price = Price.objects.filter(symbol=exchange_pair, created_on__lt=d).order_by('-created_on').first()
83 | return 1.0 / latest_price.price
84 |
85 |
86 | def get_exchange_rate_btc_to_usd(d=None):
87 | from history.models import Price
88 | if d is None:
89 | d = datetime.datetime.now()
90 |
91 | exchange_pair = 'USDT_BTC'
92 | latest_price = Price.objects.filter(symbol=exchange_pair, created_on__lt=d).order_by('-created_on').first()
93 | return latest_price.price
94 |
95 |
96 | def get_cost_basis(total_amount, symbol):
97 | from history.models import Trade
98 | running_amount = total_amount
99 | cost_basis_array = []
100 | ts = Trade.objects.filter(symbol=symbol).order_by('-created_on').values_list('amount', 'price')
101 | for t in ts:
102 | if running_amount < 0:
103 | continue
104 | trade_amount = t[0]
105 | price = t[1]
106 | if running_amount < trade_amount:
107 | cost_basis_array.append([running_amount, price])
108 | else:
109 | cost_basis_array.append([trade_amount, price])
110 | running_amount = running_amount - trade_amount
111 |
112 | total_amount = sum([t[0] for t in cost_basis_array])
113 | total_paid = sum([t[0] * t[1] for t in cost_basis_array])
114 |
115 | return total_paid / total_amount
116 |
117 |
118 | def get_deposit_balance():
119 | from history.models import Deposit
120 | btc_deposit_amount = 0
121 | usd_deposit_amount = 0
122 | for d in Deposit.objects.all():
123 | exchange_rate = get_exchange_rate_to_btc(d.symbol, d.created_on)
124 | btc_amount = d.amount * exchange_rate
125 | usd_amount = get_exchange_rate_btc_to_usd(d.created_on) * btc_amount
126 | btc_deposit_amount = btc_deposit_amount + btc_amount
127 | usd_deposit_amount = usd_deposit_amount + usd_amount
128 | return btc_deposit_amount, usd_deposit_amount
129 |
130 |
131 | def get_fee_amount(volume=settings.TRADE_VOLUME_TRAILING_30_DAYS, mode=settings.TRADE_MODE):
132 | for meta in settings.FEES['poloniex']:
133 | if meta['volume'] == volume:
134 | return meta[mode]
135 |
136 | raise ImproperlyConfigured('could not find fee amount for {} / {}'.format(volume, mode))
137 |
--------------------------------------------------------------------------------
/howto_trade.md:
--------------------------------------------------------------------------------
1 | # Trading with pytrader
2 |
3 | This document is intended for those who have [successfully deployed the repository onto their own server](https://github.com/owocki/pytrader#deployment), and would like to understand how to optimize towards profit.
4 |
5 | ## Poloniex Setup
6 |
7 | To setup your poloniex account
8 |
9 | 1. [Sign up](https://www.poloniex.com/signup)
10 | 2. Go to `Balances > Deposits & Withdrawals`
11 | 3. Scroll to `[BTC] Bitcoin`
12 | 4. Get your deposit address.
13 | 5. Send BTC to your deposit address.
14 | * Note: You will need a way to get BTC. I use [Coinbase](coinbase.com), but YMMV.
15 | 6. Wait until the transaction is confirmed.
16 |
17 | To use your poloniex account with pytrader.
18 |
19 | 1. Navigate to `[wrench] > API Keys` [{screenshot}](http://bits.owocki.com/0D472H0O3108/Image%202016-04-03%20at%201.31.13%20PM.png)
20 | 1. Generate an API key that has "enable trading" set to true.
21 | 2. Add your APIKey / Secret to your `pypolo/local_settings.py` file:
22 |
23 | ```
24 | API_KEY = "
15 |
16 |
17 | I (@owocki) built this as a side project in January / February 2016, as a practical means of getting some experience with machine learning, quantitative finance, and of course hopefully making some profit `;)`.
18 |
19 | ---
20 |
21 | __3/20/2017__ - This project has been put on ice by it's contributors. Comment here if you would like to see a revival of development => https://github.com/owocki/pytrader/issues/80
22 |
23 | __3/26/2016__ - My test portfolio was initialized with a 1 BTC deposit, and after 2 months and 23,413 trades, exited with 0.955 BTC. The system paid 2.486 BTC in fees to poloniex. CALL TO ACTION -- Get this trader to profitability. [A strategy is being fleshed out here](https://github.com/owocki/pytrader/issues/1).
24 |
25 | __3/27/2016__ - Sign up for the pytrader slack channel [here](https://github.com/owocki/pytrader/issues/23).
26 |
27 | __4/3/2016__ - New documentation -- [How to trade with pytrader](https://github.com/owocki/pytrader/blob/master/howto_trade.md)
28 |
29 | ---
30 |
31 | ## How
32 |
33 | pytrader uses _pybrain_ and _sklearn_ to make trade ( buy/sell/hold decisions ), and then acts upon them.
34 |
35 | ### 1. sklearn classifiers
36 |
37 | Supported classifiers are as follows:
38 |
39 | ```
40 | ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Decision Tree",
41 | "Random Forest", "AdaBoost", "Naive Bayes", "Linear Discriminant Analysis",
42 | "Quadratic Discriminant Analysis"]
43 | ```
44 |
45 | Here's an example of a *Decision Tree* classifier being used to make a buy (blue), sell (red), or hold(green) decision on the [BTC_ETH pair](https://www.poloniex.com/exchange#btc_eth).
46 |
47 | 
48 |
49 | and here's a *Naive Bayes* decision tree for the [USDT_BTC pair](https://www.poloniex.com/exchange#usdt_btc)
50 |
51 | 
52 |
53 | On both graphs, the x axis is a recent price movement, and the y axis is a previous price movement, the length of which is determined by a parameter called *granularity*. These graphs show only the last two price movements. The graphing library used is constrained by two dimensional space, but you could generate a classifier that acts upon *n* pricemovements ( *n* dimensional space ).
54 |
55 | There are many many different parameters one could use to train a *ClassifierTest*. This problem space is enumerated by the management command *predict_many_sk.py*. For each permutation of parameters, a _percent_correct_ value is generated against actual price movement data. Using this brute force methodology, we are able to discover which classifiers are up for the job of trading.
56 |
57 | By testing and tuning various parameters to to the *ClassifierTest*, I was able to consistently predict buy/sell/hold movements between 55-65% of the time, depending upon the currency pair and parameters to the test.
58 |
59 | ### 2. pybrain neural networks
60 |
61 | In addition to using sklearn Classifiers, Pybrain Supervised Learning tools were used to predict price movement. This is represented in the data model as a *PredictionTest*, and the problem space is enumerated in *predict_many_v2.py*. By testing and tuning various parameters in the pybrain NN, I was able to consistently predict directional price movements around 55% of the time.
62 |
63 | ### Database model
64 |
65 | 
66 |
67 | ## Administration & Optimization
68 |
69 | Administration of this tool is primarily done through the django admin.
70 |
71 | There's a series of graphs in the admin that show trades, and portfolio profitability over time.
72 |
73 | 
76 |
77 | ... and allow the graphical debugging of trade decisions ...
78 |
79 | 
80 |
81 | ... and allow the tuning of `PredictionTests` and `ClassifierTests` ...
82 |
83 | 
84 |
85 | by each of the native pybrain (Prediction Test) and sklearn (ClassiferTests) parameters ..
86 |
87 | 
88 |
89 | Once a NN or classifier is found that is better than what is being used, *trade.py* is updated with the most profitable configurations.
90 |
91 | ```
92 | self.predictor_configs = [
93 | {'type' : 'nn',
94 | 'name' : 'ETH / 5',
95 | 'symbol': 'BTC_ETH',
96 | 'weight' : 0.1,
97 | 'granularity' : granularity,
98 | 'datasetinputs': 5},
99 | {'type' : 'nn',
100 | 'name' : 'ETH / 5',
101 | 'symbol': 'BTC_ETH',
102 | 'weight' : 0.1,
103 | 'granularity' : granularity,
104 | 'datasetinputs': 4},
105 | {'type' : 'classifier',
106 | 'symbol': 'USDT_BTC',
107 | 'name' : 'AdaBoost',
108 | 'weight' : 0.1,
109 | 'granularity' : granularity,
110 | 'datasetinputs' : 2,
111 | 'minutes_back': 1000},
112 | {'type' : 'classifier',
113 | 'symbol': 'USDT_BTC',
114 | 'name' : 'Naive Bayes',
115 | 'weight' : 0.1,
116 | 'granularity' : granularity,
117 | 'datasetinputs' : 2,
118 | 'minutes_back': 1000},
119 | {'type' : 'classifier',
120 | 'symbol': 'BTC_ETH',
121 | 'name' : 'Naive Bayes',
122 | 'weight' : 2,
123 | 'granularity' : granularity * 3,
124 | 'datasetinputs' : 2,
125 | 'minutes_back': 1000},
126 | ]
127 | ```
128 |
129 | ### trade.py
130 |
131 | *trade.py* is the system's always-running trading engine. At a high level, it creates & trains ClassifierTests and PredictionTests based upon the most profitable indicators. Once those Tests are trained, it runs a loop that makes trades based upon them if a certain confidence threshold is reached amongst its `self.predictor_configs` .
132 |
133 | ## Why open source this?
134 |
135 | Although I am able to predict price movements with some degree of accuracy that beats random, I was never able to generate a robot that traded profitably *after fees*. [Especially after poloniex changed their fee structure](https://poloniex.com/fees/)
136 |
137 | My test portfolio was initialized with a 1 BTC deposit, and after 2 months and 23,413 trades, exited with 0.955 BTC. The system paid 2.486 BTC in fees to poloniex.
138 |
139 | The code is not perfect. This was a pre-product/market-fit side project. Please feel free to open an _Issue_ if you do not understand something. CALL TO ACTION -- Get this trader to profitability. [A strategy is being fleshed out here](https://github.com/owocki/pytrader/issues/1).
140 |
141 | ## Deployment
142 |
143 | After you've cloned the repo, you'll want to create a *pypolo/local_settings.py* file with the following information in it:
144 |
145 | ```
146 | import os
147 |
148 | BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
149 |
150 | API_KEY = "