📕作者简介：热编程的贝贝，致力于C/C++、Java、Python等多编程语言，热爱跑步健身，喜爱音乐的一位博主。
📗本文收录于贝贝的日常汇报系列，大家有兴趣的可以看一看
📘相关专栏深度学习、目标检测系列等，大家有兴趣的可以看一看
📙C++零基础入门系列，Web入门篇系列正在发展中，喜欢Python、C++的朋友们可以关注一下哦！
📗如有需要此项目工程，请评论区留言哦
前言
随着信息时代的来临，数据的产生和积累呈指数级增长。在这个海量数据的背景下，如何从数据中获取有价值的信息和洞见成为了各行各业的重要课题。数据分析作为一种关键的信息处理手段，在理解数据、发现规律、做出决策方面发挥着不可替代的作用。
神经网络作为一种人工智能的重要组成部分，由其在数据分析领域的成功应用引起了广泛的关注。神经网络模仿人类大脑的神经元网络结构，通过学习数据中的模式和特征，从而实现自主学习和预测能力。它能够处理非常复杂的数据关系，解决传统算法难以解决的问题，因此在数据分析领域表现出了强大的优势。
本文将探讨神经网络在数据分析中的应用。此文章中主要讨论数据分析中的分类的应用通过这些实际案例，我们将展示神经网络在数据分析中的潜力和优势。
完整代码见最后一个标题
一、数据集描述
此数据集有109列，前108列均为特征，最后一列是标签，一共6各类别。训练集一共一万条数据，数据中有部分缺失值。
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
# 加载你的数据，这里假设数据以csv格式存储
# 请将"your_data.csv"替换为你的数据文件名
df = pd.read_csv("./训练集/train_10000.csv")
df
二、实现思路
本文首先读取训练集和验证集，因为数据集中有大量的缺失值，进行中值填充会会对训练的数据造成干扰，使得准确率降低，实验中在查看各个特征的KDE图之后，
分析出以下特征会对模型最终识别精度造成负面影响，其中包括'feature0', 'feature8', 'feature11', 'feature17','feature18','feature24','feature26','feature28','feature40','feature43','feature50','feature57','feature62','feature63','feature69','feature70','feature73','feature74','feature77','feature90','feature93','feature98','feature99', 'feature100', 'feature103', 'feature104', 'feature106'，
在删除上述特征之后，再对缺失值进行中位数填充，对数据进行标准化之后，搭建神经网络对数据进行训练后，准确度可以达到0.78
三、代码实现
首先，读取数据集后，分出特征和标签，X为特征（除了最后一列的所有列），y为标签（最后一列）
# 导入需要的库
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
# 加载你的数据，这里假设数据以csv格式存储
# 请将"your_data.csv"替换为你的数据文件名
df = pd.read_csv("./训练集/train_10000.csv")
# 假设最后一列为标签，将其分离
X = df.iloc[:, 1:-1] # 特征数据，取所有行，除了最后一列之外的所有列
y = df.iloc[:, -1] # 标签数据，取所有行的最后一列
# 复制原始数据
df_filled = X.copy()
接下来对数据的缺失值进行处理，此处使用中位数对Nan进行填充
# # 对每个特征，将NaN填充为中位数
for col in df_filled.columns:
df_filled[col] = X[col].fillna(X[col].median())
df_filled= df_filled.dropna(axis=1)对数据进行归一化，并丢弃异常值
df_normalized = (df_filled - df_filled.min()) / (df_filled.max() - df_filled.min())
df_normalized = df_normalized.dropna(axis=1)删除冗余、表现效果差的特征列
drop=[0,8,11,17,18,24,26,28,40,43,50,62,63,69,70,73,74,90,93,98,99,103,104,106]
drop_list=[]
for i in drop:
name='feature'+str(i)
drop_list.append(name)
# columns_to_remove = ['column1', 'column2', 'column3']
df_normalized = df_normalized.drop(columns=drop_list)将X和y转化为列表格式
X=[]
Y=[]
for i in range(len(df)):
X.append(df_normalized.iloc[i,:].values)
Y.append(y.iloc[i])
导入神经网络工具包
import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset
from torch.utils.data import DataLoader构建数据集，重写dataset
X=torch.tensor(X,dtype=torch.float32)
Y=torch.tensor(Y,dtype=torch.int64)
X_val=torch.tensor(X_val,dtype=torch.float32)
Y_val=torch.tensor(Y_val,dtype=torch.int64)
class MyTrainDataset(Dataset):
def __init__(self,data,label):
self.data=data
self.label=label
def __len__(self):
return len(self.label)
def __getitem__(self, index):
input=self.data[index]
label=self.label[index]
return input,label
dataset_train=MyTrainDataset(X,Y)
dataset_val=MyTrainDataset(X_val,Y_val)
dataset_train[0][0].size()
trainLoader=torch.utils.data.DataLoader(dataset=dataset_train,batch_size=8)
valLoader=torch.utils.data.DataLoader(dataset=dataset_val,batch_size=8)构建神经网络模型，此处没有用什么特殊的神经网络，只用较为简单的全连接神经网络，为了保证其收敛，数据集规模和参数量规模应基本一致，经调整后，为以下模型
并设置损失函数，有乎其，学习策略
input_size=80
hidden_size=40
hidden_size2=256
output_size=6
model=torch.nn.Sequential(
nn.Linear(input_size,hidden_size),
nn.Sigmoid(),
nn.Linear(hidden_size,output_size),
# nn.Sigmoid(),
# nn.Linear(hidden_size2,output_size),
)
model=model.cuda()
cost=nn.CrossEntropyLoss()
#lr=0.01
# 设定优化器
#optimizer = torch.optim.SGD(model.parameters(), momentum=0.9, weight_decay=0.0001, lr=lr)
# 以optimizer中设定的lr为基础，每隔10步，learning rate乘上0.3
optimizer=optim.Adam(model.parameters(),lr=0.001)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.3)
最终进行训练和验证
from tqdm import tqdm
import numpy as np
best_acc=0
for i in range(200):
model.train()
losses=[]
correct=0
scheduler.step()
for data in tqdm(trainLoader):
input,label=data
input=input.cuda()
label=label.cuda()
optimizer.zero_grad()
pred=model(input)
#print(pred.size())
loss=cost(pred,label)
loss.backward(retain_graph=True)
optimizer.step()
losses.append(loss.item())
max_value,max_index=torch.max(pred,1)
pred_label=max_index.cpu().numpy()
true_label=label.cpu().numpy()
# print(pred_label,true_label)
correct+=np.sum(pred_label==true_label)
# print(correct)
print("第{}此迭代".format(i))
print("train: loss:{},acc:{},learning_rate:{}".format(sum(losses)/len(losses),correct/len(dataset_train),scheduler.get_lr()[0]))
val_losses=[]
val_correct=0
model.eval()
for data in tqdm(valLoader):
input,label=data
input=input.cuda()
label=label.cuda()
pred=model(input)
loss=cost(pred,label)
#optimizer.zero_grad()
#loss.backward(retain_graph=True)
#optimizer.step()
val_losses.append(loss.item())
max_value,max_index=torch.max(pred,1)
pred_label=max_index.cpu().numpy()
true_label=label.cpu().numpy()
val_correct+=np.sum(pred_label==true_label)
# print(pred_label,true_label)
# print(val_correct)
#print("第{}此迭代".format(i))
if(val_correct/len(dataset_val)>best_acc):
best_acc=val_correct/len(dataset_val)
torch.save(model,"./best_model_acc{}.pt".format(best_acc))
print("val: loss:{},acc:{}".format(sum(val_losses)/len(val_losses),val_correct/len(dataset_val)))四、完整代码
# 导入需要的库
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
# 加载你的数据，这里假设数据以csv格式存储
# 请将"your_data.csv"替换为你的数据文件名
df = pd.read_csv("./训练集/train_10000.csv")
# 假设最后一列为标签，将其分离
X = df.iloc[:, 1:-1] # 特征数据，取所有行，除了最后一列之外的所有列
y = df.iloc[:, -1] # 标签数据，取所有行的最后一列
# 复制原始数据
df_filled = X.copy()
# # 对每个特征，将NaN填充为中位数
for col in df_filled.columns:
df_filled[col] = X[col].fillna(X[col].median())
df_filled= df_filled.dropna(axis=1)
df_normalized = (df_filled - df_filled.min()) / (df_filled.max() - df_filled.min())
df_normalized = df_normalized.dropna(axis=1)
df_normalized.columns
drop=[0,8,11,17,18,24,26,28,40,43,50,62,63,69,70,73,74,90,93,98,99,103,104,106]
drop_list=[]
for i in drop:
name='feature'+str(i)
drop_list.append(name)
# columns_to_remove = ['column1', 'column2', 'column3']
df_normalized = df_normalized.drop(columns=drop_list)
X=[]
Y=[]
for i in range(len(df)):
X.append(df_normalized.iloc[i,:].values)
Y.append(y.iloc[i])
import pandas as pd
from sklearn.metrics import f1_score, classification_report
from sklearn.preprocessing import StandardScaler
import pickle
# 读取数据
data = pd.read_csv(r'./验证集/validate_1000.csv')
# 假设最后一列为标签，将其分离
X_valid = data.iloc[:, 1:-1] # 特征数据，取所有行，除了最后一列之外的所有列
y_valid = data.iloc[:, -1] # 标签数据，取所有行的最后一列
# 复制原始数据
X_valid_filled = X_valid.copy()
# # 对每个特征，将NaN填充为中位数
for col in X_valid.columns:
X_valid_filled[col] = X_valid[col].fillna(X_valid[col].median())
X_valid_filled= X_valid_filled.dropna(axis=1)
#对数据进行归一化
# X_valid_normalized = sc.transform(X_valid_filled)
X_valid_normalized = (X_valid_filled - df_filled.min()) / (df_filled.max() - df_filled.min())
#X_valid_normalized = (X_valid_filled - X_valid_filled.min()) / (X_valid_filled.max() - X_valid_filled.min())
# X_valid_normalized = X_valid_normalized.fillna(X_valid_normalized.median())
X_valid_normalized = X_valid_normalized.dropna(axis=1)
#print(X_valid_normalized)
X_valid_normalized = X_valid_normalized.drop(columns=drop_list)
X_val=[]
Y_val=[]
for i in range(len(X_valid_normalized)):
X_val.append(X_valid_normalized.iloc[i,:].values)
Y_val.append(y_valid[i])
import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.utils.data as Data
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
X=torch.tensor(X,dtype=torch.float32)
Y=torch.tensor(Y,dtype=torch.int64)
X_val=torch.tensor(X_val,dtype=torch.float32)
Y_val=torch.tensor(Y_val,dtype=torch.int64)
class MyTrainDataset(Dataset):
def __init__(self,data,label):
self.data=data
self.label=label
def __len__(self):
return len(self.label)
def __getitem__(self, index):
input=self.data[index]
label=self.label[index]
return input,label
dataset_train=MyTrainDataset(X,Y)
dataset_val=MyTrainDataset(X_val,Y_val)
dataset_train[0][0].size()
trainLoader=torch.utils.data.DataLoader(dataset=dataset_train,batch_size=8)
valLoader=torch.utils.data.DataLoader(dataset=dataset_val,batch_size=8)
input_size=80
hidden_size=40
hidden_size2=256
output_size=6
model=torch.nn.Sequential(
nn.Linear(input_size,hidden_size),
nn.Sigmoid(),
nn.Linear(hidden_size,output_size),
# nn.Sigmoid(),
# nn.Linear(hidden_size2,output_size),
)
model=model.cuda()
cost=nn.CrossEntropyLoss()
#lr=0.01
# 设定优化器
#optimizer = torch.optim.SGD(model.parameters(), momentum=0.9, weight_decay=0.0001, lr=lr)
# 以optimizer中设定的lr为基础，每隔10步，learning rate乘上0.3
optimizer=optim.Adam(model.parameters(),lr=0.001)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.3)
from tqdm import tqdm
import numpy as np
best_acc=0
for i in range(200):
model.train()
losses=[]
correct=0
scheduler.step()
for data in tqdm(trainLoader):
input,label=data
input=input.cuda()
label=label.cuda()
optimizer.zero_grad()
pred=model(input)
#print(pred.size())
loss=cost(pred,label)
loss.backward(retain_graph=True)
optimizer.step()
losses.append(loss.item())
max_value,max_index=torch.max(pred,1)
pred_label=max_index.cpu().numpy()
true_label=label.cpu().numpy()
# print(pred_label,true_label)
correct+=np.sum(pred_label==true_label)
# print(correct)
print("第{}此迭代".format(i))
print("train: loss:{},acc:{},learning_rate:{}".format(sum(losses)/len(losses),correct/len(dataset_train),scheduler.get_lr()[0]))
val_losses=[]
val_correct=0
model.eval()
for data in tqdm(valLoader):
input,label=data
input=input.cuda()
label=label.cuda()
pred=model(input)
loss=cost(pred,label)
#optimizer.zero_grad()
#loss.backward(retain_graph=True)
#optimizer.step()
val_losses.append(loss.item())
max_value,max_index=torch.max(pred,1)
pred_label=max_index.cpu().numpy()
true_label=label.cpu().numpy()
val_correct+=np.sum(pred_label==true_label)
# print(pred_label,true_label)
# print(val_correct)
#print("第{}此迭代".format(i))
if(val_correct/len(dataset_val)>best_acc):
best_acc=val_correct/len(dataset_val)
torch.save(model,"./best_model_acc{}.pt".format(best_acc))
print("val: loss:{},acc:{}".format(sum(val_losses)/len(val_losses),val_correct/len(dataset_val)))总结
本文对神经网络进行数据分析的分类问题，进行了阐述、代码解释和处理流程，本教程作为读者的入门教程，更多的问题均可参考此模板迅速完成建模。
如果这份博客对大家有帮助，希望各位给恒川一个免费的点赞👍作为鼓励，并评论收藏一下⭐，谢谢大家！！！
制作不易，如果大家有什么疑问或给恒川的意见，欢迎评论区留言。
661
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
