不平衡学习预处理数据

目录

一、导入数据 

 二、 处理 

三、随机分配训练集和测试集 

四、组合训练集和测试集

五、完整代码

---

一、导入数据 

data_path="D:/imdata/poker.mat"

# 命名数据data（字典）
data = mat4py.loadmat(data_path)
train_data=data.get('train_data')  # 取出data字典中train_data对应的列表
train_labels=data.get('train_labels')  # 取出data字典中train_labels对应的列表
test_data=data.get('test_data')    # 取出data字典中text_data对应的列表
test_labels=data.get('test_labels')   # 取出data字典中text_labels对应的列表

导入的数据是MATLAB格式的，其中包含训练集数据和训练集标签，测试集数据和测试集标签 。需要注意的是这里面的标签是Nx1的格式的，为了能进行训练我们需要转置为1xN

数据集使用的是poker.mat

其中，数据集中存放有train_data、train_labels、test_data、test_labels

数据集中每个样本有10个特征

标签值为-1为多数类，值为1时是少数类

---

 二、 处理 

#将训练标签和测试标签由列表转为数组 Nx1
train_labels1=np.array(train_labels)
test_labels1=np.array(test_labels)

#训练和测试中少数类的数量 
ntra_min=len(train_labels1[train_labels1==1])
ntst_min=len(test_labels1[test_labels1==1])

train_labels1[train_labels1==1]：从train_label1中取出等于1的值，组成新的数组

其中，标签为1的为少数类，标签为-1的为多数类 

#将训练和测试合在一起
X = numpy.vstack((train_data, test_data))  # 创立数组X
y = numpy.vstack((train_labels, test_labels))  # 创立数组Y

#转置y Nx1变成1xN [[-1,...,-1]]
y1=numpy.transpose(y)
#将y1变为一维数组 [-1,...,-1]
y1=y1.ravel()

 转置后的数据变成了[ [-1,-1,...,-1,-1] ]，需要通过ravel()函数将其变为一维1xN格式 [-1,-1,...,-1,-1]

#将例子分为少数类和多数类 1:少数类
X_max=X[y1==-1] #多数类数据
X_min=X[y1== 1] #少数类数据
y_max=y[y1==-1] #多数类标签
y_min=y[y1== 1] #少数类标签

 # y1 是标签数组，其中 1 表示少数类，-1表示多数类

y1 = np.array([-1, 1, -1, 1, -1, 1])

# y 是对应的数据数组

y = np.array(['A', 'B', 'C', 'D', 'E', 'F'])

# 根据 y1 等于 1 的条件来过滤 y，提取少数类标签的数据

y_min = y[y1 == 1]

最后的结果：y=['B' 'D' 'F']

N=len(X)#样本的数量
imb=len(X_max)/len(X_min)

#进行试验的次数
n_step=10
l=int(imb**0.5)
#方法参数
k=int(N**0.5+imb**0.5)

其中imb表示多数类的数据数量是少数类数据数量的多少倍，imb越大表明数据越不平衡，分类难度也越大。

---

三、随机分配训练集和测试集 

for i in range(n_step):
    print('*********')
    print(i)
    # 抽取多数例子Xtra_max
    Ntra_max = [i for i in range(len(X_max))]  # 生成0~len(X_max)的一个数组 [0,1,...,1021238]
    ntrn_max = len(train_data) - ntra_min  # 训练集中多数类的样本的个数
    n_max=int((len(train_data) - ntra_min)*0.6) #训练集数量
    random.shuffle(Ntra_max)  # 打乱原有的数组
    idxtrn_max = Ntra_max[0:n_max]  # 取前ntrn_max为新的训练集多数类的索引
    idxtst_max = Ntra_max[ntrn_max:]  # 剩下的为测试集
    Xtra_max = X_max[idxtrn_max, :]  # 组合成多数类的训练集
    Xtst_max = X_max[idxtst_max, :]  # 多数类测试集
    ytra_max = y_max[idxtrn_max, :]  # 多数类训练集标签
    ytst_max = y_max[idxtst_max, :]  # 多数类测试集标签
    print(np.shape(Xtra_max))

    # 抽取少数例子Xtra_min
    Ntra_min = [i for i in range(len(X_min))]
    ntrn_min = ntra_min
    n_min = int(ntra_min * 0.6)
    random.shuffle(Ntra_min)
    idxtrn_min = Ntra_min[0:n_min]
    idxtst_min = Ntra_min[ntrn_min:]
    Xtra_min = X_min[idxtrn_min, :]
    Xtst_min = X_min[idxtst_min, :]
    ytra_min = y_min[idxtrn_min, :]
    ytst_min = y_min[idxtst_min, :]
    print(np.shape(Xtra_min))

思想：生成一个和多数类长度相同的 一维列表[0,1,...,1021238]，然后打乱列表的顺序[3,4,1,...,42]确定训练集和测试集的比例，例如0.6作为训练集。取出打乱后列表的前0.6数据下标作为训练集。

# 示例数据

X_min = np.array([ [1, 2], [3, 4], [5, 6], [7, 8], [9, 10] ])

# 示例索引

idxtrn_min = np.array([0, 2, 4])

# 从 X_min 中提取指定索引的子集

Xtra_min = X_min[idxtrn_min, :]

最后的结果：Xtra_min =[ [1, 2],[5, 6], [9, 10] ]

---

四、组合训练集和测试集

# 组合成测试集和训练集
    X_train1 = np.vstack((Xtra_max, Xtra_min))
    X_test1 = np.vstack((Xtst_max, Xtst_min))
    y_train = np.vstack((ytra_max, ytra_min))
    y_test = np.vstack((ytst_max, ytst_min))

    y_train1 = numpy.transpose(y_train)
    y_train1 = y_train1.ravel()
    y_test1 = numpy.transpose(y_test)
    y_test1 = y_test1.ravel()

 这里的标签使用的是开始的Nx1的标签，需要转置一下。