Índice Hearst - página 33

Novo comentário
 
Roman.:


Como tudo fica legal! :-)

Estes estudos podem ser anexados (complementados) ou algo semelhante (auto-suficiente para o filtro) pode ser desenhado para a mesma conexão simples a uma coruja comercial como um filtro de tendência?

Aqui está minha parte de sinal da coruja de tendência usando leituras de indicadores iVAR .


Se os estudos teóricos forem confirmados, haverá toda uma série de indicadores descrevendo efeitos caóticos e determinísticos.

O valor preditivo do iVAR parece muito questionável. Visualmente, não é realmente melhor do que MA e sofre claramente de volatilidade. A rigor, os indicadores "caóticos" não devem reagir à volatilidade, mas ao processo determinístico e às condições iniciais, e não são os mesmos. Ou seja, os indicadores caóticos devem muitas vezes começar a mudar mesmo antes das mudanças de preço (prever a mudança), mas este não é o caso com o iVAR.

p.s. Melhor usar o indicador de eficiência fractal polarizada. Mostra momentos muito mais interessantes (imho).

 
C-4:


Se os estudos teóricos forem confirmados, haverá toda uma série de indicadores descrevendo efeitos caóticos e determinísticos.

O valor preditivo do iVAR parece ser altamente questionável. Visualmente, não é realmente melhor do que MA e sofre claramente de volatilidade. A rigor, os indicadores "caóticos" não devem reagir à volatilidade, mas ao processo determinístico e às condições iniciais, que não são a mesma coisa. Ou seja, os indicadores caóticos devem muitas vezes começar a mudar mesmo antes das mudanças de preço (prever a mudança), mas este não é o caso com o iVAR.

p.s. Melhor usar o indicador de eficiência fractal polarizada. Mostra momentos muito mais interessantes (imho).


Obrigado,C-4 .

Vou daruma olhada mais de perto, vou tratar disso ...

 

Boa tarde!

Atualmente estou aprendendo análise R/S e estou escrevendo um programa em C# que o implementa. Tenho algumas perguntas. Espero que você possa me ajudar

1. em seu livro, Peters transforma a série cronológica original

a) é a diferença entre o preço do primeiro dia e o preço do segundo dia utilizado como Yt?

b) quais devem ser as constantes a, e b?

2. e novamente do livro:

Digamos aqui uma série de 500 valores, especifico um n inicial como 20, como aumentar então o número n???

Obrigado de antemão, espero sua ajuda.

 

b) Aparentemente, o segundo livro de Peters se destina a eliminar os efeitos AR da série. A melhor solução neste caso seria encontrar os coeficientes de forma analítica para cada série individualmente. Entretanto, eu nunca usei tais transformações, portanto não posso dizer exatamente como esses coeficientes devem ser encontrados. Mas não dê muita importância a essas transformações, pois seu significado é eliminar a superestimação extremamente insignificante da estimativa de RS em séries como arco (posso estar errado, lembro-me muito vagamente). É melhor começar trabalhando com caminhadas aleatórias normalmente distribuídas (ficar preso a este método já nesta fase).

a) Utilizar melhor os retornos logarítmicos do que as diferenças em série: ln(Pi/Pi-1).

2) Peters' N aumenta em um em cada corrida: n+++. O número de execuções independentes deve ser de pelo menos 2, ou seja, se você tiver uma série de 500 valores, divida-os por 2, e você terá N variando de 20 a 250, respectivamente. Quando n cobrirá a série com um restante, por exemplo, n = 33, 250 / 33 = 7,575757575, pegue o número de barras para as quais n será um divisor inteiro, por exemplo, para n = 33 o número de barras será 231. Em seguida, primeiro calcular rs para o segmento 1-231, depois para o segmento 20-250. A média aritmética para ambas as barras será a RS desejada.

P.S. Basicamente, posso enviar-lhe meu código em C#. Lá todas estas transformações já estão feitas, mas o próprio código é inútil, porque as estatísticas de Peters não mostram nenhuma regularidade, e os resultados apresentados em seu livro são pura profanação (ver páginas 24-26 do tópico atual).

 

Sinto muito, mas não entendo bem o ponto 2)... se você não se importa de enviar código....

