Indice Hearst - pagina 33

Nuovo commento
 
Roman.:


Come è bello tutto questo! :-)

Questi studi possono essere allegati (integrati) ad esso o si può disegnare qualcosa di simile (autosufficiente per il filtro) per la stessa semplice connessione ad un gufo di trading come un filtro trend-flat?

Ecco il mio segnale parte del gufo di tendenza utilizzando le letture dell'indicatore iVAR .


Se gli studi teorici sono confermati, ci sarà tutta una serie di indicatori che descrivono effetti caotici e deterministici.

Il valore predittivo di iVAR sembra molto discutibile. Visivamente, non è davvero migliore di MA e soffre chiaramente di volatilità. In senso stretto, gli indicatori "caotici" non dovrebbero reagire alla volatilità, ma al processo deterministico e alle condizioni iniziali, e non sono la stessa cosa. Cioè, gli indicatori caotici dovrebbero spesso iniziare a cambiare anche prima che il prezzo cambi (prevedere il cambiamento), ma questo non è il caso di iVAR.

p.s. Meglio usare l'indicatore di efficienza frattale polarizzato. Mostra momenti molto più interessanti (imho).

 
C-4:


Se gli studi teorici saranno confermati, ci sarà tutta una serie di indicatori che descrivono effetti caotici e deterministici.

Il valore predittivo di iVAR sembra molto discutibile. Visivamente, non è davvero meglio di MA e soffre chiaramente di volatilità. In senso stretto, gli indicatori "caotici" non dovrebbero reagire alla volatilità, ma al processo deterministico e alle condizioni iniziali, che non sono la stessa cosa. Cioè, gli indicatori caotici dovrebbero spesso iniziare a cambiare anche prima che il prezzo cambi (prevedere il cambiamento), ma questo non è il caso di iVAR.

p.s. Meglio usare l'indicatore di efficienza frattale polarizzato. Mostra momenti molto più interessanti (imho).


Grazie,C4.

Ci darò un'occhiata più da vicino, me ne occuperò...

 

Buon pomeriggio!

Attualmente sto imparando l'analisi R/S e sto scrivendo un programma in C# che la implementa. Ho alcune domande. Spero che tu possa aiutarmi

1.Nel suo libro, Peters trasforma la serie temporale originale

a) la differenza tra il prezzo del primo giorno e il prezzo del secondo giorno è usata come Yt?

b) quali dovrebbero essere le costanti a e b?

2. e ancora dal libro:

Qui diciamo una serie di 500 valori, specifico n iniziale come 20, come faccio poi ad aumentare il numero n?

Grazie in anticipo, spero nel vostro aiuto.

 

b) Apparentemente si intende il secondo libro di Peters e si tratta di eliminare gli effetti AR della serie. La soluzione migliore in questo caso sarebbe trovare i coefficienti analiticamente per ogni serie individualmente. Tuttavia, non ho mai usato tali trasformazioni, quindi non posso dire esattamente come questi coefficienti dovrebbero essere trovati. Ma non date grande importanza a queste trasformazioni, perché il loro significato è quello di eliminare la sovrastima estremamente insignificante della stima RS su serie come l'arco (potrei sbagliarmi, ricordo molto vagamente). Meglio iniziare a lavorare con le passeggiate casuali normalmente distribuite (bloccarsi con questo metodo già in questa fase).

a) Meglio usare rendimenti logaritmici piuttosto che differenze di serie: ln(Pi/Pi-1).

2) N di Peters aumenta di uno ad ogni esecuzione: n++. Il numero di corse indipendenti deve essere almeno 2. Cioè, se avete una serie di 500 valori, divideteli per 2, e avrete N che varia da 20 a 250 rispettivamente. Quando n coprirà la serie con un resto, per esempio n = 33, 250 / 33 = 7,5757575, prendere il numero di barre per cui n sarà un divisore intero, per esempio per n = 33 il numero di barre sarà 231. Poi calcola prima rs per il segmento 1-231, poi per il segmento 20-250. La media aritmetica di entrambe le barre sarà l'RS desiderato.

