moved things to a new place !
This commit is contained in:
@@ -15,7 +15,7 @@ import datetime
|
||||
import matplotlib.dates as mdates
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
import mplfinance as mpf
|
||||
#import mplfinance as mpf
|
||||
|
||||
import plotly
|
||||
#import plotly.plotly as py
|
||||
@@ -25,7 +25,7 @@ from plotly.offline import init_notebook_mode, iplot
|
||||
from plotly.subplots import make_subplots
|
||||
init_notebook_mode()
|
||||
|
||||
import market_trade.core.CoreTraidMath
|
||||
import CoreTraidMath
|
||||
import plotly.express as px
|
||||
|
||||
|
||||
@@ -79,9 +79,10 @@ class corePlt():
|
||||
|
||||
|
||||
class coreDraw():
|
||||
def __init__(self, data=[],needShow=False):
|
||||
def __init__(self, data=[],needShow=False,subplot_titles={}):
|
||||
self.data=self.getPlts(data)
|
||||
self.needShow=needShow
|
||||
self.subplot_titles=subplot_titles
|
||||
self.ans=self.getAns()
|
||||
|
||||
|
||||
@@ -156,11 +157,11 @@ class coreDraw():
|
||||
rows=maxRow,
|
||||
cols=maxCol,
|
||||
shared_xaxes=True,
|
||||
vertical_spacing=0.02,
|
||||
vertical_spacing=0.1,
|
||||
shared_yaxes=True,
|
||||
horizontal_spacing=0.02,
|
||||
#horizontal_spacing=0.02,
|
||||
#column_widths=[]
|
||||
|
||||
subplot_titles=self.subplot_titles
|
||||
)
|
||||
|
||||
|
||||
@@ -188,7 +189,7 @@ class coreDraw():
|
||||
except:
|
||||
colorType='normal'
|
||||
colors=self.getBarColorList(i.df[j],colorType)
|
||||
fig.add_trace(go.Bar(x=i.df['date'], y=i.df[j],name=j,marker_color=colors))
|
||||
fig.add_trace(go.Bar(x=i.df['date'], y=i.df[j],name=j,marker_color=colors),row=i.row, col=i.col)
|
||||
|
||||
|
||||
|
||||
@@ -196,4 +197,4 @@ class coreDraw():
|
||||
ans=fig
|
||||
if self.needShow:
|
||||
plotly.offline.iplot(fig)
|
||||
return ans
|
||||
return ans
|
||||
@@ -1,93 +1,102 @@
|
||||
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
import plotly as pl
|
||||
import plotly.graph_objs as go
|
||||
import matplotlib.pyplot as plt
|
||||
import math
|
||||
import scipy
|
||||
import random
|
||||
import statistics
|
||||
|
||||
|
||||
import datetime
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class CoreMath:
|
||||
|
||||
def __init__(self, base_df, params=None):
|
||||
"""
|
||||
Этот класс нужен для того, чтобы проводить операции над датафреймами
|
||||
:param base_df: pandas.DataFrame , датафрейм, над которым будут проведены математические операции
|
||||
:param params: словарь, который определяет какие данные пришли в класс, и что с ними нужно делать, и как
|
||||
"""
|
||||
if params is None:
|
||||
params = {
|
||||
'dataType': 'ohcl',
|
||||
'action': None,
|
||||
'actionOptions': {}
|
||||
}
|
||||
|
||||
# нужно переопределить индексы, потому что нам ничего не известно об индексации входного файла
|
||||
self.base_df = base_df.reset_index(drop=True)
|
||||
|
||||
self.params = params
|
||||
|
||||
# Эта часть определяет с какой частью данных нужно проводить вычисления
|
||||
|
||||
def __init__(self, base_df, params={
|
||||
'dataType':'ohcl',
|
||||
'action': None,
|
||||
'actionOptions':{}
|
||||
}
|
||||
):
|
||||
|
||||
self.base_df=base_df.reset_index(drop=True)
|
||||
self.params=params
|
||||
if self.params['dataType']=='ohcl':
|
||||
self.col=self.base_df[self.params['actionOptions']['valueType']]
|
||||
elif self.params['dataType']=='series':
|
||||
self.col=self.base_df
|
||||
|
||||
# собственно производим вычисления
|
||||
self.ans=self.getAns()
|
||||
|
||||
|
||||
|
||||
def getAns(self):
|
||||
"""
|
||||
Эта функция занимается собственно рутингом вычислений, в зависимости от параметров
|
||||
:return: ans, неопределенный тип данных, в заивисимости от action
|
||||
"""
|
||||
ans=None
|
||||
|
||||
# в зависимости от параметра action производятся соответсвующие действия
|
||||
|
||||
if self.params['action']=='findExt':
|
||||
ans = self.getExtremumValue()
|
||||
elif self.params['action']=='findMean':
|
||||
ans = self.getMeanValue()
|
||||
elif self.params['action']=='findSTD':
|
||||
ans = self.getSTD()
|
||||
|
||||
ans=self.getSTD()
|
||||
|
||||
|
||||
return ans
|
||||
|
||||
|
||||
|
||||
|
||||
def getExtremumValue(self):
|
||||
"""
|
||||
Эта функция возвращает экстремум произвольного типа внутри одного столбца
|
||||
Тип контролируется разделом внутри словаря параметров `self.params` по ключу `actionOptions`:
|
||||
'extremumtype': -- тип экстремума
|
||||
ans=None
|
||||
'''
|
||||
actionOptions:
|
||||
'extremumtype':
|
||||
'min'
|
||||
'max'
|
||||
:return ans, экстремум произвольного типа
|
||||
"""
|
||||
ans=None
|
||||
'valueType':
|
||||
'open'
|
||||
'close'
|
||||
'high'
|
||||
'low'
|
||||
'''
|
||||
if self.params['actionOptions']['extremumtype']=='max':
|
||||
ans=max(self.col)
|
||||
|
||||
|
||||
if self.params['actionOptions']['extremumtype']=='min':
|
||||
ans=min(self.col)
|
||||
|
||||
|
||||
return ans
|
||||
|
||||
|
||||
|
||||
def getMeanValue(self):
|
||||
"""
|
||||
Божественный код
|
||||
Эта функция возвращает среднее значение одного из следующих типов.
|
||||
Для определения типа используется словарь `self.params`, по ключу `actionOptions`, релевантные ключи выглядят
|
||||
так:
|
||||
'''
|
||||
actionOptions:
|
||||
'MeanType':
|
||||
'MA' -- среднее по всему столбцу
|
||||
'SMA' -- скользящее среднее
|
||||
'EMA' -- экспоненциальное скользящее среднее
|
||||
'WMA' -- взвешенное скользящее среднее
|
||||
'window' -- размер окна
|
||||
'span' -- >=1 , аналог окна для экспоненциального среднего, чем он больше тем меньше коэффициент сглаживания
|
||||
'weights' -- numpy.ndarray, список размером в параметр `window`, конкретные веса для каждого элемента
|
||||
"""
|
||||
|
||||
'MA'
|
||||
'SMA'
|
||||
'EMA'
|
||||
'WMA'
|
||||
--'SMMA'
|
||||
'valueType':
|
||||
'open'
|
||||
'close'
|
||||
'high'
|
||||
'low'
|
||||
'window'
|
||||
'span'
|
||||
'weights'
|
||||
'''
|
||||
ans=None
|
||||
|
||||
if self.params['actionOptions']['MeanType']=='MA':
|
||||
ans = self.col.mean()
|
||||
if self.params['actionOptions']['MeanType']=='SMA':
|
||||
ans=np.convolve(self.col, np.ones(self.params['actionOptions']['window']), 'valid') / self.params['actionOptions']['window']
|
||||
#ans=self.col.rolling(window=self.params['actionOptions']['window']).mean().to_list()
|
||||
|
||||
if self.params['actionOptions']['MeanType']=='EMA':
|
||||
ans=self.col.ewm(span=self.params['actionOptions']['span'], adjust=False).mean().to_list()
|
||||
if self.params['actionOptions']['MeanType']=='WMA':
|
||||
@@ -97,8 +106,10 @@ class CoreMath:
|
||||
weights=np.arange(1,self.params['actionOptions']['window']+1)
|
||||
ans=self.col.rolling(window=self.params['actionOptions']['window']).apply(lambda x: np.sum(weights*x) / weights.sum(), raw=False).to_list()
|
||||
|
||||
return ans
|
||||
|
||||
|
||||
|
||||
return(ans)
|
||||
|
||||
def getSTD(self):
|
||||
'''
|
||||
actionOptions:
|
||||
@@ -109,7 +120,7 @@ class CoreMath:
|
||||
|
||||
|
||||
'''
|
||||
|
||||
|
||||
ans=None
|
||||
|
||||
|
||||
@@ -117,11 +128,11 @@ class CoreMath:
|
||||
window=self.params['actionOptions']['window']
|
||||
ans=np.asarray([])
|
||||
for i in range(len(self.col)-window+1):
|
||||
ans=np.append(ans, np.std(self.col[i:i+window], ddof=1))
|
||||
|
||||
ans=np.append(ans,np.std(self.col[i:i+window], ddof=1))
|
||||
|
||||
except:
|
||||
#window = len(self.col)
|
||||
ans=np.std(self.col, ddof=1)
|
||||
|
||||
return ans
|
||||
|
||||
|
||||
49
market_trade/core/dealManager.py
Normal file
49
market_trade/core/dealManager.py
Normal file
@@ -0,0 +1,49 @@
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
import uuid
|
||||
|
||||
class DealManager():
|
||||
|
||||
def __init__(self):
|
||||
#self.commission=0.04
|
||||
self.columns=['uuid','figi','amount','startPrice']
|
||||
self.deals = pd.DataFrame(columns=self.columns)
|
||||
self.deals = self.deals.set_index('uuid')
|
||||
|
||||
def findDealByPriceAndFig(self,price,figi):
|
||||
ans=None
|
||||
for i in range(self.deals.shape[0]):
|
||||
if self.deals.iloc[i].startPrice == price and self.deals.iloc[i].figi == figi:
|
||||
ans = self.deals.iloc[i].name
|
||||
break
|
||||
return ans
|
||||
|
||||
def openDeal(self,figi,startPrice,amount=1):
|
||||
desiredDeal=self.findDealByPriceAndFig(startPrice,figi)
|
||||
if desiredDeal == None:
|
||||
newDealDict={
|
||||
'uuid':[str(uuid.uuid4())],
|
||||
'figi':[figi],
|
||||
'startPrice':[startPrice],
|
||||
'amount':[amount]
|
||||
}
|
||||
|
||||
#newDealDict['profit']=[startPrice*pow(1+self.commission,2)]
|
||||
|
||||
|
||||
|
||||
newDeal=pd.DataFrame.from_dict(newDealDict).set_index('uuid')
|
||||
self.deals=pd.concat([self.deals, newDeal])
|
||||
else:
|
||||
self.deals.at[desiredDeal,'amount'] += amount
|
||||
|
||||
def closeDeal(self,uuid,amount):
|
||||
|
||||
desiredDeal=self.deals.loc[uuid]
|
||||
if desiredDeal.amount - amount == 0:
|
||||
self.deals = self.deals.drop(labels = [uuid],axis = 0)
|
||||
else:
|
||||
self.deals.at[uuid,'amount'] -= amount
|
||||
#self.deals.loc[uuid].amount = desiredDeal.amount - amount
|
||||
|
||||
116
market_trade/core/decisionManager.py
Normal file
116
market_trade/core/decisionManager.py
Normal file
@@ -0,0 +1,116 @@
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
|
||||
import pickle
|
||||
from signals import *
|
||||
from dealManager import *
|
||||
from trandeVoter import *
|
||||
from riskManager import riskManager
|
||||
|
||||
|
||||
class decsionManager():
|
||||
|
||||
|
||||
def __init__(self,name):
|
||||
self.name = name
|
||||
self.RM = riskManager()
|
||||
self.DM = DealManager()
|
||||
self.TV = trandeVoter(name)
|
||||
self.SA = signalAgrigator()
|
||||
pass
|
||||
|
||||
#вытащенный из signalAgrigator метод теста для сигналов
|
||||
def getSignalTest(self,data: pd.DataFrame(),reqSig: dict, batchSize=30, dataType='candel') -> dict:
|
||||
|
||||
self.SA.mode = 'retroFast'
|
||||
t.SA.createSingnalInstances(
|
||||
data = data,
|
||||
dictAgrigSignal = reqSig,
|
||||
dataType='candel',
|
||||
batchSize=30
|
||||
)
|
||||
ans = t.SA.getAns(data)
|
||||
return ans
|
||||
|
||||
#метод для генерации матрицы вероятностей.
|
||||
def generateMatrixProbability(self,
|
||||
data: pd.DataFrame(),
|
||||
reqSig: dict,
|
||||
target: str,
|
||||
batchSize=30,
|
||||
#dataType='candel'
|
||||
):
|
||||
data=data.reset_index(drop=True)
|
||||
|
||||
t.SA.createSingnalInstances(
|
||||
data = data,
|
||||
dictAgrigSignal = reqSig,
|
||||
dataType='candel',
|
||||
batchSize=batchSize
|
||||
)
|
||||
self.TV.createMatrixAmounts(reqSig.keys())
|
||||
for i in range(data.shape[0]-batchSize-1):
|
||||
sigAns=self.SA.getAns(data[i:i+batchSize])
|
||||
rightAns=self.getRetroStepAns(data[target][i],data[target][i+1])
|
||||
self.TV.setDecisionBySignals(self.KostilEbaniy(sigAns),rightAns)
|
||||
self.TV.generateMatrixProbability()
|
||||
|
||||
#без коментариев блять
|
||||
def KostilEbaniy(self,d):
|
||||
ans={}
|
||||
for i in d.keys():
|
||||
if d[i] == 0:
|
||||
ans[i] = 'none'
|
||||
elif d[i] == 1:
|
||||
ans[i] = 'up'
|
||||
elif d[i] == -1:
|
||||
ans[i] = 'down'
|
||||
return ans
|
||||
|
||||
#тож понятная хуита
|
||||
def getRetroStepAns(self, value1,value2):
|
||||
|
||||
if value1 == value2:
|
||||
ans = 'none'
|
||||
elif value1 < value2:
|
||||
ans = 'up'
|
||||
else:
|
||||
ans = 'down'
|
||||
return ans
|
||||
|
||||
#метод для онлай получения решения по сигналу
|
||||
def getSignal(self,data: pd.DataFrame(),reqSig: dict, dataType='candel') -> dict:
|
||||
data=data.reset_index(drop=True)
|
||||
self.SA.mode = 'online'
|
||||
t.SA.createSingnalInstances(
|
||||
data = data,
|
||||
dictAgrigSignal = reqSig,
|
||||
dataType='candel',
|
||||
batchSize=30
|
||||
)
|
||||
ans = t.SA.getAns(data)
|
||||
return ans
|
||||
|
||||
|
||||
#Создание сигналов. Вызывать перед getOnlineAns
|
||||
def crateSignals(self,data: pd.DataFrame(),reqSig: dict, dataType='candel'):
|
||||
data=data.reset_index(drop=True)
|
||||
self.SA.mode = 'online'
|
||||
t.SA.createSingnalInstances(
|
||||
data = data,
|
||||
dictAgrigSignal = reqSig,
|
||||
dataType='candel',
|
||||
batchSize=30
|
||||
)
|
||||
|
||||
|
||||
def getOnlineAns(self,data: pd.DataFrame(),price):
|
||||
sigAns = self.SA.getAns(data)
|
||||
prob = self.TV.getDecisionBySignals(sigAns)
|
||||
ans = self.RM.getDecision(sigAns,prob,price)
|
||||
return ans
|
||||
|
||||
|
||||
|
||||
|
||||
161
market_trade/core/decisionManager_v2.py
Normal file
161
market_trade/core/decisionManager_v2.py
Normal file
@@ -0,0 +1,161 @@
|
||||
import os
|
||||
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
|
||||
from tqdm import tqdm
|
||||
|
||||
from indicators_v2 import *
|
||||
from signals_v2 import *
|
||||
from dealManager import *
|
||||
from trandeVoter import *
|
||||
from riskManager import *
|
||||
import pickle
|
||||
|
||||
|
||||
class decsionManager:
|
||||
'''
|
||||
sigAgrReq = {
|
||||
'sig_BB':{
|
||||
'className':sig_BB,
|
||||
'params':{'source':'close','target':'close'},
|
||||
'indicators':{
|
||||
'ind_BB':{
|
||||
'className':ind_BB,
|
||||
'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2.5}
|
||||
}
|
||||
}
|
||||
},
|
||||
'sig_BB_2':{
|
||||
'className':sig_BB,
|
||||
'params':{'source':'close','target':'close'},
|
||||
'indicators':{
|
||||
'ind_BB':{
|
||||
'className':ind_BB,
|
||||
'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sigAgrData = {
|
||||
'sig_BB':{
|
||||
'signalData': df_candle[990:1000],
|
||||
'indicatorData' :{'ind_BB': df_candle[:1000]}
|
||||
},
|
||||
'sig_BB_2':{
|
||||
'signalData': df_candle[990:1000],
|
||||
'indicatorData' :{'ind_BB': df_candle[:1000]}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
sigAgrRetroTemplate = {
|
||||
'sig_BB':{
|
||||
'signalData': None,
|
||||
'indicatorData' :{'ind_BB': None}
|
||||
},
|
||||
'sig_BB_2':{
|
||||
'signalData': None,
|
||||
'indicatorData' :{'ind_BB': None}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
'''
|
||||
|
||||
|
||||
|
||||
|
||||
def __init__(self,name, sigDict: dict):
|
||||
self.RM = riskManager()
|
||||
self.DM = DealManager()
|
||||
self.TV = trandeVoter(name)
|
||||
self.SA = signalsAgrigator(sigDict)
|
||||
self.sigDict = sigDict
|
||||
|
||||
|
||||
def getOnlineAns(self, signalsAns: dict, price: float) -> dict:
|
||||
probabilityDecsion = self.TV.getDecisionBySignals(self.getSignalsAns(signalsAns))
|
||||
RMD = self.RM.getDecision(probabilityDecision=probabilityDecsion, price=price, deals = self.DM.deals)
|
||||
return RMD
|
||||
|
||||
def getSignalsAns(self, signalsDataDict: dict) -> dict:
|
||||
return self.SA.getAns(signalsDataDict)
|
||||
|
||||
def getRightAns(self,value_1, value_2):
|
||||
|
||||
ans=''
|
||||
|
||||
if value_1 > value_2:
|
||||
ans = 'down'
|
||||
elif value_1 < value_2:
|
||||
ans = 'up'
|
||||
else:
|
||||
ans = 'none'
|
||||
|
||||
return ans
|
||||
|
||||
def getRetroTrendAns(self, retroTemplateDict: dict, data: pd.DataFrame(), window: int) -> list:
|
||||
|
||||
reqSig={}
|
||||
ans = {
|
||||
'signalsAns':[],
|
||||
'rightAns':[]
|
||||
|
||||
}
|
||||
target = ''
|
||||
|
||||
|
||||
for k in tqdm(range(data.shape[0]-window-1)):
|
||||
for i in retroTemplateDict.keys():
|
||||
reqSig[i] = {'signalData': data[k:k+window], 'indicatorData':{}}
|
||||
target = self.SA.signals[i].params['target']
|
||||
for j in retroTemplateDict[i]['indicatorData'].keys():
|
||||
reqSig[i]['indicatorData'][j] = data[k:k+window]
|
||||
|
||||
sigAns = self.getSignalsAns(reqSig)
|
||||
rightAns = self.getRightAns(data[target][k], data[target][k+1])
|
||||
|
||||
ans['signalsAns'].append(sigAns)
|
||||
ans['rightAns'].append(rightAns)
|
||||
|
||||
return ans
|
||||
|
||||
|
||||
def generateMatrixProbabilityFromDict(self, dictSignals: dict) -> dict:
|
||||
self.TV.createMatrixAmounts(dictSignals['signalsAns'][0].keys())
|
||||
for i in range(len(dictSignals['signalsAns'])):
|
||||
self.TV.setDecisionBySignals(signalDecisions = dictSignals['signalsAns'][i],
|
||||
trande = dictSignals['rightAns'][i])
|
||||
self.TV.generateMatrixProbability()
|
||||
|
||||
def createDump(self,postfix='') -> str:
|
||||
dataDict = {
|
||||
'RM':self.RM,
|
||||
'DM':self.DM,
|
||||
'TV':self.TV,
|
||||
'SA':self.SA,
|
||||
'sigDict':self.sigDict
|
||||
}
|
||||
fileName='data_'+postfix+'.pickle'
|
||||
with open(fileName, 'wb') as f:
|
||||
pickle.dump(dataDict, f)
|
||||
|
||||
return os.path.abspath(fileName)
|
||||
|
||||
def loadDump(self,path: str) -> None:
|
||||
|
||||
with open(path, 'rb') as f:
|
||||
dataDict = pickle.load(f)
|
||||
|
||||
self.RM = dataDict['RM']
|
||||
self.DM = dataDict['DM']
|
||||
self.TV = dataDict['TV']
|
||||
self.SA = dataDict['SA']
|
||||
self.sigDict = dataDict['sigDict']
|
||||
@@ -2,8 +2,8 @@ import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
|
||||
import market_trade.core.CoreTraidMath as CoreTraidMath
|
||||
import market_trade.core.CoreDraw as CoreDraw
|
||||
import CoreTraidMath
|
||||
import CoreDraw
|
||||
|
||||
class coreIndicator():
|
||||
def __init__(self,
|
||||
|
||||
89
market_trade/core/indicators_v2.py
Normal file
89
market_trade/core/indicators_v2.py
Normal file
@@ -0,0 +1,89 @@
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
|
||||
import CoreTraidMath
|
||||
|
||||
class coreIndicator():
|
||||
|
||||
def __init__(self,options: dict, dataType: str = None, predictType: str = None, name: str = None):
|
||||
self.options = options
|
||||
self.dataType = dataType #ochl
|
||||
self.predictType = predictType #trend
|
||||
|
||||
|
||||
def getAns(self, data: pd.DataFrame() ):
|
||||
return "ERROR"
|
||||
|
||||
class indicatorsAgrigator:
|
||||
"""
|
||||
indicators = {
|
||||
'ind_BB':{
|
||||
'className':ind_BB,
|
||||
'params':{'MeanType':'SMA','window':15,'valueType':'close','kDev':2.5}
|
||||
}
|
||||
}
|
||||
dataDic={
|
||||
'ind_BB':df_candle[:1000]
|
||||
}
|
||||
|
||||
|
||||
"""
|
||||
|
||||
def __init__ (self,indDict={}):
|
||||
self.indDict = indDict
|
||||
self.indInst = {}
|
||||
self.ans={}
|
||||
self.createIndicatorsInstance()
|
||||
|
||||
def createIndicatorsInstance(self):
|
||||
for i in self.indDict.keys():
|
||||
self.indInst[i]=self.indDict[i]['className'](self.indDict[i]['params'])
|
||||
|
||||
def getAns(self,dataDict={}):
|
||||
ans={}
|
||||
for i in dataDict.keys():
|
||||
ans[i] = self.indInst[i].getAns(dataDict[i])
|
||||
return ans
|
||||
|
||||
class ind_BB(coreIndicator):
|
||||
"""
|
||||
options
|
||||
MeanType -> SMA
|
||||
window -> int
|
||||
valueType -> str: low, high, open, close
|
||||
kDev -> float
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self,options: dict,name = None):
|
||||
super().__init__(
|
||||
options = options,
|
||||
dataType = 'ochl',
|
||||
predictType = 'trend',
|
||||
name = name
|
||||
)
|
||||
|
||||
def getAns(self, data: pd.DataFrame()):
|
||||
data=data.reset_index(drop=True)
|
||||
ans={}
|
||||
opMA={'dataType':'ohcl',
|
||||
'action':'findMean',
|
||||
'actionOptions':{
|
||||
'MeanType':self.options['MeanType'],
|
||||
'valueType':self.options['valueType'],
|
||||
'window':self.options['window']
|
||||
}
|
||||
}
|
||||
ans['BB']=CoreTraidMath.CoreMath(data,opMA).ans
|
||||
opSTD={'dataType':'ohcl',
|
||||
'action':'findSTD',
|
||||
'actionOptions':{'valueType':self.options['valueType'],'window':self.options['window']}
|
||||
}
|
||||
ans['STD']=CoreTraidMath.CoreMath(data,opSTD).ans
|
||||
ans['pSTD']=ans['BB']+ans['STD']*self.options['kDev']
|
||||
ans['mSTD']=ans['BB']-ans['STD']*self.options['kDev']
|
||||
ans['x']=np.array(data['date'][self.options['window']-1:].to_list())
|
||||
self.ans= ans
|
||||
return ans
|
||||
|
||||
29
market_trade/core/riskManager.py
Normal file
29
market_trade/core/riskManager.py
Normal file
@@ -0,0 +1,29 @@
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
import random
|
||||
|
||||
class riskManager:
|
||||
|
||||
def __init__(self,commision=0.04):
|
||||
self.commision = commision
|
||||
pass
|
||||
def getDecision(self,probabilityDecision, price, deals=None) -> dict:
|
||||
ans = {}
|
||||
ans['decision'] = 'none'
|
||||
if probabilityDecision['trande'] == 'up':
|
||||
ans['decision'] = 'buy'
|
||||
ans['amount'] = 1
|
||||
elif probabilityDecision['trande'] == 'none':
|
||||
ans['decision'] = 'none'
|
||||
elif probabilityDecision['trande'] == 'down':
|
||||
for i in range(deals.shape[0]):
|
||||
ans['decision'] = 'None'
|
||||
ans['deals'] = []
|
||||
row = deals.iloc[i]
|
||||
if row.startPrice < price*pow(1+self.commission,2):
|
||||
ans['decision'] = 'sell'
|
||||
ans['deals'].append(row.name)
|
||||
return ans
|
||||
|
||||
|
||||
@@ -2,12 +2,11 @@ import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
|
||||
import market_trade.core.CoreTraidMath as CoreTraidMath
|
||||
import market_trade.core.CoreDraw as CoreDraw
|
||||
import CoreTraidMath
|
||||
import CoreDraw
|
||||
from tqdm import tqdm
|
||||
|
||||
from market_trade.core.indicators import *
|
||||
|
||||
from indicators import *
|
||||
|
||||
class coreSignalTrande():
|
||||
def __init__(self,
|
||||
@@ -17,140 +16,133 @@ class coreSignalTrande():
|
||||
batchSize=None,
|
||||
indParams=None,
|
||||
signalParams=None,
|
||||
# needFig=False,
|
||||
# showOnlyIndex=False,
|
||||
# drawFig=False,
|
||||
# equalityGap=0
|
||||
):
|
||||
|
||||
self.data = data.reset_index(drop=True)
|
||||
self.onlineData = data.reset_index(drop=True)
|
||||
self.dataType = dataType
|
||||
self.mode = mode
|
||||
self.ans = None
|
||||
self.softAnalizList = np.asarray([])
|
||||
self.hardAnalizList = np.asarray([])
|
||||
self.analizMetrics = {}
|
||||
self.indParams = indParams
|
||||
self.signalParams = signalParams
|
||||
self.batchSize = batchSize
|
||||
# self.needFig=needFig
|
||||
# self.showOnlyIndex=showOnlyIndex
|
||||
# self.drawFig=drawFig
|
||||
# self.equalityGap=equalityGap
|
||||
|
||||
# Роутер получения ответа
|
||||
def getAns(self, data):
|
||||
# ans='Error: unknown Mode!'
|
||||
ans = None
|
||||
#needFig=False,
|
||||
#showOnlyIndex=False,
|
||||
#drawFig=False,
|
||||
#equalityGap=0
|
||||
):
|
||||
|
||||
self.data=data.reset_index(drop=True)
|
||||
self.onlineData=data.reset_index(drop=True)
|
||||
self.dataType=dataType
|
||||
self.mode=mode
|
||||
self.ans=None
|
||||
self.softAnalizList=np.asarray([])
|
||||
self.hardAnalizList=np.asarray([])
|
||||
self.analizMetrics={}
|
||||
self.indParams=indParams
|
||||
self.signalParams=signalParams
|
||||
self.batchSize=batchSize
|
||||
#self.needFig=needFig
|
||||
#self.showOnlyIndex=showOnlyIndex
|
||||
#self.drawFig=drawFig
|
||||
#self.equalityGap=equalityGap
|
||||
#Роутер получения ответа
|
||||
def getAns(self,data):
|
||||
#ans='Error: unknown Mode!'
|
||||
ans=None
|
||||
print("Start processing...")
|
||||
if self.mode == 'online':
|
||||
ans = self.getOnlineAns(data.reset_index(drop=True))
|
||||
ans=self.getOnlineAns(data.reset_index(drop=True))
|
||||
elif self.mode == 'retro':
|
||||
ans = self.getRetroAns(data)
|
||||
ans=self.getRetroAns(data)
|
||||
elif self.mode == 'retroFast':
|
||||
ans = self.getRetroFastAns(data)
|
||||
ans=self.getRetroFastAns(data)
|
||||
print("Processing DONE!")
|
||||
return ans
|
||||
|
||||
# Ретро режим, где расширяется окно добавлением новых элементов
|
||||
def getRetroAns(self, data):
|
||||
ans = np.asarray([])
|
||||
for i in tqdm(range(self.batchSize, len(data) - 1)):
|
||||
# self.onlineData=self.data[0:i]
|
||||
#Ретро режим, где расширяется окно добавлением новых элементов
|
||||
def getRetroAns(self,data):
|
||||
ans=np.asarray([])
|
||||
for i in tqdm(range(self.batchSize,len(data)-1)):
|
||||
#self.onlineData=self.data[0:i]
|
||||
window_data = data[0:i]
|
||||
window_data.reset_index(drop=True)
|
||||
ans = np.append(ans, (self.getOnlineAns(window_data)))
|
||||
self.ans = ans
|
||||
ans=np.append(ans,(self.getOnlineAns(window_data)))
|
||||
self.ans=ans
|
||||
self.getAnaliz()
|
||||
self.getMetrix()
|
||||
return ans
|
||||
|
||||
# Ретро режим, где двигается окно
|
||||
def getRetroFastAns(self, data):
|
||||
# print('d - ',data)
|
||||
ans = np.asarray([])
|
||||
for i in tqdm(range(len(data) - 1 - self.batchSize)):
|
||||
# self.onlineData=self.data[i:i+self.batchSize]
|
||||
window_data = data[i:i + self.batchSize]
|
||||
# print('win - ',window_data)
|
||||
#Ретро режим, где двигается окно
|
||||
def getRetroFastAns(self,data):
|
||||
#print('d - ',data)
|
||||
ans=np.asarray([])
|
||||
for i in tqdm(range(len(data)-1-self.batchSize)):
|
||||
#self.onlineData=self.data[i:i+self.batchSize]
|
||||
window_data = data[i:i+self.batchSize]
|
||||
#print('win - ',window_data)
|
||||
window_data.reset_index(drop=True)
|
||||
# print('win - ',window_data)
|
||||
ans = np.append(ans, (self.getOnlineAns(window_data)))
|
||||
self.ans = ans
|
||||
#print('win - ',window_data)
|
||||
ans=np.append(ans,(self.getOnlineAns(window_data)))
|
||||
self.ans=ans
|
||||
self.getAnaliz()
|
||||
self.getMetrix()
|
||||
return ans
|
||||
|
||||
# Метод, который будет переопределять каждый дочерний класс
|
||||
#Метод, который будет переопределять каждый дочерний класс
|
||||
def getOnlineAns(self):
|
||||
return 'Error'
|
||||
|
||||
def getAnaliz(self):
|
||||
print("Start analiz...")
|
||||
for i in (range(len(self.ans))):
|
||||
sourceValue = self.data[self.signalParams['source']][i + self.batchSize]
|
||||
targetValue = self.data[self.signalParams['target']][i + self.batchSize + 1]
|
||||
if (targetValue) > sourceValue:
|
||||
if self.ans[i] == 1:
|
||||
self.softAnalizList = np.append(self.softAnalizList, 1)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, 1)
|
||||
elif self.ans[i] == -1:
|
||||
self.softAnalizList = np.append(self.softAnalizList, -1)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, -1)
|
||||
sourceValue=self.data[self.signalParams['source']][i+self.batchSize]
|
||||
targetValue=self.data[self.signalParams['target']][i+self.batchSize + 1]
|
||||
if (targetValue)>sourceValue:
|
||||
if self.ans[i]==1:
|
||||
self.softAnalizList=np.append(self.softAnalizList,1)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,1)
|
||||
elif self.ans[i]==-1:
|
||||
self.softAnalizList=np.append(self.softAnalizList,-1)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,-1)
|
||||
else:
|
||||
self.softAnalizList = np.append(self.softAnalizList, 0)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, -1)
|
||||
|
||||
elif (targetValue) < sourceValue:
|
||||
if self.ans[i] == 1:
|
||||
self.softAnalizList = np.append(self.softAnalizList, -1)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, -1)
|
||||
elif self.ans[i] == -1:
|
||||
self.softAnalizList = np.append(self.softAnalizList, 1)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, 1)
|
||||
self.softAnalizList=np.append(self.softAnalizList,0)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,-1)
|
||||
|
||||
elif (targetValue)<sourceValue:
|
||||
if self.ans[i]==1:
|
||||
self.softAnalizList=np.append(self.softAnalizList,-1)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,-1)
|
||||
elif self.ans[i]==-1:
|
||||
self.softAnalizList=np.append(self.softAnalizList,1)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,1)
|
||||
else:
|
||||
self.softAnalizList = np.append(self.softAnalizList, 0)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, -1)
|
||||
self.softAnalizList=np.append(self.softAnalizList,0)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,-1)
|
||||
else:
|
||||
if self.ans[i] == 1:
|
||||
self.softAnalizList = np.append(self.softAnalizList, -1)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, -1)
|
||||
elif self.ans[i] == -1:
|
||||
self.softAnalizList = np.append(self.softAnalizList, -1)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, -1)
|
||||
if self.ans[i]==1:
|
||||
self.softAnalizList=np.append(self.softAnalizList,-1)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,-1)
|
||||
elif self.ans[i]==-1:
|
||||
self.softAnalizList=np.append(self.softAnalizList,-1)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,-1)
|
||||
else:
|
||||
self.softAnalizList = np.append(self.softAnalizList, 0)
|
||||
self.hardAnalizList = np.append(self.hardAnalizList, 1)
|
||||
self.softAnalizList=np.append(self.softAnalizList,0)
|
||||
self.hardAnalizList=np.append(self.hardAnalizList,1)
|
||||
print("Analiz DONE!")
|
||||
return 0
|
||||
|
||||
def getMeteixDict(self, d):
|
||||
def getMeteixDict(self,d):
|
||||
'''
|
||||
1 - (сбывшиеся + несбывшиеся) \ (сбывшиеся + несбывшиеся +0)
|
||||
2 - (сбывшиеся - несбывшиеся) \ (сбывшиеся + несбывшиеся +0)
|
||||
'''
|
||||
return {
|
||||
|
||||
'1': (d['1'] + d['-1']) / (d['1'] + d['-1'] + d['0']),
|
||||
'2': (d['1'] - d['-1']) / (d['1'] + d['-1'] + d['0']),
|
||||
|
||||
|
||||
'1':(d['1'] + d['-1']) / (d['1'] + d['-1'] + d['0']),
|
||||
'2':(d['1'] - d['-1']) / (d['1'] + d['-1'] + d['0']),
|
||||
|
||||
}
|
||||
|
||||
|
||||
def getMetrix(self):
|
||||
|
||||
softAnalizCount = {'-1': 0, '0': 0, '1': 0}
|
||||
hardAnalizCount = {'-1': 0, '0': 0, '1': 0}
|
||||
softAnalizCount = {'-1':0,'0':0,'1':0}
|
||||
hardAnalizCount = {'-1':0,'0':0,'1':0}
|
||||
for i in range(len(self.softAnalizList)):
|
||||
softAnalizCount[str(int(self.softAnalizList[i]))] += 1
|
||||
hardAnalizCount[str(int(self.hardAnalizList[i]))] += 1
|
||||
self.analizMetrics = {'softAnaliz': self.getMeteixDict(softAnalizCount),
|
||||
'hardAnaliz': self.getMeteixDict(hardAnalizCount)
|
||||
}
|
||||
|
||||
softAnalizCount[str(int(self.softAnalizList[i]))]+=1
|
||||
hardAnalizCount[str(int(self.hardAnalizList[i]))]+=1
|
||||
self.analizMetrics = {'softAnaliz':self.getMeteixDict(softAnalizCount),
|
||||
'hardAnaliz':self.getMeteixDict(hardAnalizCount)
|
||||
}
|
||||
|
||||
class signal_BB(coreSignalTrande):
|
||||
|
||||
|
||||
def __init__(self,
|
||||
data=pd.DataFrame(),
|
||||
dataType='candel',
|
||||
@@ -158,37 +150,101 @@ class signal_BB(coreSignalTrande):
|
||||
batchSize=None,
|
||||
indParams=None,
|
||||
signalParams=None,
|
||||
):
|
||||
):
|
||||
super().__init__(
|
||||
data=data,
|
||||
dataType=dataType,
|
||||
mode=mode,
|
||||
batchSize=batchSize,
|
||||
indParams=indParams,
|
||||
signalParams=signalParams,
|
||||
)
|
||||
|
||||
data=data,
|
||||
dataType=dataType,
|
||||
mode=mode,
|
||||
batchSize=batchSize,
|
||||
indParams=indParams,
|
||||
signalParams=signalParams,
|
||||
)
|
||||
|
||||
if self.indParams == None:
|
||||
indParams = {'MeanType': 'SMA', 'window': 15, 'valueType': 'low', 'kDev': 2}
|
||||
indParams={'MeanType':'SMA','window':15,'valueType':'low','kDev':2}
|
||||
else:
|
||||
indParams = self.indParams
|
||||
self.BB = ind_BB(
|
||||
indParams=self.indParams
|
||||
self.BB=ind_BB(
|
||||
data=data,
|
||||
options=indParams,
|
||||
)
|
||||
|
||||
def getOnlineAns(self, data):
|
||||
ans = 0
|
||||
# print(data)
|
||||
|
||||
|
||||
def getOnlineAns(self,data):
|
||||
ans=0
|
||||
#print(data)
|
||||
|
||||
self.BB.getAns(data)
|
||||
# print(BB)
|
||||
lastValue = data[self.signalParams['source']].to_list()[-1]
|
||||
if lastValue > self.BB.ans['pSTD'][-1]:
|
||||
ans = -1
|
||||
elif lastValue < self.BB.ans['mSTD'][-1]:
|
||||
ans = +1
|
||||
#print(BB)
|
||||
lastValue=data[self.signalParams['source']].to_list()[-1]
|
||||
if lastValue>self.BB.ans['pSTD'][-1]:
|
||||
ans=-1
|
||||
elif lastValue<self.BB.ans['mSTD'][-1]:
|
||||
ans=+1
|
||||
else:
|
||||
ans = 0
|
||||
|
||||
ans=0
|
||||
|
||||
return ans
|
||||
|
||||
class signalAgrigator:
|
||||
"""
|
||||
dictAgrigSignal
|
||||
key - name str
|
||||
value - dict
|
||||
className - class
|
||||
indParams - dict
|
||||
signalParams - dict
|
||||
batchSize - int
|
||||
|
||||
|
||||
"""
|
||||
def __init__(self,
|
||||
data=pd.DataFrame(),
|
||||
dictAgrigSignal={},
|
||||
mode='online',
|
||||
dataType='candel',
|
||||
batchSize=None
|
||||
):
|
||||
self.createSingnalInstances(
|
||||
data,
|
||||
dictAgrigSignal,
|
||||
dataType,
|
||||
batchSize
|
||||
)
|
||||
self.mode=mode
|
||||
|
||||
|
||||
|
||||
def createSingnalInstances(
|
||||
self,
|
||||
data,
|
||||
dictAgrigSignal,
|
||||
dataType,
|
||||
batchSize
|
||||
):
|
||||
|
||||
ans={}
|
||||
|
||||
for i in dictAgrigSignal:
|
||||
ans[i]=dictAgrigSignal[i]['className'](
|
||||
data=data,
|
||||
dataType=dataType,
|
||||
batchSize=batchSize,
|
||||
indParams=dictAgrigSignal[i]['indParams'],
|
||||
signalParams=dictAgrigSignal[i]['signalParams'],
|
||||
mode=self.mode
|
||||
)
|
||||
self.signalsInstances = ans
|
||||
return ans
|
||||
|
||||
def getAns(self, data):
|
||||
ans={}
|
||||
|
||||
if self.mode == 'online':
|
||||
for i in self.signalsInstances:
|
||||
ans[i]=(self.signalsInstances[i].getAns(data))
|
||||
elif self.mode == 'retroFast' or self.mode == 'retro':
|
||||
for i in self.signalsInstances:
|
||||
self.signalsInstances[i].getAns(data)
|
||||
ans[i]=self.signalsInstances[i].analizMetrics
|
||||
return ans
|
||||
112
market_trade/core/signals_v2.py
Normal file
112
market_trade/core/signals_v2.py
Normal file
@@ -0,0 +1,112 @@
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
|
||||
import CoreTraidMath
|
||||
#import CoreDraw
|
||||
from tqdm import tqdm
|
||||
|
||||
from indicators_v2 import *
|
||||
|
||||
|
||||
|
||||
class coreSignalTrande:
|
||||
|
||||
def __init__(self, name: str, req: dict, dataType: str):
|
||||
self.name = name
|
||||
self.agrigateInds = self.createIndicatorsInstance(req)
|
||||
self.params = req['params']
|
||||
self.dataType = dataType
|
||||
|
||||
|
||||
def createIndicatorsInstance(self,req: dict) -> dict:
|
||||
return indicatorsAgrigator(req['indicators'])
|
||||
|
||||
def getIndAns(self, dataDict: dict) -> dict:
|
||||
return self.agrigateInds.getAns(dataDict)
|
||||
|
||||
def getAns(self, data: pd.DataFrame(), indDataDict: dict) -> dict:
|
||||
return self.getSigAns(data, self.getIndAns(indDataDict))
|
||||
|
||||
|
||||
|
||||
class sig_BB(coreSignalTrande):
|
||||
"""
|
||||
ind keys:
|
||||
ind_BB
|
||||
"""
|
||||
|
||||
def __init__(self, name: str, req:dict):
|
||||
super().__init__(name, req, 'ochl')
|
||||
|
||||
def getSigAns(self, data: pd.DataFrame(), indAnsDict: dict) -> dict:
|
||||
|
||||
lastValue = data[self.params['source']].to_list()[-1]
|
||||
if lastValue>indAnsDict['ind_BB']['pSTD'][-1]:
|
||||
ans='down'
|
||||
elif lastValue<indAnsDict['ind_BB']['mSTD'][-1]:
|
||||
ans='up'
|
||||
else:
|
||||
ans='none'
|
||||
|
||||
return ans
|
||||
|
||||
|
||||
class signalsAgrigator:
|
||||
|
||||
"""
|
||||
sigAgrReq = {
|
||||
'sig_BB':{
|
||||
'className':sig_BB,
|
||||
'params':{'source':'close','target':'close'},
|
||||
'indicators':{
|
||||
'ind_BB':{
|
||||
'className':ind_BB,
|
||||
'params':{'MeanType':'SMA','window':15,'valueType':'close','kDev':2.5}
|
||||
}
|
||||
}
|
||||
},
|
||||
'sig_BB_2':{
|
||||
'className':sig_BB,
|
||||
'params':{'source':'close','target':'close'},
|
||||
'indicators':{
|
||||
'ind_BB':{
|
||||
'className':ind_BB,
|
||||
'params':{'MeanType':'SMA','window':30,'valueType':'close','kDev':2}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sigAgrData = {
|
||||
'sig_BB':{
|
||||
'signalData': df_candle[990:1000],
|
||||
'indicatorData' :{'ind_BB': df_candle[:1000]}
|
||||
},
|
||||
'sig_BB_2':{
|
||||
'signalData': df_candle[990:1000],
|
||||
'indicatorData' :{'ind_BB': df_candle[:1000]}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
"""
|
||||
|
||||
def __init__ (self,req:dict):
|
||||
self.signals = self.createSignalsInstance(req)
|
||||
|
||||
def createSignalsInstance(self, siganlsDict: dict) -> dict:
|
||||
ans = {}
|
||||
for i in siganlsDict.keys():
|
||||
ans[i]=siganlsDict[i]['className'](name = i, req = siganlsDict[i])
|
||||
return ans
|
||||
|
||||
def getAns(self, dataDict: dict) -> dict:
|
||||
ans = {}
|
||||
for i in dataDict.keys():
|
||||
ans[i] = self.signals[i].getAns(data = dataDict[i]['signalData'],
|
||||
indDataDict = dataDict[i]['indicatorData'])
|
||||
return ans
|
||||
83
market_trade/core/trandeVoter.py
Normal file
83
market_trade/core/trandeVoter.py
Normal file
@@ -0,0 +1,83 @@
|
||||
import pandas as pd
|
||||
import datetime
|
||||
import numpy as np
|
||||
#import random
|
||||
|
||||
class trandeVoter():
|
||||
|
||||
def __init__(self,name):
|
||||
|
||||
self.name = name # просто имя
|
||||
self.trandeValuesList = ['up','none','down'] #словарь трегдов
|
||||
self.matrixAmounts = None # матрица сумм
|
||||
self.keysMatrixAmounts = None #ключи матрицы сумм, техническое поле
|
||||
self.matrixProbability = None # матрица вероятностей
|
||||
|
||||
|
||||
#функция которая создает df с заданным набором колонок и индексов. индексы - уникальные соотношения
|
||||
def createDFbyNames(self, namesIndex, namesColoms,defaultValue=0.0):
|
||||
df = pd.DataFrame(dict.fromkeys(namesColoms, [defaultValue]*pow(3,len(namesIndex))),
|
||||
index=pd.MultiIndex.from_product([self.trandeValuesList]*len(namesIndex), names=namesIndex)
|
||||
#,columns=namesColoms
|
||||
)
|
||||
return(df)
|
||||
|
||||
#создание матрицы сумм с дефолтным значением
|
||||
def createMatrixAmounts(self,namesIndex: list) -> pd.DataFrame():
|
||||
self.matrixAmounts = self.createDFbyNames(namesIndex,self.trandeValuesList,0)
|
||||
self.keysMatrixAmounts = self.matrixAmounts.to_dict('tight')['index_names']
|
||||
self.createMatrixProbability(namesIndex)
|
||||
return(self.matrixAmounts)
|
||||
|
||||
#создание матрицы вероятностей с дефолтным значением
|
||||
def createMatrixProbability(self,namesIndex: list) -> pd.DataFrame():
|
||||
self.matrixProbability = self.createDFbyNames(namesIndex,self.trandeValuesList)
|
||||
return(self.matrixProbability)
|
||||
|
||||
#установка значений в матрицы сумм. signalDecisions - значения индикаторов key:value; trande - реальное значение
|
||||
def setDecisionBySignals(self,signalDecisions: dict,trande: str) -> None:
|
||||
buff=[]
|
||||
for i in self.keysMatrixAmounts:
|
||||
buff.append(signalDecisions[i])
|
||||
self.matrixAmounts.loc[tuple(buff),trande] += 1
|
||||
|
||||
#заполнение матрицы вероятностей вычисляемыми значениями из матрицы сумм
|
||||
def generateMatrixProbability(self) -> None:
|
||||
for i in range(self.matrixAmounts.shape[0]):
|
||||
rowSum=sum(self.matrixAmounts.iloc[i])
|
||||
self.matrixProbability.iloc[i]['up'] = (self.matrixAmounts.iloc[i]['up'] / rowSum)
|
||||
self.matrixProbability.iloc[i]['none'] = self.matrixAmounts.iloc[i]['none'] / rowSum
|
||||
self.matrixProbability.iloc[i]['down'] = self.matrixAmounts.iloc[i]['down'] / rowSum
|
||||
|
||||
#получение рещения из матрицы вероятностей по заданным значениям сигналов
|
||||
def getDecisionBySignals(self,signalDecisions: dict) -> dict:
|
||||
ans = {}
|
||||
spliceSearch =self.matrixProbability.xs(tuple(signalDecisions.values()),
|
||||
level=list(signalDecisions.keys())
|
||||
)
|
||||
ans['probability'] = spliceSearch.to_dict('records')[0]
|
||||
ans['trande'] = spliceSearch.iloc[0].idxmax()
|
||||
return ans
|
||||
|
||||
#получение матриц вероятностей и суммы в видей словарей
|
||||
def getMatrixDict(self) -> dict:
|
||||
ans={}
|
||||
ans['amounts'] = self.matrixAmounts.to_dict('tight')
|
||||
ans['probability'] = self.matrixProbability.to_dict('tight')
|
||||
return ans
|
||||
|
||||
#установка матриц вероятностей и суммы в видей словарей
|
||||
def setMatrixDict(self,matrixDict: dict) -> dict:
|
||||
if matrixDict['amounts'] != None:
|
||||
self.matrixAmounts = pd.DataFrame.from_dict(y['amounts'], orient='tight')
|
||||
if matrixDict['probability'] != None:
|
||||
self.matrixProbability = pd.DataFrame.from_dict(y['probability'], orient='tight')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user