noHup - 编程语言
type: channel
link: http://chris.nohup.cc/category/programming-languages/
items: Windows10环境安装Python的Zipline包
items: TensorFlow 2.0实战Deep&Cross
items: TensorFlow 2.0实战DeepFM
items: 增量学习的主流实现
items: 内容相似推荐实现
items: TensorFlow 2.0使用RNN和LSTM进行文本分类
items: PySpark笔记之五：lightGBM调参之PySpark + mmlspark + Hyperopt
items: PySpark笔记之四：lightGBM调参之PySpark + mmlspark + Grid Search
items: PySpark笔记之三：lightGBM调参之PySpark + Grid Search
items: PySpark笔记之二：PySpark环境LightGBM训练

Windows10环境安装Python的Zipline包
type: item
date: 2024-01-28T06:33:00+00:00
description: Overview1. 安装顺序Visual Studio2. 安装ta-lib3.安装Zipline3.0 Overview 换了Windows电脑了，最近需要在Windows10系统上面使用Python的Zipline包，折腾了一上午，才终于搞定。必须记录一下整个安装过程，以后方便自己和他人。 先说明一下，github上面这个zipline包zipline最新版本是2020年的1.4.1版本，这个版本最多支持到Python3.6，所以这个老版本的Zipline应该是已经废弃了。最新的可用的应该是Zipline3.0，地址在这里Zipline 3.0。Zipline3.0最高支持到Python3.11。 1. 安装顺序Visual Studio 第一步是安装C++开发环境，Visual Studio，这一步就不介绍了。 2. 安装ta-lib 第二步是安装ta-lib包，这一步的时候，先去ta-lib-0.4.0-msvc.zip下载一个ta-lib-0.4.0-msvc.zip，然后解压，放到C盘根目录。因为这个是32位的，所以我们要手动给他编制成64位的。在开始菜单打开x64 Native Tools Command Prompt for VS 2022，在VS 2022命令行中进入到这个地方C:\ta-lib\c\make\cdr\win32\msvc，输入nmake。 编译完成后，再打开cmd，命令行中(注意本命令行和VS命令行的区别)运行pip install ta-lib。可能会报错如下: LINK : fatal error LNK1327: 运行 rc.exe 期间出错 error: command 'D:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\BIN\\x86_amd64\\link.exe' failed with exit code 1327 [end of output] note: This error originates from a subprocess, and is likely not a problem with pip. ERROR: Failed building wheel for ta-lib Failed to build ta-lib ERROR: Could not build wheels for ta-lib, which is required to install pyproject.toml-based projects 这是因为D:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin这里缺少rc.exe和rcdll.dll文件。我们从C:\Program Files (x86)\Windows Kits\10\bin\10.0.18362.0\x64文件夹中找到这俩文件，复制到D:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin文件夹。 继续执行pip install ta-lib就安装好了。 3.安装Zipline3.0 在cmd中运行以下命令pip install zipline-reloaded，即可安装成功。假如没有前两步，直接安装Zipline3.0，那么会报缺少ta_libc.h。 至此，zipline就安装好了。 本文参考了github，Stack Overflow和以下文章，鸣谢。 重装Anaconda,指定虚拟环境路径，清华源，Jupyter，zipline Failed to build ta-lib ERROR: Could not build wheels for ta-lib, which is required to install pyproject.toml-based project #566 Failed to install ta-lib #127 Windows系统下安装TA_Lib教程