P.S. Fondamentalmente posso inviarvi il mio codice in C#. Lì tutte queste conversioni sono già fatte, ma il codice stesso è inutile, perché le statistiche di Peters non mostrano alcuna regolarità, e i risultati presentati nel suo libro sono pura profanazione (vedi pagine 24-26 del thread attuale).

 

Mi dispiace, ma non capisco bene il punto 2)... se non ti dispiace inviare il codice....

P.S. Ho guardato i risultati... non voglio disturbarti... ma comunque... perché l'uso di questo algoritmo non è accettabile per voi?

 
Ho aumentato n di uno (n++)... ma si è scoperto che con n = 46, e 47 il numero di periodi è lo stesso... e c'era una specie di grafico a scaglioni...
 
kexs1k:

Mi dispiace, ma non capisco bene il punto 2)... se non ti dispiace inviare il codice....

1) P.S. Ho guardato i risultati... non voglio disturbarti... ma comunque... perché l'uso di questo algoritmo non è accettabile per voi?


kexs1k:
2) Ho aumentato n di uno (n++)... ma si è scoperto che a n = 46, e 47 il numero di periodi è lo stesso... e risulta una specie di grafico a gradini...


1) Per me usare questo algoritmo non è accettabile, perché NON FUNZIONA!

2) È difficile spiegare tutte le complessità, meglio vedere il codice, è piccolo, lo sto dando proprio qui:

#pragma warning disable 1587
///<summary>
/// <para>
/// Класс WealthLab.Strategies.Herst реализует методы R/S статистики, такие как таблица R/S оценки к периоду R/S расчета
/// в двойном логарифмическом масштабе, U-статистика, V-статистика, Коэффициент Херста (H) и т.д.</para>
/// <para>
/// Используется  два вида расчета: 1. по скользящему окну; 2. по разбиению всех доступных данных на независимые подпериоды
/// длинной N (задается пользователем).
/// </para>
/// <para>
/// При втором методе для использования всех доступных данных в случае, если 
/// имеется остаток (количество наблюдений не делится на размерность периода N без остатка)расчет производится
/// дважды. Первый раз рассчитываются значения для данных таким образом, что неиспользованные данные (остаток)
/// остаются в самом конце, на втором проходе неиспользованные данные (остаток) остаются в самом начале. Т.е.
/// используется метод скользящего окна, с шагом равным величене остатка. Таким образом и при первом и при втором
/// методе рассчета используются все доступные для наблюдения данные.
/// </para>
/// </>
///</summary>
#pragma warning restore 1587
using System;
using System.Collections.Generic;
using System.Linq;
using WealthLab.Indicators;

namespace WealthLab.MyIndicators
{
    /// <summary>
    /// Задает тип рассчета статистики Херста
    /// <param name="NotDependentSubperiods"> Не зависимые подпериоды</param>
    /// <param name="SlidingWindow"> Скользящее окно</param>
    /// </summary>
    public enum HerstCalculation
    {
        NotDependentSubperiods,
        SlidingWindow,
        Modern
    } ;
    public class EmptyStrategy : WealthScript
    {
        protected override void Execute()
        {
            PrintDebug("Run Empty Strategy...");
        }
    }


    public abstract class MyIndicators
    {
        protected WealthScript ws_strategy;
        protected bool InitEnable = false;
        public MyIndicators() : this (null){}
        /// <summary>
        /// Основной конструктор требует текущего окружения WealtLab через класс WealthLab.WealthLabScript
        /// </summary>
        /// <param name="wl_script">Класс типа WealthLab.WealthLabScript содержащий все необходимые данные</param>
        public MyIndicators(WealthScript wl_script)
        {
            if(wl_script == null) return;
            ws_strategy = wl_script;
        }
    }

    public class Herst : MyIndicators
    {
        //Хранит ценовой (аккумулятивный) ряд доходностей
        private List<double> series = new List<double>();
        /// <summary>
        /// Инициализиурет класс Herst текущем окружением WealthScript 
        /// </summary>
        /// <param name="ws"> Текущий класс WealthScript</param>
        
