1
import numpy as np
2
import matplotlib.pyplot as plt
3
x=np.arange(-np.pi,np.pi,0.01) # 产⽣ -pi 到 pi 之间数，步⻓为 0.01
4
y=np.sin(x)
5
plt.plot(x,y)
6
plt.show()

1
import numpy as np
2
import matplotlib.pyplot as plt
3
x=np.random.randn(1000) # 产⽣ 1000 个浮点数，满⾜标准正态分布（均值为 0 ，⽅差为 1 ）
4
print('mean=',np.mean(x),"std=",np.std(x))# 输出平均数和⽅差
5
plt.hist(x,bins=50) # 画柱状图
6
plt.show()

1
import numpy as np # 导⼊ numpy 包，起 np 的别名

1
# help(np)
2
help(np.array) # 查看相关帮助信息 , 在 cell 中显示

1
import numpy as np
2
# 构造⼀维数组
3
a1=np.array([1,2,3,4,5,6,7,8,9,10],dtype=float) # 指定数组元素类型为 float
4
print(type(a1)) # a1 的类型为 numpy.ndarray
5
print('a1=',a1,'\n')
6
# 构造⼆维数组
7
a2=np.array([[1,2,3,4,5],[6,7,8,9,10]]) # 默认类型为最⼩存放给定数据的的数据类型
8
print('a2=',a2)

1
import numpy as np
2
# 在指定的间隔范围内 [1,10], 返回均匀间隔的 30 个数字
3
al=np.linspace(1,10,30)
4
print(al)
5
# 构造全 0 的数组
6
a0=np.zeros(10,dtype=int)
7
print('a0=',a0,'\n')
8
# 构造全 0 的矩阵
9
a0=np.zeros((3, 3)) # 不指定类型则为浮点数
10
print(a0,'\n')
11
# 从 0 开始，到 10 结束 ( 不包括 ) ，步⻓为 2 ，不写默认为 1
12
a1=np.arange(0,10,2)
13
print('a1=',a1,'\n')
14
# 构造全 1 的数组
15
a2=np.ones((3,5),dtype=float)
16
print('a2=',a2,'\n')
17
# 构造全 3.14 的数组
18
a3=np.full((3,5),3.14)
19
print("a3=",a3,'\n')
20
# 产⽣随机阵
21
a4=np.random.random([5, 5])
22
print("a4=",a4,'\n')
23
# 创建⼀个 3*3 的， [0 ， 10) 区间的随机整型数
24
a5=np.random.randint(0,10,(3,3))
25
print("a5=",a5,'\n')
26
# 创建⼀个 3*3 的单位矩阵
27
a6=np.eye(3)
28
print("a6=",a6,'\n')

1
import numpy as np
2
# 参考⽹址： https://blog.csdn.net/u012149181/article/details/78913167
3
np.random.rand(3,3) # 产⽣每个值在 [0,1) 范围的 3X3 矩阵
4

5
np.random.randint(1,5,[3,3]) # 产⽣最⼩值为 1 ，最⼤值不超过 5 的 3X3 的随机矩阵
6

7
np.random.randn(3,3) # 产⽣符合正态分布的 3X3 的随机矩阵
8

9
# 产⽣随机阵
10
a4=np.random.random([5, 5])# 产⽣值在 (0,1) 之间 5X5 随机矩阵
11
print("a4=",a4,'\n')
12
print(a4.ndim) # 显示维数
13
print(a4.shape) # 显示维数形状

1
import numpy as np
2
# 改变⾏列
3
a1=np.array([1,2,3,4,5,6,7,8,9,10],dtype=float)
4
a2=a1.reshape(2,5)
5
print(a2,'\n')
6
# 展平数组，即变成⼀维数组 或使⽤ a2.ravel()
7
a3=a2.flatten()
8
print(a3,'\n')
9
# 数组维数
10
print(a2.shape)
11
print(a3.shape)
12
a3.shape=(5,2)
13
print(a3.shape)

1
array1=np.array([[[0,1,2,3],
2
[4,5,6,7],
3
[8,9,10,11]],
4
[[12,13,14,15],
5
[16,17,18,19],
6
[20,21,22,23]]])
7
print(array1.shape)
8
array1.shape=(6,4)
9
print(array1)

1
# 转置
2
a1=np.array([1,2,3,4,5,6,7,8,9,10],dtype=float)
3
a2=a1.reshape(2,5)
4
print(a2)
5
a3=a2.T
6
print(a3)

1
# 基本统计信息
2
print(a3.max())# 求最⼤值
3
print(a3.mean()) # 求平均值，
4
# mean 函数调⽤格式 ndarray.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)

