机器学习在材料预测方面的应用

1.机器学习的基本流程

• 实验数据集：材料数据($M_1...M_n$)、性能($P_1...P_n$)
• 特征选择与提取：描述符($F_1...F_n$)
  指纹型描述符：
  1.化学计量属性，包括元素的重量百分比和原子百分比等。
  2.元素性质，包括电负性、原子半径、有效电荷、范德华半径、共价半径、元素周期表中的行数、嵌段数、气态原子形成焓、电离能和价数等。
  3.化合物描述符，包括分子量、密度、体积、配位数和原子序数等。
  4.电子结构属性，来自所有现有元素之间的s,p,d和f价壳的电子的平均分数。
• 机器学习模型：逻辑回归、支持向量机、随机森林、卷积神经网络、深度学习、神经网络
• 预测性能评价：Hold-Out(量化评价 $R^2$)、K折交叉验证(量化评价 RMSE)、单样本交叉验证(量化评价 MAE)、

2.常见的材料性能

• 电子性能：形成能(Formation energy)、压电性(Piezoelectric properties)、带隙(Band gap)、绝对能(Absolute energy)、 自由能(Free energy)、缺陷能(Defect energetics)、费米能(Fermi energy)、电容率(Dielectric constant)。
• 力学性能：体积模量(Bulk moduli)、剪切模量(Shear moduli)、弹性模量(Elastic moduli)、泊松比(Poisson ratio)。
• 物理化学性能：密度(Density)、最近邻距离(Nearest neighbor distance)、生成焓(Formation enthalpy)、熔点(Melting temperature)、热导率(Thermal conductivities)、催化活性(Catalytic activities)、耐辐照性(Radiation resistance)、超导材料临界温度(Critical temperature)。

3.常见的材料数据库

4.机器学习模型及应用

5.数据预处理过程

• 导入所需的库：NumPy和Pandas。NumPy包含数学计算函数，Pandas用于导入和管理数据集。
• 导入数据集：数据集通常是.csv格式。csv文件以文本形式保存表格数据。文件的每一行是一条数据记录。使用Pandas的read_csv方法读取本地csv文件为一个数据帧。然后，从数据帧中制作自变量和因变量的矩阵和向量。
• 处理丢失数据：得到的数据很少是完整的。数据可能因为各种原因丢失，为了不降低机器学习模型的性能，需要处理数据。我们可以用整列的平均值或中间值替换丢失的数据。用sklearn.preprocessing库中的Imputer类完成此项任务。
• 解析分类数据：分类数据指的是含有标签值而不是数字值的变量。取值范围通常是固定的。例如“Yes”和“No”不能用于模型的数学计算，所有需要解析成数字。为实现这一功能，从sklearn.preprocessing库导入LabelEncoder类。
• 拆分数据集为测试集合和训练集合：把数据集拆分为两个：一个用来训练模型的训练集合，另一个用来验证模型的测试集合。两者比例一般为80:20。导入sklearn.crossvalidation库中的train_test_split()方法。
• 特征缩放：大部分模型算法使用两点间的欧式距离表示，但此特征在幅度、单位和范围姿态问题上变化很大。在距离计算中，高幅度的特征比低幅度特征权重更大。可用特征标准化或Z值归一化解决。导入sklearn.preprocessing库的StandardScalar类。

6.常用的机器学习模型

1.线性回归

• 简单线性回归：使用单一特征来预测因变量。若两个变量是线性相关的，寻找一种根据特征或自变量X的线性函数来精准预测因变量Y。
• 如何找到最佳的拟合线：通过最小化预测值Y与实际值y之间的长度来寻找最佳拟合线。
• 代码示例：

  import pandas as pd                                                                           # 导入基本库
  import numpy as np 
  import matplotlib.pyplot as plt
  from sklearn.model_selection import train_test_split
  from sklearn.linear_model import LinearRegression
  
  dataset = pd.read_csv('studentscores.csv')                                                    # 数据提取
  X = dataset.iloc[ : ,   : 1 ].values                                                          # 数据处理
  Y = dataset.iloc[ : , 1 ].values
  X_train, X_test, Y_train, Y_test = train_test_split( X, Y, test_size = 1/4, random_state = 0)#分为训练集与测试集
  
  regressor = LinearRegression()                                                               # 线性回归模型
  regressor = regressor.fit(X_train, Y_train)
  
  Y_pred = regressor.predict(X_test)                                                          # 结果预测
  
  plt.scatter(X_train , Y_train, color = 'red')                                         # 训练结果可视化
  plt.plot(X_train , regressor.predict(X_train), color ='blue')
  
  plt.scatter(X_test , Y_test, color = 'red')                                           # 测试结果可视化
  plt.plot(X_test , regressor.predict(X_test), color ='blue')
  plt.show()
  

2.逻辑回归