TensorFlow 2.0实战Deep&Cross
type: item
date: 2020-05-31T11:56:00+00:00
description: Overview1. 加载并处理数据2. 建模训练2.1 输入层2.2 Cross网络2.3 Deep网络2.4 输出层2.5 模型编译2.6 训练模型 Overview 之前的文章，我们记录了如何用TensorFlow 2.0中的Keras模块实现DeepFM算法，TensorFlow 2.0实战DeepFM。本文继续用TensorFlow 2.0来实现另一个常见的深度学习推荐算法Deep&Cross。 1. 加载并处理数据 依然沿用之前的1,000,000条criteo数据。 import numpy as np import pandas as pd from sklearn.preprocessing import LabelEncoder, MinMaxScaler import tensorflow as tf from tensorflow.keras import regularizers from tensorflow.keras.layers import * from tensorflow.keras.models import Model from tensorflow.keras.utils import plot_model import tensorflow.keras.backend as K from tensorflow.keras.callbacks import TensorBoard import matplotlib.pyplot as plt %matplotlib inline data = pd.read_csv('criteo/criteo_sampled_data.csv', sep='\t', header=None) data.head() label = ['label'] dense_features = ['I' + str(i) for i in range(1, 14)] sparse_features = ['C' + str(i) for i in range(1, 27)] name_list = label + dense_features + sparse_features data.columns = name_list 处理连续型特征： # 数值型特征空值填0 data[dense_features] = data[dense_features].fillna(0) # 数值型特征归一化 scaler = MinMaxScaler(feature_range=(0, 1)) data[dense_features] = scaler.fit_transform(data[dense_features]) 处理稀疏类别特征： data[sparse_features] = data[sparse_features].fillna("-1") for feat in sparse_features: lbe = LabelEncoder() data[feat] = lbe.fit_transform(data[feat]) 2. 建模训练 我们先来看看DCN算法的架构图： 2.1 输入层 # 稠密特征 dense_inputs = [] for fea in dense_features: _input = Input([1], name=fea) dense_inputs.append(_input) dense_inputs 输出13个稠密特征的张量： [<tf.Tensor 'I1:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I2:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I3:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I4:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I5:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I6:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I7:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I8:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I9:0' shape=(None, 1) dtype=float32>, <tf.Tensor 'I10:0' shape=(None, 1) dtype=float32>, <tf…

TensorFlow 2.0实战DeepFM
type: item
date: 2020-05-29T13:39:00+00:00
description: Overview1. 准备数据2. 加载并处理数据2.1 处理连续型特征2.2 处理稀疏类别特征3. 建模训练3.1 处理一阶特征3.2 二阶特征3.3 DNN层3.4 合并输出层3.5 编译模型 Overview 推荐系统最核心的部分在于排序算法，也就是我们说的CTR预估问题。这部分算法在最近几年发展迅速，我们这篇文章，希望用经典的criteo数据集，和TensorFlow 2.0中的Keras模块，来演示一下DeepFM是怎么做CTR预估的。 1. 准备数据 在这里下载criteo数据集：Download Kaggle Display Advertising Challenge Dataset。 或者直接在终端下载,然后解压： mkdir criteo cd criteo wget https://s3-eu-west-1.amazonaws.com/kaggle-display-advertising-challenge-dataset/dac.tar.gz tar -zxvf dac.tar.gz 这个数据集，训练集40,000,000行，从readme.txt中可以知道数值型特征的有13个，类别型特征有26个，特征名称未提供，样本按时间排序。测试集6,000,000行，不含label。解压后，可以看到训练集是11.1G，测试集是1.46G。当前这个单机是打不开的。那我们就读取1,000,000条训练集好了。 head -n 1000000 train.txt > criteo_sampled_data.csv cd .. 2. 加载并处理数据 首先把抽样过的数据加载到内存： import numpy as np import pandas as pd from sklearn.preprocessing import LabelEncoder, MinMaxScaler import tensorflow as tf from tensorflow.keras import regularizers from tensorflow.keras.layers import * from tensorflow.keras.models import Model from tensorflow.keras.utils import plot_model import tensorflow.keras.backend as K from tensorflow.keras.callbacks import TensorBoard import matplotlib.pyplot as plt %matplotlib inline data = pd.read_csv('criteo/criteo_sampled_data.csv', sep='\t', header=None) data.head() 我们给数据加上列名： label = ['label'] dense_features = ['I' + str(i) for i in range(1, 14)] sparse_features = ['C' + str(i) for i in range(1, 27)] name_list = label + dense_features + sparse_features data.columns = name_list data.head() 2.1 处理连续型特征 # 数值型特征空值填0 data[dense_features] = data[dense_features].fillna(0) # 数值型特征归一化 scaler = MinMaxScaler(feature_range=(0, 1)) data[dense_features] = scaler.fit_transform(data[dense_features]) 2.2 处理稀疏类别特征 data[sparse_features] = data[sparse_features].fillna("-1") for feat in sparse_features: lbe = LabelEncoder() data[feat] = lbe.fit_transform(data[feat]) 3. 建模训练 这个部分就是DeepFM模型的精髓所在。算法原理如图所示。 DeepFM模型是对Wide&Deep模型的改进。左边FM层和右边DNN层共享了Embedding层。 3.1 处理一阶特征 首先，数值型特征可以直接变成tensorflow.keras.layers.Input单元。 dense_inputs = [] for fea in dense_fe…

