【机器学习】使用 generative model 和 logistic regression 预测年收入

def read(self,name,path):
        with open(path,newline = '') as csvfile:
            # 读取数据,从第二行开始读取
            rows = np.array(list(csv.reader(csvfile))[1:] ,dtype = float)   

if name == 'X_train':
	self.mean = np.mean(rows,axis = 0).reshape(1,-1)
	self.std = np.std(rows,axis = 0).reshape(1,-1)
	self.theta = np.ones((rows.shape[1] + 1,1),dtype = float) #初始化参数
 	for i in range(rows.shape[0]):
		rows[i,:] = (rows[i,:] - self.mean) / self.std #标准化
# 注意，testing data要跟training data的normalize方式一致，要用training data的mean和std
elif name == 'X_test': 
	for i in range(rows.shape[0]):
		rows[i,:] = (rows[i,:] - self.mean) / self.std #标准化

        class_0_id = []
        class_1_id = []
        for i in range(self.data['Y_train'].shape[0]): # 对数据进行分类
            if self.data['Y_train'][i][0] == 0:
                class_0_id.append(i)
            else:
                class_1_id.append(i)
        class_0 = self.data['X_train'][class_0_id]
        class_1 = self.data['X_train'][class_1_id]

        mean_0 = np.mean(class_0, axis=0)  # 分别计算两类的均值
        mean_1 = np.mean(class_1, axis=0)

        n = class_0.shape[1]
        cov_0 = np.zeros((n, n))
        cov_1 = np.zeros((n, n))
        
        n_0 = class_0.shape[0]
        n_1 = class_1.shape[0]

        for i in range(class_0.shape[0]):  # 计算协方差矩阵
            # please add code here
            cov_0 += np.dot(np.transpose([class_0[i]-mean_0]),
                            [class_0[i]-mean_0]) / n_0

        for i in range(class_1.shape[0]):
            cov_1 += np.dot(np.transpose([class_1[i]-mean_1]),
                            [class_1[i]-mean_1]) / n_1

        cov = (n_0*cov_0+n_1*cov_1)/(n_0+n_1)  # 计算协方差矩阵，使用加权的方法

        cov_inv = inv(cov)

self.w = np.dot((mean_0-mean_1).transpose(),
                cov_inv).transpose()  # 计算w
self.b = (-0.5)*np.dot(np.dot(mean_0.transpose(), cov_inv), mean_0)+0.5 * \
		np.dot(np.dot(mean_1.transpose(), cov_inv),mean_1)+np.log(float(n_0)/n_1)  # 计算b

def func(self, x):
    arr = np.empty([x.shape[0], 1], dtype=float)
    for i in range(x.shape[0]):
        z = x[i, :].dot(self.w) + self.b
        z *= (-1)
        arr[i][0] = 1 / (1 + np.exp(z))
    return np.clip(arr, 1e-8, 1-(1e-8))

def predict(self, x):
    ans = np.ones([x.shape[0], 1], dtype=int)
    for i in range(x.shape[0]):
        if x[i] > 0.5:
            ans[i] = 0
    return ans

def accuracy(self, x, y):  # 根据训练数据计算准确率
	result = self.func(x)
	answer = self.predict(result)
	return 1 - np.mean(np.abs(answer-y))

def write_file(self, path): #预测测试数据并将结果写入文件
    result = self.func(self.data['X_test'])
    answer = self.predict(result)
    with open(path, 'w', newline='') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(['id', 'label'])
        for i in range(answer.shape[0]):
            writer.writerow([i+1, answer[i][0]])

def normalize(X, mean=None, std=None):
    mean = np.mean(X, axis=0).reshape(1, -1)  # 将每一行的元素相加求均值，实际上返回的是1行106列的数组
    std = np.std(X, axis=0).reshape(1, -1)  # 将每一行的元素相加求标准差，实际上返回的是1行106列的数组
    X = (X - mean) / std  # 标准化
    return X, mean, std

X_train, mean, std = normalize(X_train)  # 标准化
X_test = (X_test - mean) / std  # 使用训练集的均值和方差对测试集进行标准化

def train_data_split(X, Y, ratio=0.8):  # 对训练集进行划分
    size = int(X.shape[0] * ratio)
    return X[:size], Y[:size], X[size:], Y[size:]


X_train, Y_train, X_val, Y_val = train_data_split(X_train, Y_train)


# 输出数据的大小和维度
print("Size of X_train: {}".format(X_train.shape[0]))
print("Size of X_val: {}".format(X_val.shape[0]))
print("Size of X_test: {}".format(X_test.shape[0]))
print("Dimension of X_train: {}".format(X_train.shape[1]))

def shuffle(X, Y):  # 对数据进行打乱
    np.random.seed(0)
    randomize = np.arange(X.shape[0])
    np.random.shuffle(randomize)
    return X[randomize], Y[randomize]

def cross_entropy_loss(y_pred, Y_label):
    cross_entropy = -np.mean(
        Y_label * np.log(y_pred) + (1 - Y_label) * np.log(1 - y_pred)
    )
    return cross_entropy

def gradient(X, Y_label, w, b): # 计算梯度
    y_pred = f(X, w, b)
    pred_error = Y_label - y_pred
    w_grad = -np.dot(pred_error, X)
    b_grad = -np.sum(pred_error)
    return w_grad, b_grad

# 开始训练
Y_train = Y_train.flatten()  # 将Y_train展平
Y_val = Y_val.flatten()  # 将Y_val展平

w = np.zeros((X_train.shape[1],))  # 初始化w
b = np.zeros((1,))  # 初始化b

iter = 20  # 迭代次数
batch_size = 8  # 批次大小
learning_rate = 0.1  # 学习率

train_loss = []
val_loss = []
train_acc = []
val_acc = []

count = 1

# 初始化累积梯度
w_accum_grad = np.zeros((X_train.shape[1],))
b_accum_grad = np.zeros((1,))

for epoch in tqdm(range(iter)):
    X_train, Y_train = shuffle(X_train, Y_train)
    # 每次取batch_size个数据进行训练
    for idx in range(int(np.floor(X_train.shape[0] / batch_size))):
        X = X_train[idx * batch_size:(idx + 1) * batch_size]
        Y = Y_train[idx * batch_size:(idx + 1) * batch_size]
        w_grad, b_grad = gradient(X, Y, w, b)

        # 累积梯度平方和，adagrad
        w_accum_grad += w_grad**2
        b_accum_grad += b_grad**2

        # 更新w和b
        w -= (learning_rate / np.sqrt(w_accum_grad + 1e-8)) * w_grad
        b -= (learning_rate / np.sqrt(b_accum_grad + 1e-8)) * b_grad

# 找到影响最大的特征
with open('X_train', newline='') as csvfile:
    featrues = list(csv.reader(csvfile))[0] # 通过表头获取特征名

max = np.max(np.abs(w)) # 获取绝对值最大的权重

for i in range(len(w)):
    if abs(w[i]) == max:
        print("The most important feature is: ",
              featrues[i], "with weight: ", w[i])
        # 找出前五个特征
        top_5_indices = np.argsort(-np.abs(w))[:5]
        print("Top 5 important features and their weights:")
        for i in top_5_indices:
            print(f"Feature: {featrues[i]}, Weight: {w[i]}")