        public Herst() : this(new EmptyStrategy()){}
        public Herst(WealthScript ws) : base(ws) {}
        #region RSAnalysis
        /// <summary>
        /// Возвращает пролагорифмированное по основанию 10 отношение R/S для периода N.
        /// </summary>
        /// <param name="N"> Период расчета R/S</param>
        /// <param name="CalcType"> Тип рассчета</param>
        /// <returns>
        /// Значение RS
        /// </returns>
        /*public static DataSeries operator + (DataSeries ds1, DataSeries ds2){}*/
        public double RS(ref DataSeries data, int N, HerstCalculation CalcType)
        {
            if (N > data.Count) return -1.0;
            switch (CalcType)
            {
                case HerstCalculation.NotDependentSubperiods:
                    return RSAnalysisInLogScaleSubperiods(ref data, N);
                //case HerstCalculation.Modern(N):
                //    return RSAnalysisInLogModern(N);
                default:
                    return RSAnalysisInLogScaleSubperiods(ref data, N);
            }
        }
        
        private double RSAnalysisInLogScaleSubperiods(ref DataSeries series, int N)
        {
            //находим количество не используемых наблюдений для выбранного периода.
            int NotUsingM = series.Count - (int)(Math.Floor((double)series.Count/N))*N;
            //Создаем конвертер данных
            //Для простоты рассчетов конвертируем DataSeries в List<double>
            List<double> first = Convert.DataSeriesToList(ref series);
            //if(NotUsingM != 0){}

            List<double> second = Convert.DataSeriesToList(ref series);
            //1. Удаляем неиспользуемые наблюдения с начала списка
            first.RemoveRange(0, NotUsingM);
            //2. Затем удаляем неиспользуемые наблюдения с конца списка (0 - первый элемент)
            second.RemoveRange(second.Count - NotUsingM, NotUsingM);
            //3. Разбиваем ряд на k равных групп, и для каждой из них подсчитываем R/S размах к периоду затем
            //   находим их среднее значение.
            //Для простоты рассчета индикатора снова конвертируем списки в DataSeries
            DataSeries firstDS = Convert.ListToDataSeries(ref first);
            DataSeries secondDS = Convert.ListToDataSeries(ref second);
            double avrg_r1 = CountR(ref firstDS, N);
            double avrg_r2 = CountR(ref secondDS, N);
            double R = (avrg_r1 + avrg_r2)/2;
            return R;
        }
        private double CountR(ref DataSeries series, int N)
        {
            //DataSeries R = new DataSeries("R");
            double R = 0.0;
            int count = 0;
            for (int i = 0; i < series.Count; i++)
            {
                if ((i + 1) % N == 0)
                {
                    count++;
                    int first_element = i + 1 - N;
                    //находим среднее значение или математическое ожидание периода:
                    double sma = Indicators.SMA.Value(i, series, N);
                    //находим стандартное отклонение
                    double std_dev = Indicators.StdDev.Value(i, series, N, StdDevCalculation.Sample);
                    double acum = 0.0;
                    DataSeries acum_series = new DataSeries("Acum Series");
                    double min = double.MaxValue, max = double.MinValue;
                    for (int k = first_element; k <= i; k++)
                    {
                        acum += series[k] - sma;
                        acum_series.Add(acum, DateTime.Now);
                        if (acum < min) min = acum;
                        if (acum > max) max = acum;
                    }
                    if (std_dev == 0.0) return 0.0;
                    R += Math.Log10((max - min)/std_dev);
                }
            }
            R /= count;
            return R;
        }

        public double RSS(DataSeries series, int bar, int N)
        {
            if(bar < N) return 0.0;
            int first_element = bar + 1 - N;
            //находим среднее значение или математическое ожидание периода:
            double sma = Indicators.SMA.Value(bar, series, N);
            //находим стандартное отклонение
            double std_dev = Indicators.StdDev.Value(bar, series, N, StdDevCalculation.Sample);
            double acum = 0.0;
            DataSeries acum_series = new DataSeries("Acum Series");
            double min = double.MaxValue, max = double.MinValue;
            for (int k = first_element; k <= bar; k++)
            {
                acum += series[k] - sma;
                acum_series.Add(acum, DateTime.Now);
                if (acum < min) min = acum;
                if (acum > max) max = acum;
            }
            if (std_dev == 0.0) return 0.0;
            double RS = Math.Log10((max - min) / std_dev);
            return RS;
        }

