数学建模算法总结 -算法应用场景和算法代码实现（1）

数学建模算法总结 -算法应用场景和算法代码实现（1）

1.文本主题提取算法-LDA

算法分类：无监督学习方法

建模应用方向：可以根据文本的词向量分布提取出，文本的主题分布

输入：N个文本的文本词向量（w1,w2,w3,wn）,分类主题个数K
输出：各个文本分别数据k个主题的概率

代码示例：

# 主题数目
n_topics = 5
lda = LatentDirichletAllocation(n_topics=n_topics, max_iter=50, 
                                learning_method='online',                 
                                learning_offset=50., random_state=0)
# 模型应用于数据
lda.fit(tf)
# 得到每个章节属于某个主题的可能性
chapter_top = pd.DataFrame(lda.transform(tf),index=range(120),columns=np.arange(n_topics)+1)

2.主成分分析法

算法分类：无监督学习

建模应用方向：
1.可以用于特征降维，提取主要特征，并去除冗余数据。
2.可以通过第一主成分的各分量权重，得到各个权重的信息占比

代码：

from sklearn.decomposition import PCA
import pandas as pd
import os

path="C:/Users/Administrator/Desktop/o25mso/homework/AMZN.csv"#存放文件路径，这个文件在我的资源上传里

df=pd.read_csv(path)#读取文件

pca=PCA()#创建对象
df=(df.iloc[:,2:]-df.iloc[:,2:].mean())/df.iloc[:,2:].std()#对数据进行中心化处理
#print(df)
pca.fit(df)
print(pca.components_)#返回模型的各个特征向量
print(pca.explained_variance_ratio_)#返回各个成分各自的方差百分比
pca=PCA(2)#设置转化主成分个数两个
pca.fit(df)
low_d=pca.transform(df)
print(low_d)#返回降维后的数据

3. Svm-支持向量机模型

算法分类：监督学习

应用场景：经典的机器学习算法，适用于分类问题，比较好的分类算法

代码示例：

import numpy as np
import joblib
from sklearn import svm
import matplotlib.pyplot as plt
x = [[1, 2], [4, 5], [18, 9], [12, 6], [2, 3], [13, 18]]
x = np.array(x)
y = [1, 1, 0, 0, 1, 0]
y = np.array(y)
# 训练模型
model = svm.SVC(C=10, kernel='linear')
model.fit(x, y)

# 预测
a = [[8, 6]]
a_pre = model.predict(a)
print("a_pre:", a_pre)
# 对应的支持向量
Support_vector = model.support_vectors_
print("Support_vector:", Support_vector)
# 线性分类对应的参数
w = model.coef_
print("w:", w)
b = model.intercept_
print("b:", b)
# 训练集散点图
plt.scatter(x[:, 0], x[:, 1])

if w[0, 1] != 0:
    xx = np.arange(0, 20, 0.1)
    # 最佳分类线
    yy = -w[0, 0]/w[0, 1] * xx - b/w[0, 1]
    plt.scatter(xx, yy, s=4)
    # 支持向量
    b1 = Support_vector[0, 1] + w[0, 0]/w[0, 1] * Support_vector[0, 0]
    b2 = Support_vector[1, 1] + w[0, 0]/w[0, 1] * Support_vector[1, 0]
    yy1 = -w[0, 0] / w[0, 1] * xx + b1
    plt.scatter(xx, yy1, s=4)
    yy2 = -w[0, 0] / w[0, 1] * xx + b2
    plt.scatter(xx, yy2, s=4)
else:
    xx = np.ones(100) * (-b) / w[0, 0]
    yy = np.arange(0, 10, 0.1)
    plt.scatter(xx, yy)
plt.show()

4.lstm模型-时间序列模型
算法分类：监督学习

应用场景：对于时间序列型的的数据有良好的预测效果

代码实例：

#数据预处理以及绘制图形需要的模块
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#构建长短时神经网络需要的方法
from sklearn.preprocessing import MinMaxScaler
from keras.models import Sequential
from keras.layers import Dense, LSTM, BatchNormalization
 
#需要之前90次的数据来预测下一次的数据
need_num = 90
#训练数据的大小
training_num = 6000
#迭代10次
epoch = 10
batch_size = 32
 
