DBAREN个人站 - Aren's Blog - 粤ICP备18014360号-1

基于Python的Xgboost实战代码

Aren — Sun, 19 Dec 2021 18:02:57 GMT

参加了一下单位组织的大数据建模比赛，记录一下，当做个笔记

import pandas as pd
import numpy as np
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from itertools import product as prod

封装工具函数

# 数据清洗函数
def data_filter(data):
	"""
    处理缺失值，挑选特征等等
    Input: 
        data: pd.Dataframe or np.array, 原始数据
    Return:
        filted_data: pd.Dataframe or np.array, 处理后的数据
    """
    # 假设输入 Dataframe, 删除具有缺失值的数据样本
	# 数据清洗操作
	filted_data = data
	# filted_data["sample"] = filted_data["sample"].replace(np.nan, filted_data["sample"].mean()) # 把NaN替换成均值

	filted_data = filted_data.dropna()  # 删除有缺少值的行
	return filted_data

# 字符串转数值枚举
def str_enum(data):
	filted_data = data
	# 字符串映射转数值枚举
	# 把品牌字段处理为枚举值
	a = filted_data["brnd_nam"].drop_duplicates().reset_index()
	brand_dict = {}
	for i in a.index:
	    brand_dict[a["brnd_nam"][i]] = i
	filted_data["brnd_nam"] = filted_data["brnd_nam"].map(brand_dict)
	filted_data["gdr_typ_nam"].map({"资料不详":0, "男":1, "女":2})
	filted_data["dou_ca_usr"] = filted_data["dou_ca_usr"].map({"否":0, "是":1})
	
	return filted_data

# K折获取训练数据、测试数据
def K_fold_train_test(X, y, random_seed=0):
    """
    使用 K 折交叉验证获取多个训练集和测试集
    Input:
        X: np.array with shape(sample_num, feature_dim) 数据集所有样本的特征值
        y: np.array with shape(sample_num,) 数据集所有样本的对应标签
        random_seed: int 设置随机种子，决定每次随机采样是否产生相同的随机值
    Return:
        train_data: [tuple(X, y)] 返回一个 tuple 的列表，每一个 tuple 代表一个训练集
        test_data: [tuple(X, y)] 返回一个 tuple 的列表，每一个 tuple 代表一个测试集
    """
    train_data = []
    test_data = []
    
    # sklearn.model_selection.RepeatedKFold 函数
    kf = KFold(n_splits=5, shuffle=True, random_state=random_seed)
    for train_index, test_index in kf.split(X):
        train_tup = (X[train_index], y[train_index])
        test_tup = (X[test_index], y[test_index])
        train_data.append(train_tup)
        test_data.append(test_tup)
    
    return train_data, test_data


"""
模型参数处理模块
Function to convert dictionary of lists to list of dictionaries of all combinations of listed variables. 
Example:
    list_of_param_dicts({'a': [1, 2], 'b': [3, 4]}) ---> [{'a': 1, 'b': 3}, {'a': 1, 'b': 4}, {'a': 2, 'b': 3}, {'a': 2, 'b': 4}]
"""
def list_of_param_dicts(param_dict):
    """
    Arguments:
        param_dict   -(dict) dictionary of parameters
    """
    vals = list(prod(*[v for k, v in param_dict.items()]))
    keys = list(prod(*[[k]*len(v) for k, v in param_dict.items()]))
    return [dict([(k, v) for k, v in zip(key, val)]) for key, val in zip(keys, vals)]

# 训练集数据
df_train = pd.read_csv("train_set.csv")
# 测试集数据
df_test = pd.read_csv("test_set.csv")

# 训练数据删除指定的某几列
train_d=df_train.drop(labels=['usr_id',"month","cust_typ_cd"],axis=1)
train_d = str_enum(train_d)
train_d = data_filter(train_d)
train_d

# 测试数据删除指定的某几列
test_d = df_test.drop(labels=["month", "cust_typ_cd"],axis=1)
test_d = str_enum(test_d)
test_d = data_filter(test_d)
test_d

73分的方式调试模型：