1
# 数组整体运算
2
a2=np.arange(10).reshape(2,5)
3
max=a2.max()
4
min=a2.min()
5
a2 = (a2-min)/(max-min) # 数组中每个元素与 min ， max 参与运算
6
print(a2)
7
In [ ]:
8
import numpy as np
9
X=np.random.randint(0,10,[3,3])
10
print(X)
11
Y = X - X.mean(axis=1, keepdims=True) # 实现每⾏上数据减去这⾏的平均值
12
# mean 函数调⽤格式 ndarray.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)
13
print(Y)

1
# 产⽣随机数
2
xlist=np.random.randint(10, size=(10))
3
ylist=np.random.rand(10)
4
ylist

1
# 通⽤函数 ufunc ⼀元函数
2
import numpy as np
3
a=np.array([1,-1,2,-2,3])
4
a1=np.abs(a)
5
print(a1)
6
a2=np.square(a)
7
print(a2)

1
# 通⽤函数 ufunc ⼆元函数
2
a=np.array([1,-1,2,-2,3])
3
b=np.arange(1,6)
4
c=np.add(a,b)
5
print(c)
6
d=np.subtract(a,b)

1
# 复杂运算
2
# 堆叠数组
3
help(np.hstack)
4
help(np.vstack)
5
# 拆分数组
6
help(np.hsplit)
7
help(np.vsplit)
8
help(np.split)

1
help(np.mat)

1
A=np.mat("1 2 3;4 5 6") # 构造 2*3 的矩阵
2
print(A)
3
B=np.array([[1, 2],[3,4], [5, 6]])# 构造 3*2 的矩阵
4
print(B)
5
a=[[1,2,3],[4,5,6],[7,8,9]] # 构造 3*3 的矩阵
6
C=np.array(a)
7
print(C)

1
D=A.dot(B) # 矩阵运算
2
print(D)

1
a=[[1,2,3],[4,5,6],[7,8,9]]
2
arr3=np.array(a)
3
tt=np.tril(arr3) # 下三⻆
4
print(tt)
5
tt=np.triu(arr3) # 上三⻆
6
print(tt)

1
# np.mgrid(start ： end ： step) # ⽣成等差数组， [start ： end) 闭包关系
2
import numpy as np # 导⼊ numpy 模块
3
a = np.mgrid[1:4:1] # ⽣成等差数组 a
4
# np.mgrid[0:5,0:5] # 按⾏递增，然后按列递增，两个数组再堆叠起来
5
print(a)
6
# help(np.mgrid)

1
# 导⼊ pandas 库包为 pd 名字
2
import pandas as pd
3
# 导⼊ numpy 库包为 np 名字
4
import numpy as np

1
from keras.models import Sequential
2
from keras.layers import Dense
3

4
n_input = 784
5
n_hidden_1 = 512
6
n_hidden_2 = 216
7
n_hidden_3 = 128
8
n_classes = 10
9

10
model = Sequential()
11

12
model.add(Dense(n_hidden_1, activation="relu", input_dim=n_input))
13
model.add(Dense(n_hidden_2, activation="relu"))
14
model.add(Dense(n_hidden_3, activation="relu"))
15
model.add(Dense(n_classes, activation="softmax"))

1
from tensorflow import keras
2
from tensorflow.keras import layers
3

4
input_shape = (28, 28, 1)
5
num_classes = 10
6

7
model = keras.Sequential(
8
[
9
keras.Input(shape=input_shape),
10
layers.Conv2D(128, kernel_size=(4,4), activation="relu"),
11
layers.MaxPooling2D(pool_size=(2,2)),
12
layers.Conv2D(64, kernel_size=(4,4), activation="relu"),
13
layers.MaxPooling2D(pool_size=(2,2)),
14
layers.Dense(64, activation="relu"),
15
layers.Dense(num_classes, activation="softmax")
16
]
17
)

1
from keras.models import Sequential
2
from keras.layers import LSTM, Dense
3

4
n_input = 784
5
num_classes = 10
6

7
model = Sequential()
8

9
model.add(LSTM(128, input_dim=n_input))
10
model.add(Dense(128, activation="relu"))
11
model.add(Dense(num_classes, activation="softmax"))

1
import pandas as pd
2
from sklearn.model_selection import train_test_split
3
from sklearn.preprocessing import StandardScaler
4

5
from keras.models import Sequential
6
from keras.layers import Dense
7
from keras.optimizers import adam_v2
8
#from tensorflow.keras.optimizers import Adam
9
import matplotlib.pyplot as plt
10

11

