Пример #1
0
    def sse_theo_event(self, para):
        """ Returns the Sum Squared Error """

        from Event import Event

        evnt = Event(self.data)
        evnt.e4_mean_rev1 = para[0]
        evnt.e4_resp1 = para[1]
        evnt.e4_mean_rev2 = para[2]
        evnt.e4_resp2 = para[3]
        evnt.e4_mean_rev3 = para[4]
        evnt.e4_resp3 = para[5]
        evnt.e4_mean_rev4 = para[6]
        evnt.e4_resp4 = para[7]
        evnt.e4_spread = False
        evnt.e4_voladj = False

        evnt.event_type = 'e4'
        evnt.decay_type = 'exp'

        error = 0.0
        for i in range(int(len(self.data.events))):
            if self.data.events[i] == 'E':
                est = self.cmpt_theo_event(i, evnt)
                error += (self.data.prices[i] - est)**2
        if self.verbose:
            print(
                str(error) + ' ' + str(para[0]) + ' ' + str(para[1]) + ' ' +
                str(para[2]) + ' ' + str(para[3]) + ' ' + str(para[4]) + ' ' +
                str(para[5]) + ' ' + str(para[6]) + ' ' + str(para[7]))

        return error
Пример #2
0
    def pred_theo_LT(self):

        from statistics import mean
        from Compute import Compute
        from Event import Event

        printfile = 'Predicted/pred_LT.txt'

        out = open(printfile, 'w')

        cmpt = Compute(self.data)
        evnt = Event(self.data)

        # Which decay function and which event type
        evnt.event_type = 'evntLT'
        evnt.decay_type = 'LastTrade'

        sqerr = []
        for i in range(len(self.data.events) - 2):
            if self.data.events[i] == 'E':
                pred = cmpt.cmpt_theo_event(i, evnt)
                out.write(
                    str(self.data.tgates[i]) + ' ' + str(pred) + ' ' +
                    str(self.data.prices[i]) + ' ' + str(self.data.bid_1s[i]) +
                    ' ' + str(self.data.ask_1s[i]) + '\n')
                sqerr.append(abs(pred - self.data.prices[i]))

        print('MAE LT ' + str(mean(sqerr)))
Пример #3
0
    def pred_theo_eOmniPresent(self, fCol):

        from statistics import mean
        from Compute import Compute
        from Event import Event
        import re

        summary = open('Parameters/fit_' + str(fCol) + '_eOmniPresent.txt',
                       'r')
        out = open('Predicted/pred_' + str(fCol) + '_eOmniPresent.txt', 'w')

        cmpt = Compute(self.data)
        evnt = Event(self.data)

        para = []
        for line in summary:
            if re.search('Parameters', line):
                temp = re.findall('Parameters\s\[\s?(.*)\]', line)[0].split()
                for t in temp:  # IF ERROR HERE: Check parameters file for newline commands
                    para.append(float(t))

        # Set estimation specific paramters
        evnt.paraD = para[0]
        evnt.paraImp = para[1:]
        # evnt.lots_traded_trigger = para[-1]

        evnt.event_type = 'eOmniPresent'
        evnt.decay_type = 'LongMemory'
        evnt.fCol = fCol

        sqerr = []
        for i in range(len(self.data.events)):
            if self.data.events[i] == 'E':
                pred = cmpt.cmpt_theo_event(i, evnt)
                out.write(
                    str(self.data.tgates[i]) + ' ' + str(pred) + ' ' +
                    str(self.data.prices[i]) + ' ' + str(self.data.bid_1s[i]) +
                    ' ' + str(self.data.ask_1s[i]) + ' \n')
                sqerr.append(abs(pred - self.data.prices[i]))

        print('MAE eOmniPresent ' + str(fCol) + ' ' + str(mean(sqerr)))
Пример #4
0
    def sse_theo_eZero(self, para):
        """ Returns the Sum Squared Error """

        from Event import Event
        evnt = Event(self.data)
        evnt.event_type = 'eZero'
        evnt.decay_type = 'LongMemory'
        evnt.fCol = self.fCol

        #  Set estimation specific paramters
        evnt.paraD = para[0:int(len(para) / 2)]
        evnt.paraImp = para[int(len(para) / 2):]

        error = 0.0
        for i in range(int(len(self.data.events))):
            if self.data.events[i] == 'E':
                est = self.cmpt_theo_event(i, evnt)
                error += (self.data.prices[i] - est)**2
        if self.verbose:
            print(str(error) + ' ' + str(evnt.paraD) + ' ' + str(evnt.paraImp))

        return error
Пример #5
0
    def sse_theo_eCEP(self, para):
        """ Returns the Sum Squared Error """

        from Event import Event
        evnt = Event(self.data)
        evnt.event_type = 'eOmniPresent'
        evnt.decay_type = 'LongMemory'
        evnt.fCol = self.fCol

        #  Set estimation specific paramters
        evnt.paraD = para[0]
        evnt.paraImp = para[1:]
        # evnt.lots_traded_trigger = round(para[-1])

        error = 0.0
        for i in range(int(len(self.data.events))):
            if self.data.events[i] == 'E':
                est = self.cmpt_theo_event(i, evnt)
                error += (self.data.prices[i] - est)**2
        if self.verbose:
            print(str(error) + ' ' + str(evnt.paraD) + ' ' + str(evnt.paraImp))

        return error
Пример #6
0
    def sse_theo_LT(self, para):
        """ Returns the Sum Squared Error """

        from Event import Event

        evnt = Event(self.data)
        evnt.e2_mean_rev1 = para[0]
        evnt.e2_resp1 = para[1]
        evnt.e2_mean_rev2 = para[2]
        evnt.e2_resp2 = para[3]
        evnt.event_type = 'evntLT'
        evnt.decay_type = 'LastTrade'

        error = 0.0
        for i in range(int(len(self.data.events))):
            if self.data.events[i] == 'E':
                est = self.cmpt_theo_event(i, evnt)
                error += (self.data.prices[i] - est)**2
        if self.verbose:
            print('SSE Const ' + str(error) + ' ' + str(para[0]) + ' ' +
                  str(para[1]) + ' ' + str(para[2]) + ' ' + str(para[3]))

        return error