python逻辑回归优化参数_【机器学习算法】逻辑回归调优
环境
spark-1.6
python3.5
vsn⼀、有⽆截距
对于逻辑回归分类，就是找到z那条直线，不通过原点有截距的直线与通过原点的直线相⽐，有截距更能将数据分类的彻底。
packagecom.bjsxt.lrimportorg.apache.spark.mllib.classification.
{LogisticRegressionWithLBFGS}importorg.apache.spark.mllib.util.MLUtilsimportorg.apache.spark.{SparkConf,
SparkContext}/*** 逻辑回归 健康状况训练集*/object LogisticRegression {
def main(args: Array[String]) {
val conf= new SparkConf().tAppName("spark").tMaster("local[3]")
服装设计与工艺val sc= newSparkContext(conf)//加载 LIBSVM 格式的数据 这种格式特征前缀要从1开始
val inputData = MLUtils.loadLibSVMFile(sc, "健康状况训练集.txt")
val splits= inputData.randomSplit(Array(0.7, 0.3), ed = 1L)
val (trainingData, testData)= (splits(0), splits(1))
val lr= newLogisticRegressionWithLBFGS()//lr.tIntercept(true)
val model =lr.run(trainingData)
val result=testData
.map{point=>Math.abs(point.label-model.predict(point.features)) }
println("正确率="+(an()))/***逻辑回归算法训练出来的模型，模型中的参数个数(w0....w6)=训练集中特征数
(6)+1*/println(Array.mkString(" "))
println(model.intercept)
sc.stop()
}
}
packagecom.bjsxt.lrimportorg.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS,
LogisticRegressionWithSGD}importorg.apache.ssion.LabeledPointimportorg.apache.spark.mllib.util.MLUtilsimportor {SparkConf, SparkContext}/*** 有⽆截距*/object LogisticRegression2 {
def main(args: Array[String]) {
val conf= new SparkConf().tAppName("spark").tMaster("local[3]")
val sc= newSparkContext(conf)
val inputData: RDD[LabeledPoint]= MLUtils.loadLibSVMFile(sc, "w0测试数据.txt")/*** randomSplit(Array(0.7, 0.3))⽅法就是将⼀
个RDD拆分成N个RDD，N = Array.length
* 第⼀个RDD中的数据量和数组中的第⼀个元素值相关*/val splits= inputData.randomSplit(Array(0.7, 0.3),11L)
val (trainingData, testData)= (splits(0), splits(1))
val lr= newLogisticRegressionWithSGD//设置要有W0，也就是有截距
lr.tIntercept(true)
val model=lr.run(trainingData)
val result=testData.map{labeledpoint=>Math.abs(labeledpoint.label-model.predict(labeledpoint.features)) }
println("正确率="+(an()))
println(Array.mkString(" "))
println(model.intercept)
}
}
⼆、线性不可分问题
对于线性不可分问题，可以使⽤升⾼维度的⽅式转换成线性可分问题。低维空间的⾮线性问题在⾼维空间往往会成为线性问题。
packagecom.bjsxt.lrimportorg.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS,eurus
LogisticRegressionWithSGD}importorg.apache.spark.mllib.linalg.Vectorsimportorg.apache.ssion.LabeledPointimpor {SparkConf, SparkContext}/*** 线性不可分 ----升⾼维度*/object LogisticRegression3 {
def main(args: Array[String]) {
val conf= new SparkConf().tAppName("spark").tMaster("local[3]")
val sc= newSparkContext(conf)//解决线性不可分我们来升维，升维有代价，计算复杂度变⼤了
val inputData = MLUtils.loadLibSVMFile(sc, "线性不可分数据集.txt")
.map { labelpoint=>val label=labelpoint.label
val feature=labelpoint.features//新维度的值，必须基于已有的维度值的基础上，经过⼀系列的数学变换得来
val array = Array(feature(0), feature(1), feature(0) * feature(1))
val convertFeature=Vectors.den(array)newLabeledPoint(label, convertFeature)
}
val splits= inputData.randomSplit(Array(0.7, 0.3),11L)
val (trainingData, testData)= (splits(0), splits(1))
val lr= newLogisticRegressionWithLBFGS()
lr.tIntercept(true)
val model=lr.run(trainingData)
val result=testData
.map { point=> Math.abs(point.label -model.predict(point.features)) }
println("正确率=" + (1.0 -an()))
println(Array.mkString(" "))
println(model.intercept)新概念英语课件下载
}
}
三、调整分类阈值
在⼀些特定的场景下，如果按照逻辑回归默认的分类阈值0.5来进⾏分类的话，可能存在⼀些潜在的风
险，⽐如，假如使⽤逻辑回归预测⼀个病⼈得癌症的概率是0.49，那么按照0.5的阈值，病⼈推测出来是没有得癌症的，但是49%的概率得癌症，⽐例相对来说得癌症的可能性也是很⾼，那么我们就可以降低分类的阈值，⽐如将阈值设置为0.3，⼩于0.3认为不得癌症，⼤于0.3认为得癌症，这样如果病⼈真的是癌症患者，规避掉了0.49概率下推断病⼈是不是癌症的风险。
降低阈值会使逻辑回归整体的正确率下降，错误率增⼤，但是规避了⼀些不能接受的风险。
packagecom.bjsxt.lrimportorg.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}importorg.apache.spark.mllib.util.MLUtilsimportorg.apache.spark.{SparkConf, SparkContext}/***设置分类阈值*/object LogisticRegression4 {
def main(args: Array[String]) {
val conf= new SparkConf().tAppName("spark").tMaster("local[3]")
val sc= newSparkContext(conf)/*** LabeledPoint = Vector+Y*/val inputData= MLUtils.loadLibSVMFile(sc, "健康状况训练
集.txt")
val splits= inputData.randomSplit(Array(0.7, 0.3),11L)
val (trainingData, testData)= (splits(0), splits(1))
val lr= newLogisticRegressionWithLBFGS()
lr.tIntercept(true)//val model = lr.run(trainingData)//val result = testData//.map{point=>Math.abs(point.label-
model.predict(point.features)) }//println("正确率="+(an()))//println(Array.mkString("
"))//println(model.intercept)
/*** 如果在训练模型的时候没有调⽤clearThreshold这个⽅法，那么这个模型预测出来的结果都是分类号
* 如果在训练模型的时候调⽤clearThreshold这个⽅法，那么这个模型预测出来的结果是⼀个概率*/val
model=lr.run(trainingData).clearThreshold()
val errorRate= testData.map{p=>
/
lenkatroubleisafriend/score就是⼀个概率值
val score =model.predict(p.features)//癌症病⼈宁愿判断出得癌症也别错过⼀个得癌症的病⼈
val result = score>0.3 match {ca true => 1 ; ca fal => 0}
Math.abs(result-p.label)
}.mean()
println(1-errorRate)
}
}
四、鲁棒性调优
鲁棒是Robust的⾳译，也就是健壮和强壮的意思,⽐如说，计算机软件在输⼊错误、磁盘故障、⽹络过载或有意攻击情况下，能不死机、不崩溃，就是该软件的鲁棒性，那么算法的鲁棒性就是指这个算法的抗⼲扰能⼒强。
packagecom.bjsxt.lrimportorg.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS, LogisticRegressionWithSGD}importorg.apache.spark.mllib.optimization.{L1Updater,
SquaredL2Updater}importorg.apache.spark.mllib.util.MLUtilsimportorg.apache.spark.{SparkConf, SparkContext}/*** 鲁棒性调优
* 提⾼模型抗⼲扰能⼒*/object LogisticRegression5 {
def main(args: Array[String]) {
val conf= new SparkConf().tAppName("spark").tMaster("local[3]")
val sc= newSparkContext(conf)
val inputData= MLUtils.loadLibSVMFile(sc, "健康状况训练集.txt")
val splits= inputData.randomSplit(Array(0.7, 0.3),100)
val (trainingData, testData)= (splits(0), splits(1))/*** LogisticRegressionWithSGD 既有L1 ⼜有L2正则化(默认)*/val lr= newLogisticRegressionWithSGD()
lr.tIntercept(true)//lr.optimizer.tUpdater(new L1Updater())
lr.optimizer.tUpdater(newSquaredL2Updater)/*** LogisticRegressionWithLBFGS 既有L1 ⼜有L2正则化(默认)*/
//val lr = new LogisticRegressionWithLBFGS()//lr.tIntercept(true)//lr.optimizer.tUpdater(new
L1Updater)//lr.optimizer.tUpdater(new SquaredL2Updater)
/*** 这块设置的是我们的lambda，越⼤越看重这个模型的推⼴能⼒,⼀般不会超过1,0.4是个⽐较好的值*/lr.optimizer.tRegParam(0.4)
val model=lr.run(trainingData)
val result=testData
.map{point=>Math.abs(point.label-model.predict(point.features)) }
println("正确率="+(an()))
println(Array.mkString(" "))
println(model.intercept)
}
}
五、归⼀化数据
多个维度特征的量级不同，会导致训练出来模型中不同特征对应的w参数差异很⼤，容易导致参数⼩的特征对⽬标函数的影响被覆盖，所以
需要对每个特征的数据进⾏归⼀化处理，以减少不同量级的特征数据覆盖其他特征对⽬标函数的影响。
归⼀化数据可以使各个特征维度对⽬标函数的影响权重⼀致，提⾼迭代的求解的收敛速度。
最⼤最⼩值归⼀化： ，缺点是抗⼲扰能⼒弱，受离群值影响⽐较⼤，中间容易没有数据。最⼤最⼩值归⼀化后的数据落在[0,1]之间。假设
ymca
某个特征下有⼀组数据：1,2,3,4,5,100那么对数据使⽤最⼤最⼩值归⼀化后的值为：0,2/99,3/99,4/99,1。中间没有数据，受离群值
胶水英文100的影响⼤。
packagecom.bjsxt.lrimportorg.apache.spark.SparkConfimportorg.apache.spark.SparkContextimportorg.apache.spark.ml.feature 最⼤最⼩值归⼀化*/object LogisticRegression7 {
def main(args: Array[String]): Unit={
val conf= new SparkConf().tAppName("spark").tMaster("local")
val sc= newSparkContext(conf)
val sqlContext= newSQLContext(sc)/*** 加载⽣成的DataFrame⾃动有两列：label features*/val df=
/*** MinMaxScaler fit需要DataFrame类型数据
* tInputCol：设置输⼊的特征名
* tOutputCol：设置归⼀化后输出的特征名
男士祛痘痕
**/val minMaxScalerModel= newMinMaxScaler()
.tInputCol("features")
.tOutputCol("scaledFeatures")
.fit(df)/*** 将所有数据归⼀化*/val ansform(df)
features.show()
val normalizeInputData= features.rdd.map(row=>{
val label= As("label").toString().toDouble
val den= (As("scaledFeatures")).asInstanceOf[DenVector]newLabeledPoint(label,den)
})
val splits= normalizeInputData.randomSplit(Array(0.7, 0.3),11L)
英语六级考试网val (trainingData, testData)= (splits(0), splits(1))
val lr=newLogisticRegressionWithLBFGS()
lr.tIntercept(true)英语翻译器在线
val model=lr.run(trainingData)
val result=testData.map{point=>Math.abs(point.label-model.predict(point.features)) }
println("正确率="+(an()))
println(Array.mkString(" "))
println(model.intercept)
}
}
⽅差归⼀化： ，其中u是样本的均值， 是样本的标准差(⽅差的开⽅，⽅差：所有点与均值的差值平⽅和)。⽅差归⼀化抗⼲扰能⼒强，和所有
数据有关，求标准差需要所有的值介⼊，若有离群值，会被抑制下来。但是归⼀化后的数据最终的结果不⼀定落在0到1之间。
注意：理论上⼀个模型算法如果拿到训练集所有的特征⼀起训练模型就要归⼀化数据。决策树算法可以不归⼀化数据。
packagecom.bjsxt.lrimportorg.apache.spark.mllib.classification.{LogisticRegressionWithLBFGS,
LogisticRegressionWithSGD}importorg.apache.spark.mllib.feature.StandardScalerimportorg.apache.ssion.LabeledP {SparkConf, SparkContext}importorg.apache.spark.ml.feature.MinMaxScalerimportorg.apache.spark.sql.SQLContext/*** ⽅差
归⼀化*/object LogisticRegression6 {
def main(args: Array[String]) {
val conf= new SparkConf().tAppName("spark").tMaster("local[3]")
val sc= newSparkContext(conf)
val sqlContext= newSQLContext(sc)/*** scalerModel 这个对象中已经有每⼀列的均值和⽅差
* withStd：代表的是⽅差归⼀化
* withMean：代表的是均值归⼀化
* scalerModel：存放每⼀列的⽅差值