        public double CountH(double RS, int Period)
        {
            double n = RS / (Math.Log10(Period));
            return n;
        }
        #endregion
    }
}
Non potete eseguirlo direttamente, perché è progettato per lavorare insieme a WealthLab. Sto allegando le librerie appropriate. Con un po' di persistenza, è possibile capire i metodi di chiamata.
File:
wld5lib.zip  268 kb
 

Come promesso, pubblico un interessante studio:

Davanti a voi c'è uno studio di due segmenti temporali dell'indice RTS. Il primo segmento (linea verde) testa dal 2006 al 2009, il secondo dal 2009 al 2012. Potete vedere che l'RTS è cambiato fondamentalmente dal 2008. La prima cosa che salta all'occhio è che l'RTS è diventato molto più efficiente: la sua curva è diventata molto più vicina alla casualità. Il grado di entropia e di incertezza è aumentato. Tuttavia, il grado di massima entropia, che è pura passeggiata casuale, non è ancora stato raggiunto. Ma bisogna capire che in questa fase l'algoritmo tende a sovrastimare le sue letture sulle distribuzioni di Pareto e in realtà la componente deterministica nel moderno RTS è ancora più piccola.

L'orizzonte temporale da 3 a 30 minuti è di interesse (il periodo è 10^N min, dove N è tracciato sull'asse delle ascisse nell'intervallo da 0,5 (10^0,5 = 3 min) a 3,5 (10^3,5 = 3162 min, o 52 ore o 3,7 giorni)). Si noti che c'è una componente anti-trend altamente insignificante ma statisticamente distinguibile in questo intervallo. È probabile che sia ancora più grande nella realtà, dato che abbiamo stime gonfiate sulle distribuzioni di Pareto. Non esisteva prima del 2009. Il mercato è stato estremamente trendy su tutti gli orizzonti temporali disponibili per l'analisi. Che cos'è questo? Forse stiamo vedendo gli effetti degli algoritmi HFT che non erano così diffusi prima della crisi del 2008. Non per niente gli scalper su RTS dicono da tempo che è quasi impossibile operare - i robot non permettono il trading delle solite formazioni.

Possiamo supporre che i risultati così diversi dei due segmenti siano causati dal dimezzamento del campione statistico. Ma la quantità totale di dati è grande e ammonta a circa 1 000 000 di barre di minuti dal 2006 al 2012 che dà 500 000 punti di dati per ogni intervallo. Per i piccoli periodi si tratta di decine di migliaia di sottoperiodi, il che significa che la riduzione della significatività statistica è estremamente piccola e non può dare una tale diffusione dei risultati (come è evidente dalla piattezza delle curve). Tuttavia, c'è un'altra variante: dal 2006 al 2009, il mercato RTS era più Pareto e con la coda, ora il mercato è più liquido e più vicino alla distribuzione normale. Questa è una forte controargomentazione, ed è il motivo per cui ora sto lavorando duramente sulla stima della volatilità per smussare gli effetti di tali distribuzioni e contrastare efficacemente l'ondulazione casuale di tipo Pareto.

 
C-4:


Questo riguarda più il metodo stesso. Se il vostro metodo dà 0,5 su Norm. Casuale esattamente 0,5 e 0,47-0,48 sulle valute - significa che dovremmo capire seriamente la vostra metodologia. Teoricamente i mercati non dovrebbero dividersi in trendy e anti-trendy. A Peters tutti i mercati studiati avevano H superiore a 0,5.

Hai provato a mescolare casualmente i dati delle serie? In teoria dovrebbe distruggere le correlazioni e portare le stime di H al massimo a 0,5 (si tratta di verificare la correttezza del metodo di calcolo).

Per quanto riguarda l'anti-ricompensa - dopo tutto la maggior parte delle major valutarie, per quanto mi ricordo, hanno AC di ritorni vicini inferiori a 0, e se assumiamo che la serie è un moto browniano generalizzato, allora C ~ 2^(H-1) - 1, cioè H deve essere inferiore a 0,5...

 

Che casino maledetto!!! È solo un'assurdità!