#训练数据的处理，我们选取整个数据集的前6000个数据作为训练数据，后面的数据为测试数据
#从csv读取数据
dataset = pd.read_csv('Shanghai.csv')
#我们需要预测开盘数据，因此选取所有行、第三列数据
dataset = dataset.iloc[:, 2:3].values
#训练数据就是上面已经读取数据的前6000行
training_dataset = dataset[:training_num]
#因为数据跨度几十年，随着时间增长，人民币金额也随之增长，因此需要对数据进行归一化处理
#将所有数据归一化为0-1的范围
sc = MinMaxScaler(feature_range=(0, 1))
'''
fit_transform()对部分数据先拟合fit，
找到该part的整体指标，如均值、方差、最大值最小值等等（根据具体转换的目的），
然后对该trainData进行转换transform，从而实现数据的标准化、归一化等等。
'''
training_dataset_scaled = sc.fit_transform(X=training_dataset)
 
x_train = []
y_train = []
#每90个数据为一组，作为测试数据，下一个数据为标签
for i in range(need_num, training_dataset_scaled.shape[0]):
    x_train.append(training_dataset_scaled[i-need_num: i])
    y_train.append(training_dataset_scaled[i, 0])
#将数据转化为数组
x_train, y_train = np.array(x_train), np.array(y_train)
#因为LSTM要求输入的数据格式为三维的，[training_number, time_steps, 1]，因此对数据进行相应转化
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
 
#构建网络，使用的是序贯模型
model = Sequential()
#return_sequences=True返回的是全部输出，LSTM做第一层时，需要指定输入shape
model.add(LSTM(units=128, return_sequences=True, input_shape=[x_train.shape[1], 1]))
model.add(BatchNormalization())
 
model.add(LSTM(units=128))
model.add(BatchNormalization())
 
model.add(Dense(units=1))
#进行配置
model.compile(optimizer='adam',
              loss='mean_squared_error')
model.fit(x=x_train, y=y_train, epochs=epoch, batch_size=batch_size)
 
 
#进行测试数据的处理
#前6000个为测试数据，但是将5910，即6000-90个数据作为输入数据，因为这样可以获取
#测试数据的潜在规律
inputs = dataset[training_num - need_num:]
 
inputs = inputs.reshape(-1, 1)
#这里使用的是transform而不是fit_transform，因为我们已经在训练数据找到了
#数据的内在规律，因此，仅使用transform来进行转化即可
inputs = sc.transform(X=inputs)
x_validation = []
 
for i in range(need_num, inputs.shape[0]):
    x_validation.append(inputs[i - need_num:i, 0])
 
x_validation = np.array(x_validation)
x_validation = np.reshape(x_validation, (x_validation.shape[0], x_validation.shape[1], 1))
 
#这是真实的股票价格，是源数据的[6000:]即剩下的231个数据的价格
real_stock_price = dataset[training_num:]
#进行预测
predictes_stock_price = model.predict(x=x_validation)
#使用 sc.inverse_transform()将归一化的数据转换回原始的数据，以便我们在图上进行查看
predictes_stock_price = sc.inverse_transform(X=predictes_stock_price)
 
 
#绘制数据图表，红色是真实数据，蓝色是预测数据
plt.plot(real_stock_price, color='red', label='Real Stock Price')
plt.plot(predictes_stock_price, color='blue', label='Predicted Stock Price')
plt.title(label='ShangHai Stock Price Prediction')
plt.xlabel(xlabel='Time')
plt.ylabel(ylabel='ShangHai Stock Price')
plt.legend()
plt.show()

5.方差分析：

应用场景：可以鉴别各因素对结果的影响程度

单因素方差分析
代码：

#one_way variance analysis for mean
def oneway_var_test(df, sig):
    data = np.array(df)
    x = np.mean(data)
    n = len(data)*len(data[0])
    k = len(data[0])
    m = len(data)
    SStotal = np.var(data)*n
    df_total = n-1
    SSE = np.var(df).sum()*m
    SST = (np.square(np.mean(df)-np.mean(arr))).sum()*m
    df_e = n-k
    df_t = k-1
    MST = SST/df_t
    MSE = SSE/df_e
    F = MST/MSE
    p = stats.f.sf(F,df_t,df_e)
    result = pd.DataFrame(index =['Treatment','Error','Total'],
                          columns = ['Sum of Squares', 'Degree of Freedom', 'Mean Square','F', 'p'])
    result['Sum of Squares'],result['Degree of Freedom']= [SST, SSE, SStotal],[df_t, df_e, df_total]
    result['Mean Square'],result['F'],result['p'] = [MST, MSE,np.nan],[F, np.nan, np.nan],[p, np.nan, np.nan]
    if p < sig:
        print('在显著度为'+str(sig)+'下，组间均值有差异')
    else:
        print('在显著度为'+str(sig)+'下，组间均值无差异')
    print (result)
