라이브스마트

The cryptocurrency market, like Bitcoin, is highly volatile and uncertain. To build an automated trading system in such a market, effective prediction models must be created by applying deep learning and machine learning techniques. This course will explore how to enhance the stability of the model and improve performance using techniques such as Dropout and Batch Normalization.

1. Overview of Automated Trading Systems

An automated trading system is a system that makes trading decisions based on algorithms. Such systems analyze various data, including price, trading volume, and technical indicators, to generate buy or sell signals. By using machine learning and deep learning techniques, improved predictive power can be achieved.

1.1. Data Collection

The first step for automated trading is data collection. Bitcoin price data can be collected through various APIs. For example, CoinGecko or Binance API can be used to retrieve BTC-USD price data. The data collected should include various factors such as time, price, and trading volume.

1.2. Data Preprocessing

The collected data must be preprocessed before being inputted into the model. This includes handling missing values, normalization, and feature selection. For example, simple normalization can be performed using the closing price.

2. Building a Deep Learning Model

To build a deep learning model, libraries such as TensorFlow, Keras, or PyTorch can be used. In this example, we will create a simple model using Keras.

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense, Dropout, BatchNormalization
from sklearn.model_selection import train_test_split

# Load and preprocess data
data = pd.read_csv('bitcoin_price.csv')  # Data file
data['Close'] = data['Close'].shift(-1)  # Predict the next day's closing price
data.dropna(inplace=True)

# Normalization
scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(data[['Close', 'Volume']])
X = scaled_data[:-1]
y = scaled_data[1:, 0]  # Next day's closing price

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    

3. Dropout and Batch Normalization for Model Stabilization

Various techniques are applied during the training process of deep learning models to prevent overfitting. Among them, dropout and batch normalization are the most commonly used techniques.

3.1. Dropout

Dropout is a technique that randomly omits certain neurons during the training process to increase the generalization of the network. This approach reduces the likelihood of the model recognizing unnecessary patterns and allows it to learn more general features.

3.2. Batch Normalization

Batch normalization is a method that normalizes data using the mean and variance of each mini-batch. This technique helps to increase the training speed and reduce overfitting.

4. Model Construction and Training

# Build model
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(X.shape[1],)))
model.add(Dropout(0.5))  # Apply dropout
model.add(BatchNormalization())
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))  # Apply dropout
model.add(BatchNormalization())
model.add(Dense(1, activation='linear'))

# Compile model
model.compile(optimizer='adam', loss='mean_squared_error')

# Train model
model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.2)
    

5. Model Evaluation and Prediction

The trained model is evaluated, and future price predictions are made. To assess the model’s performance, metrics such as MSE (Mean Squared Error) can be used.

# Evaluate model
loss = model.evaluate(X_test, y_test)
print(f'Test loss: {loss}')

# Prediction
predictions = model.predict(X_test)
predictions = scaler.inverse_transform(predictions)  # Inverse normalization
    

6. Conclusion

An automated trading system for Bitcoin utilizing deep learning and machine learning techniques enables more effective decision-making in a changing market. Techniques such as dropout and batch normalization can enhance the stability of the model and improve predictive performance by preventing overfitting. Every step, from data collection and preprocessing to model construction, training, evaluation, and prediction, must be carried out thoroughly, and continuous model improvement can yield optimal results.

References

• TensorFlow Documentation
• Keras Documentation
• Scikit-learn Documentation
• Automated Trading – Investopedia

Author: [Author Name]

Published on: [Published Date]

Introduction

As the volatility of cryptocurrency markets like Bitcoin increases, automated trading systems utilizing machine learning and deep learning are gaining attention. These systems are designed to analyze real-time price data and automatically make buy or sell decisions. In this article, we will detail the preprocessing techniques used to organize and normalize the collected data alongside the real-time price data collection using exchange APIs.

1. Real-Time Price Data Collection Using Exchange APIs

Cryptocurrency exchanges provide APIs that allow users to collect real-time price data. Here, we will take Binance, one of the representative exchanges, as an example to explain how to collect real-time price data.