P.S. Eu estava olhando para os resultados... não quero incomodar você... mas ainda assim... por que o uso deste algoritmo não é aceitável para você?

 
Aumentei n em um (n++)... mas verificou-se que com n = 46, e 47 o número de períodos é o mesmo. e havia algum tipo de gráfico escalonado...
 
kexs1k:

Sinto muito, mas não entendo bem o ponto 2)... se você não se importa de enviar código....

1) P.S. Analisei os resultados... não quero incomodar você... mas ainda assim... por que o uso deste algoritmo não é aceitável para você?


kexs1k:
2) Aumentei n em um (n++)... mas verificou-se que com n = 46, e 47 o número de períodos é o mesmo. e acontece algum tipo de gráfico escalonado...


1) Para mim o uso deste algoritmo não é aceitável, porque NÃO funciona!

2) É difícil explicar todas as complexidades, é melhor ver o código, é pequeno, estou dando aqui mesmo:

#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
    }
}
Você não pode executá-lo diretamente, pois foi projetado para trabalhar em conjunto com o WealthLab. Estou anexando bibliotecas apropriadas. Com alguma persistência, é possível compreender os métodos de chamada.
Arquivos anexados:
wld5lib.zip  268 kb
 

Como prometido, estou publicando um estudo interessante:

Antes de você está um estudo de dois segmentos de tempo do Índice RTS. O primeiro segmento (linha verde) testa de 2006 a 2009, o segundo de 2009 a 2012. Você pode ver que a RTS mudou fundamentalmente desde 2008. A primeira coisa que chama sua atenção é que a RTS se tornou muito mais eficiente: sua curva se tornou muito mais próxima do aleatório. O grau de entropia e incerteza tem aumentado. No entanto, o grau de entropia máximo, que é pura caminhada aleatória, ainda não foi alcançado. Mas deve ser entendido que no estágio atual o algoritmo tende a superestimar suas leituras sobre as distribuições de Pareto e na realidade o componente determinístico na RTS moderna é ainda menor.

O horizonte de tempo de 3 a 30 minutos é de interesse (o período é de 10^N min, onde N é plotado no eixo de abcissas na faixa de 0,5 (10^0,5 = 3 min) a 3,5 (10^3,5 = 3162 min, ou 52 horas ou 3,7 dias)). Note que há um componente antitendência altamente insignificante, mas estatisticamente distinguível, nesta faixa. É provável que seja ainda maior na realidade, pois temos estimativas inflacionadas sobre as distribuições de Pareto. Ela não existia antes de 2009. O mercado estava extremamente na moda em todos os horizontes de tempo disponíveis para análise. O que é isto? Talvez estejamos vendo os efeitos dos algoritmos HFT que não eram tão amplamente representados antes da crise de 2008. Não é por nada que os escalpadores na RTS vêm dizendo há muito tempo que é quase impossível operar - os robôs não permitem a comercialização das formações usuais.

Podemos supor que resultados tão diferentes dos dois segmentos são causados pela redução pela metade da amostra estatística. Mas a quantidade total de dados é grande e totaliza cerca de 1 000 000 de barras de minutos de 2006 a 2012, o que dá 500 000 pontos de dados para cada intervalo. Para períodos pequenos, isto é dezenas de milhares de subperíodos, o que significa que a redução da significância estatística é extremamente pequena e não pode dar tal difusão de resultados (o que é evidente a partir da planicidade das curvas). Entretanto, há mais uma variante: de 2006 a 2009, o mercado de RTS foi mais Pareto e mais seguido, agora o mercado é mais líquido e mais próximo da distribuição normal. Este é um forte contra-argumento, e é por isso que agora estou trabalhando duro na estimativa da volatilidade para suavizar os efeitos de tais distribuições e contrariar efetivamente a agitação aleatória do tipo Pareto.

 
C-4:


Isto é mais sobre o método em si. Se seu método der 0,5 na Norma. Aleatório exatamente 0,5 e 0,47-0,48 em moedas - isso significa que devemos entender seriamente sua metodologia. Teoricamente, os mercados não devem se dividir em trendy e antitrendy. Em Peters todos os mercados estudados tinham H acima de 0,5.

Você já tentou misturar aleatoriamente os dados da série? Em teoria, deveria destruir correlações e levar as estimativas de H ao máximo para 0,5 (é uma questão de verificar a exatidão do método de cálculo).

