来源：https://mp.weixin.qq.com/s?__biz=MzA4OTAwMjY2Nw==&mid=2650190833&idx=1&sn=3cb27f10dfb86b0f397891f472796cdd&chksm=88239435bf541d23c1149d59eab8d766a22a1a46d85f2b8c89a1ecfb0ac1e58d963ac3d749c7&scene=21#wechat_redirect

基于深度学习Autoencoder的信用卡欺诈异常检测 - 图1
大家好，我是小伍哥，今天接着搞异常检测。异常检测断断续续写了好几篇的，合集请看：异常检测算法汇总
深度学习用于异常检测，效果还是相当牛逼的。信用卡欺诈数据集，在孤立森林上能做到26%的top1000准确率，但是在Autoencoder算法上，最高做到了33.6%，但是这个数据很不稳定，有时候只有25%左右，但是至少这个模型潜力巨大，需要更多的试验，找到更稳定的网络结构。
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图2
自编码器（AutoEncoder, AE）是一类在半监督学习和非监督学习中使用的人工神经网络，其功能是通过将输入信息作为学习目标，对输入信息进行表征学习（representation learning），自编码器包含编码器（encoder）和解码器（decoder）两部分 。
AutoEncoder是深度学习的一个重要内容，并且非常有意思，神经网络通过大量数据集，进行end-to-end的训练，不断提高其准确率，而AutoEncoder通过设计encode和decode过程使输入和输出越来越接近，是一种无监督学习过程，可以被应用于降维（dimensionality reduction）和异常值检测（anomaly detection），包含卷积层构筑的自编码器可被应用于计算机视觉问题，包括图像降噪（image denoising） 、神经风格迁移（neural style transfer）等 ，本文主要讲解如何利用AutoEncoder进行异常检测试验。
用AutoEncoder进行降噪，可以看到通过卷积自编码器，我们的降噪效果还是非常好的，最终生成的图片看起来非常顺滑，噪声也几乎看不到了。
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图3
用AutoEncoder进行降维。
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图4

一、Autoencoder结构简介

Autoencoder本质上它使用了一个神经网络来产生一个高维输入的低维表，Autoencoder与主成分分析PCA类似，但是Autoencoder在使用非线性激活函数时克服了PCA线性的限制。
Autoencoder包含两个主要的部分，encoder（编码器）和 decoder（解码器）。Encoder的作用是用来发现给定数据的压缩表示，decoder是用来重建原始输入。在训练时，decoder 强迫 autoencoder 选择最有信息量的特征，最终保存在压缩表示中。最终压缩后的表示就在中间的coder层当中。
以下图为例，原始数据的维度是10，encoder和decoder分别有两层，中间的coder共有3个节点，也就是说原始数据被降到了只有3维。Decoder根据降维后的数据再重建原始数据，重新得到10维的输出。从Input到Ouptut的这个过程中，autoencoder实际上也起到了降噪的作用。
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图5

二、Autoencoder异常检测流程

异常检测(anomaly detection)通常分为有监督和无监督两种情形。在无监督的情况下，我们没有异常样本用来学习，而算法的基本上假设是异常点服从不同的分布。根据正常数据训练出来的Autoencoder，能够将正常样本重建还原，但是却无法将异于正常分布的数据点较好地还原，导致还原误差较大。
如果样本的特征都是数值变量，我们可以用MSE或者MAE作为还原误差。例如上图，如果输入样本为
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图6
经过Autoencoder重建的结果为
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图7
还原误差MSE为
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图8
还原误差MAE为
基于深度学习Autoencoder的信用卡欺诈异常检测 - 图9

三、模型算法过程

数据还是使用信用卡的数据，数据来自于kaggle上的一个信用卡欺诈检测比赛，数据质量高，正负样本比例非常悬殊，很典型的异常检测数据集，在这个数据集上来测试一下各种异常检测手段的效果。当然，可能换个数据集结果就会有很大不同，结果仅供参考。