12
# 利用pandas读'数据集有氨氮的数据.xlsx' 到data
13
data = pd.read_excel("./数据/数据集有氨氮的数据.xlsx")
14
# 取data溶解氧列数据给y
15
y =data["溶解氧"].values
16
# 将data数据删除溶解氧列后的结果赋给x
17
x = data.drop("溶解氧", axis=1).values
18
print(x)
19
# 利用sklearn.preprocessing 的 StandardScaler 标准化数据集
20
scaler = StandardScaler()
21
x = scaler.fit_transform(x)
22

23
# 利用 sklearn.model_selection 的 train_test_split 设定训练集和测试集，测试集占%20
24
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
25

26

27
# 创建keras的Sequential模型
28
model = Sequential()
29
# 搭建3层的BP神经网络的结构,units表示隐含层神经元数，input_dim表示输入层神经元数，
30
# activation表示激活函数
31
model.add(Dense(14, activation='sigmoid', input_dim=6))
32
model.add(Dense(1, activation='sigmoid'))
33

34
# 编译模型，参数loss表示损失函数，这里损失函数为mse，优化算法采用Adam，metrics表示训练集的拟合误差
35
model.compile(loss='mse', optimizer=adam_v2.Adam(learning_rate=0.01), metrics=['mape'])
36
# 显示模型摘要信息
37
model.summary()
38

39
# 模型训练
40
# 将训练集的x和y输入到BP神经网络进行训练，epoch表示训练次数，
41
# batch_size表示每次训练的训练集大小，此处为24）使用sklearn对输入数据进行极大极小归一化。
42

43
history = model.fit(x_train, y_train, batch_size=10, epochs=200)
44

45
# 评估模型
46
score = model.evaluate(x_test, y_test, verbose=0)
47
print("Test accuracy:", score[1])
48

49
# 取history中历史损失值
50
loss = history.history['loss']
51
# 计算轮次
52
epochs = range(len(loss))
53
# 利用轮次和损失值画线条图
54
plt.plot(epochs, loss, label="Train_loss")
55
# 显示图例
56
plt.legend()
57
plt.show()
58

59
# 利用x_test数据，进行测试集的预测
60
result = model.predict(x_test)
61
# 显示真实数据
62
print(y_test)
63
# 显示预测结果
64
print('测试集的预测结果为：', result)
65
#对预测结果和实际值进行可视化
66
plt.figure()
67
plt.plot(y_test, label='true data')
68
plt.plot(result, 'r:',label='predict')
69
plt.legend()
70
plt.show()

1
# 根据上述要求补全下列代码：
2
import pandas as pd
3
titantic = pd.read_csv('./data/泰坦尼克乘客数据.txt')#1.读取数据⽂件 3分
4
titantic.head()
5
titantic.info()
6
X = titantic[['pclass','age','sex']]#2.筛选pclass，age，sex关键因素 2分
7
Y = titantic['survived']
8
#3，使⽤平均值对age的缺失数据进⾏补全 3分
9
#X['age'].fillna(X['age'].mean(),inplace=True) # 注意inplace=True不能少
10
X=X.fillna({'age':X['age'].mean()})
11
X.info()
12
# from sklearn.model_selection import KFold
13
from sklearn.model_selection import train_test_split
14
X_train,X_test,Y_tran,Y_test = train_test_split(X,Y,test_size=0.2,random_state=33) #4.划分数据集 2分
15
# random_state随机数种⼦：其实就是该组随机数的编号，在需要重复试验的时候，保证得到⼀组⼀样的随机数
16
X_train.info()
17
X_test.info()
18
from sklearn.feature_extraction import DictVectorizer
19
vec=DictVectorizer(sparse=True)#5.进⾏特征转换 4分 sparse=True 转换后的量是否为稀疏矩阵的形式
20
X_train = vec.fit_transform(X_train.to_dict(orient='records'))
21
X_test = vec.transform(X_test.to_dict(orient='records'))
22
print(X_train)
23
#6.初始化决策树模型 3分
24
from sklearn.tree import DecisionTreeClassifier
25
dtc = DecisionTreeClassifier()
26
#7.进⾏训练 3分
27
dtc.fit(X_train,Y_tran)
28
#8,进⾏预测并输出 4分
29
y_predict = dtc.predict(X_test)
30
print(y_predict)
31
#9.评估分类性能并输出 4分
32
from sklearn.metrics import classification_report
33
print (dtc.score(X_test,Y_test))
34
result=classification_report(Y_test,y_predict,target_names=['died','survived'])
35
print(result)