Em relação ao anti-recompensativo - afinal a maioria dos majores da moeda, tanto quanto me lembro, tem AC de retorno vizinho inferior a 0, e se assumirmos que a série é um movimento Browniano generalizado, então C ~ 2^(H-1) - 1, ou seja, H deve ser inferior a 0,5...

 

Que bagunça!!! É um absurdo!

Neste momento estou trabalhando para misturar os dados. Foi o que fiz no início: baralhei todas as barras RTS, fiz um teste nas baralhadas, acabei com o enviesamento RS ainda mais! Mas não pode ser assim. Se o RS mostra apenas o fato de que a distribuição não é normal, então a estimativa não deve mudar: afinal de contas, estatisticamente ambas as distribuições são idênticas. Se o RS captura correlações complexas, então elas devem ser quebradas pela mistura de dados, e o RS não deve ser distinguível do passeio aleatório. Em vez disso, a terceira opção cai teimosamente. Talvez seja a completa incomparabilidade dimensional das barras RTS em períodos diferentes. As volatilidades de 2006 são muito diferentes das dos últimos anos. Como resultado, as grandes barras de 2006 que se arrastam para a gama moderada dos últimos anos fazem com que as aberturas pareçam ser ainda maiores. Meu algoritmo está escrito de tal forma que deveria lidar efetivamente com tais aberrações, mas aparentemente algo está rompendo as defesas.

Ok, com base no seguinte, vamos apresentar o cenário mais negativo: o algoritmo só captura o fato de que a distribuição é não-normal. Não há nenhum componente determinístico na série de mercado. Vamos verificar da seguinte maneira: se o aumento de preço é mais provável que seja seguido de aumento (e vice-versa, se a queda é seguida de queda), então o gráfico será mais plano, não importa como você o vire. O número de reversões para o período de N barras será menor e, portanto, o número de linhas zag-zag também será menor. Descrevemos a dependência da seguinte forma: dividimos o número de barras pelo número de linhas em zig-zag e obtemos o número médio de barras por linha ZZ. A distância percorrida não é importante, portanto, o tipo de distribuição não deve desempenhar um papel. Elaboramos um gráfico semelhante em dupla escala logarítmica. Tomamos o último histórico EURUSD de 1 milhão de barras como ferramenta de teste e a testamos. Então vamos gerar uma caminhada aleatória nos mesmos volumes de EURUSD. Normalmente não será distribuído. Agora compare dois gráficos, se forem idênticos, isso significa que o algoritmo só captura distribuição não-normal e não tem utilidade. Então, vamos dar uma olhada:

Uau, uau. Nossos piores medos se tornaram realidade. Ambos os gráficos são idênticos. Ambos são Pareto distribuídos e indistinguíveis de uma caminhada aleatória, mas um é um verdadeiro mercado e o outro um simples gerador baseado em volumes reais.

Uma verificação final: novamente pegamos estas duas séries e calculamos a distância para elas. Se o indicador reagir apenas à não-normalidade da distribuição, a oscilação do valor aleatório normal deve mostrar estritamente 0,5, a oscilação do eurusd real estará acima de 0,5 (porque a distribuição não é normal), a oscilação da distribuição aleatória gerada será quase indistinguível do eurusd real como visto no gráfico acima. Teste e assista:

Puta merda!!! Você viu isso!? O EURUSD aleatório é apenas um pouco mais alto do que a rampa aleatória normal. Seu declive é quase igual a 0,5. O valor aleatório permaneceu inalterado, como esperado. Mas EURUSD tem subestimado seriamente(!) seu alcance! Ao mesmo tempo, o índice Hurst de eurusd chega a 0,53, ou seja, a moeda está em tendência, mas vemos apenas o início de sua tendência. Sua tendência só ganha força após 70 dias(!), e antes disso é um mercado fortemente puxado para trás. Isto significa que o EURUSD tem um horizonte gigantesco, vemos apenas o início do prólogo.

Aparentemente, é a não normalidade da distribuição que esconde todos os efeitos determinísticos. Entretanto, a principal anormalidade não está tanto na estranha volatilidade, mas nos próprios incrementos de preços (barras). É um mecanismo muito complexo e profundo e não há como trabalhar com ele de forma aleatória.

s.s. embora talvez seja tudo conclusões erradas por causa de dados e métodos errados. hh.

1...262728293031323334353637383940...46
Novo comentário
Razão: