[Radiómica] Diseño de modelo de clasificador - Bosque aleatorio + Máquina de vectores de soporte

---

1. Clasificación aleatoria de bosques

• Árbol de decisión ( Decision Tree)
  • Se basa en conocer la probabilidad de ocurrencia de diversas situaciones, mediante la construcción de un árbol de decisión para obtener la probabilidad de que el valor esperado del valor presente neto sea mayor o igual a cero.
  • Un árbol de decisión es una estructura de árbol en la que cada nodo interno representa una prueba sobre un atributo, cada rama representa un resultado de prueba y cada nodo hoja representa una categoría.

• Implementación de árboles de decisión en Python
  • Función: sklearn.tree.DecisionTreeClassifier ( from sklearn.tree import DecisionTreeClassifier)
  • Inicialización del modelo: dt_model = DecisionTreeClassifier()
  • Datos de entrenamiento:dt_model.fit(X, y)

• Random Forest
  • Random Forest hace referencia a un clasificador que utiliza varios árboles para entrenar y predecir muestras .

• Las principales ventajas de los bosques aleatorios
  • Tiene una excelente precisión
  • Puede ejecutarse de manera eficiente en grandes conjuntos de datos
  • Puede manejar muestras de entrada con características de alta dimensión
  • Puede evaluar la importancia (peso) de cada característica en el problema de clasificación

• Implementación de Random Forest Classification en Python
  • Funciones: from sklearn.ensemble import RandomForestClassifier
  • Inicialización del modelo: model_rf = RandomForestClassifier()
  • Datos de entrenamiento:model_rf.fit(X, y)

• Código de Python de clasificación de bosque aleatorio :
  referencia de código R: lenguaje R - clasificación de bosque aleatorio

  # 导入包
  import pandas as pd
  import numpy as np
  from sklearn.preprocessing import StandardScaler
  from scipy.stats import ttest_ind, levene
  from sklearn.linear_model import LassoCV
  from sklearn.utils import shuffle
  from sklearn.ensemble import RandomForestClassifier # 随机森林分类器
  from sklearn.model_selection import train_test_split # 训练集测试集分割
  
  # 导入数据
  xlsx_a = 'data/featureTable/aa.xlsx'
  xlsx_b = 'data/featureTable/bb.xlsx'
  data_a = pd.read_excel(xlsx_a)
  data_b = pd.read_excel(xlsx_b)
  print(data_a.shape,data_b.shape)
  # (212, 30) (357, 30)
  
  # t 检验特征筛选
  index = []
  for colName in data_a.columns[:]: 
      if levene(data_a[colName], data_b[colName])[1] > 0.05: 
          if ttest_ind(data_a[colName], data_b[colName])[1] < 0.05: 
              index.append(colName)
      else: 
          if ttest_ind(data_a[colName], data_b[colName],equal_var=False)[1] < 0.05: 
              index.append(colName)
  print(len(index))  # 25
  print(index)
  # ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'M', 'N', 'P', 'Q', 'R', 'U', 'V', 'W', 'X', 'Y', 'Z', 'AA', 'AB', 'AC', 'AD']
  
  # t 检验后数据处理
  data_a = data_a[index]
  data_b = data_b[index]
  rows_a,cols_a = data_a.shape
  rows_b,cols_b = data_b.shape
  labels_a = np.zeros(rows_a)
  labels_b = np.ones(rows_b)
  data_a.insert(0, 'label', labels_a)
  data_b.insert(0, 'label', labels_b)
  data = pd.concat([data_a,data_b])
  data = shuffle(data)
  data.index = range(len(data))
  X = data[data.columns[1:]]
  y = data['label']
  X = X.apply(pd.to_numeric, errors='ignore')
  colNames = X.columns
  X = X.fillna(0)
  X = X.astype(np.float64)
  X = StandardScaler().fit_transform(X)
  X = pd.DataFrame(X)
  X.columns = colNames
  print(data.shape)  # (569, 26)
  
  # LASSO 特征筛选
  alphas = np.logspace(-4,1,50)
  model_lassoCV = LassoCV(alphas = alphas,max_iter = 100000).fit(X,y)
  coef = pd.Series(model_lassoCV.coef_, index = X.columns)
  print(model_lassoCV.alpha_)
  print('%s %d'%('Lasso picked',sum(coef != 0)))
  print(coef[coef != 0])
  index = coef[coef != 0].index  # 提取权重不为 0 的特征数据
  X = X[index]  
  
  np.set_printoptions(threshold=np.inf)  # 设置输出结果不带省略
  
  # 分割训练集、测试集
  X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.3,random_state = 15)
  # X 数据，y label 分组，test_size=0.3 训练集：测试集=7:3，random_state = 15（随机种子）
  
  # 随机森林分类
  model_rf = RandomForestClassifier(
    n_estimators = 200  # default 100 设置随机森林中有多少棵树
    , criterion = 'entropy' # 分类标准：'gini' and 'entropy'熵，default 'gini'，gini 指数
    , random_state = 20  # default = None（随机种子）
    , class_weight = 'balanced' # default = None 分类出的数据组别之间平衡处理
    )
  
  model_rf.fit(X_train,y_train)  # 训练集训练
  # print(model_rf.score(X_test,y_test))  # 测试集准确率
  # print(model_rf.predict(X_test))  # 测试集各病例基于训练集模型的预测结果
  # print(model_rf.predict_proba(X_test)) # 测试集预测结果的预测概率
  # print(model_rf.n_features_)  # 拟合模型过程中用了多少特征
  # print(model_rf.feature_importances_)  # 各特征的权重，权重加和=1
  print(model_rf.get_params())  # 构建模型时的各项参数
  

---

2. Clasificación de máquinas de vectores de soporte

• Máquina de vectores de soporte : máquinas de vectores de soporte, SVM
  • Un modelo de clasificación binaria (en realidad, se puede realizar una clasificación múltiple y el procesamiento de SVM)
  • Modelo básico : un clasificador lineal con el intervalo más grande definido en el espacio de características (en realidad, no lineal)
  • Idea básica : resolverEl hiperplano de separación que puede dividir correctamente el conjunto de datos de entrenamiento y tiene el intervalo geométrico más grande(Al igual que una línea recta en un espacio bidimensional y un plano en un espacio tridimensional, se pueden dividir dos clases de casos).
  • Tiene un truco del núcleo , que lo convierte en un clasificador sustancialmente no lineal.
  

• Función kernel
  • En aplicaciones prácticas, la mayoría de los datos no son separables linealmente , es decir, no hay un hiperplano que satisfaga las condiciones
  • Los datos se pueden mapear en un espacio de alta dimensión a través de la función kernel para resolver el problema de la inseparabilidad lineal del espacio original
  • Función kernel comúnmente utilizada: función kernel lineal (lineal), función kernel polinómica (poly), función kernel de base radial (rbf), función kernel sigmoidea (forma S)
  

• Parámetros importantes de la función kernel de base radial rbf
  • Parámetro γ(gamma): define el rango de influencia de una sola muestra, cuanto mayor es γ, más vectores de soporte (cuantas más muestras se consideran, y todas las muestras son fáciles de sobreajustar, como se muestra en la línea amarilla de la figura siguiente )
  • Factor de penalizaciónC : define la tolerancia para las muestras " sucias "
  

• Implementar la clasificación de máquinas de vectores de soporte en Python
  • Funciones: from sklearn.svm import SVC
  • Inicialización del modelo: model_svc = svm.SVC(kernel = ‘rbf’, gamma = 0.05, C = 1)establecer la función kernel kernel, el parámetro γ y el factor de penalización C.
  • Entrenamiento de datos: model_svc.fit(X_train, y_train)
  • Precisión: model_svc.score(X, y)
  • Obtención de parámetros:model_svc.get_params()

• Referencias :
  Máquinas de vectores de soporte para algoritmos de clasificación: SVM (Teoría)
  Máquinas de vectores de soporte para algoritmos de clasificación: SVM (Aplicaciones)

• Admite el código Python de clasificación de máquinas vectoriales :
  Excepto para la importación de módulos, los pasos antes de la clasificación SVM son los mismos que para la clasificación aleatoria de bosques.

  # 导入包
  import pandas as pd
  import numpy as np
  from sklearn.preprocessing import StandardScaler
  from scipy.stats import ttest_ind, levene
  from sklearn.utils import shuffle
  from sklearn.linear_model import LassoCV
  from sklearn.model_selection import train_test_split
  from sklearn.svm import SVC  # 支持向量分类器
  
  # 导入数据
  xlsx_a = 'data/featureTable/aa.xlsx'
  xlsx_b = 'data/featureTable/bb.xlsx'
  data_a = pd.read_excel(xlsx_a)
  data_b = pd.read_excel(xlsx_b)
  print(data_a.shape,data_b.shape)
  # (212, 30) (357, 30)
  
  # t 检验特征筛选
  index = []
  for colName in data_a.columns[:]: 
      if levene(data_a[colName], data_b[colName])[1] > 0.05: 
          if ttest_ind(data_a[colName], data_b[colName])[1] < 0.05: 
              index.append(colName)
      else: 
          if ttest_ind(data_a[colName], data_b[colName],equal_var=False)[1] < 0.05: 
              index.append(colName)
  print(len(index))  # 25
  print(index)
  # ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'M', 'N', 'P', 'Q', 'R', 'U', 'V', 'W', 'X', 'Y', 'Z', 'AA', 'AB', 'AC', 'AD']
  
  # t 检验后数据处理
  data_a = data_a[index]
  data_b = data_b[index]
  rows_a,cols_a = data_a.shape
  rows_b,cols_b = data_b.shape
  labels_a = np.zeros(rows_a)
  labels_b = np.ones(rows_b)
  data_a.insert(0, 'label', labels_a)
  data_b.insert(0, 'label', labels_b)
  data = pd.concat([data_a,data_b])
  data = shuffle(data)
  data.index = range(len(data))
  X = data[data.columns[1:]]
  y = data['label']
  X = X.apply(pd.to_numeric, errors='ignore')
  colNames = X.columns
  X = X.fillna(0)
  X = X.astype(np.float64)
  X = StandardScaler().fit_transform(X)
  X = pd.DataFrame(X)
  X.columns = colNames
  print(data.shape)  # (569, 26)
  
  # LASSO 特征筛选
  alphas = np.logspace(-4,1,50)
  model_lassoCV = LassoCV(alphas = alphas,max_iter = 100000).fit(X,y)
  coef = pd.Series(model_lassoCV.coef_, index = X.columns)
  print(model_lassoCV.alpha_)
  print('%s %d'%('Lasso picked',sum(coef != 0)))
  print(coef[coef != 0])
  index = coef[coef != 0].index  # 提取权重不为 0 的特征数据
  X = X[index]  
  
  np.set_printoptions(threshold=np.inf)  # 设置输出结果不带省略
  
  # 分割训练集、测试集
  X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.3,random_state = 15)
  # X 数据，y label 分组，test_size=0.3 训练集：测试集=7:3，random_state = 15（随机种子）
  
  # SVM 分类
  model_svm = SVC(kernel='rbf', gamma = 'scale', probability=True)
  # 设置核函数为 rbf
  # gamma = 'scale' =1/（特征数×方差）；'auto' = 1/特征数；还可以写浮点数，具体需要做参数优化
  # probability=True 设置为 True，后面才能查看概率
  
  # 训练集拟合模型
  model_svm.fit(X_train,y_train)
  # print(model_svm.score(X_test,y_test))  # 测试集准确率
  # print(model_svm.predict(X_test))   # 测试集各病例基于训练集模型的预测结果
  # print(model_svm.predict_proba(X_test))  # 测试集预测结果的预测概率
  print(model_svm.get_params())  # 构建模型时的各项参数
  

---