classifier = Sequential()

通过循环添加隐藏层和 Dropout 层：

for _ in range(nb\_hidden\_layer):
    classifier.add(Dense(75, input\_shape = (X\_train.shape\[1\],), activation="relu"))

这里添加了一个包含 75 个神经元的隐藏层，输入形状根据训练集特征数量确定，激活函数为“relu”，可以有效地引入非线性。接着添加输出层：

---

---

classifier.add(Dense(1, activation="sigmoid"))

输出层包含 1 个神经元，激活函数为“sigmoid”，适用于二分类任务。然后编译模型：

classifier.compile(loss="binary_crossentropy", optimizer="adam")

使用“binary_crossentropy”作为损失函数，“adam”作为优化器。最后进行训练：

classifier.fit(X\_train\_scaled, y\_train\_cla, epochs=15, batch_size=150, verbose=1)

使用标准化后的训练集进行训练，设置训练轮数为 15，批次大小为 150，并显示训练过程中的信息。

综上所述，通过合理的数据准备和模型构建，可以有效地利用深度神经网络进行分类任务。

• 
  代码如下：df\["prediction"\] = np.where(df\["prediction"\] == 0, -1,1)
• 最后，根据预测结果计算策略（strategy），即通过预测值的符号（np.sign）乘以收益（returns）得到。
• 代码如下：# 计算策略 df\["strategy"\] = np.sign(df\["prediction"\]) * df\["returns"\]

1. 回归预测

• 对于回归任务，使用回归器（regressor）来进行预测。同样是对合并后的训练集和测试集数据进行操作，将预测结果存储在数据框的prediction列中。
• 代码如下：# 创建整个数据集的预测
• df\["prediction"\] = regressor.predict(np.concatenate((X\_train,X\_test),                              axis=0))
• 然后按照与分类预测中相同的方式计算策略。
• 代码如下：# 计算策略 df\["strategy"\] = np.sign(df\["prediction"\]) * df\["returns"\]

回测

1. 分类回测

• 在分类任务中，对数据框中strategy列的前split个数据进行动态投资组合的回测（backtest_dynamic_portfolio）。
• 代码如下：# 回测 backtest\_dynamic\_portfolio(df\["strategy"\].iloc\[:split\])

3. 回归回测

• 在回归任务中，对数据框中strategy列从split之后的数据进行动态投资组合的回测。
• 代码如下：# 回测 backtest\_dynamic\_portfolio(df\["strategy"\].iloc\[split:\])

深度神经网络（DNN）实现回归

1. 自定义损失函数 ALPHA_MSE

定义了一个自定义的损失函数ALPHA_MSE，它用于衡量预测值（y\_pred）和真实值（y\_true）之间的误差。在这个函数中，通过一些张量操作（如tf.roll进行数据的滚动，tf.math.sign获取符号，tf.where根据条件赋值等）来计算一个缩放的均方误差（scale_mse）。

代码如下：

def ALPHA\_MSE(y\_true, y_pred):  y\_true\_roll = tf.roll(y_true, shift=1, axis=0)  y\_pred\_roll = tf.roll(y_pred, shift=1, axis=0)  y\_true\_dif = tf.math.sign(y\_true\_roll - y_true)  y\_pred\_dif = tf.math.sign(y\_pred\_roll - y_pred)  booleen\_vector = y\_true\_dif == y\_pred_dif  alpha = tf.where(booleen_vector, 1, 3)  alpha = tf.cast(alpha, dtype=tf.float32)  mse = F.square(y\_true - y\_pred)  mse = tf.cast(mse, dtype=tf.float32)  scale_mse = tf.multiply(alpha, mse)  alpha\_mse = F.mean(scale\_mse)  return alpha_mse

3. 构建深度神经网络模型

导入必要的库（如tensorflow、tensorflow_probability、tensorflow.keras.backend as F等）。

设定隐藏层数（nb_hidden_layer = 3）。

初始化一个顺序模型（Sequential）作为回归器（regressor）。

通过循环添加多个具有 75 个神经元、relu激活函数的全连接层（Dense）和Dropout层。

再添加一个具有 1 个神经元、线性激活函数（linear）的全连接层。

编译模型，指定损失函数为自定义的ALPHA_MSE，优化器为adam。

训练模型，使用缩放后的训练数据（X_train_scaled）和训练目标（y_train_reg），设置训练轮数（epochs = 13）、批大小（batch_size = 32）等参数。

代码如下：