增量学习的主流实现
type: item
date: 2020-05-18T07:27:00+00:00
description: Overview1. XGBoost2. LightGBM3. TensorFlow2.0 Overview 之前的文章介绍了一些推荐系统的理论知识，理论虽然很容易理解，但是实际项目当中会有一些细节问题是需要我们去解决的。比如在很多流量很大的电商以及资讯网站的推荐系统中，每天的数据其实是增长很快的，所以模型迭代的频率也是非常高的，甚至于需要每天更新。那么我们就要面临一个很现实的问题，我们每天更新模型，那么每次都要用全量数据去训练模型吗？显然这是不可能的。一来耗费资源，二来时间也不允许。那么，增量学习Incremental Learning就派上用场了。增量学习是这几年才出来的概念，其目的在于训练新数据的同时也能保留以前模型的效果，即在之前的模型基础上对新增的数据进行训练。 主流的几种机器学习框架，已经实现了增量学习的功能，接下来看一下他们是怎么做到的。 1. XGBoost 我们一般情况下用XGBoost训练一个全新的模型，其相关方法是这样的： watchlist = [(xgb_train, 'train'), (xgb_val, 'val'), (xgb_test, 'test')] # training model_path = 'init.model' model = xgb.train(params, xgb_train, num_boost, watchlist) model.save_model(model_path) 如果我们线上已经有一个效果很好的模型，需要在此基础上对新增的数据进行增量训练，那么XGBoost是这样实现的： # 指定基础模型参数，xgb_model # 传入新的增量训练数据，xgb_train_new model_new = xgb.train(params, xgb_train_new, num_boost, xgb_model=model_path) 我们来看这个参数的作用： xgb_model : file name of stored xgb model or 'Booster' instance Xgb model to be loaded before training (allows training continuation). 即在指定的模型上继续训练。 更多相关知识请参考： How can I implement incremental training for xgboost? dmlc/xgboost 2. LightGBM model = lgb.train(params, lgb_train, num_boost_round=1000, valid_sets=lgb_eval, feature_name=x_cols, early_stopping_rounds=10, verbose_eval=False, init_model=model, # 如果init_model不为None，那么就是在init_model基础上接着训练 keep_training_booster=True) # 增量训练 LightGBM实现增量训练也很简单，只需要设置init_model为当前线上的模型，且keep_training_booster设置为True即可。 更多相关知识请参考： Incremental learning using Dataset.subset LightGBM 2.1.1 python API Standard outputs infos even when disabled lightgbm.train 3. TensorFlow2.0 我们知道，TensorFlow2.0已经集成好了Keras高级API，所以，我们看看增量学习在Keras当中是如何实现的。 # 加载线上的模型 model_path = 'init.model' loaded_model = tf.keras.models.load_model(model_path) # 新数据上接着训练 history = loaded_model.fit( train_data_gen, steps_per_epoch=total_train // batch_size, epochs=epochs, validation_data=val_data_gen, validation_steps=total_val // batch_size ) 可以看到，TensorFlow2.0对于增量训练支持也是很完备的。