全文代码汇总：

  1. # -*- coding: utf-8 -*-
  3. # 加载所需要的包
  4. import warnings
  5. warnings.filterwarnings("ignore")
  6. import os 
  7. import pandas as pd 
  8. import numpy as np 
  9. import matplotlib.pyplot as plt
  10. #plt.style.use('seaborn')
  11. import tensorflow as tf
  12. import seaborn as sns
  13. from sklearn.model_selection import train_test_split
  15. from keras.models import Model, load_model
  16. from keras.layers import Input, Dense,LeakyReLU,BatchNormalization
  17. from keras.callbacks import ModelCheckpoint
  18. from keras import regularizers
  19. from sklearn.preprocessing import StandardScaler
  20. from sklearn.metrics import roc_curve, auc, precision_recall_curve
  23. # 解决报错“ImportError: cannot import name 'get_config' from 'tensorflow.python.eager.context'”
  24. # 升级 tensorflow
  26. # 工作空间设置
  27. os.chdir('/Users/yingtao.xiang/Downloads/archive/')
  28. os.getcwd()
  32. # 读取数据
  33. d = pd.read_csv('creditcard.csv')
  35. # 查看样本比例
  36. num_nonfraud = np.sum(d['Class'] == 0)
  37. num_fraud = np.sum(d['Class'] == 1)
  38. plt.bar(['Fraud', 'non-fraud'], [num_fraud, num_nonfraud], color='dodgerblue')
  39. plt.show()
  41. # 删除时间列，对Amount进行标准化
  42. data = d.drop(['Time'], axis=1)
  43. data['Amount'] = StandardScaler().fit_transform(data[['Amount']])
  44. X = data.drop(['Class'],axis=1)
  45. Y = data.Class
  49. # 设置Autoencoder的参数
  50. input_dim    = X.shape[1]
  51. encoding_dim = 128
  52. num_epoch    = 30
  53. batch_size   = 256
  55. input_layer = Input(shape=(input_dim, ))
  57. encoder = Dense(encoding_dim, 
  58.                 activation="tanh", 
  59.                 activity_regularizer=regularizers.l1(10e-5)
  60.                 )(input_layer)
  61. encoder =BatchNormalization()(encoder)
  62. encoder=LeakyReLU(alpha=0.2)(encoder)
  64. encoder = Dense(int(encoding_dim/2), 
  65.                 activation="relu"
  66.                 )(encoder)
  67. encoder =BatchNormalization()(encoder)
  68. encoder=LeakyReLU(alpha=0.1)(encoder)
  70. encoder = Dense(int(encoding_dim/4), 
  71.                 activation="relu"
  72.                 )(encoder)
  73. encoder =BatchNormalization()(encoder)
  77. ### decoder
  78. decoder = LeakyReLU(alpha=0.1)(encoder)
  79. decoder = Dense(int(encoding_dim/4),
  80.                 activation='tanh'
  81.                 )(decoder)
  82. decoder = BatchNormalization()(decoder)
  83. decoder = LeakyReLU(alpha=0.1)(decoder)
  86. decoder = Dense(int(encoding_dim/2),
  87.                 activation='tanh'
  88.                 )(decoder)
  89. decoder = BatchNormalization()(decoder)
  90. decoder = LeakyReLU(alpha=0.1)(decoder)
  92. decoder = Dense(input_dim, 
  93.                 #activation='relu'
  94.                 )(decoder)
  96. autoencoder = Model(inputs = input_layer, 
  97.                     outputs = decoder
  98.                     )
  99. autoencoder.compile(optimizer='adam', 
  100.                     loss='mean_squared_error', 
  101.                     metrics=['mae','mse']
  102.                     )
  104. # 模型保存为 XiaoWuGe_model.h5，并开始训练模型
  105. checkpointer = ModelCheckpoint(filepath="XiaoWuGe_model.h5",
  106.                                verbose=0,
  107.                                save_best_only=True
  108.                                )
  110. history = autoencoder.fit(X, 
  111.                           X,
  112.                           epochs=num_epoch,
  113.                           batch_size=batch_size,
  114.                           shuffle=True,
  115.                           #validation_data=(X_test, X_test),
  116.                           verbose=1, 
  117.                           callbacks=[checkpointer]
  118.                           ).history
  119. # Epoch 1/30
  120. # 284807/284807 [==============================] - 39s 136us/step - loss: 0.6593 - mae: 0.3893 - mse: 0.4098
  121. # Epoch 2/30
  122. # Epoch 29/30
  123. # 284807/284807 [==============================] - 41s 144us/step - loss: 0.1048 - mae: 0.1188 - mse: 0.0558
  124. # Epoch 30/30
  125. # 284807/284807 [==============================] - 39s 135us/step - loss: 0.0891 - mae: 0.1134 - mse: 0.0495
  129. # 模型结果可视化
  131. # 画出损失函数曲线
  132. plt.figure(figsize=(14, 5))
  133. plt.subplot(121)
  134. plt.plot(history['loss'], c='dodgerblue', lw=3)
  135. plt.title('model loss')
  136. plt.ylabel('mse')
  137. plt.xlabel('epoch')
  138. plt.legend(['train'], loc='upper right')
  141. # 画出损失函数曲线
  142. plt.figure(figsize=(14, 5))
  143. plt.subplot(121)
  144. plt.plot(history['mae'], c='dodgerblue', lw=3)
  145. plt.title('model mae')
  146. plt.ylabel('mae')
  147. plt.xlabel('epoch')
  148. plt.legend(['train'], loc='upper right')
  150. # 画出损失函数曲线
  151. plt.figure(figsize=(14, 5))
  152. plt.subplot(121)
  153. plt.plot(history['mse'], c='dodgerblue', lw=3)
  154. plt.title('model mse')
  155. plt.ylabel('mse')
  156. plt.xlabel('epoch')
  157. plt.legend(['train'], loc='upper right')
  161. # 模型结果预测
  162. #利用训练好的autoencoder重建测试集
  163. pred_X  = autoencoder.predict(X)
  164. # 计算还原误差MSE和MAE
  165. mse_X = np.mean(np.power(X-pred_X,2), axis=1)
  166. mae_X = np.mean(np.abs(X-pred_X),     axis=1)
  168. data['mse_X'] = mse_X
  169. data['mae_X'] = mae_X
  170. # TopN准确率评估
  171. n = 1000
  172. df =  data.sort_values(by='mae_X',ascending=False)
  173. df = df.head(n)
  174. rate = df[df['Class']==1].shape[0]/n
  175. print('Top{}的准确率为:{}'.format(n,rate))
  177. # Top1000的准确率为:0.336
  178. # 我实际跑出来：Top1000的准确率为:0.145
  179. # 可以看到，我们的准确率为0.336，比之前的孤立森林又有了很大的提高，但是我经过了比较多的试验，这是比较理想的结果。
  185. # 下面我可以可以看看，正样本和负样本的一个分布差异。
  186. # 提取负样本，并且按照7:3切成训练集和测试集
  187. mask = (data['Class'] == 0)
  188. X_train, X_test = train_test_split(X, test_size=0.3,
  189.                                    random_state=520)
  191. # 提取所有正样本，作为测试集的一部分
  192. X_fraud = X[~mask]
  195. # 利用训练好的autoencoder重建测试集
  196. pred_test  = autoencoder.predict(X_test)
  197. pred_fraud = autoencoder.predict(X_fraud)
  200. # 计算还原误差MSE和MAE
  201. mse_test = np.mean(np.power(X_test - pred_test, 2), axis=1)
  202. mse_fraud = np.mean(np.power(X_fraud - pred_fraud, 2), axis=1)
  203. mae_test = np.mean(np.abs(X_test - pred_test), axis=1)
  204. mae_fraud = np.mean(np.abs(X_fraud - pred_fraud), axis=1)
  205. mse_df = pd.DataFrame()
  206. mse_df['Class'] = [0] * len(mse_test) + [1] * len(mse_fraud)
  207. mse_df['MSE'] = np.hstack([mse_test, mse_fraud])
  208. mse_df['MAE'] = np.hstack([mae_test, mae_fraud])
  209. mse_df = mse_df.sample(frac=1).reset_index(drop=True)
  212. # 分别画出测试集中正样本和负样本的还原误差MAE和MSE
  213. markers = ['o', '^']
  214. markers = ['o', '^']
  215. colors = ['dodgerblue', 'red']
  216. labels = ['Non-fraud', 'Fraud']
  218. plt.figure(figsize=(14, 5))
  219. plt.subplot(121)
  220. for flag in [1, 0]:
  221.     temp = mse_df[mse_df['Class'] == flag]
  222.     plt.scatter(temp.index, 
  223.                 temp['MAE'],  
  224.                 alpha=0.7, 
  225.                 marker=markers[flag], 
  226.                 c=colors[flag], 
  227.                 label=labels[flag])
  228. plt.title('Reconstruction MAE')
  229. plt.ylabel('Reconstruction MAE')
  230. plt.xlabel('Index')
  232. plt.subplot(122)
  233. for flag in [1, 0]:
  234.     temp = mse_df[mse_df['Class'] == flag]
  235.     plt.scatter(temp.index, 
  236.                 temp['MSE'],  
  237.                 alpha=0.7, 
  238.                 marker=markers[flag], 
  239.                 c=colors[flag], 
  240.                 label=labels[flag])
  241. plt.legend(loc=[1, 0], fontsize=12)
  242. plt.title('Reconstruction MSE')
  243. plt.ylabel('Reconstruction MSE')
  244. plt.xlabel('Index')
  245. plt.show()