import tensorflow from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout nb\_hidden\_layer = 3 np.random.seed(15) # 初始化顺序模型 regressor = Sequential() # 添加密集层和丢弃层 for _ in range(nb\_hidden\_layer):  regressor.add(Dense(75, input\_shape = (X\_train.shape\[1\],), activation="relu")) # 添加密集层 regressor.add(Dense(1, activation="linear")) # 编译模型 regressor.compile(loss=ALPHA_MSE, optimizer="adam") regressor.fit(X\_train\_scaled, y\_train\_reg, epochs=13, batch_size=32, verbose=1)

5. 进行预测和回测

与前面回归预测和回测的步骤相同，使用训练好的回归器对合并后的数据集进行预测，计算策略，并对策略进行回测。

代码如下：

# 创建整个数据集的预测 df\["prediction"\] = regressor.predict(np.concatenate((X\_train,X\_test),                              axis=0)) # 计算策略 df\["strategy"\] = np.sign(df\["prediction"\]) * df\["returns"\] # 回测 from Backtest import * backtest\_dynamic\_portfolio(df\["strategy"\].iloc\[split:\])

循环神经网络（RNN）

一、将二维数据转换为三维数据

在循环神经网络的应用中，常常需要将二维数据转换为三维数据。以下是一个实现此功能的函数X_3d_RNN：

1. 数据验证

• 首先进行简单的数据验证，检查输入特征数据X_s的长度和目标数据y_s的长度是否相等。如果不相等，则打印警告信息。
• 代码如下：# 简单验证 if len(X\_s)!= len(y\_s):  print("Warnings")

3. 创建三维的训练特征数据（X_train）

对于每个特征变量（通过range(0, X_s.shape[1])遍历），创建一个新的列表X。

对于每个时间步（通过range(lag, X_s.shape[0])遍历，其中lag是一个给定的时间滞后参数），从原始特征数据X_s中提取从i - lag到i的切片，并将其添加到X中。

将所有特征变量对应的X组合成X_train，并进行轴的交换（np.swapaxes）以得到合适的三维数据结构。

代码如下：

# 创建 X_train X_train = \[\] for variable in range(0, X_s.shape\[1\]):  X = \[\]  for i in range(lag, X_s.shape\[0\]):      X.append(X_s\[i - lag:i, variable\])  X_train.append(X) X\_train = np.array(X\_train) X\_train = np.swapaxes(np.swapaxes(X\_train, 0, 1), 1, 2)

1. 创建训练目标数据（y_train）

• 对于目标数据y_s，从lag开始（因为前面的时间步可能用于构建序列信息），将每个时间步的数据进行重塑（reshape(-1, 1)）和转置（transpose），并添加到y_train列表中。
• 最后，将y_train列表中的所有数据沿轴 0 进行拼接（np.concatenate）。
• 代码如下：# 创建 y_train y_train = \[\] for i in range(lag, y_s.shape\[0\]):  y\_train.append(y\_s\[i, :\].reshape(-1, 1).transpose()) y\_train = np.concatenate(y\_train, axis=0)
• 例如，给定一个滞后值lag = 15，对经过缩放的训练特征数据X_train_scaled和分类目标数据y_train_cla.values以及测试特征数据X_test_scaled和测试分类目标数据y_test_cla.values进行转换，得到三维的训练特征数据X_train_3d、训练目标数据y_train_3d、测试特征数据X_test_3d和测试目标数据y_test_3d。
• 代码如下：lag = 15 X\_train\_3d, y\_train\_3d = X\_3d\_RNN(X\_train\_scaled, y\_train\_cla.values, 15) X\_test\_3d, y\_test\_3d = X\_3d\_RNN(X\_test\_scaled, y\_test\_cla.values, 15)
• 可以打印出转换后的训练特征数据的形状（np.shape(X_train_3d)）和第一个数据点（X_train_3d[0]）来查看数据的结构。

预测和回测

1. 分类问题的预测和数据整理

对于分类问题，创建整个数据集的预测。首先，在预测结果前添加lag个零值（np.zeros([lag, 1])），然后与分类器（classifier）对三维训练特征数据X_train_3d和测试特征数据X_test_3d的预测结果进行拼接（np.concatenate），并将其存储在数据框（df）的prediction列中。

代码如下：

# 创建整个数据集的预测 y\_pred\_train = np.concatenate((np.zeros(\[lag, 1\]), classifier.predict(X\_train\_3d)),                              axis=0) y\_pred\_test = np.concatenate((np.zeros(\[lag, 1\]), classifier.predict(X\_test\_3d)),                              axis=0) df\["prediction"\] = np.concatenate((y\_pred\_train, y\_pred\_test),                              axis=0)