• 逻辑回归：逻辑回归被用来处理不同的分类问题，即预测被研究的对象属于哪个组，通过提供一个离散的二进制输出结果。
• 如何工作：逻辑回归通过估算概率来预测因变量和一个或者多个自变量之间的关系。这些概率值必须转换为二进制，以便在实践中进行预测。然后使用阈值分类器将(0,1)范围的值转化为0和1的值来表示结果。
• Sigmoid函数：Sigmoid函数是一个S形曲线，可以实现将任意真实值映射为值域范围为0-1的值。
  3.逻辑回归与线性回归
  逻辑回归给出离散的输出结果，然而线性回归给出的是连续的输出结果。
• 代码示例：

  import numpy as np                                                                           # 导入基本库
  import matplotlib.pyplot as plt
  import pandas as pd
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import StandardScaler
  from sklearn.linear_model import LogisticRegression
  from sklearn.metrics import confusion_matrix
  from sklearn.metrics import classification_report
  from matplotlib.colors import ListedColormap
  
  dataset = pd.read_csv('Social_Network_Ads.csv')                                             # 数据提取
  X = dataset.iloc[:, [2, 3]].values                                                          # 数据处理
  y = dataset.iloc[:, 4].values
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)#分为训练集与测试集
  
  sc = StandardScaler()                                                     # 特征标准化处理 (缩放特征)
  X_train = sc.fit_transform(X_train)
  X_test = sc.transform(X_test)
  
  
  
  classifier = LogisticRegression()                                                     # 逻辑回归模型
  classifier.fit(X_train, y_train)
  
  
  y_pred = classifier.predict(X_test)                                                       # 结果预测
  
  cm = confusion_matrix(y_test, y_pred)                 
  print(cm)                                                                             # 输出混淆矩阵
  print(classification_report(y_test, y_pred))                                          # 输出分类报告
  
  X_set,y_set=X_train,y_train                                           # 训练结果可视化
  X1,X2=np. meshgrid(np. arange(start=X_set[:,0].min()-1, stop=X_set[:, 0].max()+1, step=0.01),
                     np. arange(start=X_set[:,1].min()-1, stop=X_set[:,1].max()+1, step=0.01))
  plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(),X2.ravel()]).T).reshape(X1.shape),
               alpha = 0.75, cmap = ListedColormap(('red', 'green')))
  plt.xlim(X1.min(),X1.max())
  plt.ylim(X2.min(),X2.max())
  for i,j in enumerate(np. unique(y_set)):
      plt.scatter(X_set[y_set==j,0],X_set[y_set==j,1],
                  c = ListedColormap(('red', 'green'))(i), label=j)
  
  plt.title(' LOGISTIC(Training set)')
  plt.xlabel(' Age')
  plt.ylabel(' Estimated Salary')
  plt.legend()
  plt.show()
  
  X_set,y_set=X_test,y_test                                           # 测试结果可视化
  X1,X2=np. meshgrid(np. arange(start=X_set[:,0].min()-1, stop=X_set[:, 0].max()+1, step=0.01),
                     np. arange(start=X_set[:,1].min()-1, stop=X_set[:,1].max()+1, step=0.01))
  
  plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(),X2.ravel()]).T).reshape(X1.shape),
               alpha = 0.75, cmap = ListedColormap(('red', 'green')))
  plt.xlim(X1.min(),X1.max())
  plt.ylim(X2.min(),X2.max())
  for i,j in enumerate(np. unique(y_set)):
      plt.scatter(X_set[y_set==j,0],X_set[y_set==j,1],
                 c = ListedColormap(('red', 'green'))(i), label=j)
  
  plt.title(' LOGISTIC(Test set)')
  plt.xlabel(' Age')
  plt.ylabel(' Estimated Salary')
  plt.legend()
  plt.show()
  

3.支持向量机(SVM)