1、数据集介绍

信用卡欺诈是指故意使用伪造、作废的信用卡，冒用他人的信用卡骗取财物，或用本人信用卡进行恶意透支的行为,信用卡欺诈形式分为3种：失卡冒用、假冒申请、伪造信用卡。欺诈案件中，有60%以上是伪造信用卡诈骗，其特点是团伙性质，从盗取卡资料、制造假卡、贩卖假卡，到用假卡作案，牟取暴利。而信用卡欺诈检测是银行减少损失的重要手段。
该数据集包含欧洲持卡人于 2013 年 9 月通过信用卡进行的交易信息。此数据集显示的是两天内发生的交易，在 284807 笔交易中，存在 492 起欺诈，数据集高度不平衡，正类（欺诈）仅占所有交易的 0.172%。原数据集已做脱敏处理和PCA处理，匿名变量V1， V2， …V28 是 PCA 获得的主成分，唯一未经过 PCA 处理的变量是 Time 和 Amount。Time 是每笔交易与数据集中第一笔交易之间的间隔，单位为秒；Amount 是交易金额。Class 是分类变量，在发生欺诈时为1，否则为0。项目要求根据现有数据集建立分类模型，对信用卡欺诈行为进行检测。
注：PCA - “Principal Component Analysis” - 主成分分析，用于提取数据集的”主成分”特征，即对数据集进行降维处理。