1. 回归问题的预测和数据整理

对于回归问题，首先对回归器（regressor）对三维训练特征数据X_train_3d的预测结果进行逆变换（sc_y.inverse_transform），得到原始数据尺度下的预测值y_train_sc。

然后在预测结果前添加lag个零值，并进行拼接。

代码如下：

# 逆变换 y\_train\_sc = sc\_y.inverse\_transform(regressor.predict(X\_train\_3d)) # 预测 y\_pred\_train = np.concatenate((np.zeros(\[lag, 1\]), y\_train\_sc),                              axis=0)

通过上述步骤，实现了二维数据到三维数据的转换，以及基于转换后数据的分类和回归问题的预测准备工作。这些步骤为在循环神经网络中进行后续的模型训练、评估和分析奠定了基础。

请注意，上述代码中的X_train_scaled、y_train_cla、X_test_scaled、y_test_cla、classifier、regressor和sc_y等变量需要根据实际情况进行定义和导入。

# Create predictions for the whole dataset# Inverse transformy\_train\_sc = sc\_y.inverse\_transform(regressor.predict(X\_train\_3d))# Predictionsy\_pred\_train = np.concatenate((np.zeros(\[lag,1\]),y\_train\_sc),axis=0)

循环卷积神经网络（RCNN）

一、创建一个 RCNN

以下是一个用于创建循环卷积神经网络（RCNN）的函数RCNN：

1. 库的导入和模型初始化

首先，导入必要的库，包括tensorflow、tensorflow.keras.models中的Sequential以及tensorflow.keras.layers中的Conv1D、Dense、LSTM和Dropout。

代码如下：

# 库的导入 import tensorflow from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Conv1D, Dense, LSTM, Dropout

然后，初始化一个顺序模型（Sequential），这是构建神经网络模型的基础结构。

代码如下：# 模型初始化 model = Sequential()

3. 添加 LSTM 层

• 向模型中添加一个长短期记忆（LSTM）层。units参数指定了该层中神经元的数量（由输入参数number_neurons给定），return_sequences = True表示输出序列的最后一个输出将作为下一层的输入，input_shape参数指定了输入数据的形状（由输入参数shape给定）。
• 代码如下：# 添加 LSTM 层 model.add(LSTM(units = number\_neurons, return\_sequences = True, input_shape = shape))

5. 添加 Dropout 层

• 通常在神经网络中，为了防止过拟合，会添加 Dropout 层。Dropout 层会在训练过程中随机地将神经元的输出设置为 0，从而强制模型学习更鲁棒的特征。虽然代码中给出了添加 Dropout 层的注释，但具体实现还未给出。一般来说，添加 Dropout 层的代码如下（假设pct_dropout为要设置的丢弃率）：model.add(Dropout(rate = pct_dropout))

在构建 RCNN 模型时，除了上述已展示的部分，还可以继续添加其他类型的层（如卷积层 Conv1D、全连接层 Dense 等），并根据具体的任务（如回归或分类）选择合适的损失函数（loss）、评估指标（metrics）、激活函数（activation）和优化器（optimizer）。这些参数都可以作为函数的输入进行灵活配置。

决策树、SVM、回归机器学习方法金融交易策略

一、数据导入

1. 初始化设备与创建空列表

• 首先初始化mt5设备（mt5.initialize()），然后创建三个空列表：symbols用于存储交易品种符号，sectors用于存储交易品种所属板块，descriptions用于存储交易品种描述。
• 代码如下：# 初始化设备 mt5.initialize() # 创建空列表 symbols = \[\] sectors = \[\] descriptions = \[\]

3. 获取交易品种信息并提取相关数据

• 通过mt5.symbols_get()获取所有交易品种的信息，将其转换为列表形式（symbols_information_list）。
• 然后从列表中的每个元素提取交易品种符号、所属板块和描述信息，并分别添加到对应的列表中。
• 代码如下：# 获取所有交易品种信息 symbols\_information = mt5.symbols\_get() # 将元组转换为列表 symbols\_information\_list = list(symbols_information) # 提取交易品种符号、所属板块和描述信息 for element in symbols\_information\_list:  symbols.append(list(element)\[-3\])  sectors.append(list(element)\[-1\].split("\\\")\[0\])  descriptions.append(list(element)\[-7\])