1.1 Obtaining Binance API Key

To use the Binance API, you first need to obtain an API key. Follow the steps below to create an API key:

1. Log in to your Binance account.
2. Click on ‘API Management’ from the top menu.
3. Create a new API key and store it in a safe place.
4. Access the API using the API key and secret key.

1.2 Using Binance API in Python

To access the Binance API using Python, install the ccxt library. This library is a useful tool that integrates and manages APIs from multiple exchanges.

pip install ccxt

The following code is an example of collecting real-time Bitcoin (BTC) price data from Binance.

import ccxt
import time

# Create a Binance API object
binance = ccxt.binance({'enableRateLimit': True})

def fetch_btc_price():
    # Collect Bitcoin price data
    ticker = binance.fetch_ticker('BTC/USDT')
    return ticker['last']

while True:
    price = fetch_btc_price()
    print(f'Current Bitcoin Price: {price} USDT')
    time.sleep(5)  # Updates the price every 5 seconds.

2. Data Collection and Storage

We use the pandas library to store the collected data. This allows us to create a data frame and save it as a CSV file.

2.1 Installing the Pandas Library

pip install pandas

2.2 Example Code for Creating a Data Frame and Saving as CSV

The code below shows how to convert the collected Bitcoin price data into a data frame and save it as a CSV file.

import pandas as pd

# Create an empty data frame
df = pd.DataFrame(columns=["timestamp", "price"])

while True:
    price = fetch_btc_price()
    timestamp = pd.Timestamp.now()
    
    # Add data
    df = df.append({"timestamp": timestamp, "price": price}, ignore_index=True)
    
    # Save to file every 5 minutes
    if len(df) % 60 == 0:  # Collect one data point every 5 minutes
        df.to_csv('btc_price_data.csv', index=False)
        print("Data has been saved to CSV file.")
    
    time.sleep(5)  # Updates the price every 5 seconds.

3. Preprocessing Collected Data

After data collection, it is essential to preprocess the data before training the machine learning model. The preprocessing aims to improve data quality and maximize learning effectiveness.

3.1 Data Cleaning

Data cleaning involves tasks such as handling missing values and removing duplicates.

3.2 Handling Missing Values

# Handling missing values
df = df.fillna(method='ffill')  # Fill missing values with the previous value

3.3 Removing Duplicates

# Remove duplicates
df = df.drop_duplicates(subset=["timestamp"], keep='last')

3.4 Data Normalization

To enhance the efficiency of machine learning models, we normalize the data. Here, we will use Min-Max normalization.

# Min-Max normalization
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
df['normalized_price'] = scaler.fit_transform(df[['price']])

4. Applying Machine Learning Models

Based on the preprocessed data, we can train a machine learning model. Here, we will implement a price prediction model using a simple LSTM (Long Short-Term Memory) model.

4.1 Data Transformation for LSTM Model

The LSTM model is suitable for time series data. The data must be split into a consistent temporal order for model input. The code below shows how to create the dataset.

import numpy as np

def create_dataset(data, time_step=1):
    X, Y = [], []
    for i in range(len(data)-time_step-1):
        X.append(data[i:(i+time_step), 0])
        Y.append(data[i + time_step, 0])
    return np.array(X), np.array(Y)

# Convert to normalized data
data = df['normalized_price'].values
data = data.reshape(-1, 1)

# Create dataset
X, Y = create_dataset(data, time_step=10)
X = X.reshape(X.shape[0], X.shape[1], 1)  # LSTM input shape

4.2 Building and Training the LSTM Model

from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout

# Create LSTM model
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(X.shape[1], 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(units=1))  # Predict next price

model.compile(optimizer='adam', loss='mean_squared_error')

# Train the model
model.fit(X, Y, epochs=50, batch_size=32)

Conclusion