In questo momento sto lavorando per mescolare i dati. Questo è quello che ho fatto all'inizio: ho mischiato tutte le barre RTS, ho fatto un test su quelle mischiate, e mi sono ritrovato con RS che sbandava ancora di più! Ma non può essere così. Se RS mostra solo il fatto che la distribuzione non è normale, allora la stima non dovrebbe cambiare: dopo tutto, statisticamente entrambe le distribuzioni sono identiche. Se la RS cattura correlazioni complesse, allora queste dovrebbero essere rotte dal mescolamento dei dati, e la RS non dovrebbe essere distinguibile dal random walk. Invece la terza opzione cade ostinatamente. Forse è la completa incomparabilità dimensionale delle barre RTS in diversi periodi. Le volatilità del 2006 sono troppo diverse dagli ultimi anni. Di conseguenza, le grandi barre del 2006 che si insinuano nella gamma moderata degli ultimi anni fanno sembrare i valori anomali ancora più grandi. Il mio algoritmo è scritto in modo tale che dovrebbe gestire efficacemente tali outlier, ma apparentemente qualcosa sta sfondando le difese.

Ok, in base a quanto segue, presentiamo lo scenario più negativo: l'algoritmo cattura solo il fatto che la distribuzione non è normale. Non c'è una componente deterministica nella serie del mercato. Verifichiamo il seguente modo: se l'aumento del prezzo è più probabile che sia seguito da un aumento (e viceversa, se la caduta è seguita da una caduta), allora il grafico sarà più piatto, non importa come lo giri. Il numero di inversioni per un periodo di N barre sarà inferiore e quindi anche il numero di linee a zag sarà inferiore. Descriviamo la dipendenza come segue: dividiamo il numero di barre per il numero di linee a zig-zag e otteniamo il numero medio di barre per linea ZZ. La distanza coperta non è importante, quindi il tipo di distribuzione non dovrebbe giocare un ruolo. Disegniamo un grafico simile in doppia scala logaritmica. Prendiamo l'ultima storia EURUSD di 1 milione di barre come strumento di prova e la testiamo. Poi generiamo una passeggiata casuale sugli stessi volumi EURUSD. Non sarà distribuito normalmente. Ora confronta due grafici, se sono identici, significa che l'algoritmo cattura solo la distribuzione non normale e non è di alcuna utilità. Quindi, diamo un'occhiata:

Whoa, whoa. Le nostre peggiori paure si sono avverate. Entrambi i grafici sono identici. Entrambi sono distribuiti a Pareto e indistinguibili da una passeggiata casuale, ma uno è un vero mercato e l'altro un semplice generatore basato su volumi reali.

Un controllo finale: ancora una volta prendiamo queste due serie e calcoliamo la distanza per loro. Se l'indicatore reagisce solo alla non normalità della distribuzione, lo swing del valore casuale normale dovrebbe mostrare rigorosamente 0,5, lo swing dell'eurusd reale sarà superiore a 0,5 (perché la distribuzione non è normale), lo swing della distribuzione casuale generata sarà quasi indistinguibile dall'eurusd reale come visto nel grafico sopra. Prova e guarda:

Porca puttana!!! Hai visto? L'EURUSD casuale è solo un po' più alto della normale rampa casuale. La sua pendenza è quasi uguale a 0,5. Il valore casuale è rimasto invariato come previsto. Ma EURUSD ha seriamente sottovalutato(!) il suo range! Allo stesso tempo, l'indice Hurst di eurusd è fino a 0,53, cioè la valuta è in tendenza, ma vediamo solo l'inizio della sua tendenza. Il suo trend prende forza solo dopo 70 giorni(!), e prima di questo è un mercato fortemente pullback. Questo significa che l'EURUSD ha un orizzonte gigantesco, noi vediamo solo l'inizio del prologo.

Apparentemente è la non normalità della distribuzione che nasconde tutti gli effetti deterministici. Tuttavia, l'anomalia principale non è tanto nella strana volatilità, ma negli stessi incrementi di prezzo (barre). È un meccanismo molto complesso e profondo e non c'è modo di lavorarci a caso.

s.s. anche se forse sono tutte conclusioni sbagliate a causa di dati e metodi sbagliati. hh.

1...262728293031323334353637383940...46
Nuovo commento