5. 创建数据框并计算价差

• 根据提取的信息创建一个数据框（informations）。
• 计算每个交易品种的价差（spread），将其添加到数据框中，并筛选出价差小于0.0035的交易品种（lowest_spread_asset）。
• 代码如下：

# 创建数据框 informations = pd.DataFrame(\[symbols, sectors, descriptions\], index=\["Symbol", "Sector", "Description"\]).transpose() # 创建空列表用于存储价差 spread = \[\] # 计算价差 for symbol in informations\["Symbol"\]:  try:      ask =  mt5.symbol\_info\_tick(symbol).ask      bid =  mt5.symbol\_info\_tick(symbol).bid      spread.append((ask - bid) / bid )  except:      spread.append(None) # 将价差添加到数据框并筛选 informations\["Spread"\] = spread lowest\_spread\_asset = informations.dropna().loc\[informations\["Spread"\]<0.0035\]

7. 定义获取数据的函数

定义一个函数get_data，用于获取指定交易品种（symbol）、数量（n）和时间框架（timeframe）的数据。在函数内部，初始化mt5设备，将获取的数据放入数据框（rates_frame），并将时间列转换为日期时间格式。

代码如下：

def get\_data(symbol, n, timeframe=mt5.TIMEFRAME\_D1):  """ 函数用于返回交易品种的数据 """  # 初始化 MetaTrader 设备  mt5.initialize()  # 将数据放入数据框  utc_from = datetime.now()+timedelta(hours=2)  rates = mt5.copy\_rates\_from(symbol, timeframe, utc_from,n)   rates_frame = pd.DataFrame(rates)  # 将时间（单位：秒）转换为日期时间格式  rates\_frame\['time'\]=pd.to\_datetime(rates_frame\['time'\], unit='s')  rates\_frame\['time'\] =  pd.to\_datetime(rates_frame\['time'\], format='%Y-%m-%d')  rates\_frame = rates\_frame.set_index('time')  return rates_frame

二、特征工程

1. 定义特征工程函数

定义函数features_engineering，在函数内部，定义了一些全局变量（如X_train、X_test等）用于存储后续划分的数据集。

代码如下：

def features_engineering(df):  """ 此函数创建算法所需的所有数据集 """  # 使变量可在函数外部调用  global X_train  global X_test  global y\_train\_reg  global y\_train\_cla   global X\_train\_scaled   global X\_test\_scaled  global split\_train\_test  global split\_test\_valid  global X_valid  global X\_valid\_scaled  global X\_train\_pca  global X\_test\_pca  global X\_val\_pca

3. 创建自定义指标和特征

创建了一些自定义指标（如returns、sLow、sHigh）来计算策略收益，并进行特征工程（如returns t - 1、不同窗口的mean returns和volatility returns）。

代码如下：

# 创建自定义指标来计算策略收益 df\["returns"\] = ((df\["close"\] - df\["close"\].shift(1)) / df\["close"\]) df\["sLow"\] = ((df\["low"\] - df\["close"\].shift(1)) / df\["close"\].shift(1)) df\["sHigh"\] = ((df\["high"\] - df\["close"\].shift(1)) / df\["close"\].shift(1)) # 特征工程 df\["returns t - 1"\] = df\[\["returns"\]\].shift(1) # 平均收益 df\["mean returns 15"\] = df\[\["returns"\]\].rolling(15).mean().shift(1) df\["mean returns 60"\] = df\[\["returns"\]\].rolling(60).mean().shift(1) # 收益波动率 df\["volatility returns 15"\] = df\[\["returns"\]\].rolling(15).std().shift(1) df\["volatility returns 60"\] = df\[\["returns"\]\].rolling(60).std().shift(1)

数据预处理

丢弃含有缺失值的数据，计算训练集、测试集和验证集的划分点，并创建训练集、测试集和验证集（X_train、X_test、X_val）。

代码如下：

# 丢弃缺失值
df = df.dropna()

# 计算训练集划分点
split = int(0.80*len(df))


list_x = \["returns t - 1", "mean returns 15", "mean returns 60",
           "volatility returns 15",
           "volatility returns 60"\]


split\_train\_test = int(0.70*len(df))
split\_test\_valid = int(0.90*len(df))

# 创建训练集
X\_train = df\[list\_x\].iloc\[:split\_train\_test\]

y\_train\_reg = df\[\["returns"\]\].iloc\[:split\_train\_test\]

y\_train\_cla = np.round(df\[\["returns"\]\].iloc\[:split\_train\_test\]+0.5)