内容相似推荐实现
type: item
date: 2020-05-13T08:50:00+00:00
description: Overview1. jieba分词工具2. Word2Vec2.1 Spark Word2Vec2.2 NLP ChineseEmbedding3. Top N相似近邻搜索3.1 scipy余弦相似度3.2 LSH局部敏感哈希 Overview 内容相似推荐算法，是推荐系统当中的一个常用的算法。假设我们做的是文章推荐，那么，我们该怎样求两篇文章的相似度呢？本文将记录几个常用工具的使用方法。 1. jieba分词工具 可以说是当前最好用的中文分词组件。我们拿到文章的标题、摘要、全文之后，可以用jieba提取关键词，然后去另一篇文章当中做Doc2Vec，把另一篇文章转化为一个向量，可以用平均或者加权平均的方式得到一个文章的向量。 首先安装这个组件： pip3 install jieba 之后就可以直接导入使用了： import jieba seg_list = jieba.cut("我正在做推荐系统当中的内容相似推荐部分。", cut_all=False) print("Default Mode: " + "/ ".join(seg_list)) # 精确模式 输出如下： Default Mode: 我/ 正在/ 做/ 推荐/ 系统/ 当中/ 的/ 内容/ 相似/ 推荐/ 部分/ 。 直接分词会把所有的词都得到，这样显然是不符合要求的。我们可以提取关键词功能来获得最重要的K个关键词。 import jieba.analyse key_words = jieba.analyse.extract_tags("我正在做推荐系统当中的内容相似推荐部分。", topK=3, withWeight=True, allowPOS=()) print(key_words) 显示如下： [('推荐', 1.386500847515), ('当中', 0.82161213919375), ('相似', 0.80830253373)] 我们会得到一个带权重的关键词列表。 这种只能对文章进行精确匹配，鲁棒性稍微差点。因此我们更需要下面这种更强大的工具Word2Vec。 2. Word2Vec Word2Vec其实是一个神经网络模型。我们不用自己实现，可以使用开源届的现有工具，Spark Word2Vec或腾讯Word2Vec工具NLP ChineseEmbedding。 2.1 Spark Word2Vec 具体用法如下： from pyspark.sql import SparkSession from pyspark.sql import functions as F from pyspark.ml.feature import Word2Vec spark = SparkSession.builder.appName("Spark Word2Vec") \ .master("spark://***.***.***.***:7077") \ .config("spark.cores.max", "10") \ .config("spark.driver.memory", "2G") \ .config("spark.executor.memory", "2G") \ .config("spark.executor.cores", "2")\ .getOrCreate() # 输入数据可以是一个词袋、一个句子或者一个文档 documentDF = spark.createDataFrame([ ("我 正在 做 推荐 系统 当中 的 内容 相似 推荐 部分".split(" "), ), ("我 喜欢 做 推荐 系统".split(" "), ), ("做 机器 学习 我 是 专业 的".split(" "), ) ], ["text"]) # 学习一个词到向量的映射模型 word2Vec = Word2Vec(vectorSize=3, minCount=0, inputCol="text", outputCol="result") model = word2Vec.fit(documentDF) result = model.transform(documentDF) for row in result.collect(): text, vector = row print("Text: [%s] => \nVector: %s\n" % (", ".join(text), str(vector))) 最后我们得到如下答案： Text: [我, 正在, 做, 推荐, 系统, 当中, 的, 内容, 相似, 推荐, 部分] => Vector: [0.02447097257456996,-0.05411485582590103,0.020404360…

