Analyse quantitative du marché des monnaies numériques

Analyse quantitative du marché des monnaies numériques

Une approche basée sur les données pour l'analyse spéculative des monnaies numériques

Qu'en est-il du prix du Bitcoin? Quelles sont les raisons de l'augmentation et de la diminution du prix de la monnaie numérique? Les prix du marché des différents Altcoins sont-ils inextricablement liés ou largement indépendants? Comment pouvons-nous prédire ce qui va se passer ensuite?

Des centaines d'experts autoproclamés préconisent la tendance qu'ils attendent. Ce qui manque à beaucoup de ces analyses, c'est une base solide pour les données de base et les modèles statistiques.

L'objectif de cet article est de fournir une brève introduction à l'analyse de la monnaie numérique à l'aide de Python. Nous utiliserons un script Python simple pour récupérer, analyser et visualiser les données de différentes monnaies numériques. Dans ce processus, nous trouverons des tendances intéressantes dans le comportement du marché de ces fluctuations et leur développement.

Il ne s'agit pas d'un article expliquant la monnaie numérique, ni d'une opinion sur les monnaies spécifiques qui augmenteront et diminueront.

Étape 1: Configurer notre environnement de travail sur les données

Ce tutoriel est destiné aux passionnés, ingénieurs et scientifiques des données à tous les niveaux de compétence. Que vous soyez un leader de l'industrie ou un novice en programmation, la seule compétence dont vous avez besoin est une compréhension de base du langage de programmation Python et une connaissance suffisante des opérations de ligne de commande (être en mesure de configurer un projet de science des données est suffisant).

1.1 Installez le docker FMZ Quant et installez Anaconda

• Système Docker de la plateforme FMZ Quant La plateforme FMZ QuantFMZ.COMIl fournit non seulement des sources de données de haute qualité pour les principaux échanges traditionnels, mais fournit également un ensemble d'interfaces API riches pour nous aider à effectuer des transactions automatiques après avoir terminé l'analyse des données. Cet ensemble d'interfaces comprend des outils pratiques, tels que la requête d'informations de compte, la requête de prix élevé, ouvert, bas, reçu, volume de négociation et divers indicateurs d'analyse technique couramment utilisés de divers échanges traditionnels. En particulier, il fournit un fort support technique pour les interfaces API publiques reliant les principaux échanges traditionnels dans le processus de négociation réel.

Toutes les fonctionnalités mentionnées ci-dessus sont encapsulées dans un système de type Docker. Ce que nous devons faire est d'acheter ou de louer nos propres services de cloud computing et de déployer le système Docker.

Dans le nom officiel de la plateforme FMZ Quant, ce système Docker est appelé le système Docker.

Veuillez consulter mon précédent article sur le déploiement d'un docker et d'un robot:https://www.fmz.com/bbs-topic/9864.

Les lecteurs qui veulent acheter leur propre serveur de cloud computing pour déployer des dockers peuvent se référer à cet article:https://www.fmz.com/digest-topic/5711.

Après avoir déployé avec succès le serveur de cloud computing et le système docker, nous allons ensuite installer le plus grand artefact actuel de Python: Anaconda.

Afin de réaliser tous les environnements de programme pertinents (bibliothèques de dépendances, gestion de version, etc.) requis dans cet article, le moyen le plus simple est d'utiliser Anaconda.

Puisque nous installons Anaconda sur le service cloud, nous recommandons que le serveur cloud installe le système Linux plus la version en ligne de commande d'Anaconda.

Pour la méthode d'installation d'Anaconda, veuillez consulter le guide officiel d'Anaconda:https://www.anaconda.com/distribution/.

Si vous êtes un programmeur Python expérimenté et si vous pensez que vous n'avez pas besoin d'utiliser Anaconda, ce n'est pas un problème du tout. Je suppose que vous n'avez pas besoin d'aide pour installer l'environnement dépendant nécessaire. Vous pouvez sauter cette section directement.

