深度学习：基于TensorFlow 和 Keras，使用神经网络回归模型预测 IPL 分数_tensorflow kears回归神经网络

前言

系列专栏：机器学习：高级应用与实践【项目实战100+】【2024】✨︎
在本专栏中不仅包含一些适合初学者的最新机器学习项目，每个项目都处理一组不同的问题，包括监督和无监督学习、分类、回归和聚类，而且涉及创建深度学习模型、处理非结构化数据以及指导复杂的模型，如卷积神经网络、门控循环单元、大型语言模型和强化学习模型

自 2008 年 IPL 开始举办以来，它吸引了全球各地的观众。高度的不确定性和最后时刻的钉子户促使球迷观看比赛。在很短的时间内，IPL 已成为板球界收入最高的联赛。在板球比赛中，我们经常会看到比分线显示根据当前比赛形势球队获胜的概率。这种预测通常是在数据分析的帮助下完成的。以前，在机器学习还不发达的时候，预测通常是基于直觉或一些基本算法。

作为一名板球迷，板球统计数据的可视化令人着迷。我们浏览了各种博客，发现了一些可以用来提前预测 IPL 比赛得分的模式。

我们人类无法轻易从海量数据中找出模式，因此，机器学习和深度学习在此发挥了作用。它可以了解球员和球队之前对阵对方球队时的表现，并据此训练模型。仅使用机器学习算法的准确率不高，因此我们使用了深度学习，它的性能比我们之前的模型要好得多，并且考虑到了能够提供准确结果的属性。

1. 相关库和数据集

1.1 相关库介绍

Python 库使我们能够非常轻松地处理数据并使用一行代码执行典型和复杂的任务。

• Numpy – 可用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。
• Pandas – 该库有助于以 2D 数组格式加载数据框，并具有多种功能，可一次性执行分析任务。
• Matplotlib/Seaborn – 此库用于绘制可视化效果，用于展现数据之间的相互关系。
• Sklearn – 包含多个库，这些库具有预实现的功能，用于执行从数据预处理到模型开发和评估的任务。
• TensorFlow™ – 是一个基于数据流编程的符号数学系统，被广泛应用于各类机器学习算法的编程实现。
• Keras – 是一个由Python编写的开源人工神经网络库，可以作为 Tensorflow 的高阶应用程序接口。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn import preprocessing
import keras 
import tensorflow as tf
1
2
3
4
5
6
7
8

1.2 加载数据集

在处理板球数据时，它包含 2008 年至 2017 年的数据。数据集可以从这里下载。该数据集包含场地、日期、击球和保龄球队、击球手和投球手的名称、检票口等特征。

我们使用 .read_csv() 方法将两个数据集导入到 pandas 的数据帧中，并显示每个数据集的前 5 行。

ipl = pd.read_csv('ipl.csv')
ipl.head()
1
2

2. 数据预处理

2.1 数据清理

删除不重要的功能

1. 我们通过从原始 DataFrame 中删除几列来创建一个新的 DataFrame。
2. 新的 DataFrame 包含我们将要训练预测模型的其余列。

#Dropping certain features 
df = ipl.drop(['date', 'runs', 'wickets', 'overs', 'runs_last_5', 'wickets_last_5','mid', 'striker', 'non-striker'], axis =1)
1
2

3. 我们将数据框拆分为输入特征 (X) 和目标特征 (y)，我们的目标特征是总分。

X = df.drop(['total'], axis =1)
y = df['total']
1
2

X.head()
1

2.2 标签编码

• 我们在 X 中对分类特征进行了标签编码。
• 我们为每个分类特征创建了单独的对象，并对其值进行了编码。标签编码器
• 我们创建了映射，将编码标签转换回原始值，这对解释结果很有帮助。

#Label Encoding

from sklearn.preprocessing import LabelEncoder

# Create a LabelEncoder object for each categorical feature
venue_encoder = LabelEncoder()
batting_team_encoder = LabelEncoder()
bowling_team_encoder = LabelEncoder()
striker_encoder = LabelEncoder()
bowler_encoder = LabelEncoder()