This article provided a detailed explanation of the components of an automated Bitcoin trading system utilizing deep learning and machine learning, specifically focusing on data collection and preprocessing. We explored the process of collecting real-time price data using the Binance API, structuring the data with pandas, and learning an LSTM model through normalization and time series dataset creation. This process is a fundamental aspect of building a basic automated trading system.

In the future, this model can be improved for better predictive performance through more complex strategies, feature tuning, and hyperparameter adjustments. Implementing a Bitcoin automated trading system is a time- and effort-intensive process, and continuous data collection and model improvement are essential.

1. Introduction

The cryptocurrency market, such as Bitcoin, is highly volatile, and various technologies are being researched to automate trading. Deep Learning and Machine Learning techniques are effective in building such automated trading systems. This post explains how to build a self-learning trading agent using Reinforcement Learning techniques.

2. Basics of Machine Learning and Deep Learning

Machine Learning is a methodology for learning patterns from data and creating predictive models. Deep Learning is a subfield of Machine Learning that uses artificial neural networks to learn the structure of complex data. Their advantage is the ability to process large amounts of data.

2.1. Understanding Reinforcement Learning

Reinforcement Learning is a method where an agent learns the optimal actions through interaction with the environment. The agent selects specific actions from a given state and receives rewards as a result. Through this reward, the agent improves its actions.

3. Building a Trading Agent Based on Reinforcement Learning

3.1. Configuring the Environment

Configuring the environment for the trading agent is very important. To this end, we define the market environment based on OHLC (Open, High, Low, Close) data.

3.2. Installing OpenAI Gym

You can use OpenAI’s Gym library to create a reinforcement learning environment. Installation can be done via the following command.

pip install gym

3.3. Implementing the Trading Environment

Below is a code that implements a simple trading environment.

import gym
from gym import spaces
import numpy as np

class CryptoTradingEnv(gym.Env):
    def __init__(self, data):
        super(CryptoTradingEnv, self).__init__()
        self.data = data
        self.current_step = 0
        self.action_space = spaces.Discrete(3)  # 0: Hold, 1: Buy, 2: Sell
        self.observation_space = spaces.Box(low=0, high=np.inf, shape=(len(data[0]),), dtype=np.float32)

    def reset(self):
        self.current_step = 0
        return self.data[self.current_step]

    def step(self, action):
        self.current_step += 1
        if self.current_step >= len(self.data):
            self.current_step = len(self.data) - 1
        
        prev_state = self.data[self.current_step - 1]
        current_state = self.data[self.current_step]

        reward = 0
        if action == 1:  # Buy
            reward = current_state[3] - prev_state[3]  # Close price
        elif action == 2:  # Sell
            reward = prev_state[3] - current_state[3]

        done = self.current_step == len(self.data) - 1
        return current_state, reward, done, {}
    

3.4. Building the Deep Learning Model

Now we implement a deep learning model to train the reinforcement learning agent. Here, we use a simple Multi-layer Perceptron (MLP).

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

def create_model(input_shape):
    model = keras.Sequential()
    model.add(layers.Dense(24, activation='relu', input_shape=input_shape))
    model.add(layers.Dense(24, activation='relu'))
    model.add(layers.Dense(3, activation='linear'))  # 3 actions
    model.compile(optimizer='adam', loss='mse')
    return model
    

3.5. Training the Agent

The agent learns its policy through multiple episodes. Here, we apply a simple Q-learning algorithm.

import random

class DQNAgent:
    def __init__(self, state_size):
        self.state_size = state_size
        self.memory = []
        self.gamma = 0.95  # discount rate
        self.epsilon = 1.0  # exploration rate
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.model = create_model((state_size,))

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(3)  # exploration
        q_values = self.model.predict(state)
        return np.argmax(q_values[0])  # exploitation

    def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target += self.gamma * np.amax(self.model.predict(next_state)[0])
            target_f = self.model.predict(state)
            target_f[0][action] = target
            self.model.fit(state, target_f, epochs=1, verbose=0)
        
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay
    

4. Conclusion