# ================ Xgboost =====================
import xgboost as xgb
import random                              

train_data = train_d.values
train_features = train_data[:, 1:]                       # 训练数据特征
train_labels = train_data[:, 0]                          # 训练数据标签

data_length = len(train_data)
random.seed(2)                                            # 设置随机数，改变不同的种子会有不同的随机结果
sample_idx = list(range(len(train_data)))
random.shuffle(sample_idx)
split_idx = int(0.7*data_length)
train_X = train_features[sample_idx[:split_idx]]
train_y = train_labels[sample_idx[:split_idx]]
test_X = train_features[sample_idx[split_idx:]]
test_y = train_labels[sample_idx[split_idx:]]
train_y = train_y.astype('int')
test_y = test_y.astype('int')

# 数据归一化
std = StandardScaler()
train_X = std.fit_transform(train_X)
test_X = std.transform(test_X)

dtrain = xgb.DMatrix(train_X,train_y)
dtest = xgb.DMatrix(test_X)

# 用最优参数构建模型
param = {'max_depth':20, 'eta':0.3, 'objective':'binary:logistic', 'eval_metric':'logloss'}
xgboost_model = xgb.train(param, dtrain, num_boost_round=20)

predicted_y = xgboost_model.predict(dtest)
for i in range(len(predicted_y)):
    if predicted_y[i] > 0.5:
        predicted_y[i]=1
    else:
        predicted_y[i]=0

print('=========================================================================================')
print('参数: ')
print(param)
print('准确率：', accuracy_score(test_y, predicted_y))
print('精度：', precision_score(test_y, predicted_y))
print('召回率：', recall_score(test_y, predicted_y))
print('F1：', f1_score(test_y, predicted_y))

或者用K折(效果更好，但因为进行K次会更耗时)

# ================================= XGBoost =============================
import xgboost as xgb

# 设定不同的参数
"""
param_dict = dict(
    max_depth = [6],
    eta = [0.3],
    subsample = [ 0.8],
	colsample_bytree = [0.8],
    objective = ['binary:logistic'],
    eval_metric = ['error','logloss','map', 'auc'],
    seed = [0]
	gamma = [0.1]
	
)
"""
param_dict = dict(
    max_depth = [20],
	eta = [0.5],
	subsample = [1],
	colsample_bytree = [1],
	objective = ['binary:logistic'],
	eval_metric = ['error']
)
# 获得多组不同的参数组合
param_list = list_of_param_dicts(param_dict)

# 每个参数组合运行一次结果，看看哪个好
best_f1 = 0.0
best_param = None
for param in param_list:
    accs = []
    pres = []
    recalls = []
    f1s = []
    for sample_idx in range(len(train_data)):
        train_X, train_y = train_data[sample_idx]
        test_X, test_y = test_data[sample_idx]
        train_y = train_y.astype('int')
        test_y = test_y.astype('int')
        
        # 数据归一化处理
        std = StandardScaler()
        train_X = std.fit_transform(train_X)
        test_X = std.transform(test_X)
        
        dtrain = xgb.DMatrix(train_X,train_y)
        dtest = xgb.DMatrix(test_X,test_y)
        
        xgboost_model = xgb.train(param, dtrain, num_boost_round=20)
        predicted_y = xgboost_model.predict(dtest)
        
        for i in range(len(predicted_y)):
            if predicted_y[i] > 0.5:
                 predicted_y[i]=1
            else:
                predicted_y[i]=0
        accs.append(accuracy_score(dtest.get_label(), predicted_y))
        pres.append(precision_score(dtest.get_label(), predicted_y))
        recalls.append(recall_score(dtest.get_label(), predicted_y))
        f1s.append(f1_score(dtest.get_label(), predicted_y))
    print('=========================================================================================')
    print('参数: ')
    print(param)
    print('准确率：', np.mean(np.array(accs)))
    print('精度：', np.mean(np.array(pres)))
    print('召回率：', np.mean(np.array(recalls)))
    print('F1：', np.mean(np.array(f1s)))
        
    if np.mean(np.array(f1s)) > best_f1:
        best_f1 = np.mean(np.array(f1s))
        best_param = param