1.2 Créer un environnement de projet d'analyse de données pour Anaconda

Une fois Anaconda installé, nous devons créer un nouvel environnement pour gérer nos paquets dépendants.

conda create --name cryptocurrency-analysis python=3

pour créer un nouvel environnement Anaconda pour notre projet.

Suivant, entrée:

source activate cryptocurrency-analysis (linux/MacOS operating system)
or
activate cryptocurrency-analysis (windows operating system)

pour activer l'environnement.

Suivant, entrée:

conda install numpy pandas nb_conda jupyter plotly

d'installer les différents paquets dépendants requis pour ce projet.

Remarque: Pourquoi utiliser l'environnement Anaconda? Si vous prévoyez d'exécuter de nombreux projets Python sur votre ordinateur, il est utile de séparer les paquets dépendants (bibliothèques logicielles et paquets) de différents projets pour éviter les conflits.

1.3 Créez un carnet Jupyter

Après l'installation de l'environnement et des paquets dépendants, exécutez:

jupyter notebook

pour démarrer le noyau iPython, puis visitezhttp://localhost:8888/avec votre navigateur, créez un nouveau bloc-notes Python, en vous assurant qu'il utilise:

Python [conda env:cryptocurrency-analysis]

le noyau

1.4 Forfaits dépendants des importations

Créez un bloc-notes Jupyter vide, et la première chose que nous devons faire est d'importer les paquets dépendants requis.

import os
import numpy as np
import pandas as pd
import pickle
from datetime import datetime

Nous devons aussi importer Plotly et activer le mode hors ligne:

import plotly.offline as py
import plotly.graph_objs as go
import plotly.figure_factory as ff
py.init_notebook_mode(connected=True)

Étape 2: obtenir les informations sur le prix de la monnaie numérique

La préparation est terminée, et maintenant nous pouvons commencer à obtenir les données à analyser.

Pour l'utilisation de ces deux fonctions, veuillez consulter:https://www.fmz.com/api.

2.1 Écrire une fonction de collecte de données Quandl

Pour faciliter l'acquisition de données, nous devons écrire une fonction pour télécharger et synchroniser les données de Quandl (quandl.comIl s'agit d'une interface de données financières gratuite, qui jouit d'une grande réputation à l'étranger. La plate-forme FMZ Quant fournit également une interface de données similaire, qui est principalement utilisée pour les transactions de robots réels.

Pendant la transaction réelle du bot, vous pouvez appeler les fonctions GetTicker et GetRecords en Python directement pour obtenir des données de prix.https://www.fmz.com/api.

def get_quandl_data(quandl_id):
    # Download and cache data columns from Quandl
    cache_path = '{}.pkl'.format(quandl_id).replace('/','-')
    try:
        f = open(cache_path, 'rb')
        df = pickle.load(f)   
        print('Loaded {} from cache'.format(quandl_id))
    except (OSError, IOError) as e:
        print('Downloading {} from Quandl'.format(quandl_id))
        df = quandl.get(quandl_id, returns="pandas")
        df.to_pickle(cache_path)
        print('Cached {} at {}'.format(quandl_id, cache_path))
    return df

Ici, la bibliothèque de cornichons est utilisée pour sérialiser les données et enregistrer les données téléchargées sous forme de fichier, de sorte que le programme ne télécharge pas les mêmes données à chaque fois qu'il s'exécute. Cette fonction renverra les données au format Pandas Dataframe. Si vous n'êtes pas familier avec le concept de cadre de données, vous pouvez l'imaginer comme un puissant Excel.

2.2 Accès aux données sur les prix des monnaies numériques de l'échange Kraken

Prenons l'échange Kraken Bitcoin comme exemple, en commençant par obtenir son prix Bitcoin.

# Get prices on the Kraken Bitcoin exchange
btc_usd_price_kraken = get_quandl_data('BCHARTS/KRAKENUSD')