This post explained the automatic trading system for Bitcoin using reinforcement learning techniques. We built a simple trading environment and a deep learning model, and covered the approach of learning using Q-learning. More data and hyperparameter tuning are needed to predict actual Bitcoin prices and establish trading strategies. Lastly, exchange API integration will be necessary for real trading.

5. References

• TensorFlow Documentation
• OpenAI Gym
• Reinforcement Learning: An Introduction (2nd Edition)

1. Introduction

In recent years, the popularity of cryptocurrencies like Bitcoin has surged. Additionally,
machine learning and deep learning techniques have gained attention in the financial sector,
leading many investors to utilize these technologies to develop automated trading systems.
This article will explore methods to enhance the performance of momentum-based trading strategies
through reinforcement learning.

2. Basic Concepts

2.1. Machine Learning and Deep Learning

Machine learning is the field that develops algorithms to learn patterns and make predictions from
data. In contrast, deep learning is a subset of machine learning that utilizes artificial neural
networks to learn complex patterns. These two technologies serve as powerful tools for data
analysis and prediction.

2.2. Reinforcement Learning

Reinforcement learning is a method where an agent learns to maximize rewards by interacting with
the environment. In this process, the agent learns the impact of its actions on the outcomes.
This approach is suitable for automated trading systems, as it can harness market volatility to
pursue profits.

2.3. Momentum Strategy

The momentum strategy is an investment technique that predicts future prices based on past price trends.
Generally, it involves buying assets believing that the uptrend will continue and selling them
believing that the downtrend will persist. This strategy includes purchasing assets that are
rising in price over a certain period.

3. Combining Reinforcement Learning and Momentum Strategy

3.1. System Design

When designing an automated trading system, the first step is to define the environment.
This environment consists of price data and trading information, and the agent will make trading
decisions within this environment. The agent’s ultimate goal is to achieve the maximum reward.

3.2. Data Collection

Bitcoin price data can be collected from various sources.
Here, we will collect price data through a simple API and use it for training the reinforcement
learning model. The data may consist of historical prices, trading volume, etc.

3.3. Defining States and Actions

The agent selects actions based on the current state.
The state is defined using price data along with technical indicators (moving average, RSI, etc.),
and actions can be set as buying, selling, or holding.

3.4. Designing the Reward Function

The reward function serves as a criterion to assess how successful the agent’s actions are.
Typically, it is designed to reward the agent when a profit is made after buying, and impose
a penalty when a loss occurs. The reward can be based on trading profits and losses.

4. Example Code

Below is a simple example code for automated trading of Bitcoin using reinforcement learning.
This code structures the environment using OpenAI’s Gym and demonstrates how to train the agent using
the deep learning library TensorFlow.

        
        import numpy as np
        import pandas as pd
        import gym
        from gym import spaces
        from tensorflow.keras import Sequential
        from tensorflow.keras.layers import Dense
        from tensorflow.keras.optimizers import Adam

        class BitcoinEnv(gym.Env):
            def __init__(self, data):
                super(BitcoinEnv, self).__init__()
                self.data = data
                self.action_space = spaces.Discrete(3)  # 0: Sell, 1: Buy, 2: Hold
                self.observation_space = spaces.Box(low=0, high=1, shape=(data.shape[1],), dtype=np.float32)
                self.current_step = 0
                self.balance = 1000  # Initial capital
                self.position = 0  # Current holdings

            def reset(self):
                self.current_step = 0
                self.balance = 1000
                self.position = 0
                return self.data[self.current_step]

            def step(self, action):
                current_price = self.data[self.current_step]['close']
                reward = 0

                if action == 1:  # Buy
                    self.position = self.balance / current_price
                    self.balance = 0
                elif action == 0:  # Sell
                    if self.position > 0:
                        self.balance = self.position * current_price
                        reward = self.balance - 1000  # Profit
                        self.position = 0

                self.current_step += 1
                done = self.current_step >= len(self.data) - 1
                next_state = self.data[self.current_step]
                return next_state, reward, done, {}

        # Define a simple neural network model.
        def build_model(input_shape):
            model = Sequential()
            model.add(Dense(24, input_shape=input_shape, activation='relu'))
            model.add(Dense(24, activation='relu'))
            model.add(Dense(3, activation='linear'))  # 3 actions
            model.compile(optimizer=Adam(lr=0.001), loss='mse')
            return model

        # Main execution code
        if __name__ == "__main__":
            # Load data
            data = pd.read_csv('bitcoin_price.csv')  # Bitcoin price data
            env = BitcoinEnv(data)
            model = build_model((data.shape[1],))

            # Agent training
            for episode in range(1000):
                state = env.reset()
                done = False

                while not done:
                    action = np.argmax(model.predict(state.reshape(1, -1)))
                    next_state, reward, done, _ = env.step(action)
                    model.fit(state.reshape(1, -1), reward, verbose=0)  # Simple training
                    state = next_state
        
    