1
import pandas as pd
2
import numpy as np
3
column_names=['Sample code number','Clump Thickness','Uniformity of Cell Size','Uniformity of Cell Shape','Marginal Adhesion','Single Epithelial Cell Size','Bare Nuclei','Bland Chromatin']
4
data=pd.read_csv('./data/breast-cancer-wisconsin.data',names=column_names)#1.读取⽂件 3分
5
data.info()#2.查看数据统计特性 2分
6

7
data=data.replace(to_replace='?',value=np.nan) #3.将‘？’替换为标准缺失值表示 2分
8
data=data.dropna(how='any')#4.丢弃带有缺失值的数据（只要有⼀个维度有缺失） 3分
9
data.info()
10
data.shape
11

12
from sklearn.model_selection import train_test_split
13
X_train,X_test,Y_train,Y_test=train_test_split(data[column_names[1:10]], data[column_names[10]], test_size=0.2,random_state=33)#5.数据集划分 2分
14
X_train.info()
15
X_test.info()
16

17
from sklearn.preprocessing import StandardScaler
18
from sklearn.neighbors import KNeighborsClassifier
19
ss=StandardScaler()#6.数据标准化 2分
20
X_train=ss.fit_transform(X_train)
21
X_test=ss.fit_transform(X_test)
22
knc=KNeighborsClassifier() #7.选择分类器 2分
23
knc.fit(X_train,Y_train)
24
y_predict=knc.predict(X_test)#8.预测结果 3分
25
print("预测结果：")
26
print(y_predict)
27
from sklearn.metrics import classification_report
28
print("Accuracy of K-Nearest Neighbor Classifier is",knc.score(X_test,Y_test))#9.预测性能评估 2分
29
print(classification_report(Y_test,y_predict,target_names=['Benign','Malignant']))

1
from sklearn.datasets import fetch_20newsgroups
2
news=fetch_20newsgroups(subset='train')
3
#1.设置数据路径 1分
4
print(len(news.data))
5
print(news.data[0])#2.打印数据信息 1分
6
from sklearn.model_selection import train_test_split
7
X_train,X_test,Y_train,Y_test=train_test_split(news.data,news.target, test_size=0.2,random_state=33)#3.对数据集进⾏划分 4分
8
from sklearn.feature_extraction.text import CountVectorizer
9
vec=CountVectorizer() #4.⽂本向量化 1分
10
X_train=vec.fit_transform(X_train) #5.训练集处理 1分
11
X_test=vec.transform(X_test) #6.测试集处理 1分
12
from sklearn.naive_bayes import MultinomialNB#7.导⼊朴素⻉叶斯 8分
13
mnb=MultinomialNB()#8.朴素⻉叶斯模型建⽴ 4分
14
mnb.fit(X_train,Y_train)#9.朴素⻉叶斯模型训练 2分
15
y_predict=mnb.predict(X_test)
16
#10.模型结果预测 2分
17
print(y_predict)
18
from sklearn.metrics import classification_report
19
print("The accuracy of Naive Bayes Classification is",mnb.score)#11.accuracy结果输出 1分
20
print(classification_report(Y_test,y_predict,target_names=news.target_names))#12.classification_report报告输出 1分

1
from sklearn.linear_model import LinearRegression
2
from sklearn.preprocessing import StandardScaler
3
from sklearn.model_selection import train_test_split
4
from sklearn.metrics import mean_squared_error,mean_absolute_error
5
import pandas as pd
6
import matplotlib.pyplot as plt
7
# 1、加载数据集 2分
8
data = pd.read_excel('./data/⽔质参数.xlsx')
9
# 2、查看数据统计特性 2分
10
print(data.info())
11
data.head()
12
# 3、分离输⼊数据和标签数据 4分 y = data['溶解氧(DO)'].values
13
x = data.drop(columns=['溶解氧(DO)'])
14
# 4、划分数据 3分
15
x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.2)
16
# 5、归⼀化处理 4分
17
std_x = StandardScaler()
18
x_train = std_x.fit_transform(x_train)
19
x_test = std_x.transform(x_test)
20
# 6、模型构造和训练 4 分
21
lr = LinearRegression()
22
lr.fit(x_train, y_train)
23
# 7、模型预测 2分
24
y_lr_predict = lr.predict(x_test)
25
# 模型评估结果
26
print("lr的均⽅误差为：", mean_squared_error(y_test,y_lr_predict)) #8、均⽅误差 4分
27
print("lr的平均绝对误差为：", mean_absolute_error(y_test,y_lr_predict)) #9、平均绝对误差 4分
28
# 结果可视化
29
plt.plot(y_test, 'r', label='true_data') #10 红⾊ 2分
30
plt.plot(y_lr_predict, 'b', label='predict')#11 蓝⾊ 2分
31
plt.legend()
32
plt.show()