return result

双因素方差分析：

#two_way variance analysis for mean
def twoway_var_test(df, sig):
    data = np.array(df)
    x = np.mean(data)
    n = len(data)*len(data[0])
    k = len(data[0])
    m = len(data)
    SStotal = np.var(data)*n
    SST = (np.square(np.mean(df)-np.mean(arr))).sum()*m
    SSB = (np.square(np.mean(df, axis=1)-np.mean(arr))).sum()*k
    SSE = SStotal - SST - SSB
    df_total = n-1
    df_e = (k-1)*(m-1)
    df_t = k-1
    df_b = m-1
    MST = SST/df_t
    MSE = SSE/df_e
    MSB = SSB/df_b
    FT = MST/MSE
    FB = MSB/MSE
    pt = stats.f.sf(FT,df_t,df_e)
    pb = stats.f.sf(FB,df_b,df_e)
    result = pd.DataFrame(index =['TreatmentT','TreatmentB','Error','Total'],
                          columns = ['Sum of Squares', 'Degree of Freedom', 'Mean Square','F', 'p'])
    result['Sum of Squares'],result['Degree of Freedom']= [SST,SSB,SSE, SStotal],[df_t,df_b,df_e, df_total]
    result['Mean Square'],result['F'],result['p'] = [MST,MSB, MSE,np.nan],[FT,FB,np.nan, np.nan],[pt,pb, np.nan, np.nan]
    if pt < sig:
        print('在显著度为'+str(sig)+'下，T因素对均值有影响')
    else:
        print('在显著度为'+str(sig)+'下，T因素对均值无影响')
    if pb < sig:
        print('在显著度为'+str(sig)+'下，B因素对均值有影响')
    else:
        print('在显著度为'+str(sig)+'下，B因素对均值无影响')
    print (result)
    return result

6.元胞自动机模型

算法说明：采用离散的空间布局和离散的时间间隔，将元胞分成有限种状态，元胞个体状态的演变仅与其当前状态以及其某个局部邻域的状态有关。
应用场景：在实际应用过程中，有的元胞自动机模型对其中的某些特征进行了扩展，有的在规则设计中引入随机因素，如：森林火灾模型。 又如，在交通、通讯发达的今天， 研究流行病或计算机病毒的传播问题时， 我们还可以将空间背景换成复杂网络的结点，用网络邻接点作为邻居。这样的调整显然比仍旧使用二维欧氏空间、采用欧氏距离的模型更加符合实际情况。 在大型场所人群紧急疏散问题模拟研究中，可以考虑年龄、性别等因素，即元胞不是同质的，更加有利于使模拟系统接近真实系统。

代码：需根据具体问题制定
7.K近邻算法
算法分类：有监督学习算法
应用场景:可以已有的数据，对于待测试的数据进行类别预测，即通过最近邻的K个样本进行对未知数据的预测
代码：

def classify0(intX, dataSet, labels, k):
    # intX是测试的用例，dataset训练集，labels是训练集对应的标签，k是用于选择最近邻的数目
    dataSetSize = dataSet.shape[0]
    # 用欧式距离公式进行距离计算
    diffMat = tile(intX, (dataSetSize,1)) - dataSet   # numpy.tile进行数组的重复生成
    sqdiffMat = diffMat**2
    sqDistances = sqdiffMat.sum(axis=1)
    distances = sqDistances**0.5
    sortedDistIndicies = distances.argsort()  # 返回的是数组值从小到大的索引值
    classCount = {}
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1
    sortedClassCount = sorted(classCount.items(), key=op.itemgetter(1), reverse=True)
    # python3中函数为：items(),python2中函数为：iteritems()
    return sortedClassCount[0][0]片

8.解耦分析应用场景可以衡量变量之间的依赖性

数学模型：

代码：待调试

9.联立方程模型
应用场景，可以求得各变量对因变量的影响权重
数学模型

代码实例

import numpy as np
from numpy.linalg import solve
a=np.mat([[2,3],[1,3]])#系数矩阵
b=np.mat([5,3]).T    #常数项列矩阵
x=solve(a,b)        #方程组的解
print(x)

10.神经网络模型
算法说明：强大的分类与回归模型，具有很强的拟合能力

应用场景：可应用于分类预测等问题
代码：根据需求制定

注：后续将继续完善模型模板