5. Result Analysis

After running the code, various metrics can be used to analyze how efficiently the agent traded Bitcoin.
For example, the final return, maximum drawdown, and Sharpe ratio can be calculated to evaluate the
performance of the strategy.

6. Conclusion

This course introduced methods to improve momentum-based trading strategies through reinforcement learning.
It demonstrated how machine learning and deep learning technologies can be utilized in automated trading
in financial markets, and provided hints on future research directions.
This field still has great potential for development, and more innovative automated trading systems can be
developed through various techniques.

7. References

• 1. Sutton, R. S., & Barto, A. G. (2018). Reinforcement Learning: An Introduction.
• 2. Goodfellow, I., Yoshua Bengio, & Aaron Courville. (2016). Deep Learning.
• 3. Bitcoin historical data source: CoinGecko.

To build an automated trading system for cryptocurrencies like Bitcoin, an effective price prediction model is essential. This article will detail how to predict Bitcoin’s price fluctuations using Gaussian Process Regression (GPR), one of the machine learning techniques.

1. Overview of Machine Learning and Deep Learning

Machine learning is a field of artificial intelligence (AI) that enables predictions on new data by learning patterns from data. Deep learning is a subset of machine learning that uses artificial neural networks to learn the features of complex data independently.

2. What is Gaussian Process Regression (GPR)?

Gaussian Process Regression (GPR) is a form of nonparametric Bayesian statistical model, particularly effective for predicting continuous data. GPR creates a probabilistic model for the given data, naturally incorporating uncertainty. This allows for estimating the confidence level of predictions alongside predicted values.

2.1 Mathematical Background of GPR

GPR is based on Gaussian distribution and learns the functional relationship between input data and output data. For the given training dataset (X, y), GPR uses the following covariance function for predictions:

K(X, X') = σ² * exp(-||X - X'||² / (2 * l²))

Here, K is the kernel function, σ is the standard deviation of noise, and l is the length scale. This kernel function determines the similarity between data points.

3. Collecting Bitcoin Price Data

To build a Bitcoin price prediction model, historical Bitcoin price data is required. We will use the pandas library and the yfinance module in Python to collect data.

import pandas as pd
import yfinance as yf

# Download Bitcoin data
btc_data = yf.download('BTC-USD', start='2020-01-01', end='2023-01-01')
btc_data = btc_data[['Close']]
btc_data = btc_data.rename(columns={'Close': 'price'})
btc_data = btc_data.reset_index()
btc_data['Date'] = pd.to_datetime(btc_data['Date'])
btc_data.sort_values('Date', inplace=True)
print(btc_data.head())

4. Data Preprocessing

The collected data must be preprocessed to fit the GPR model. In particular, for time series data, trends and seasonality may need to be removed.

btc_data['returns'] = btc_data['price'].pct_change()
btc_data = btc_data.dropna()

# Reset index
btc_data.reset_index(drop=True, inplace=True)
print(btc_data.head())

5. Building the Gaussian Process Regression Model

To build the model, we will use the GaussianProcessRegressor class from the scikit-learn library. This allows us to predict Bitcoin prices.

from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C

# Define kernel
kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))

# Initialize model
gpr = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)