# Fit and transform the categorical features with label encoding
X['venue'] = venue_encoder.fit_transform(X['venue'])
X['bat_team'] = batting_team_encoder.fit_transform(X['bat_team'])
X['bowl_team'] = bowling_team_encoder.fit_transform(X['bowl_team'])
X['batsman'] = striker_encoder.fit_transform(X['batsman'])
X['bowler'] = bowler_encoder.fit_transform(X['bowler'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.3 数据准备（拆分为训练集和测试集）

我们将数据分为训练集和测试集。训练集包含数据集的 70%，其余 30% 为测试集。

• X_train 包含输入特征的训练数据。
• X_test 包含输入特征的测试数据。
• y_train 包含目标变量的训练数据。
• y_test 包含目标变量的测试数据。

# Train test Split 
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
1
2
3

2.4 特征缩放（归一化）

• 我们对输入特征进行了最小-最大缩放，以确保所有特征都在同一比例上
• 缩放是为了确保尺度一致，以提高模型性能。
• 缩放使用缩放参数对训练数据和测试数据进行了转换。

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

# Fit the scaler on the training data and transform both training and testing data
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
1
2
3
4
5
6
7

3. 神经网络

3.1 定义神经网络

• 我们使用 TensorFlow 和 Keras 定义了一个用于回归的神经网络。
• 定义模型后，我们使用 Huber Loss 对模型进行了编译。

# Define the neural network model
model = keras.Sequential([
	keras.layers.Input( shape=(X_train_scaled.shape[1],)), # Input layer
	keras.layers.Dense(512, activation='relu'), # Hidden layer with 512 units and ReLU activation
	keras.layers.Dense(216, activation='relu'), # Hidden layer with 216 units and ReLU activation
	keras.layers.Dense(1, activation='linear') # Output layer with linear activation for regression
])

# Compile the model with Huber loss
huber_loss = tf.keras.losses.Huber(delta=1.0) # You can adjust the 'delta' parameter as needed
model.compile(optimizer='adam', loss=huber_loss) # Use Huber loss for regression
1
2
3
4
5
6
7
8
9
10
11

3.2 模型训练

# Train the model
model.fit(X_train_scaled, y_train, epochs=50, batch_size=64, validation_data=(X_test_scaled, y_test))
1
2

Epoch 1/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 56.2658 - val_loss: 22.3282
Epoch 2/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 22.4136 - val_loss: 22.7654
Epoch 3/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 22.2383 - val_loss: 21.9184
Epoch 4/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 22.1480 - val_loss: 22.1336
Epoch 5/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.2213 - val_loss: 21.8952
Epoch 6/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 22.1529 - val_loss: 21.8332
Epoch 7/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.0361 - val_loss: 21.9755
Epoch 8/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 22.1623 - val_loss: 23.2852
Epoch 9/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.1077 - val_loss: 21.8450
Epoch 10/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 22.0598 - val_loss: 21.7673
Epoch 11/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.1538 - val_loss: 21.8079
Epoch 12/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 22.0716 - val_loss: 21.8496
Epoch 13/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.0589 - val_loss: 21.7739
Epoch 14/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.2804 - val_loss: 21.9109
Epoch 15/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 22.1427 - val_loss: 21.7200
Epoch 16/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 22.3138 - val_loss: 21.7095
Epoch 17/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.9855 - val_loss: 21.6038
Epoch 18/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.9500 - val_loss: 21.9648
Epoch 19/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 21.8497 - val_loss: 21.4573
Epoch 20/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 21.7528 - val_loss: 21.6321
Epoch 21/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.6298 - val_loss: 21.3790
Epoch 22/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.6973 - val_loss: 21.4358
Epoch 23/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 21.7973 - val_loss: 22.0959
Epoch 24/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.6350 - val_loss: 21.4656
Epoch 25/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.5059 - val_loss: 21.4100
Epoch 26/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.4734 - val_loss: 21.2435
Epoch 27/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.4959 - val_loss: 21.1024
Epoch 28/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 21.4274 - val_loss: 21.0573
Epoch 29/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.3708 - val_loss: 21.0899
Epoch 30/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 21.3479 - val_loss: 21.3070
Epoch 31/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.3438 - val_loss: 20.9639
Epoch 32/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 21.1507 - val_loss: 20.8814
Epoch 33/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 21.0879 - val_loss: 20.9932
Epoch 34/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 20.9838 - val_loss: 20.7426
Epoch 35/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 21.0293 - val_loss: 20.6817
Epoch 36/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 20.8811 - val_loss: 20.5242
Epoch 37/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 20.6925 - val_loss: 20.5147
Epoch 38/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - loss: 20.5798 - val_loss: 20.3213
Epoch 39/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 20.4411 - val_loss: 20.2086
Epoch 40/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 20.4475 - val_loss: 20.2530
Epoch 41/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 20.3650 - val_loss: 20.0541
Epoch 42/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 20.2180 - val_loss: 20.0937
Epoch 43/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 20.0702 - val_loss: 19.9618
Epoch 44/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 19.8153 - val_loss: 19.9452
Epoch 45/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 19.8323 - val_loss: 19.4963
Epoch 46/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 19.8802 - val_loss: 19.7684
Epoch 47/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 19.5058 - val_loss: 19.3091
Epoch 48/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 19.7167 - val_loss: 19.1579
Epoch 49/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - loss: 19.2688 - val_loss: 19.1043
Epoch 50/50
832/832 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - loss: 19.3352 - val_loss: 18.9863
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

训练完成后，我们会在训练过程中将训练和验证损失值存储到神经网络中。

model_losses = pd.DataFrame(model.history.history)
model_losses.plot()
1
2

3.3 模型评估

• 我们使用训练好的神经网络对测试数据进行预测。
• 变量预测包含基于模型学习模式的测试集预测总运行分数。

# Make predictions
predictions = model.predict(X_test_scaled)

from sklearn.metrics import mean_absolute_error,mean_squared_error
mean_absolute_error(y_test,predictions)
1
2
3
4
5

713/713 ━━━━━━━━━━━━━━━━━━━━ 1s 687us/step
19.47724912576941
1
2

4. 创建互动小部件

• 我们使用ipywidgets创建了一个交互式小部件，根据用户输入的场地、击球队、保龄球队、前锋和投球手来预测得分。
• 我们创建了下拉小部件来选择场地、击球队、保龄球队、前锋和投球手的值。
• 我们添加了一个“预测分数”按钮小部件。无论何时单击该按钮，都会调用predict_score函数，然后执行以下步骤：①将用户选择的值解码为其原始分类值。②对这些值进行编码和缩放，以匹配模型训练中使用的格式。③使用训练好的模型根据用户的输入进行预测。④显示预测分数。

import ipywidgets as widgets
from IPython.display import display, clear_output

import warnings
warnings.filterwarnings("ignore")

venue = widgets.Dropdown(options=df['venue'].unique().tolist(),description='Select Venue:')
batting_team = widgets.Dropdown(options =df['bat_team'].unique().tolist(), description='Select Batting Team:')
bowling_team = widgets.Dropdown(options=df['bowl_team'].unique().tolist(), description='Select Batting Team:')
striker = widgets.Dropdown(options=df['batsman'].unique().tolist(), description='Select Striker:')
bowler = widgets.Dropdown(options=df['bowler'].unique().tolist(), description='Select Bowler:')

predict_button = widgets.Button(description="Predict Score")

def predict_score(b):
	with output:
		clear_output() # Clear the previous output
		

		# Decode the encoded values back to their original values
		decoded_venue = venue_encoder.transform([venue.value])
		decoded_batting_team = batting_team_encoder.transform([batting_team.value])
		decoded_bowling_team = bowling_team_encoder.transform([bowling_team.value])
		decoded_striker = striker_encoder.transform([striker.value])
		decoded_bowler = bowler_encoder.transform([bowler.value])


		input = np.array([decoded_venue, decoded_batting_team, decoded_bowling_team,decoded_striker, decoded_bowler])
		input = input.reshape(1,5)
		input = scaler.transform(input)
		#print(input)
		predicted_score = model.predict(input)
		predicted_score = int(predicted_score[0,0])

		print(predicted_score)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

基于小部件的界面允许您交互式地预测特定比赛场景的得分。现在，我们已经设置了按钮，当单击时触发predict_score函数，并显示场地、击球队、保龄球队、击球手和投球手的小部件。

predict_button.on_click(predict_score)
output = widgets.Output()
display(venue, batting_team, bowling_team, striker, bowler, predict_button, output)
1
2
3

我们预测了在印度旁遮普邦球场举行的 CSK 与 King XI Punjab 之间比赛的比分。预测的比赛比分为 183。

通过利用 ML 和 DL 的力量，我们根据历史数据成功预测了板球得分。对于 IPL 爱好者、球队和分析师来说，该模型预测板球比分的能力是一笔宝贵的财富。它可以让人们深入了解比赛的动态，帮助预测不同因素对最终比分的影响。