TensorFlow 2.0使用RNN和LSTM进行文本分类
type: item
date: 2020-05-02T12:53:00+00:00
description: Overview1. 加载IMDB评论数据2. 构建RNN模型3. 模型编译训练 Overview 本篇文章我们记录一下怎么用TensorFlow 2.0当中的Keras模块来进行RNN和LSTM文本分类。 1. 加载IMDB评论数据 import tensorflow_datasets as tfds import tensorflow as tf from tensorflow.keras import models, layers, losses, optimizers, Sequential import matplotlib.pyplot as plt dataset, info = tfds.load('imdb_reviews/subwords8k', with_info=True, as_supervised=True) train_dataset, test_dataset = dataset['train'], dataset['test'] encoder = info.features['text'].encoder print('Vocabulary size: {}'.format(encoder.vocab_size)) BUFFER_SIZE = 10000 BATCH_SIZE = 64 train_dataset = train_dataset.shuffle(BUFFER_SIZE) train_dataset = train_dataset.padded_batch(BATCH_SIZE) test_dataset = test_dataset.padded_batch(BATCH_SIZE) 2. 构建RNN模型 model = Sequential([ layers.Embedding(encoder.vocab_size, 64), layers.Bidirectional(layers.LSTM(64)), layers.Dense(64, activation='relu'), layers.Dense(1) ]) 其中，Embedding层是用来做word embedding的，把稀疏向量转换成稠密向量；Bidirectional层是一个RNN的双向封装器，用于对序列进行前向和后向计算。 3. 模型编译训练 model.compile(loss=losses.BinaryCrossentropy(from_logits=True), optimizer=optimizers.Adam(1e-4), metrics=['acc']) history = model.fit(train_dataset, epochs=10, validation_data=test_dataset, validation_steps=30) test_loss, test_acc = model.evaluate(test_dataset) print('Test Loss: {}'.format(test_loss)) print('Test Accuracy: {}'.format(test_acc)) 测试集效果如下： 391/391 [==============================] - 109s 280ms/step - loss: 0.4388 - acc: 0.8553 Test Loss: 0.43875041604042053 Test Accuracy: 0.8552799820899963 画个图，看看效果： plt.rcParams['font.size'] = 14 def plot_graphs(history, metric): plt.plot(history.history[metric]) plt.plot(history.history['val_'+metric], '') plt.xlabel("Epochs") plt.ylabel(metric) plt.legend([metric, 'val_'+metric]) plt.show() plot_graphs(history, 'acc') plot_graphs(history, 'loss') 本文参考了如下文章： Text classification with an RNN TensorFlow 2 中文文档 - RNN LSTM 文本分类

PySpark笔记之五：lightGBM调参之PySpark + mmlspark + Hyperopt
type: item
date: 2020-04-28T09:33:00+00:00
description: Overview1. 加载相关包2. 加载数据3. 定义参数空间和代价函数4. 随机搜索调参和贝叶斯优化调参 Overview 之前的文章中记录了大数据平台上lightGBM分类器的Grid Search调参方法的应用。这次我们继续用lightGBM分类器，看看另外两种常用的调参方法随机搜索Random Search和贝叶斯优化Bayesian Optimization怎么在Spark平台上使用。 1. 加载相关包 import numpy as np import pyspark spark = pyspark.sql.SparkSession.builder.appName("spark lightgbm") \ .master("spark://***.***.***.***:7077") \ .config("spark.jars.packages", "com.microsoft.ml.spark:mmlspark_2.11:0.18.1") \ .config("spark.cores.max", "20") \ .config("spark.driver.memory", "6G") \ .config("spark.executor.memory", "6G") \ .config("spark.executor.cores", "6") \ .getOrCreate() import mmlspark from mmlspark.lightgbm import LightGBMClassifier from pyspark.ml.feature import VectorAssembler from hyperopt import fmin, rand, tpe, hp, space_eval, Trials 其中hyperopt是一款强大的调参工具，实现了随机搜索和贝叶斯优化。 如果没有安装hyperopt,那么先在master节点安装hyperopt： pip3 install hyperopt 2. 加载数据 df_train = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/yangbingjiao/训练集特征.csv") df_val = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/yangbingjiao/验证集特征.csv") df_test = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/yangbingjiao/测试集特征.csv") 处理特征： feature_cols = list(df_train.columns) feature_cols.remove("label") assembler = VectorAssembler(inputCols=feature_cols, outputCol="features") df_train = assembler.transform(df_train) df_val = assembler.transform(df_val) df_test = assembler.transform(df_test) 3. 定义参数空间和代价函数 定义参数搜索空间，以lambdaL1和lambdaL2为例： space = { 'objective':"binary", 'boostingType':'gbdt', 'isUnbalance':True, 'featuresCol':'features', 'labelCol':'label', 'maxBin':60, 'baggingFreq':1, 'baggingSeed':696, 'earlyStoppingRound':20, 'learningRate':0.1, 'maxDepth':3, 'numLeaves':128, 'baggingFraction':0…