# Training data
X_train = btc_data.index.values.reshape(-1, 1)
y_train = btc_data['price'].values

# Fit model
gpr.fit(X_train, y_train)

6. Price Prediction

Let’s use the trained GPR model to predict future prices. We will decide on a date for prediction and create an index to perform the prediction.

import numpy as np

# Number of days to predict
n_days = 30
X_test = np.arange(len(btc_data), len(btc_data) + n_days).reshape(-1, 1)

# Prediction
y_pred, sigma = gpr.predict(X_test, return_std=True)

# Visualize results
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))
plt.plot(btc_data['Date'], btc_data['price'], 'r.', markersize=10, label='Observed Data')
plt.plot(btc_data['Date'].iloc[-1] + pd.to_timedelta(np.arange(1, n_days + 1), unit='D'), y_pred, 'b-', label='Predicted Price')
plt.fill_between(btc_data['Date'].iloc[-1] + pd.to_timedelta(np.arange(1, n_days + 1), unit='D'),
                 y_pred - 2 * sigma, y_pred + 2 * sigma, color='gray', alpha=0.2, label='Confidence Interval')
plt.title('Bitcoin Price Prediction using Gaussian Process Regression')
plt.xlabel('Date')
plt.ylabel('Price in USD')
plt.legend()
plt.show()

7. Performance Evaluation

To evaluate the model’s performance, we can use the Root Mean Squared Error (RMSE) and R² Score. This can help gauge the accuracy of the predictions.

from sklearn.metrics import mean_squared_error, r2_score

# Calculate RMSE
y_train_pred = gpr.predict(X_train)
rmse = np.sqrt(mean_squared_error(y_train, y_train_pred))
r2 = r2_score(y_train, y_train_pred)

print(f"RMSE: {rmse:.2f}, R² Score: {r2:.2f}")

8. Building a Real-time Automated Trading System

Finally, automated trading can be implemented based on the predicted prices. This should include logic to generate trading signals (buy/sell) and interface with exchanges through APIs for actual trading.

def generate_signals(predicted_prices):
    buy_signals = []
    sell_signals = []
    for i in range(1, len(predicted_prices)):
        if predicted_prices[i] > predicted_prices[i - 1]:
            buy_signals.append(predicted_prices[i])
            sell_signals.append(np.nan)
        elif predicted_prices[i] < predicted_prices[i - 1]:
            sell_signals.append(predicted_prices[i])
            buy_signals.append(np.nan)
        else:
            buy_signals.append(np.nan)
            sell_signals.append(np.nan)
    return buy_signals, sell_signals

buy_signals, sell_signals = generate_signals(y_pred)

plt.figure(figsize=(12, 6))
plt.plot(btc_data['Date'], btc_data['price'], label='Actual Price')
plt.plot(btc_data['Date'].iloc[-1] + pd.to_timedelta(np.arange(1, n_days + 1), unit='D'), y_pred, label='Predicted Price', color='orange')
plt.plot(btc_data['Date'].iloc[-1] + pd.to_timedelta(np.arange(1, n_days + 1), unit='D'), buy_signals, marker='^', color='g', label='Buy Signal', markersize=10)
plt.plot(btc_data['Date'].iloc[-1] + pd.to_timedelta(np.arange(1, n_days + 1), unit='D'), sell_signals, marker='v', color='r', label='Sell Signal', markersize=10)
plt.title('Buy/Sell Signals based on Predictions')
plt.xlabel('Date')
plt.ylabel('Price in USD')
plt.legend()
plt.show()

9. Conclusion

In this tutorial, we explored how to build a Bitcoin price prediction model using Gaussian Process Regression. GPR has the advantage of effectively reflecting the uncertainty of price predictions and can be applied to automated trading systems.

In the future, adding more features and testing other machine learning algorithms could be beneficial to improve this system. Additionally, integrating real-time data could help implement a more effective automated trading system.

Finally, remember that trading stocks or cryptocurrencies always involves risks. It is important to operate an automated trading system after sufficient research and testing.