2、数据来源

数据集 Credit Card Fraud Detection 由比利时布鲁塞尔自由大学(ULB) - Worldline and the Machine Learning Group 提供。可从Kaggle上下载：https://www.kaggle.com/mlg-ulb/creditcardfraud
不想自己下载数据的，后台回复【信用卡欺诈】领取。

3、模型搭建

需要的包比较多，我们先加载下

  1. # 加载所需要的包
  2. import warnings
  3. warnings.filterwarnings("ignore")
  4. import os 
  5. import pandas as pd 
  6. import numpy as np 
  7. import matplotlib.pyplot as plt
  8. #plt.style.use('seaborn')
  9. import tensorflow as tf
  10. import seaborn as sns
  11. from sklearn.model_selection import train_test_split
  12. from keras.models import Model, load_model
  13. from keras.layers import Input, Dense,LeakyReLU,BatchNormalization
  14. from keras.callbacks import ModelCheckpoint
  15. from keras import regularizers
  16. from sklearn.preprocessing import StandardScaler
  17. from sklearn.metrics import roc_curve, auc, precision_recall_curve
  18. # 工作空间设置
  19. os.chdir('/Users/wuzhengxiang/Documents/DataSets/CreditCardFraudDetection')
  20. os.getcwd()

数据读取和简单的特征工程

  2. # 读取数据
  3. d = pd.read_csv('creditcard.csv')
  5. # 查看样本比例
  6. num_nonfraud = np.sum(d['Class'] == 0)
  7. num_fraud = np.sum(d['Class'] == 1)
  8. plt.bar(['Fraud', 'non-fraud'], [num_fraud, num_nonfraud], color='dodgerblue')
  9. plt.show()
  11. # 删除时间列，对Amount进行标准化
  12. data = d.drop(['Time'], axis=1)
  13. data['Amount'] = StandardScaler().fit_transform(data[['Amount']])
  14. X = data.drop(['Class'],axis=1)
  15. Y = data.Class