PySpark笔记之四：lightGBM调参之PySpark + mmlspark + Grid Search
type: item
date: 2020-04-23T12:48:00+00:00
description: Overview1. 加载PySpark和mmlspark相关包2.加载数据3.建模4.预测测试集 Overview 上一篇文章PySpark笔记之三：lightGBM调参之PySpark + Grid Search，我们记录了分别用PySpark中自带的CrossValidator和更通用的生成多个分类器同时执行训练预测的方式选取最好的模型。其中CrossValidator并不能得到验证集上最佳的分类器，而是得到训练集上最佳的效果。而mmlspark当中却有更为简单的方式，既可以得到验证集上最佳的效果，也可以方便地记录我们每一组参数对应的结果，是一种很好的方式。 1. 加载PySpark和mmlspark相关包 import numpy as np import pyspark spark = pyspark.sql.SparkSession.builder.appName("spark lightgbm") \ .master("spark://***.***.***.***:7077") \ .config("spark.jars.packages", "com.microsoft.ml.spark:mmlspark_2.11:0.18.1") \ .config("spark.cores.max", "20") \ .config("spark.driver.memory", "6G") \ .config("spark.executor.memory", "6G") \ .config("spark.executor.cores", "6") \ .getOrCreate() from pyspark.ml.feature import VectorAssembler from pyspark.ml.evaluation import BinaryClassificationEvaluator import mmlspark from mmlspark.lightgbm import LightGBMClassifier from mmlspark.automl import * from mmlspark.train import TrainClassifier, ComputeModelStatistics 2.加载数据 df_train = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/训练集特征.csv") df_val = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/验证集特征.csv") df_test = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/测试集特征.csv") 处理训练集、验证集和测试集数据： feature_cols = list(df_train.columns) feature_cols.remove("label") assembler = VectorAssembler(inputCols=feature_cols, outputCol="features") df_train = assembler.transform(df_train) df_val = assembler.transform(df_val) df_test = assembler.transform(df_test) 3.建模 lgb = LightGBMClassifier( objective="binary", boostingType='gbdt', isUnbalance=True, featuresCol='features', labelCol='label', maxBin=60, baggingFreq=1, baggingSeed=696, earlyStoppingRound=20, learningRate=0.1, #l…

PySpark笔记之三：lightGBM调参之PySpark + Grid Search
type: item
date: 2020-04-18T12:33:00+00:00
description: Overview1. 引入依赖包2. 加载数据3. 模型构建4. 交叉验证选择模型5. 官方调参探讨 Overview 在实际机器学习工作当中，调参是我们一个重要的内容。PySpark当中就实现了一个最常用的调参方法Grid Search，我们结合lightGBM使用一下PySpark的调参。这个程序需要安装的依赖的安装方式，可以参考上一篇博客。 1. 引入依赖包 import numpy as np import pyspark spark = pyspark.sql.SparkSession.builder.appName("spark lightgbm") \ .master("spark://***.***.***.***:7077") \ .config("spark.jars.packages", "com.microsoft.ml.spark:mmlspark_2.11:0.18.1") \ .config("spark.cores.max", "20") \ .config("spark.driver.memory", "6G") \ .config("spark.executor.memory", "6G") \ .config("spark.executor.cores", "6") \ .getOrCreate() import mmlspark from mmlspark.lightgbm import LightGBMClassifier from pyspark.ml.feature import VectorAssembler from pyspark.ml.tuning import CrossValidator, ParamGridBuilder from pyspark.ml.evaluation import BinaryClassificationEvaluator from pyspark.ml import Pipeline 其中，pyspark.ml.tuning.ParamGridBuilder就是用以实现Grid Search的包。 2. 加载数据 df_train = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/训练集特征.csv") df_val = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/验证集特征.csv") df_test = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/测试集特征.csv") 处理训练集特征： feature_cols = list(df_train.columns) feature_cols.remove("label") # 从列名当中删除label才是真正的特征列表 assembler = VectorAssembler(inputCols=feature_cols, outputCol="features") df_train = assembler.transform(df_train) 3. 模型构建 lgb = LightGBMClassifier( objective="binary", boostingType='gbdt', isUnbalance=True, featuresCol='features', labelCol='label', maxBin=60, baggingFreq=1, baggingSeed=696, earlyStoppingRound=30, learningRate=0.1, # lambdaL1=1.0, # lambdaL2=45.0, maxDepth=3, numLeaves=128, baggingFraction=0.7, featureFraction=0.7, minSumHessianInLeaf=0.001, …