print('=========================================================================================')
print('best F1 score:', best_f1)
print('best parameter: ', best_param)

# 确定最优参数后用最优参数在整个训练集上训练模型
import xgboost as xgb

train_data = train_d.values
train_features = train_data[:, 1:]                       # 训练数据特征
train_labels = train_data[:, 0]                          # 训练数据标签

test_data = test_d.values                                
test_features = test_data[:,1:]                          # 预测数据特征

# 数据归一化
std = StandardScaler()
train_features = std.fit_transform(train_features)
train_labels = train_labels.astype('int')
test_features = std.transform(test_features)

dtrain = xgb.DMatrix(train_features,train_labels)
dtest = xgb.DMatrix(test_features)
# 用最优参数构建模型
param = {'max_depth': 20, 'eta': 0.3, 'subsample': 1, 'colsample_bytree': 1, 'objective': 'binary:logistic', 'eval_metric': 'logloss'}
xgboost_model = xgb.train(param, dtrain, num_boost_round=20)

# 输入没有标签的测试集特征
predicted_y = xgboost_model.predict(dtest)
for i in range(len(predicted_y)):
    if predicted_y[i] > 0.5:
        predicted_y[i]=1
    else:
        predicted_y[i]=0

# 结果组合成df，保存输出结果
df_y = pd.DataFrame(predicted_y.tolist(),columns=['pre_result'])
df_u = test_d['usr_id']
result = pd.concat([df_u,df_y], axis=1)
result.to_csv("result.csv",index=False)

Linux下的用户创建和sudo授权，以及添加ssh-keygen免密码登录

Aren — Tue, 03 Nov 2020 16:22:30 GMT

因为一般不直接用root用户操作，添加用户并且授权、免密登录就是一套常规操作了。

注：环境为centos7.8,操作的初始角色root

用户创建和授权

创建用户
adduser username

设置密码
passwd username

vim /etc/sudoers 进入文件编辑器，root用户wq!保存即可

## Allow root to run any commands anywhere
root ALL=(ALL) ALL #已有行
## 增加一行
username ALL=(ALL) ALL

客户端键入

ssh-keygen

一路回车

服务端切换用户,创建文件

$ su username
$ cd ~
$ ssh-keygen
$ cd .ssh/
$ vim authorized_keys

把客户端内的 ~/.ssh/id_rsa.pub 的内容全部复制服务端的 authorized_keys 内

ssh username@host -p22

done.

如果ssh连接提示无权限：

在本地 SSH 登录服务器，使用新创建的用户，提示：
Permission denied (publickey,gssapi-keyex,gssapi-with-mic).
原因是用户主目录下的 .ssh 目录与它里面的 authorized_keys 文件的权限不能。
.ssh 目录的权限应该是 700，authorized_keys 这个文件的权限应该设置成 600 。
注意 .ssh 目录与 authorized_keys 的拥有者都必须是你创建的那个用户。比如我创建了一个叫 aren 的用户，那它应该是 .ssh 与 authorized_keys 的拥有者，并且必须要设置合适的权限

$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh_authorized_keys

sudo 下环境变量没有加入到/usr/local/bin导致找不到命令的话

# 修改 /etc/sudoers
# 找到
# Defaults    secure_path = /sbin:/bin:/usr/sbin:/usr/bin

#改为
Defaults    secure_path = /sbin:/bin:/usr/sbin:/usr/bin:/usr/local/bin

Centos下通过docker搭建ghost博客

Aren — Tue, 27 Oct 2020 10:15:07 GMT

一些前言：

很早我就想搭个blog，N年前的标准答案是wordpress，撇开代码不谈，外观实在太落后了（来自外貌协会的一票否决），也轻微折腾了一下fork了一些基于laravel的博客、想着基于自己熟悉的框架也比较方便，甚至想着不如自己用go或者java全新写一个一切尽在掌握，均不了了之。