• 什么是SVM？：支持向量机(SVM)是一个有监督的机器学习算法，它可用于分类和回归分析，主要用于分类问题中。在此算法中，根据特征值，构建一个n维空间(n为特征数量)，将每个数据点投影到此空间中。
• 数据如何分类？：通过构建一个超平面，将数据区分成两类。在SVM中，最佳超平面是指距离两类数据最远的一个超平面。
• 代码示例：

  import numpy as np                                                                           # 导入基本库
  import matplotlib.pyplot as plt
  import pandas as pd
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import StandardScaler
  from sklearn.svm import SVC
  from sklearn.metrics import confusion_matrix
  from sklearn.metrics import classification_report
  from matplotlib.colors import ListedColormap
  
  dataset = pd.read_csv('Social_Network_Ads.csv')                                             # 数据提取
  X = dataset.iloc[:, [2, 3]].values                                                          # 数据处理
  y = dataset.iloc[:, 4].values
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)#分为训练集和测试集
  
  sc = StandardScaler()                                                      # 特征标准化处理 (缩放特征)
  X_train = sc.fit_transform(X_train)
  X_test = sc.transform(X_test)
  
  classifier = SVC(kernel = 'linear', random_state = 0)                                      # SVM模型
  classifier.fit(X_train, y_train)
  
  y_pred = classifier.predict(X_test)                                                        # 结果预测
  
  cm = confusion_matrix(y_test, y_pred)
  print(cm)                                                                                  # 输出混淆矩阵
  print(classification_report(y_test, y_pred))                                               # 输出分类报告
  
  X_set, y_set = X_train, y_train                                           # 训练结果可视化
  X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                       np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
  plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
               alpha = 0.75, cmap = ListedColormap(('red', 'green')))
  plt.xlim(X1.min(), X1.max())
  plt.ylim(X2.min(), X2.max())
  for i, j in enumerate(np.unique(y_set)):
      plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                  c = ListedColormap(('red', 'green'))(i), label = j)
  plt.title('SVM (Training set)')
  plt.xlabel('Age')
  plt.ylabel('Estimated Salary')
  plt.legend()
  plt.show()
  
  X_set, y_set = X_test, y_test                                           # 测试结果可视化
  X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                       np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
  plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
               alpha = 0.75, cmap = ListedColormap(('red', 'green')))
  plt.xlim(X1.min(), X1.max())
  plt.ylim(X2.min(), X2.max())
  for i, j in enumerate(np.unique(y_set)):
      plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                  c = ListedColormap(('red', 'green'))(i), label = j)
  plt.title('SVM (Test set)')
  plt.xlabel('Age')
  plt.ylabel('Estimated Salary')
  plt.legend()
  plt.show()
  

4.随机森林

• 什么是随机森林：随机森林是有监督的集成学习模型，主要用于分类和回归。集成学习模型复合了多个机器学习模型(指决策树)，使整体性能更好。究其逻辑，每个模型的个体在单独使用时效果是薄弱的，但多个模型个体集合在一起的时候，整体的功能会变得强大。在随机森林的情况下，单个决策树做出的决策都是“弱”因素。而大量决策树一起被使用时把它们的结果整合，就会产生“强”合奏。
• 随机森林的工作原理：随机森林算法分为两步。第一步是创建决策树，第二步是根据第一步中决策树的分类器结果做出预测。随机森林算法与决策树算法之间的区别是，在随机森林中，查找根节点和分割特征节点的过程是随机进行的。
  1.构建：每棵树按如下方式生成：
    1.(数据的随机选取)如果训练集中有N个样本，有放回的随机抽取n个。此样本将是生成决策树的训练集。
    2.(特征的随机选取)对于每个样本，如果有M个输入变量(或特征)，指定一个常数m，然后随机地从M个特征中选取m个特征子集，然后将m个特征中最优的分裂特征用来分裂节点。
  2.预测：随机森林的预测分以下三步：
    1.使用每一个随机创建的决策树的规则来预测测试特征的结果(目标)。
    2.计算每个预测目标的票数.
    3.获得票数最多的预测目标视为随机森林算法的最终预测。
• 代码示例：

  import numpy as np                                                                           # 导入基本库
  import matplotlib.pyplot as plt
  import pandas as pd
  from sklearn.model_selection import train_test_split
  from sklearn.preprocessing import StandardScaler
  from sklearn.ensemble import RandomForestClassifier
  from sklearn.metrics import confusion_matrix
  from matplotlib.colors import ListedColormap
  
  dataset = pd.read_csv('Social_Network_Ads.csv')                                             # 数据提取
  X = dataset.iloc[:, [2, 3]].values                                                          # 数据处理
  y = dataset.iloc[:, 4].values
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0) #分为训练集和测试集
  
  sc = StandardScaler()                                                     # 特征标准化处理 (缩放特征)
  X_train = sc.fit_transform(X_train)
  X_test = sc.transform(X_test)
  
  classifier = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0)# 随机森林模型
  classifier.fit(X_train, y_train)
  
  y_pred = classifier.predict(X_test)                                                        # 结果预测
  cm = confusion_matrix(y_test, y_pred)                                      # 混淆矩阵和分类报告
  
  
  X_set, y_set = X_train, y_train                                           # 训练结果可视化
  X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
  plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
  plt.xlim(X1.min(), X1.max())
  plt.ylim(X2.min(), X2.max())
  for i, j in enumerate(np.unique(y_set)):
      plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                  c = ListedColormap(('red', 'green'))(i), label = j)
  plt.title('Random Forest Classification (Training set)')
  plt.xlabel('Age')
  plt.ylabel('Estimated Salary')
  plt.legend()
  plt.show()
  
  X_set, y_set = X_test, y_test                                           # 测试结果可视化
  X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
  plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
               alpha = 0.75, cmap = ListedColormap(('red', 'green')))
  plt.xlim(X1.min(), X1.max())
  plt.ylim(X2.min(), X2.max())
  for i, j in enumerate(np.unique(y_set)):
      plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                  c = ListedColormap(('red', 'green'))(i), label = j)
  plt.title('Random Forest Classification (Test set)')
  plt.xlabel('Age')
  plt.ylabel('Estimated Salary')
  plt.legend()
  plt.show()