# 创建测试集
X\_test = df\[list\_x\].iloc\[split\_train\_test:split\_test\_valid\]

# 创建验证集
X\_val = df\[list\_x\].iloc\[split\_test\_valid:\]

数据标准化和主成分分析（PCA）

导入StandardScaler类对数据进行标准化处理，得到标准化后的训练集、测试集和验证集（X_train_scaled、X_test_scaled、X_val_scaled）。

导入PCA类对标准化后的数据进行主成分分析，得到降维后的训练集、测试集和验证集（X_train_pca、X_test_pca、X_val_pca）。

代码如下：

# 标准化
from sklearn.preprocessing import StandardScaler

# 初始化标准化类
sc = StandardScaler()

# 对数据进行标准化
X\_train\_scaled = sc.fit\_transform(X\_train)
X\_test\_scaled = sc.transform(X_test)
X\_val\_scaled = sc.transform(X_val)


# PCA
from sklearn.decomposition import PCA

# 初始化 PCA 类
pca = PCA(n_components=3)

# 应用 PCA
X\_train\_pca = pca.fit\_transform(X\_train_scaled)
X\_test\_pca = pca.transform(X\_test\_scaled)
X\_val\_pca = pca.transform(X\_val\_scaled)

寻找最佳资产

定义预测函数

定义函数predictor，用于对给定的数据（df）和模型（model）进行预测，并根据模型类型（reg）计算夏普比率。

代码如下：

def predictor(df, model, reg=True, spread = 0.035):
 model.fit(X\_train\_pca, y\_train\_cla)


 df = df.dropna()
 # 为整个数据集创建预测
 df\["prediction"\] = model.predict(np.concatenate((X\_train\_pca,X\_test\_pca, X\_val\_pca),
                                     axis=0))

 if reg==False:
     df\["prediction"\] = np.where(df\["prediction"\]==0, -1, 1)

 df\["prediction"\] = df.prediction
 df=df.dropna()
 # 计算策略
 df\["strategy"\] = df\["prediction"\]* df\["returns"\]

 returns = df\["strategy"\].iloc\[split\_train\_test:split\_test\_valid\]

 return np.sqrt(252) * (returns.mean()-(spread/100))/ returns.std()

导入模型并进行循环预测

导入一些机器学习模型（如SVC、DecisionTreeClassifier、LogisticRegression），并对每个交易品种进行数据获取、特征工程和模型预测，将结果存储在列表中。

代码如下：

from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

from tqdm import tqdm
# 模型
tree = DecisionTreeClassifier(max_depth=6)
svr = SVC(C=1.5)
lin = LogisticRegression()


# 初始化
symbols = lowest\_spread\_asset\["Symbol"\]
lists = \[\]
lenght = \[\]
mt5.initialize()
for symbol in tqdm(symbols):

 try:
     df = get_data(symbol, 3500).dropna()

     df\["returns"\] = (df\["close"\] - df\["close"\].shift(1)) / df\["close"\].shift(1)


     features_engineering(df)


     """ 决策树回归器 """
     sharpe_tree = predictor(df, tree, reg=True)    
     lists.append(\[symbol, "Tree", sharpe_tree, len(df)\])

     """ SVR """
     sharpe_svr = predictor(df, svr, reg=False)    
     lists.append(\[symbol, "SVR", sharpe_svr, len(df)\])

     """ 线性回归 """
     sharpe_linreg = predictor(df, lin, reg=False)    
     lists.append(\[symbol, "LinReg", sharpe_linreg, len(df)\])
 except:
     print("数据导入过程中出现问题")

四、组合算法

定义投票函数

定义函数voting，用于创建基于投票方法的策略。在函数内部，根据reg参数选择不同的模型（分类或回归），进行训练、预测和策略计算。

代码如下：