基于深度学习Autoencoder的信用卡欺诈异常检测 - 图10
模型搭建+模型训练

  1. # 设置Autoencoder的参数
  2. input_dim    = X.shape[1]
  3. encoding_dim = 128
  4. num_epoch    = 30
  5. batch_size   = 256
  7. input_layer = Input(shape=(input_dim, ))
  9. encoder = Dense(encoding_dim, 
  10.                 activation="tanh", 
  11.                 activity_regularizer=regularizers.l1(10e-5)
  12.                 )(input_layer)
  13. encoder =BatchNormalization()(encoder)
  14. encoder=LeakyReLU(alpha=0.2)(encoder)
  16. encoder = Dense(int(encoding_dim/2), 
  17.                 activation="relu"
  18.                 )(encoder)
  19. encoder =BatchNormalization()(encoder)
  20. encoder=LeakyReLU(alpha=0.1)(encoder)
  22. encoder = Dense(int(encoding_dim/4), 
  23.                 activation="relu"
  24.                 )(encoder)
  25. encoder =BatchNormalization()(encoder)
  29. ### decoder
  30. decoder = LeakyReLU(alpha=0.1)(encoder)
  31. decoder = Dense(int(encoding_dim/4),
  32.                 activation='tanh'
  33.                 )(decoder)
  34. decoder = BatchNormalization()(decoder)
  35. decoder = LeakyReLU(alpha=0.1)(decoder)
  38. decoder = Dense(int(encoding_dim/2),
  39.                 activation='tanh'
  40.                 )(decoder)
  41. decoder = BatchNormalization()(decoder)
  42. decoder = LeakyReLU(alpha=0.1)(decoder)
  44. decoder = Dense(input_dim, 
  45.                 #activation='relu'
  46.                 )(decoder)
  48. autoencoder = Model(inputs = input_layer, 
  49.                     outputs = decoder
  50.                     )
  51. autoencoder.compile(optimizer='adam', 
  52.                     loss='mean_squared_error', 
  53.                     metrics=['mae','mse']
  54.                     )
  56. # 模型保存为 XiaoWuGe_model.h5，并开始训练模型
  57. checkpointer = ModelCheckpoint(filepath="XiaoWuGe_model.h5",
  58.                                verbose=0,
  59.                                save_best_only=True
  60.                                )
  61. history = autoencoder.fit(X, 
  62.                           X,
  63.                           epochs=num_epoch,
  64.                           batch_size=batch_size,
  65.                           shuffle=True,
  66.                           #validation_data=(X_test, X_test),
  67.                           verbose=1, 
  68.                           callbacks=[checkpointer]
  69.                           ).history
  70. Epoch 1/30
  71. 284807/284807 [==============================] - 39s 136us/step - loss: 0.6593 - mae: 0.3893 - mse: 0.4098
  72. Epoch 2/30
  73. Epoch 29/30
  74. 284807/284807 [==============================] - 41s 144us/step - loss: 0.1048 - mae: 0.1188 - mse: 0.0558
  75. Epoch 30/30
  76. 284807/284807 [==============================] - 39s 135us/step - loss: 0.0891 - mae: 0.1134 - mse: 0.0495
  80. 模型结果可视化
  82. # 画出损失函数曲线
  83. plt.figure(figsize=(14, 5))
  84. plt.subplot(121)
  85. plt.plot(history['loss'], c='dodgerblue', lw=3)
  86. plt.title('model loss')
  87. plt.ylabel('mse')
  88. plt.xlabel('epoch')
  89. plt.legend(['train'], loc='upper right')
  92. # 画出损失函数曲线
  93. plt.figure(figsize=(14, 5))
  94. plt.subplot(121)
  95. plt.plot(history['mae'], c='dodgerblue', lw=3)
  96. plt.title('model mae')
  97. plt.ylabel('mae')
  98. plt.xlabel('epoch')
  99. plt.legend(['train'], loc='upper right')
  101. # 画出损失函数曲线
  102. plt.figure(figsize=(14, 5))
  103. plt.subplot(121)
  104. plt.plot(history['mse'], c='dodgerblue', lw=3)
  105. plt.title('model mse')
  106. plt.ylabel('mse')
  107. plt.xlabel('epoch')
  108. plt.legend(['train'], loc='upper right')