PySpark笔记之二：PySpark环境LightGBM训练
type: item
date: 2020-04-04T10:00:00+00:00
description: Overview1. 安装mmlspark2. 引入依赖包3. 加载数据4. 模型构建 Overview 就目前的PySpark版本2.4.5来说，虽有pyspark.ml这个模块可以进行机器学习，但是都是一些工业界不太常用的算法，而XGBoost和LightGBM这样的常用算法还没有集成。幸好微软前几年发布了mmlspark这个包，其中包含了深度学习和LightGBM等算法，可以和PySpark无缝对接。下面我们看看怎么用PySpark和mmlspark来运行LightGBM。 1. 安装mmlspark 首先，我们默认已经安装好了PySpark，如果没有安装，那么安装命令如下： pip3 install pyspark 然后，安装mmlspark的方式如下，命令行输入： pyspark --packages com.microsoft.ml.spark:mmlspark_2.11:0.18.1 或者直接在jupyter notebook中，使用PySpark时，这样启动： import pyspark spark = pyspark.sql.SparkSession.builder.appName("MyApp") \ .config("spark.jars.packages", "com.microsoft.ml.spark:mmlspark_2.11:1.0.0-rc1") \ .config("spark.jars.repositories", "https://mmlspark.azureedge.net/maven") \ .getOrCreate() import mmlspark 这个包比较大，第一次安装需要较长时间。我们服务器上maven仓库当中，mmlspark版本是0.18.1，而这个版本训练时会导致一个bug，下面会提到。 详细安装方式可参考官方文档：Azure / mmlspark，最新的mmlspark版本是1.0.0-rc1。 2. 引入依赖包 import numpy as np import pyspark spark = pyspark.sql.SparkSession.builder.appName("spark lightgbm") \ .master("spark://***.***.***.***:7077") \ .config("spark.jars.packages", "com.microsoft.ml.spark:mmlspark_2.11:0.18.1") \ .config("spark.cores.max", "20") \ .config("spark.driver.memory", "6G") \ .config("spark.executor.memory", "6G") \ .config("spark.executor.cores", "6") \ .getOrCreate() import mmlspark from mmlspark.lightgbm import LightGBMClassifier from pyspark.ml.feature import VectorAssembler # from pyspark.ml.tuning import CrossValidator, ParamGridBuilder from pyspark.ml.evaluation import BinaryClassificationEvaluator from pyspark.ml import Pipeline 其中，VectorAssembler这个类，可以将特征转换成一个向量，作为分类器的输入。BinaryClassificationEvaluator可以评价预测效果。Pipeline相当于Spark的流水线，将各个步骤连接在一起后，一起由Spark运行。 3. 加载数据 df_train = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/训练集特征.csv") df_val = spark.read.format("csv") \ .option("inferSchema", "true") \ .option("header", "true") \ .option("sep", ",") \ .load("hdfs://***.***.***.***:39000/young/验证集特征.csv…