def voting(df, reg=True):    
 """ 创建一个使用投票方法的策略 """
 # 导入类


 # 导入模型
 if reg:
     tree = DecisionTreeRegressor(max_depth=6)
     svr = SVR(epsilon=1.5)
     lin = LinearRegression()
     vot = VotingRegressor(estimators=\[
         ('lr', lin), ("tree", tree), ("svr", svr)\])
 else:
     tree = DecisionTreeClassifier(max_depth=6)
     svr = SVC()
     lin = LogisticRegression()

     vot = VotingClassifier(estimators=\[
         ('lr', lin), ("tree", tree), ("svr", svr)\])

 # 训练模型
 if reg==False:
     vot.fit(X\_train\_pca, y\_train\_cla)
 else:
     vot.fit(X\_train\_pca, y\_train\_reg)

 # 删除缺失值
 df = df.dropna()

 # 为整个数据集创建预测
 df\["prediction"\] = vot.predict(np.concatenate((X\_train\_pca,
                                                X\_test\_pca,
                                                X\_val\_pca),
                                     axis=0))

 # 删除缺失值
 df = df.dropna()

 if reg==False:
     df\["prediction"\] = np.where(df\["prediction"\]==0, -1, 1)

 # 计算策略
 df\["strategy"\] = np.sign(df\["prediction"\]) * df\["returns"\]
 df\["low_strategy"\] = np.where(df\["prediction"\]>0, df\["sLow"\], -df\["sHigh"\])
 df\["high_strategy"\] = np.where(df\["prediction"\]>0, df\["sHigh"\], -df\["sLow"\])


 return vot, df\["strategy"\], df\["low\_strategy"\], df\["high\_strategy"\]

对多个资产进行操作

对多个资产（如US2000、Bitcoin等）进行数据获取、特征工程、策略计算，并保存模型。

代码如下：

mt5.initialize()

# 导入类
from sklearn.svm import SVR, SVC
from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
from sklearn.linear_model import LinearRegression, LogisticRegression

from sklearn.ensemble import VotingRegressor, VotingClassifier
import pickle
from joblib import dump, load

# 初始化
lists = \[\]
res = pd.DataFrame()
low_assets = pd.DataFrame()
high_assets = pd.DataFrame()

for symbol in \["US2000", "Bitcoin", "JPN225", "XPTUSD", "NAS100"\]:
 print(symbol)


 # 导入数据
 df = get_data(symbol, 3500).dropna()

 # 创建自定义指标来计算策略收益
 df\["returns"\] = ((df\["close"\] - df\["close"\].shift(1)) / df\["close"\])
 df\["sLow"\] = ((df\["low"\] - df\["close"\].shift(1)) / df\["close"\].shift(1))
 df\["sHigh"\] = ((df\["high"\] - df\["close"\].shift(1)) / df\["close"\].shift(1))
 # 删除缺失值
 df = df.dropna()

 # 创建数据集
 features_engineering(df)

 # 计算策略
 vot, res\[symbol\],low\_assets\[symbol\],high\_assets\[symbol\] = voting(df, reg=False)

 # 保存模型
 s = pickle.dumps(vot)
 alg = pickle.loads(s)

 dump(alg,f"Models/{symbol}_voting.joblib")

展示策略累积收益

对计算出的策略收益进行可视化展示，通过绘制累积收益图来观察策略在测试集上的表现。

代码如下：

# 显示测试集上策略的累积收益
data = res.dropna().loc\["2020 - 01":"2021 - 01"\]
data.cumsum().plot(figsize=(15,8))

最优止盈、止损和杠杆

最优止盈

设定止盈比例（tp），对投资组合数据（pf）进行处理，根据止盈条件调整收益值，然后进行动态投资组合回测。

代码如下：

tp = 2.1/100
pf = pd.concat((low\_portfolio, portfolio\_return\_MV,high\_portfolio), axis=1).dropna()-spread
pf.columns = \["low", "Return", "high"\]

pf\["Return"\] = np.where(pf\["high"\].values>tp, tp, pf\["Return"\].values)
pf\["Return"\] = np.where(pf\["Return"\].values>tp, tp, pf\["Return"\].values)

backtest\_dynamic\_portfolio(pf\["Return"\])

最优止损

定义函数find_best_sl，用于寻找最佳止损比例（sl）。在函数内部，根据止损条件调整投资组合的收益值，并计算夏普比率。

代码如下：

def find\_best\_sl(sl):
    sl = sl/100

    # 创建投资组合
    pf = pd.concat((low\_portfolio, portfolio\_return\_test,high\_portfolio), axis=1).dropna()-spread
    pf.columns = \["low", "Return", "high"\]

    # 应用止损
    pf\["Return"\] = np.where(pf\["low"\].values<-sl, -sl, pf\["Return"\].values)
    pf\["Return"\] = np.where(pf\["Return"\].values<-sl, -sl, pf\["Return"\].values)

    # 返回夏普比率

---

关于分析师

在此对 Aijun Zhang 对本文所作的贡献表示诚挚感谢，他完成了数据科学与大数据技术专业的学位。擅长 Python、深度学习、数据处理分析。