• 基于自编码器和LSTM自编码器的心电信号异常检测

    1. import os
    2. import numpy as np
    3. import pandas as pd
    4. import seaborn as sns
    5. import matplotlib as mpl
    6. import matplotlib.pyplot as plt
    7.  
    8.  
    9. from sklearn.preprocessing import MinMaxScaler
    10. from sklearn.model_selection import train_test_split
    11.  
    12.  
    13. import tensorflow as tf
    14. from tensorflow.keras import layers,losses
    15. from tensorflow.keras.layers import Input, Dense, LSTM, RepeatVector, TimeDistributed
    16. from tensorflow.keras.models import Model
    17. from tensorflow.keras.utils import plot_model
    18.  
    19.  
    20. RANDOM_SEED = 42
    21. np.random.seed(RANDOM_SEED)
    22. # Import the dataset files
    23.  
    24.  
    25. ecg_train_file = 'ECG5000_TRAIN.csv'
    26. ecg_test_file = 'ECG5000_TEST.csv'
    27.  
    28.  
    29. train_data = pd.read_csv(ecg_train_file)
    30. test_data = pd.read_csv(ecg_test_file)
    31.  
    32.  
    33. df_train = pd.DataFrame(train_data)
    34. df_test = pd.DataFrame(test_data)
    35. df = pd.concat([df_train, df_test], ignore_index=True)
    36. df = df.drop(labels='id', axis=1)
    37. # 140 timesteps + target
    38. new_columns = list(df.columns)
    39. new_columns[-1] = 'target'
    40. df.columns = new_columns
    41. df

    1. normal_class = 1
    2. class_names = ['Normal','R on T','PVC','SP','UB']
    3. df['target'].value_counts()
    4. 1    2919
    5. 2    1767
    6. 4     194
    7. 3      96
    8. 5      24
    9. Name: target, dtype: int64
    10. plt.figure(figsize=(12,8))
    11. ax = sns.countplot(x=df.target)
    12. ax.set_xticklabels(class_names);

    1. def plot_time_series_class(data, class_name, ax, n_steps=10):
    2.   '''
    3.   This function plots an averaged time series for each class, 
    4.   smoothed out with a standard deviation around it.
    5.   '''
    6.  
    7.  
    8.   time_series_df = pd.DataFrame(data) 
    9.   
    10.   # sliding window iterator rolling(win_size)
    11.   smooth_path = time_series_df.rolling(n_steps).mean()
    12.   path_deviation = 2 * time_series_df.rolling(n_steps).std()
    13.  
    14.  
    15.   # smooth with a std under and over the line
    16.   under_line = (smooth_path - path_deviation)[0]
    17.   over_line = (smooth_path + path_deviation)[0]
    18.  
    19.  
    20.   ax.plot(smooth_path, linewidth=2)
    21.   ax.fill_between(path_deviation.index, under_line, over_line, alpha=.200)
    22.   ax.set_title(class_name)
    23. classes = df.target.unique()
    24.  
    25.  
    26. fig, axs = plt.subplots(
    27.   nrows=len(classes) // 3 + 1,
    28.   ncols=3,
    29.   sharey=True,
    30.   figsize=(18, 8)
    31. )
    32.  
    33.  
    34. # plot for each class (1-5)
    35. for i, cls in enumerate(classes):
    36.   ax = axs.flat[i]
    37.   data = df[df.target == cls] \
    38.     .drop(labels='target', axis=1) \
    39.     .mean(axis=0) \
    40.     .to_numpy()    
    41.   plot_time_series_class(data, class_names[i], ax)
    42.  
    43.  
    44. fig.delaxes(axs.flat[-1])
    45. fig.tight_layout();

    1. X_train, X_test, y_train, y_test = train_test_split(df.values,
    2.                                                     df.values[:,-1], 
    3.                                                     test_size=0.33,
    4.                                                     random_state=RANDOM_SEED)
    5.  
    6.  
    7. X_test, X_val, y_test, y_val = train_test_split(X_test,
    8.                                                     y_test, 
    9.                                                     test_size=0.5,
    10.                                                     random_state=RANDOM_SEED)
    11. print('The shape of the training set: ', X_train.shape)
    12. print('The shape of the validation set:  ', X_val.shape)
    13. print('The shape of the test set:  ', X_test.shape)
    14. The shape of the training set:  (3350, 141)
    15. The shape of the validation set:   (825, 141)
    16. The shape of the test set:   (825, 141)
    17. scaler = MinMaxScaler()
    18. data_scaled = scaler.fit(X_train[:,:-1])
    19. X_train[:,:-1] = data_scaled.transform(X_train[:,:-1])
    20. X_val[:,:-1] = data_scaled.transform(X_val[:,:-1])
    21. X_test[:,:-1] = data_scaled.transform(X_test[:,:-1])
    22. df_train = pd.DataFrame(X_train)
    23. df_val = pd.DataFrame(X_val)
    24. df_test = pd.DataFrame(X_test)
    25. def filter_normal_signals(df):
    26.   '''Filters out normal signals (target = 1)'''
    27.   
    28.   df = df[df.iloc[:,-1] == 1].drop(columns=df.columns[-1], axis=1)
    29.   return df.values
    30.  
    31.  
    32. def filter_anomalous_signals(df):
    33.   ''' Filters out anomalous signals (target > 1)'''
    34.  
    35.  
    36.   df = df[df.iloc[:,-1] > 1].drop(columns=df.columns[-1], axis=1)
    37.   return df.values
    38. normal_X_train = filter_normal_signals(df_train)
    39. normal_X_val = filter_normal_signals(df_val) 
    40. normal_X_test = filter_normal_signals(df_test)
    41. print('The shape of the normal signals training set: ', normal_X_train.shape)
    42. print('The shape of the normal signals validation set:  ', normal_X_val.shape)
    43. print('The shape of the normal signals test set:  ', normal_X_test.shape)
    44. The shape of the normal signals training set:  (1932, 140)
    45. The shape of the normal signals validation set:   (492, 140)
    46. The shape of the normal signals test set:   (495, 140)
    47. anomaly_X_train = filter_anomalous_signals(df_train)
    48. anomaly_X_val = filter_anomalous_signals(df_val) 
    49. anomaly_X_test = filter_anomalous_signals(df_test)
    50. print('The shape of the normal signals training set: ', anomaly_X_train.shape)
    51. print('The shape of the normal signals validation set:  ', anomaly_X_val.shape)
    52. print('The shape of the normal signals test set:  ', anomaly_X_test.shape)
    53. The shape of the normal signals training set:  (1418, 140)
    54. The shape of the normal signals validation set:   (333, 140)
    55. The shape of the normal signals test set:   (330, 140)
    56. # normal signals
    57.  
    58.  
    59. plt.figure(figsize=(12,8)) 
    60. for i in range(5,10):
    61.   plt.plot(normal_X_train[i])

    1. # anomalous signals
    2.  
    3.  
    4. plt.figure(figsize=(12,8)) 
    5. for i in range(5,10):
    6.   plt.plot(anomaly_X_train[i])

    1. class AutoEncoder(Model):
    2.   def __init__(self):
    3.     super(AutoEncoder, self).__init__()
    4.     # Define the encoder 
    5.     self.encoder = tf.keras.Sequential([
    6.       layers.Dense(64, activation="relu"),
    7.       layers.Dense(32, activation="relu"),
    8.       layers.Dense(16, activation="relu"),
    9.       layers.Dense(8, activation="relu")])
    10.  
    11.  
    12.     # Define the decoder 
    13.     self.decoder = tf.keras.Sequential([
    14.       layers.Dense(16, activation="relu"),
    15.       layers.Dense(32, activation="relu"),
    16.       layers.Dense(64, activation="relu"),
    17.       layers.Dense(140, activation="sigmoid")])
    18.  
    19.  
    20.   def call(self, x):
    21.     # Define how an evaluation of the network is performed
    22.     encoded = self.encoder(x)
    23.     decoded = self.decoder(encoded)
    24.     return decoded

    1. autoencoder = AutoEncoder()
    2.  
    3.  
    4. early_stopping = tf.keras.callbacks.EarlyStopping(
    5.                     monitor='val_loss', 
    6.                     patience=5,
    7.                     mode='min',
    8.                     restore_best_weights=True)
    9.  
    10.  
    11. lr_plateau = tf.keras.callbacks.ReduceLROnPlateau(
    12.     monitor='val_loss', 
    13.     factor=0.5,
    14.     patience=5, 
    15.     min_lr=1e-6, 
    16.     mode='min')
    17.  
    18.  
    19. autoencoder.compile(optimizer='adam', loss='mse')
    20. history = autoencoder.fit(normal_X_train, normal_X_train, 
    21.                     epochs=30,
    22.                     batch_size=128,
    23.                     validation_data=(normal_X_val, normal_X_val),
    24.                     callbacks=[early_stopping, lr_plateau],
    25.                     shuffle=True)
    26. autoencoder.decoder.summary()
    27. Model: "sequential_1"
    28. _________________________________________________________________
    29.  Layer (type)                Output Shape              Param #   
    30. =================================================================
    31.  dense_4 (Dense)             (None, 16)                144       
    32.                                                                  
    33.  dense_5 (Dense)             (None, 32)                544       
    34.                                                                  
    35.  dense_6 (Dense)             (None, 64)                2112      
    36.                                                                  
    37.  dense_7 (Dense)             (None, 140)               9100      
    38.                                                                  
    39. =================================================================
    40. Total params: 11,900
    41. Trainable params: 11,900
    42. Non-trainable params: 0
    43. plt.figure(figsize=(12,8)) 
    44. plt.plot(history.history["loss"], label="Training Loss")
    45. plt.plot(history.history["val_loss"], label="Validation Loss")
    46. plt.legend()

    1. encoded_signal = autoencoder.encoder(normal_X_test).numpy()
    2. decoded_signal = autoencoder.decoder(encoded_signal).numpy()
    3.  
    4.  
    5. plt.figure(figsize=(12,8)) 
    6. plt.plot(normal_X_test[100], 'b')
    7. plt.plot(decoded_signal[100], 'r')
    8. plt.fill_between(np.arange(140), decoded_signal[100], normal_X_test[100], color='lightcoral')
    9. plt.legend(labels=["Input", "Reconstruction", "Error"])
    10. plt.show()

    1. encoded_signal = autoencoder.encoder(anomaly_X_test).numpy()
    2. decoded_signal = autoencoder.decoder(encoded_signal).numpy()
    3.  
    4.  
    5. plt.figure(figsize=(12,8)) 
    6. plt.plot(anomaly_X_test[100], 'b')
    7. plt.plot(decoded_signal[100], 'r')
    8. plt.fill_between(np.arange(140), decoded_signal[100], anomaly_X_test[100], color='lightcoral')
    9. plt.legend(labels=["Input", "Reconstruction", "Error"])
    10. plt.show()

    1. reconstruction = autoencoder.predict(normal_X_train)
    2. train_loss = tf.keras.losses.mse(reconstruction, normal_X_train)
    3. fig, ax = plt.subplots(figsize=(12, 8))
    4. sns.distplot(train_loss, bins=50, kde=True, ax=ax.grid()).set(title='Distribution of normal train data reconstruction loss')

    1. mean_normal = np.mean(train_loss)
    2. std_normal = np.std(train_loss)
    3. threshold = mean_normal + 2*std_normal
    4. print("Threshold: ", threshold)
    5. Threshold:  0.008762959466782183
    6. reconstruction_test = autoencoder.predict(normal_X_test)
    7. test_loss_normal = tf.keras.losses.mse(reconstruction_test, normal_X_test)
    8. fig, ax = plt.subplots(figsize=(12, 8))
    9. sns.distplot(test_loss_normal, bins=50, kde=True, ax=ax.grid()).set(title='Distribution of normal test data reconstruction loss')

    1. reconstruction_anomalies = autoencoder.predict(anomaly_X_test)
    2. test_loss_anomalies = tf.keras.losses.mse(reconstruction_anomalies, anomaly_X_test)
    3. fig, ax = plt.subplots(figsize=(12, 8))
    4. sns.distplot(test_loss_anomalies, bins=50, kde=True, ax=ax.grid()).set(title='Distribution of anomalous test data reconstruction loss')

    1. sns.set(rc={'figure.figsize':(12,8)})
    2.  
    3.  
    4. # Plot two histograms of normal and anomalous data
    5. sns.distplot(test_loss_normal.numpy(), bins=50, label='normal')
    6. sns.distplot(test_loss_anomalies.numpy(), bins=50, label='anomaly')
    7.  
    8.  
    9. # Plot a vertical line representing the threshold
    10. plt.axvline(threshold, color='r', linewidth=2, linestyle='dashed', label='{:0.3f}'.format(threshold))
    11.  
    12.  
    13. # Add legend and title
    14. plt.legend(loc='upper right')
    15. plt.title('Threshold for detecting anomalies')
    16. plt.show()

    1. def predict_metrics(normal, anomalous, threshold):
    2.   ''' Compute the True Positives (TP), True Negatives (TN), 
    3.       False Positives (FP) and False Negatives (FN) given the 
    4.       normal data, anomalous data and the threshold.
    5.   '''
    6.     # We correctly detect normal data if the normal loss is smaller than the threshold
    7.     pred_normal = tf.math.less(normal, threshold)
    8.     
    9.     # We correctly detect anomalous data if the normal loss is greater than the threshold
    10.     pred_anomaly = tf.math.greater(anomalous, threshold)
    11.  
    12.  
    13.     tn = tf.math.count_nonzero(pred_normal).numpy()
    14.     fp = normal.shape[0] - tn
    15.  
    16.  
    17.     tp = tf.math.count_nonzero(pred_anomaly).numpy()
    18.     fn = anomalous.shape[0] - tp
    19.     
    20.     return tp, tn, fp, fn
    21. tp, tn, fp, fn = predict_metrics(test_loss_normal, test_loss_anomalies, threshold)
    22.  
    23.  
    24. cm = [[tn, fp], 
    25.       [fn, tp]]
    26. categories = ['Normal', 'Anomalies']
    27.  
    28.  
    29. plt.figure(figsize=(8,6))
    30. g = sns.heatmap(cm, annot=True, fmt="d",
    31.             xticklabels=categories, 
    32.             yticklabels=categories, 
    33.             cmap="GnBu")
    34.  
    35.  
    36. g.set(xlabel='Predicted', ylabel='Actual', title='Confusion Matrix')
    37.  
    38.  
    39. plt.show()

    1. tpr_val = []
    2. fpr_val = []
    3.  
    4.  
    5. for t in np.linspace(0, 1, 100):
    6.     tp, tn, fp, fn = predict_metrics(test_loss_normal, 
    7.                                     test_loss_anomalies, 
    8.                                     t/10)
    9.     tpr = tp/(tp + fn)
    10.     fpr = fp/(fp + tn)
    11.     tpr_val.append(tpr)
    12.     fpr_val.append(fpr)
    13.  
    14.  
    15. fig, ax = plt.subplots(figsize=(10,7))
    16. ax.plot(fpr_val, tpr_val)
    17. ax.plot(np.linspace(0, 1, 100),
    18.          np.linspace(0, 1, 100),
    19.          label='baseline',
    20.          linestyle='--')
    21. plt.title('Receiver Operating Characteristic Curve', fontsize=18)
    22. plt.ylabel('TPR', fontsize=16)
    23. plt.xlabel('FPR', fontsize=16)
    24. plt.legend(fontsize=12);

    1. def compute_stats(tp, tn, fp, fn):
    2.   ''' Computes accuracy, precision, recall and f1 scores
    3.   given TP, TN, FP and FN'''
    4.   
    5.   acc = (tp + tn) / (tp + tn + fp + fn)
    6.   prec = tp / (tp + fp) 
    7.   rec = tp / (tp + fn)
    8.   f1 = 2 * (prec * rec) / (prec + rec)
    9.  
    10.  
    11.   return acc, prec, rec, f1
    12. tp, tn, fp, fn = predict_metrics(test_loss_normal, test_loss_anomalies, threshold)
    13. accuracy, precision, recall, f1 = compute_stats(tp, tn, fp, fn)
    14.  
    15.  
    16. print("Accuracy = {}".format(np.round(accuracy,4)))
    17. print("Precision = {}".format(np.round(precision,4)))
    18. print("Recall = {}".format(np.round(recall,4)))
    19. print("F1-score = {}".format(np.round(f1,4)))
    20. Accuracy = 0.9745
    21. Precision = 0.9558
    22. Recall = 0.9818
    23. F1-score = 0.9686
    24. class LSTMAutoencoder(Model):
    25.   def __init__(self):
    26.     super(LSTMAutoencoder, self).__init__()
    27.     self.encoder = tf.keras.Sequential([
    28.         layers.Reshape((normal_X_train.shape[1], 1)),
    29.         layers.LSTM(128, input_shape=(normal_X_train.shape[1], 1), return_sequences=True),
    30.         layers.LSTM(64, return_sequences=False),
    31.     ])
    32.  
    33.  
    34.     self.repeat_vector = layers.RepeatVector(normal_X_train.shape[1])
    35.  
    36.  
    37.     self.decoder = tf.keras.Sequential([
    38.         layers.LSTM(64, return_sequences=True),
    39.         layers.LSTM(128, return_sequences=True),
    40.         layers.TimeDistributed(layers.Dense(1)),
    41.         layers.Reshape((normal_X_train.shape[1],))
    42.     ])
    43.  
    44.  
    45.   def call(self, x):
    46.     encoded = self.encoder(x)
    47.     repeated = self.repeat_vector(encoded)
    48.     decoded = self.decoder(repeated)
    49.     return decoded
    50. LSTMautoencoder = LSTMAutoencoder()
    51.  
    52.  
    53. early_stopping = tf.keras.callbacks.EarlyStopping(
    54.                     monitor='val_loss', 
    55.                     patience=5,
    56.                     mode='min',
    57.                     verbose=1,
    58.                     restore_best_weights=True)
    59.  
    60.  
    61. lr_plateau = tf.keras.callbacks.ReduceLROnPlateau(
    62.     monitor='val_loss', 
    63.     factor=0.5, 
    64.     patience=5, 
    65.     verbose=1,
    66.     mode='min')
    67. LSTMautoencoder.compile(optimizer='adam', loss='mse')
    68.  
    69.  
    70. history =  LSTMautoencoder.fit(normal_X_train, normal_X_train, 
    71.                                epochs=20, 
    72.                                validation_data=(normal_X_val, normal_X_val),
    73.                                callbacks=[early_stopping, lr_plateau], 
    74.                                shuffle=True)
    75. plt.figure(figsize=(12,8)) 
    76. plt.plot(history.history["loss"], label="Training Loss")
    77. plt.plot(history.history["val_loss"], label="Validation Loss")
    78. plt.legend()

    1. encoded_signal_lstm = LSTMautoencoder.encoder(normal_X_test).numpy()
    2. repeated_signal_lstm = LSTMautoencoder.repeat_vector(encoded_signal_lstm).numpy()
    3. decoded_signal_lstm = LSTMautoencoder.decoder(repeated_signal_lstm).numpy()
    4.  
    5.  
    6. plt.figure(figsize=(12,8)) 
    7. plt.plot(normal_X_test[100], 'b')
    8. plt.plot(decoded_signal_lstm[100], 'r')
    9. plt.fill_between(np.arange(140), decoded_signal_lstm[100], normal_X_test[100], color='lightcoral')
    10. plt.legend(labels=["Input", "Reconstruction", "Error"])
    11. plt.show()

    1. encoded_data_lstm = LSTMautoencoder.encoder(anomaly_X_test).numpy()
    2. repeated_signal_lstm = LSTMautoencoder.repeat_vector(encoded_signal_lstm).numpy()
    3. decoded_data_lstm = LSTMautoencoder.decoder(repeated_signal_lstm).numpy()
    4.  
    5.  
    6. plt.figure(figsize=(12,8)) 
    7. plt.plot(anomaly_X_test[100], 'b')
    8. plt.plot(decoded_data_lstm[100], 'r')
    9. plt.fill_between(np.arange(140), decoded_data_lstm[100], anomaly_X_test[100], color='lightcoral')
    10. plt.legend(labels=["Input", "Reconstruction", "Error"])
    11. plt.show()

    1. reconstruction = LSTMautoencoder.predict(normal_X_train)
    2. train_loss = tf.keras.losses.mse(reconstruction, normal_X_train)
    3. fig, ax = plt.subplots(figsize=(12, 8))
    4. sns.distplot(train_loss, bins=50, kde=True, ax=ax.grid()).set(title='Distribution of normal train data reconstruction loss')

    1. mean_normal = np.mean(train_loss)
    2. std_normal = np.std(train_loss)
    3. threshold = mean_normal + std_normal
    4. print("Threshold: ", threshold)
    5. Threshold:  0.009467508550873416
    6. reconstruction_test = LSTMautoencoder.predict(normal_X_test)
    7. test_loss_normal = tf.keras.losses.mse(reconstruction_test, normal_X_test)
    8. fig, ax = plt.subplots(figsize=(12, 8))
    9. sns.distplot(test_loss_normal, bins=50, kde=True, ax=ax.grid()).set(title='Distribution of normal test data reconstruction loss')

    1. reconstruction_anomalies = LSTMautoencoder.predict(anomaly_X_test)
    2. test_loss_anomalies = tf.keras.losses.mse(reconstruction_anomalies, anomaly_X_test)
    3. fig, ax = plt.subplots(figsize=(12, 8))
    4. sns.distplot(test_loss_anomalies, bins=50, kde=True, ax=ax.grid()).set(title='Distribution of anomalous test data reconstruction loss')

    1. sns.set(rc={'figure.figsize':(12,8)})
    2.  
    3.  
    4. # Plot two histograms of normal and anomalous data
    5. sns.distplot(test_loss_normal.numpy(), bins=50, label='normal')
    6. sns.distplot(test_loss_anomalies.numpy(), bins=50, label='anomaly')
    7.  
    8.  
    9. # Plot a vertical line representing the threshold
    10. plt.axvline(threshold, color='r', linewidth=2, linestyle='dashed', label='{:0.3f}'.format(threshold))
    11.  
    12.  
    13. # Add legend and title
    14. plt.legend(loc='upper right')
    15. plt.title('Threshold for detecting anomalies')
    16. plt.show()

    1. tp, tn, fp, fn = predict_metrics(test_loss_normal, test_loss_anomalies, threshold)
    2.  
    3.  
    4. cm = [[tn, fp], 
    5.       [fn, tp]]
    6.  
    7.  
    8. categories = ['Normal', 'Anomalies']
    9.  
    10.  
    11. plt.figure(figsize=(8,6))
    12. g = sns.heatmap(cm, annot=True, fmt="d",
    13.             xticklabels=categories, 
    14.             yticklabels=categories,
    15.             cmap="GnBu")
    16.  
    17.  
    18. g.set(xlabel='Predicted', ylabel='Actual', title='Confusion Matrix')
    19.  
    20.  
    21. plt.show()

    1. tpr_val = []
    2. fpr_val = []
    3.  
    4.  
    5. for t in np.linspace(0, 1, 100):
    6.     tp,tn,fp,fn = predict_metrics(test_loss_normal, 
    7.                                   test_loss_anomalies, 
    8.                                   t/10)
    9.     tpr = tp/(tp + fn)
    10.     fpr = fp/(fp + tn)
    11.     tpr_val.append(tpr)
    12.     fpr_val.append(fpr)
    13.  
    14.  
    15. fig, ax = plt.subplots(figsize=(10,7))
    16. ax.plot(fpr_val, tpr_val)
    17. ax.plot(np.linspace(0, 1, 100),
    18.          np.linspace(0, 1, 100),
    19.          label='baseline',
    20.          linestyle='--')
    21. plt.title('Receiver Operating Characteristic Curve', fontsize=18)
    22. plt.ylabel('TPR', fontsize=16)
    23. plt.xlabel('FPR', fontsize=16)
    24. plt.legend(fontsize=12);

    1. tp, tn, fp, fn = predict_metrics(test_loss_normal, test_loss_anomalies, threshold)
    2. accuracy, precision, recall, f1 = compute_stats(tp, tn, fp, fn)
    3.  
    4.  
    5. print("Accuracy = {}".format(np.round(accuracy,4)))
    6. print("Precision = {}".format(np.round(precision,4)))
    7. print("Recall = {}".format(np.round(recall,4)))
    8. print("F1-score = {}".format(np.round(f1,4)))

    Accuracy = 0.9552
    Precision = 0.9104
    Recall = 0.9848
    F1-score = 0.9461

    工学博士，担任《Mechanical System and Signal Processing》《中国电机工程学报》《控制与决策》等期刊审稿专家，擅长领域：现代信号处理，机器学习，深度学习，数字孪生，时间序列分析，设备缺陷检测、设备异常检测、设备智能故障诊断与健康管理PHM等。

  • 相关阅读:
    Phaser帧动画没有效果
    Web自动化测试理解
    TMS320F28335启动过程
    数据分析案例-顾客购物数据可视化分析（文末送书）
    uni-app解决表格uni-table样式问题
    Nginx 通过A域名代理B域名，保持A域名访问状态
    账户、权限中心
    flink集群与资源@k8s源码分析-集群
    Mongodbd的简学
    2022年最新前端面试题
  • 原文地址：https://blog.csdn.net/weixin_39402231/article/details/139759235