基于深度学习Autoencoder的信用卡欺诈异常检测 - 图11
模型结果预测

  2. #利用训练好的autoencoder重建测试集
  3. pred_X  = autoencoder.predict(X)
  4. # 计算还原误差MSE和MAE
  5. mse_X = np.mean(np.power(X-pred_X,2), axis=1)
  6. mae_X = np.mean(np.abs(X-pred_X),     axis=1)
  9. data['mse_X'] = mse_X
  10. data['mae_X'] = mae_X
  11. # TopN准确率评估
  12. n = 1000
  13. df =  data.sort_values(by='mae_X',ascending=False)
  14. df = df.head(n)
  15. rate = df[df['Class']==1].shape[0]/n
  16. print('Top{}的准确率为:{}'.format(n,rate))
  18. Top1000的准确率为:0.336

可以看到，我们的准确率为0.336，比之前的孤立森林又有了很大的提高，但是我经过了比较多的试验，这是比较理想的结果。后期我会找个更加稳定的结构分享给大家，下面我可以可以看看，正样本和负样本的一个分布差异。

  1. # 提取负样本，并且按照7:3切成训练集和测试集
  2. mask = (data['Class'] == 0)
  3. X_train, X_test = train_test_split(X, test_size=0.3,
  4.                                    random_state=520)
  6. # 提取所有正样本，作为测试集的一部分
  7. X_fraud = X[~mask]
  10. # 利用训练好的autoencoder重建测试集
  11. pred_test  = autoencoder.predict(X_test)
  12. pred_fraud = autoencoder.predict(X_fraud)
  15. # 计算还原误差MSE和MAE
  16. mse_test = np.mean(np.power(X_test - pred_test, 2), axis=1)
  17. mse_fraud = np.mean(np.power(X_fraud - pred_fraud, 2), axis=1)
  18. mae_test = np.mean(np.abs(X_test - pred_test), axis=1)
  19. mae_fraud = np.mean(np.abs(X_fraud - pred_fraud), axis=1)
  20. mse_df = pd.DataFrame()
  21. mse_df['Class'] = [0] * len(mse_test) + [1] * len(mse_fraud)
  22. mse_df['MSE'] = np.hstack([mse_test, mse_fraud])
  23. mse_df['MAE'] = np.hstack([mae_test, mae_fraud])
  24. mse_df = mse_df.sample(frac=1).reset_index(drop=True)
  27. # 分别画出测试集中正样本和负样本的还原误差MAE和MSE
  28. markers = ['o', '^']
  29. markers = ['o', '^']
  30. colors = ['dodgerblue', 'red']
  31. labels = ['Non-fraud', 'Fraud']
  33. plt.figure(figsize=(14, 5))
  34. plt.subplot(121)
  35. for flag in [1, 0]:
  36.     temp = mse_df[mse_df['Class'] == flag]
  37.     plt.scatter(temp.index, 
  38.                 temp['MAE'],  
  39.                 alpha=0.7, 
  40.                 marker=markers[flag], 
  41.                 c=colors[flag], 
  42.                 label=labels[flag])
  43. plt.title('Reconstruction MAE')
  44. plt.ylabel('Reconstruction MAE')
  45. plt.xlabel('Index')
  47. plt.subplot(122)
  48. for flag in [1, 0]:
  49.     temp = mse_df[mse_df['Class'] == flag]
  50.     plt.scatter(temp.index, 
  51.                 temp['MSE'],  
  52.                 alpha=0.7, 
  53.                 marker=markers[flag], 
  54.                 c=colors[flag], 
  55.                 label=labels[flag])
  56. plt.legend(loc=[1, 0], fontsize=12)
  57. plt.title('Reconstruction MSE')
  58. plt.ylabel('Reconstruction MSE')
  59. plt.xlabel('Index')
  60. plt.show()

基于深度学习Autoencoder的信用卡欺诈异常检测 - 图12
可以看到，正负样本的MAE和MSE有比较明显的差异，证明这个算法有很好的异常检测能力，当然，有部分正常样本还是很难通过异常检测分开。