后来我“痛定思痛”想了下，我只是想要个美观的、功能满足需求的的博客系统，至于自定义做一些开发这种事，如果是可以动鼠标和敲命令解决的问题、我是绝对懒得写代码的。

于是我重新考察了一下流行的博客系统，Hexo/Ghost/Vuepress，最后我决定用Ghost，简单理由如下：

默认就比较符合审美的简约风格（黑白），也可以自己换主题
支持移动端良好访问
支持markdown写法（用过md、这辈子都不想用doc）
支持文章评论（通过插件或者gitalk）
后台管理，可以选择接入数据库，也可以纯文档部署
资料和开发工具支撑比较完善

那，决定了就安装部署呗，生产环境官方给的例子是ubuntu的安装，但我tx云用的是centos7，考虑了下我觉得不如用docker好了，毕竟docker现在来看早就是大势所趋，docker可以很好解决各种不同环境下的服务部署问题，docker既是技术力也是生产力、多学学也不亏。

下面正式开始安装部署教程：

1、更新yum

$ yum update

2、删除可能存在的旧版本

$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

3、安装 yum-utils 组件，获取稳定的docker安装包。

$ sudo yum install -y yum-utils

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

注意：
有些安装教程会用下边的命令安装yum-utils，但个人发现centos7已经默认就启用了device-mapper和安装了lvm2，所以没必要安装那两个依赖，低版本的centos可能才需要。

#  preinstall utils 
sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

4、安装docker

$ sudo yum install docker-ce docker-ce-cli containerd.io

5、安装docker-compose

sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

墙的关系这里很难下，我是直接本地下载了再scp传上服务器。

6、赋予docker-compose执行权限

sudo chmod +x /usr/local/bin/docker-compose

7、启动docker、给当前用户赋权

# start deamon and enable auto start when power on
sudo systemctl start docker
sudo systemctl enable docker

# add current user 
sudo groupadd docker
sudo gpasswd -a ${USER} docker
sudo systemctl restart docker

8、配置ghost的docker-compose.yml

vim docker-compose.yml

version: '3.1'
services:
  ghost:
    image: ghost:3.36-alpine
    restart: always
    container_name: ghost
    ports:
      - 2368:2368
    depends_on:
      - mysql
    links:
      - mysql
    environment:
      database__client: mysql
      database__connection__host: mysql
      database__connection__user: root
      database__connection__password: xxxxyyyy
      database__connection__database: ghost
      url: https://www.dbaren.com
    volumes:
      - ./ghost-data:/var/lib/ghost/content
    network_mode: bridge
  mysql:
    image: mysql:5.7
    restart: always
    container_name: mysql
    volumes:
      - ./mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: xxxxyyyy
    network_mode: bridge

启动：

$ docker-compose up -d

9、安装配置nginx代理2368端口

$ yum install nginx

$ sudo touch /etc/nginx/conf.d/blog.conf

server {
    listen 80;
    server_name www.dbaren.com;
    client_max_body_size 50M;
    access_log  /var/log/nginx/dbaren.com.access.log  main;
    error_log /var/log/nginx/dbaren.com.error.log     warn;

    location / {
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_set_header   Host $http_host;
        proxy_set_header   X-Forwarded-For $remote_addr;
        proxy_set_header   X-Forwarded-Proto https;
        proxy_connect_timeout   30;
        proxy_read_timeout      30;
        proxy_send_timeout      30;
        proxy_pass http://127.0.0.1:2368;
    }
}

10、配置highlight.js优化代码显示

Code injection -> Site Header

我这里用的高亮主题是darcula，可以按自己需要的选的：highlight.js

Site footer

参考资料：

官方的安装文档

不折腾了, 决定使用Ghost写博客

给ghost添加gitalk评论功能

Aren — Tue, 27 Oct 2020 05:25:54 GMT

虽然有墙的关系github访问是不太行，但终究还是喜欢gitalk的方案来实现评论功能，Gitalk Demo & Gitalk

前置准备：

github帐户，没有可创建；
github repository，用于保存评论（issues），没有可创建；
github application授权，没有可创建。

进到Ghost后台 > Settings > Code injection，在Site Header增加以下代码：