Contact for feedback / inquiries.


H3 AI, codenamed & packaged as hydra is a proprietary machine learning model that uses genetic algorithms and statistical price momenta to discover high risk portfolios:

Whereas current deep learning techniques attempt to classify or regress individual assets, requiring significant computational resources, unique datasets, and significant human intervention to assist in portfolio construction; Hydra attempts to generate a successful asset portfolio out of random combinations of assets, using the least resources possible and only price over time.

Hydra relies instead on the notion of emergent intelligence, and is an attempt to build something more “adversarial” for the crypto-economic and / or logarithmic era of finance; a machine evolved portfolio selection engine designed to hunt for alpha across any time scale or asset class with a price.

Other features include:

  • Simple: Python 3.7 with 3 core dependencies (numPy, Pandas & Parmap)
  • Functional: Lazily loadable, impure functions with explicit side effects, typing, and NumPy optimizations for Cython / C performance where available
  • Parallelized: Thread-pooled *map implementation with unary flags for multithreaded, parallel map reduce
  • Parametrized: Tunable, tractable Hyperparameters including asset count, risk tolerance & sample size
  • Async: Daemon logic for naive server-client setups on cloud / local machines; coordinating via PubSub and cron triggers for automated prediction across geographies or server providers
  • Adversarial: Core strategy chosen for an academic history of strong competitiveness with standard industry techniques (Mean-Variance models), before modifications to generate 10x-100x more samples than any reference variant
  • Lean: Ingests only historical price time series, arbitrarily analyzing properties with randomized hyperparameter tuning
  • Cheap: CPU scalable by updating probabilistic single-dimension Dirichlet vectors via arithmetic instead of transforming multi-dimensional tensors via Hessian matrices (and GPUs)
  • Minimal: Additional memoized data structures via nested dictionaries & global dataframes to reuse memory where possible
  • Dropout: Information deletion mechanics to prevent overfitting while encouraging chaos
  • Natural Selection: Population sampling alongside crossover to select upper bound genomes only
  • Random Search: Randomized lower level parameters to explore price space in a nonlinear way
  • Novelty Search: Genetic algorithms that propagate parts of both the best and most diverse strategies


A Hydra is recursively composed of two parts: A meta AI (Hydra) that selects from random genetic evolutions of a candidate AI (Head), currently tuned to perform some single dimensional / probabilistic prediction.

The head we have implemented at H3 is a financial investment AI, building upon a multi-agent, cooperative solution tailored to the offline cardinality constrained portfolio selection problem, and generally solving it by transforming a chaotic position using statistical momenta descriptors and genetics to transform it into an informed one, using only price over time.

$hydra -m predict

                     .^.      _._     .^`````*^.
                   #`   *##**`   `*##`   .#*#.  `#
                  #   .#``      .#*`    #     #   `#.
                 #    `         `    .#`     #`      #.
                #                   `*...-*``          `#.
               #                                       '#
             .#                                        #
           .#`                                        #
         .#`                                        ##
      .##`                                      .##`'
     ##                                ...`##'``
     #                            .##*``
     #.                         .`
     `λλ:λ`*..              .#`
      `λλλ    ``--...   .#``
       `λλ          `λλ:λ
          `          `λλλ

  v1.3.2                                                      2021-06-24 20:05:54
  2015-01-02 <> 2020-11-27 nasdaq                               1624579554.5897632
  © 2020, 11759574 Inc.

|hydra| predicting using 1 threads
|hydra| Exploring [(1217, 1486)] (1) slice
|hydra| selecting 5 by eating 1486 rows x 465 assets including [INFN, TER, LI, ...]
|hydra| maximum exposure 66%, taking 99 best past μ+(1.96)σ return in last 13 periods
|hydra| bmFzZGFxXzEuMy4yXzIwMjEtMDYtMjRfMjAwNTU0

  0%|                                                            | 0/1 [00:00<?, ?it/s]

We then reduce these Heads into an average position for that point of time, creating the final Hydra and finding the portfolio recommended for a given date; theoretically any arbitrary date, but typically the end of historical prices, or today. We believe this process to be O(nlog(n) \* n^2) -> O(n^3) because we are mapping a memorized random search n times over an n x n vector of prices over time, then reducing.


The paper below was written prior to the completion of the runtime, and includes references to:

It is provided here as a novelty, and is in no way a reflection on the authors or sources used.