Utilisez la méthode head ((() pour afficher les cinq premières lignes de la zone de données.

btc_usd_price_kraken.head()

Le résultat est le suivant:

Ensuite, nous allons faire un tableau simple afin de vérifier la justesse des données par visualisation.

# Make a table of BTC prices
btc_trace = go.Scatter(x=btc_usd_price_kraken.index, y=btc_usd_price_kraken['Weighted Price'])
py.iplot([btc_trace])

Ici, nous utilisons Plotly pour compléter la partie de visualisation. Par rapport à l'utilisation de bibliothèques de visualisation de données Python plus matures, telles que Matplotlib, Plotly est un choix moins courant, mais c'est vraiment un bon choix, car il peut appeler des graphiques entièrement interactifs D3.js. Ces graphiques ont de beaux paramètres par défaut, faciles à explorer et très faciles à intégrer dans la page Web.

Conseils: le graphique généré peut être comparé au graphique des prix Bitcoin des échanges traditionnels (comme le graphique sur OKX, Binance ou Huobi) comme un contrôle rapide de l'intégrité pour confirmer si les données téléchargées sont généralement cohérentes.

2.3 Obtenir des données sur les prix des principaux échanges Bitcoin

Les lecteurs attentifs ont peut-être remarqué qu'il manque des données dans les données ci-dessus, en particulier à la fin de 2014 et au début de 2016.

La caractéristique de l'échange de monnaie numérique est que la relation d'offre et de demande détermine le prix de la monnaie. Par conséquent, aucun prix de transaction ne peut devenir le "prix courant" du marché. Afin de résoudre le problème et le problème de perte de données mentionné (éventuellement en raison de pannes de courant techniques et d'erreurs de données), nous téléchargerons des données de trois échanges Bitcoin traditionnels dans le monde, puis calculerons le prix moyen du Bitcoin.

Commençons par télécharger les données de chaque échange dans le cadre de données composé de types de dictionnaire.

# Download price data from COINBASE, BITSTAMP and ITBIT
exchanges = ['COINBASE','BITSTAMP','ITBIT']

exchange_data = {}

exchange_data['KRAKEN'] = btc_usd_price_kraken

for exchange in exchanges:
    exchange_code = 'BCHARTS/{}USD'.format(exchange)
    btc_exchange_df = get_quandl_data(exchange_code)
    exchange_data[exchange] = btc_exchange_df

2.4 Intégrer toutes les données dans un cadre de données unique

Ensuite, nous allons définir une fonction spéciale pour fusionner les colonnes qui sont communes à chaque cadre de données dans un nouveau cadre de données.

def merge_dfs_on_column(dataframes, labels, col):
    '''Merge a single column of each dataframe into a new combined dataframe'''
    series_dict = {}
    for index in range(len(dataframes)):
        series_dict[labels[index]] = dataframes[index][col]
        
    return pd.DataFrame(series_dict)

Maintenant, tous les cadres de données sont intégrés en fonction de la colonne prix pondéré de chaque ensemble de données.

# Integrate all data frames
btc_usd_datasets = merge_dfs_on_column(list(exchange_data.values()), list(exchange_data.keys()), 'Weighted Price')

Enfin, nous utilisons la méthode tail () pour afficher les cinq dernières lignes des données fusionnées afin de nous assurer que les données sont correctes et complètes.

btc_usd_datasets.tail()

Les résultats sont présentés comme suit:

Du tableau ci-dessus, nous pouvons voir que ces données sont conformes à nos attentes, avec à peu près la même plage de données, mais légèrement différentes en fonction du retard ou des caractéristiques de chaque échange.

2.5 Processus de visualisation des données sur les prix

D'un point de vue de la logique d'analyse, l'étape suivante consiste à comparer ces données par visualisation. Pour ce faire, nous devons d'abord définir une fonction auxiliaire. En fournissant une commande en une seule ligne pour utiliser les données pour créer un graphique, nous l'appelons fonction df_scatter.

def df_scatter(df, title, seperate_y_axis=False, y_axis_label='', scale='linear', initial_hide=False):
    '''Generate a scatter plot of the entire dataframe'''
    label_arr = list(df)
    series_arr = list(map(lambda col: df[col], label_arr))
    
    layout = go.Layout(
        title=title,
        legend=dict(orientation="h"),
        xaxis=dict(type='date'),
        yaxis=dict(
            title=y_axis_label,
            showticklabels= not seperate_y_axis,
            type=scale
        )
    )
    
    y_axis_config = dict(
        overlaying='y',
        showticklabels=False,
        type=scale )
    
    visibility = 'visible'
    if initial_hide:
        visibility = 'legendonly'
        
    # Table tracking for each series
    trace_arr = []
    for index, series in enumerate(series_arr):
        trace = go.Scatter(
            x=series.index, 
            y=series, 
            name=label_arr[index],
            visible=visibility
        )
        
        # Add a separate axis to the series
        if seperate_y_axis:
            trace['yaxis'] = 'y{}'.format(index + 1)
            layout['yaxis{}'.format(index + 1)] = y_axis_config    
        trace_arr.append(trace)

    fig = go.Figure(data=trace_arr, layout=layout)
    py.iplot(fig)

Pour votre compréhension facile, cet article ne discutera pas trop du principe logique de cette fonction auxiliaire.

Maintenant, nous pouvons créer des graphiques de données de prix Bitcoin facilement!

# Plot all BTC transaction prices
df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange')

2.6 Données claires et agrégées sur les prix

Comme le montre le graphique ci-dessus, bien que les quatre séries de données suivent à peu près la même trajectoire, il y a encore des changements irréguliers.

Dans la période 2012-2017, nous savons que le prix du Bitcoin n'a jamais été égal à zéro, donc nous supprimons d'abord toutes les valeurs zéro dans le cadre de données.

# Clear the "0" value
btc_usd_datasets.replace(0, np.nan, inplace=True)

Après avoir reconstruit les données, nous pouvons voir un graphique plus clair sans données manquantes.

# Plot the revised data frame
df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange')

Nous pouvons maintenant calculer une nouvelle colonne: le prix moyen quotidien du Bitcoin de tous les échanges.

# Calculate the average BTC price as a new column
btc_usd_datasets['avg_btc_price_usd'] = btc_usd_datasets.mean(axis=1)

La nouvelle colonne est l'indice de prix du Bitcoin!

# Plot the average BTC price
btc_trace = go.Scatter(x=btc_usd_datasets.index, y=btc_usd_datasets['avg_btc_price_usd'])
py.iplot([btc_trace])

Plus tard, nous continuerons à utiliser ces données de séries de prix agrégées pour déterminer le taux de change entre les autres monnaies numériques et le USD.

Étape 3: Collectez le prix des Altcoins

Jusqu'à présent, nous avons les données des séries chronologiques du prix du Bitcoin. Ensuite, jetons un coup d'œil à certaines données sur les monnaies numériques non Bitcoin, c'est-à-dire les Altcoins. Bien sûr, le terme Altcoins peut être un peu hyperbole, mais en ce qui concerne le développement actuel des monnaies numériques, à l'exception des dix premières en valeur marchande (comme Bitcoin, Ethereum, EOS, USDT, etc.), la plupart d'entre elles peuvent être appelées Altcoins. Nous devrions essayer de rester à l'écart de ces monnaies lors du trading, car elles sont trop déroutantes et trompeuses.

3.1 Définir les fonctions auxiliaires à travers l'API de l'échange Poloniex

Tout d'abord, nous utilisons l'API de l'échange Poloniex pour obtenir les informations de données des transactions de devises numériques. Nous définissons deux fonctions auxiliaires pour obtenir les données liées aux Altcoins. Ces deux fonctions téléchargent et cachent principalement les données JSON via les API.

Tout d'abord, nous définissons la fonction get_json_data, qui téléchargera et cache les données JSON de l'URL donnée.

def get_json_data(json_url, cache_path):
    '''Download and cache JSON data, return as a dataframe.'''
    try:        
        f = open(cache_path, 'rb')
        df = pickle.load(f)   
        print('Loaded {} from cache'.format(json_url))
    except (OSError, IOError) as e:
        print('Downloading {}'.format(json_url))
        df = pd.read_json(json_url)
        df.to_pickle(cache_path)
        print('Cached {} at {}'.format(json_url, cache_path))
    return df

Ensuite, nous définissons une nouvelle fonction qui générera la requête HTTP de l'API Poloniex et appelons la fonction get_json_data qui vient d'être définie pour enregistrer les résultats de l'appel.

base_polo_url = 'https://poloniex.com/public?command=returnChartData&currencyPair={}&start={}&end={}&period={}'
start_date = datetime.strptime('2015-01-01', '%Y-%m-%d') # Data acquisition since 2015
end_date = datetime.now() # Until today
pediod = 86400 # pull daily data (86,400 seconds per day)

def get_crypto_data(poloniex_pair):
    '''Retrieve cryptocurrency data from poloniex'''
    json_url = base_polo_url.format(poloniex_pair, start_date.timestamp(), end_date.timestamp(), pediod)
    data_df = get_json_data(json_url, poloniex_pair)
    data_df = data_df.set_index('date')
    return data_df

La fonction ci-dessus extrait le code de caractère correspondant de la monnaie numérique (comme BTC_ETH) et renvoie le cadre de données contenant les prix historiques de deux devises.

3.2 Télécharger les données sur les prix de transaction de Poloniex

La grande majorité des Altcoins ne peuvent pas être achetés en USD directement. Pour obtenir ces monnaies numériques, les individus doivent généralement acheter Bitcoin d'abord, puis les convertir en Altcoins en fonction de leur ratio de prix. Par conséquent, nous devons télécharger le taux de change de chaque monnaie numérique vers Bitcoin, puis utiliser les données existantes sur le prix du Bitcoin pour le convertir en USD. Nous téléchargerons les données de taux de change pour les 9 principales monnaies numériques: Ethereum, Litecoin, Ripple, EthereumClassic, Stellar, Dash, Siacoin, Monero et NEM.

altcoins = ['ETH','LTC','XRP','ETC','STR','DASH','SC','XMR','XEM']

altcoin_data = {}
for altcoin in altcoins:
    coinpair = 'BTC_{}'.format(altcoin)
    crypto_price_df = get_crypto_data(coinpair)
    altcoin_data[altcoin] = crypto_price_df

Maintenant, nous avons un dictionnaire contenant 9 cadres de données, dont chacun contient des données historiques de prix quotidiens moyens entre Altcoins et Bitcoin.

Nous pouvons déterminer si les données sont correctes à travers les dernières lignes de la table des prix Ethereum.

altcoin_data['ETH'].tail()

3.3 Unifier l'unité monétaire de toutes les données sur les prix en USD

Maintenant, nous pouvons combiner les données de taux de change de BTC et Altcoins avec notre indice de prix Bitcoin pour calculer le prix historique de chaque Altcoin (en USD) directement.

# Calculate USD Price as a new column in each altcoin data frame
for altcoin in altcoin_data.keys():
    altcoin_data[altcoin]['price_usd'] =  altcoin_data[altcoin]['weightedAverage'] * btc_usd_datasets['avg_btc_price_usd']

Ici, nous ajoutons une nouvelle colonne pour chaque cadre de données Altcoin pour stocker son prix USD correspondant.

Ensuite, nous pouvons réutiliser la fonction merge_dfs_on_column définie précédemment pour créer un cadre de données combiné et intégrer le prix USD de chaque monnaie numérique.

# Combine the USD price of each Altcoin into a single data frame
combined_df = merge_dfs_on_column(list(altcoin_data.values()), list(altcoin_data.keys()), 'price_usd')

Ça y est!

Maintenant, ajoutons le prix Bitcoin comme la dernière colonne à la base de données fusionnée.

# Add BTC price to data frame
combined_df['BTC'] = btc_usd_datasets['avg_btc_price_usd']

Maintenant, nous avons un cadre de données unique, qui contient les prix quotidiens en USD de dix monnaies numériques que nous vérifions.

Nous appelons à nouveau la fonction précédente df_scatter, montrant les prix correspondants de tous les Altcoins sous forme de graphique.

Il semble qu'il n'y ait pas de problème dans le graphique. Ce graphique nous montre une image complète de l'évolution du prix de change pour chaque monnaie numérique au cours des dernières années.

Remarque: ici, nous utilisons l'axe y de la spécification logarithmique pour comparer toutes les monnaies numériques sur le même graphique.

3.4 Début de l'analyse de corrélation

Les lecteurs attentifs ont peut-être remarqué que les prix des monnaies numériques semblent pertinents, bien que leurs valeurs monétaires varient considérablement et soient très volatiles.

Bien sûr, les conclusions fondées sur des données sont plus convaincantes que les intuitions basées sur des images.

Nous pouvons utiliser la fonction Pandas corr() pour vérifier l'hypothèse de corrélation ci-dessus. Cette méthode de test calcule le coefficient de corrélation de Pearson de chaque colonne du cadre de données correspondant à l'autre colonne.

Note de révision du 22.8.2017: Cette section a été modifiée pour utiliser le taux de rendement journalier au lieu de la valeur absolue du prix lors du calcul du coefficient de corrélation.

Le calcul direct basé sur une série temporelle non solide (comme les données de prix bruts) peut entraîner un écart du coefficient de corrélation. Pour résoudre ce problème, notre solution consiste à utiliser la méthode pct_change() pour convertir la valeur absolue de chaque prix dans le cadre de données en taux de rendement quotidien correspondant.

Par exemple, calculons le coefficient de corrélation en 2016.

# Calculating the Pearson correlation coefficient for digital currencies in 2016
combined_df_2016 = combined_df[combined_df.index.year == 2016]
combined_df_2016.pct_change().corr(method='pearson')

Le graphique ci-dessus montre le coefficient de corrélation. Lorsque le coefficient est proche de 1 ou -1, cela signifie que cette série est respectivement corrélée positivement ou négativement. Lorsque le coefficient de corrélation est proche de 0, cela signifie que les objets correspondants ne sont pas corrélés et que leurs fluctuations sont indépendantes les unes des autres.

Pour mieux visualiser les résultats, nous créons une nouvelle fonction d'aide visuelle.

def correlation_heatmap(df, title, absolute_bounds=True):
    '''Plot a correlation heatmap for the entire dataframe'''
    heatmap = go.Heatmap(
        z=df.corr(method='pearson').as_matrix(),
        x=df.columns,
        y=df.columns,
        colorbar=dict(title='Pearson Coefficient'),
    )
    
    layout = go.Layout(title=title)
    
    if absolute_bounds:
        heatmap['zmax'] = 1.0
        heatmap['zmin'] = -1.0
        
    fig = go.Figure(data=[heatmap], layout=layout)
    py.iplot(fig)

correlation_heatmap(combined_df_2016.pct_change(), "Cryptocurrency Correlations in 2016")

Ici, la valeur rouge foncé représente une forte corrélation (chaque devise est évidemment fortement corrélée avec elle-même), et la valeur bleu foncé représente une corrélation inverse.

Qu'est-ce que ce graphique nous dit? Fondamentalement, il montre la fluctuation des prix des différentes monnaies numériques en 2016, avec peu de corrélation statistiquement significative.

Maintenant, afin de vérifier notre hypothèse selon laquelle la corrélation de la monnaie numérique a augmenté ces derniers mois, nous utiliserons les données de 2017 pour répéter le même test.

combined_df_2017 = combined_df[combined_df.index.year == 2017]
combined_df_2017.pct_change().corr(method='pearson')

Les données ci-dessus sont-elles plus pertinentes et suffisantes pour être utilisées comme norme de jugement pour l'investissement?

Cependant, il convient de noter que presque toutes les monnaies numériques sont devenues de plus en plus interconnectées.

correlation_heatmap(combined_df_2017.pct_change(), "Cryptocurrency Correlations in 2017")

Comme nous pouvons le voir sur le graphique ci-dessus, les choses deviennent de plus en plus intéressantes.

Pourquoi cela arrive-t-il?

Mais la vérité est que je ne suis pas sûr...

Ma première réaction est que les fonds spéculatifs ont récemment commencé à négocier publiquement sur le marché des devises numériques. Ces fonds détiennent beaucoup plus de capital que les traders ordinaires. Lorsqu'un fonds couvre son capital investi entre plusieurs devises numériques, il utilise des stratégies de négociation similaires pour chaque devise en fonction de variables indépendantes (comme le marché boursier).

Une compréhension plus approfondie du XRP et du STR

Par exemple, il est évident du graphique ci-dessus que XRP (le jeton de Ripple) a le moins de corrélation avec les autres monnaies numériques. Cependant, une exception notable est STR (le jeton de Stellar, officiellement connu sous le nom de Lumens), qui a une forte corrélation avec XRP (coefficient de corrélation: 0,62).

Il est intéressant de noter que Stellar et Ripple sont des plateformes de technologie financière très similaires, qui visent toutes deux à réduire les étapes fastidieuses du transfert transfrontalier entre les banques.

C'est à ton tour!

Les explications ci-dessus sont largement spéculatives, et vous pourriez faire mieux.

Les lecteurs peuvent se référer aux recherches dans les directions suivantes:

• Ajoutez plus de données sur la monnaie numérique à l'ensemble de l'analyse.
• Ajustez la fourchette de temps et la granularité de l'analyse de corrélation pour obtenir une vue de tendance optimisée ou à grains grossiers.
• Trouvez des tendances à partir de la quantité de négociation ou de l'exploration de données de la blockchain. Par rapport aux données de prix originales, si vous voulez prédire les fluctuations futures des prix, vous aurez peut-être besoin de plus de données sur le ratio quantité achat/vente.
• Ajoutez des données sur les prix des actions, des matières premières et des monnaies fiduciaires pour déterminer laquelle d'entre elles est pertinente pour les monnaies numériques (mais n'oubliez pas le vieux dicton corrélation n'implique pas causalité).
• Utilisez Event Registry, GDELT, et Google Trends pour quantifier le nombre de mot chaud entourant une monnaie numérique spécifique.
• Utilisez les données pour former un modèle d'apprentissage automatique prédictif pour prédire les prix de demain.
• Utilisez votre analyse pour créer un robot de trading automatique, qui peut être appliqué sur le site d'échange de Poloniex ou Coinbase via l'interface de programmation d'application (API) correspondante.FMZ.COM) est recommandée ici.

La meilleure partie de Bitcoin et de la monnaie numérique en général est leur nature décentralisée, ce qui la rend plus libre et démocratique que tout autre actif. Vous pouvez partager votre analyse open-source, participer à la communauté ou écrire un blog! J'espère que vous avez maîtrisé les compétences requises pour l'auto-analyse et la capacité de penser dialectiquement lorsque vous lisez des articles spéculatifs sur la monnaie numérique à l'avenir, en particulier les prédictions sans support de données. Merci de lire. Si vous avez des commentaires, des suggestions ou des critiques sur ce tutoriel, veuillez laisser un message surhttps://www.fmz.com/bbs.

Relationnée

Plus de