精华内容
下载资源
问答
  • 逻辑斯蒂回归:逻辑斯蒂回归是统计学习中的经典分类方法,属于对数线性模型。...与图像如下,其中分布函数是以为中心对阵,越小曲线变化越快二项logistic回归模型;二项logistic回归模型如下: 其中...

    逻辑斯蒂回归:

    逻辑斯蒂回归是统计学习中的经典分类方法,属于对数线性模型。logistic回归的因变量可以是二分类的,

    也可以是多分类的

    基本原理

    logistic 分布

    折X是连续的随机变量,X服从logistic分布是指X具有下列分布函数和密度函数:

    其中

    为位置参数,

    为形状参数。

    图像如下,其中分布函数是以

    为中心对阵,

    越小曲线变化越快

    二项logistic回归模型;

    二项logistic回归模型如下:

    其中

    是输入,

    输出,W称为权值向量,b称为偏置,

    是w和x的内积

    参数估计

    ​ 假设:

    ​ 则似然函数为:

    ​ 求对数似然函数:

    ​ 从而对

    求极大值,得到w的估计值。求极值的方法可以是梯度下降法,梯度上升法等。

    示例代码:

    #导入需要的包:

    from pyspark import SparkContext

    from pyspark.sql import SparkSession,Row,functions

    from pyspark.ml.linalg import Vector,Vectors

    from pyspark.ml.evaluation import MulticlassClassificationEvaluator

    from pyspark.ml import Pipeline

    from pyspark.ml.feature import IndexToString,StringIndexer,VectorIndexer,HashingTF,Tokenizer

    from pyspark.ml.classification import LogisticRegression,LogisticRegressionModel,BinaryLogisticRegressionSummary,LogisticRegression

    #用二项逻辑斯蒂回归解决 二分类 问题

    sc = SparkContext('local','用二项逻辑斯蒂回归解决二分类问题')

    spark = SparkSession.builder.master('local').appName('用二项逻辑斯蒂回归解决二分类问题').getOrCreate()

    #读取数据,简要分析

    #我们定制一个函数,来返回一个指定的数据,然后读取文本文件,第一个map把每行的数据用","

    #隔开,比如在我们的数据集中,每行被分成了5部分,目前4部分是鸢尾花的四个特征,最后一部分鸢尾花的分类;

    #我们这里把特征存储在Vector中,创建一个Iris模式的RDd,然后转化成DataFrame;最后调用show()方法查看数据

    def f(x):

    rel ={}

    rel['features'] = Vectors.dense(float(x[0]),float(x[1]),float(x[2]),float(x[3]))

    rel['label'] = str(x[4])

    return rel

    data= sc.textFile("file:///usr/local/spark/mycode/exercise/iris.txt").map(lambda line : line.split(',')).map(lambda p : Row(**f(p))).toDF()

    # 因为我们现在处理的是2分类问题,所以我们不需要全部的3类数据,我们要从中选出两类的

    #数据。这里首先把刚刚得到的数据注册成一个表iris,注册成这个表之后,我们就可以

    #通过sql语句进行数据查询,比如我们这里选出了所有不属于“Iris-setosa”类别的数

    #据;选出我们需要的数据后,我们可以把结果打印出来看一下,这时就已经没有“Iris-setosa”类别的数据

    data.createOrReplaceTempView("iris")

    df = spark.sql("select * from iris where label != 'Iris-setosa'")

    rel = df.rdd.map(lambda t : str(t[1])+":"+str(t[0])).collect()

    for item in rel:

    print(item)

    如图:

    #构建ML的pipeline

    #分别获取标签列和特征列,进行索引,并进行了重命名

    labelIndexer = StringIndexer().setInputCol('label').setOutputCol('indexedLabel').fit(df)

    featureIndexer = VectorIndexer().setInputCol('features').setOutputCol('indexedFeatures').fit(df)

    #把数据集随机分成训练集和测试集,其中训练集占70%

    trainingData, testData =df.randomSplit([0.7,0.3])

    #设置logistic的参数,这里我们统一用setter的方法来设置,也可以用ParamMap来设置

    #(具体的可以查看spark mllib的官网)。这里我们设置了循环次数为10次,正则化项为

    #0.3等,具体的可以设置的参数可以通过explainParams()来获取,还能看到我们已经设置

    #的参数的结果。

    lr= LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol('indexedFeatures').setMaxIter(10).setRegParam(0.3).setElasticNetParam(0.8)

    print("LogisticRegression parameters:\n"+ lr.explainParams())

    如图:

    #设置一个labelConverter,目的是把预测的类别重新转化成字符型的

    labelConverter = IndexToString().setInputCol("prediction").setOutputCol("predictedLabel").setLabels(labelIndexer.labels)

    #构建pipeline,设置stage,然后调用fit()来训练模型

    LrPipeline = Pipeline().setStages([labelIndexer, featureIndexer, lr, labelConverter])

    LrPipelineModel = LrPipeline.fit(trainingData)

    #用训练得到的模型进行预测,即对测试数据集进行验证

    lrPredictions = LrPipelineModel.transform(testData)

    preRel = lrPredictions.select("predictedLabel",'label','features','probability').collect()

    for item in preRel:

    print(str(item['label'])+','+str(item['features'])+'-->prob='+str(item['probability'])+',predictedLabel'+str(item['predictedLabel']))

    如图:

    #模型评估1

    #创建一个MulticlassClassificationEvaluator实例,用setter方法把预测分类的列名和真实分类的列名进行设置;然后计算预测准确率和错误率

    evaluator = MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")

    lrAccuracy = evaluator.evaluate(lrPredictions)

    print("Test Error=" + str(1.0- lrAccuracy))

    如图:

    #从上面可以看到预测的准确性达到94%,接下来我们可以通过model来获取我们训练得到

    #的逻辑斯蒂模型。前面已经说过model是一个PipelineModel,因此我们可以通过调用它的

    #stages来获取模型

    lrModel = LrPipelineModel.stages[2]

    print("Coefficients: " + str(lrModel.coefficients)+"Intercept: "+str(lrModel.intercept)+"numClasses: "+str(lrModel.numClasses)+"numFeatures: "+str(lrModel.numFeatures))

    如图:

    #模型评估2

    #spark的ml库还提供了一个对模型的摘要总结(summary),不过目前只支持二项逻辑斯

    #蒂回归,而且要显示转化成BinaryLogisticRegressionSummary 。在下面的代码中,首

    #先获得二项逻辑斯模型的摘要;然后获得10次循环中损失函数的变化,并将结果打印出来

    #,可以看到损失函数随着循环是逐渐变小的,损失函数越小,模型就越好;接下来,我们

    #把摘要强制转化为BinaryLogisticRegressionSummary,来获取用来评估模型性能的矩阵;

    #通过获取ROC,我们可以判断模型的好坏,areaUnderROC达到了 0.969551282051282,说明

    #我们的分类器还是不错的;最后,我们通过最大化fMeasure来选取最合适的阈值,其中fMeasure

    #是一个综合了召回率和准确率的指标,通过最大化fMeasure,我们可以选取到用来分类的最合适的阈值

    trainingSummary = lrModel.summary

    objectiveHistory = trainingSummary.objectiveHistory

    for item in objectiveHistory:

    print (item)

    print("areaUnderRoC:"+str(trainingSummary.areaUnderROC))

    如图:

    fMeasure = trainingSummary.fMeasureByThreshold

    maxFMeasure = fMeasure.groupBy().max('F-Measure').select('max(F-Measure)').head()

    print(maxFMeasure)

    如图:

    bestThreshold = fMeasure.where(fMeasure['F-Measure'] == maxFMeasure['max(F-Measure)']).select('threshold').head()['threshold']

    print(bestThreshold)

    lr.setThreshold(bestThreshold)

    #用多项逻辑斯蒂回归解决 二分类 问题

    mlr = LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(10).setRegParam(0.3).setElasticNetParam(0.8).setFamily("multinomial")

    mlrPipeline = Pipeline().setStages([labelIndexer, featureIndexer, mlr, labelConverter])

    mlrPipelineModel = mlrPipeline.fit(trainingData)

    mlrPrediction = mlrPipelineModel.transform(testData)

    mlrPreRel =mlrPrediction.select("predictedLabel", "label", "features", "probability").collect()

    for item in mlrPreRel:

    print('('+str(item['label'])+','+str(item['features'])+')-->prob='+str(item['probability'])+',predictLabel='+str(item['predictedLabel']))

    如图:

    mlrAccuracy = evaluator.evaluate(mlrPrediction)

    print("mlr Test Error ="+ str(1.0-mlrAccuracy))

    如图:

    mlrModel = mlrPipelineModel.stages[2]

    print("Multinomial coefficients: " +str(mlrModel.coefficientMatrix)+"Multinomial intercepts: "+str(mlrModel.interceptVector)+"numClasses: "+str(mlrModel.numClasses)+"numFeatures: "+str(mlrModel.numFeatures))

    如图;

    #用多项逻辑斯蒂回归解决多分类问题

    mlrPreRel2 = mlrPrediction.select("predictedLabel", "label", "features", "probability").collect()

    for item in mlrPreRel2:

    print('('+str(item['label'])+','+str(item['features'])+')-->prob='+str(item['probability'])+',predictLabel='+str(item['predictedLabel']))

    如图:

    mlr2Accuracy = evaluator.evaluate(mlrPrediction)

    print("Test Error = " + str(1.0 - mlr2Accuracy))

    mlr2Model = mlrPipelineModel.stages[2]

    print("Multinomial coefficients: " + str(mlrModel.coefficientMatrix)+"Multinomial intercepts: "+str(mlrModel.interceptVector)+"numClasses: "+str(mlrModel.numClasses)+"numFeatures: "+str(mlrModel.numFeatures))

    展开全文
  • 逻辑斯蒂回归: 逻辑斯蒂回归是统计学习中的经典分类方法,属于对数线性模型。logistic回归的因变量可以是二分类的, 也可以是多分类的 基本原理 logistic 分布 ...折X是连续的随机变量,X服从...二项logisti...

    逻辑斯蒂回归:

    逻辑斯蒂回归是统计学习中的经典分类方法,属于对数线性模型。logistic回归的因变量可以是二分类的,

    也可以是多分类的

    基本原理
    logistic 分布

    折X是连续的随机变量,X服从logistic分布是指X具有下列分布函数和密度函数:

     

    其中为位置参数,为形状参数。图像如下,其中分布函数是以为中心对阵,越小曲线变化越快

     

    二项logistic回归模型;

    二项logistic回归模型如下:

     

    其中是输入,输出,W称为权值向量,b称为偏置, 是w和x的内积

     

    参数估计

     

    ​ 假设:

     

     

      \[P(Y=1|x)=\pi (x), \quad P(Y=0|x)=1-\pi (x)\]

     

    ​ 则似然函数为:

     

     

      \[\prod_{i=1}^N [\pi (x_i)]^{y_i} [1 - \pi(x_i)]^{1-y_i}\]

     

    ​ 求对数似然函数:

     

     

      \[L(w) = \sum_{i=1}^N [y_i \log{\pi(x_i)} + (1-y_i) \log{(1 - \pi(x_i)})]\]

     

     

      \[\sum_{i=1}^N [y_i \log{\frac {\pi (x_i)} {1 - \pi(x_i)}} + \log{(1 - \pi(x_i)})]=\sum_{i=1}^N [y_i \log{\frac {\pi (x_i)} {1 - \pi(x_i)}} + \log{(1 - \pi(x_i)})]\]

     

    ​ 从而对

     

      \[L(w)\]

     

    求极大值,得到w的估计值。求极值的方法可以是梯度下降法,梯度上升法等。

     

    示例代码: 

    #导入需要的包:
    from pyspark import SparkContext
    from pyspark.sql import SparkSession,Row,functions
    from pyspark.ml.linalg import Vector,Vectors
    from pyspark.ml.evaluation import MulticlassClassificationEvaluator
    from pyspark.ml import Pipeline
    from pyspark.ml.feature import IndexToString,StringIndexer,VectorIndexer,HashingTF,Tokenizer
    from pyspark.ml.classification import LogisticRegression,LogisticRegressionModel,BinaryLogisticRegressionSummary,LogisticRegression

    #用二项逻辑斯蒂回归解决 二分类 问题
     
    sc = SparkContext('local','用二项逻辑斯蒂回归解决二分类问题')
    spark = SparkSession.builder.master('local').appName('用二项逻辑斯蒂回归解决二分类问题').getOrCreate()
     
    #读取数据,简要分析
    #我们定制一个函数,来返回一个指定的数据,然后读取文本文件,第一个map把每行的数据用","
    #隔开,比如在我们的数据集中,每行被分成了5部分,目前4部分是鸢尾花的四个特征,最后一部分鸢尾花的分类;
    #我们这里把特征存储在Vector中,创建一个Iris模式的RDd,然后转化成DataFrame;最后调用show()方法查看数据
    def f(x):
    rel ={}
    rel['features'] = Vectors.dense(float(x[0]),float(x[1]),float(x[2]),float(x[3]))
    rel['label'] = str(x[4])
    return rel
    data= sc.textFile("file:///usr/local/spark/mycode/exercise/iris.txt").map(lambda line : line.split(',')).map(lambda p : Row(**f(p))).toDF()
    # 因为我们现在处理的是2分类问题,所以我们不需要全部的3类数据,我们要从中选出两类的
    #数据。这里首先把刚刚得到的数据注册成一个表iris,注册成这个表之后,我们就可以
    #通过sql语句进行数据查询,比如我们这里选出了所有不属于“Iris-setosa”类别的数
    #据;选出我们需要的数据后,我们可以把结果打印出来看一下,这时就已经没有“Iris-setosa”类别的数据
    data.createOrReplaceTempView("iris")
    df = spark.sql("select * from iris where label != 'Iris-setosa'")
    rel = df.rdd.map(lambda t : str(t[1])+":"+str(t[0])).collect()
    for item in rel:
    print(item)
    如图:
      

     

    #构建ML的pipeline
    #分别获取标签列和特征列,进行索引,并进行了重命名
    labelIndexer = StringIndexer().setInputCol('label').setOutputCol('indexedLabel').fit(df)
    featureIndexer = VectorIndexer().setInputCol('features').setOutputCol('indexedFeatures').fit(df)
    #把数据集随机分成训练集和测试集,其中训练集占70%
    trainingData, testData =df.randomSplit([0.7,0.3])
    #设置logistic的参数,这里我们统一用setter的方法来设置,也可以用ParamMap来设置
    #(具体的可以查看spark mllib的官网)。这里我们设置了循环次数为10次,正则化项为
    #0.3等,具体的可以设置的参数可以通过explainParams()来获取,还能看到我们已经设置
    #的参数的结果。
    lr= LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol('indexedFeatures').setMaxIter(10).setRegParam(0.3).setElasticNetParam(0.8)
    print("LogisticRegression parameters:\n"+ lr.explainParams())
    如图:

     

    #设置一个labelConverter,目的是把预测的类别重新转化成字符型的
    labelConverter = IndexToString().setInputCol("prediction").setOutputCol("predictedLabel").setLabels(labelIndexer.labels)
    #构建pipeline,设置stage,然后调用fit()来训练模型
    LrPipeline = Pipeline().setStages([labelIndexer, featureIndexer, lr, labelConverter])
    LrPipelineModel = LrPipeline.fit(trainingData)
    #用训练得到的模型进行预测,即对测试数据集进行验证
    lrPredictions = LrPipelineModel.transform(testData)
    preRel = lrPredictions.select("predictedLabel",'label','features','probability').collect()
    for item in preRel:
    print(str(item['label'])+','+str(item['features'])+'-->prob='+str(item['probability'])+',predictedLabel'+str(item['predictedLabel']))
    如图:

     

    #模型评估1
    #创建一个MulticlassClassificationEvaluator实例,用setter方法把预测分类的列名和真实分类的列名进行设置;然后计算预测准确率和错误率
    evaluator = MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")
    lrAccuracy = evaluator.evaluate(lrPredictions)
    print("Test Error=" + str(1.0- lrAccuracy))
    如图:

     

    #从上面可以看到预测的准确性达到94%,接下来我们可以通过model来获取我们训练得到
    #的逻辑斯蒂模型。前面已经说过model是一个PipelineModel,因此我们可以通过调用它的
    #stages来获取模型
    lrModel = LrPipelineModel.stages[2]
    print("Coefficients: " + str(lrModel.coefficients)+"Intercept: "+str(lrModel.intercept)+"numClasses: "+str(lrModel.numClasses)+"numFeatures: "+str(lrModel.numFeatures))
    如图:

     

     
    #模型评估2
    #spark的ml库还提供了一个对模型的摘要总结(summary),不过目前只支持二项逻辑斯
    #蒂回归,而且要显示转化成BinaryLogisticRegressionSummary 。在下面的代码中,首
    #先获得二项逻辑斯模型的摘要;然后获得10次循环中损失函数的变化,并将结果打印出来
    #,可以看到损失函数随着循环是逐渐变小的,损失函数越小,模型就越好;接下来,我们
    #把摘要强制转化为BinaryLogisticRegressionSummary,来获取用来评估模型性能的矩阵;
    #通过获取ROC,我们可以判断模型的好坏,areaUnderROC达到了 0.969551282051282,说明
    #我们的分类器还是不错的;最后,我们通过最大化fMeasure来选取最合适的阈值,其中fMeasure
    #是一个综合了召回率和准确率的指标,通过最大化fMeasure,我们可以选取到用来分类的最合适的阈值
    trainingSummary = lrModel.summary
    objectiveHistory = trainingSummary.objectiveHistory
    for item in objectiveHistory:
    print (item)
    print("areaUnderRoC:"+str(trainingSummary.areaUnderROC))
    如图:

     

     
    fMeasure = trainingSummary.fMeasureByThreshold
    maxFMeasure = fMeasure.groupBy().max('F-Measure').select('max(F-Measure)').head()
    print(maxFMeasure)
    如图:
     
    bestThreshold = fMeasure.where(fMeasure['F-Measure'] == maxFMeasure['max(F-Measure)']).select('threshold').head()['threshold']
    print(bestThreshold)
    lr.setThreshold(bestThreshold)
    #用多项逻辑斯蒂回归解决 二分类 问题
    mlr = LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(10).setRegParam(0.3).setElasticNetParam(0.8).setFamily("multinomial")
    mlrPipeline = Pipeline().setStages([labelIndexer, featureIndexer, mlr, labelConverter])
    mlrPipelineModel = mlrPipeline.fit(trainingData)
    mlrPrediction = mlrPipelineModel.transform(testData)
    mlrPreRel =mlrPrediction.select("predictedLabel", "label", "features", "probability").collect()
    for item in mlrPreRel:
    print('('+str(item['label'])+','+str(item['features'])+')-->prob='+str(item['probability'])+',predictLabel='+str(item['predictedLabel']))
    如图:

     

    mlrAccuracy = evaluator.evaluate(mlrPrediction)
    print("mlr Test Error ="+ str(1.0-mlrAccuracy))
    如图:
    mlrModel = mlrPipelineModel.stages[2]
    print("Multinomial coefficients: " +str(mlrModel.coefficientMatrix)+"Multinomial intercepts: "+str(mlrModel.interceptVector)+"numClasses: "+str(mlrModel.numClasses)+"numFeatures: "+str(mlrModel.numFeatures))
    如图;
    #用多项逻辑斯蒂回归解决多分类问题
    mlrPreRel2 = mlrPrediction.select("predictedLabel", "label", "features", "probability").collect()
    for item in mlrPreRel2:
    print('('+str(item['label'])+','+str(item['features'])+')-->prob='+str(item['probability'])+',predictLabel='+str(item['predictedLabel']))
    如图:

     

    mlr2Accuracy = evaluator.evaluate(mlrPrediction)
    print("Test Error = " + str(1.0 - mlr2Accuracy))

     

    mlr2Model = mlrPipelineModel.stages[2]
    print("Multinomial coefficients: " + str(mlrModel.coefficientMatrix)+"Multinomial intercepts: "+str(mlrModel.interceptVector)+"numClasses: "+str(mlrModel.numClasses)+"numFeatures: "+str(mlrModel.numFeatures))

     

    转载于:https://www.cnblogs.com/SoftwareBuilding/p/9512653.html

    展开全文
  • 二项逻辑回归__二分类 { val spark =SparkSession.builder().master( " local " ).getOrCreate() import spark.implicits._ // 支持把一个RDD隐式转换为一个DataFrame def main(args: Array[String]): Unit = ...
    package Spark_MLlib
    
    import org.apache.spark.ml.Pipeline
    import org.apache.spark.ml.classification.{BinaryLogisticRegressionSummary, LogisticRegression, LogisticRegressionModel}
    import org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator
    import org.apache.spark.ml.feature.{IndexToString, StringIndexer, VectorIndexer}
    import org.apache.spark.sql.SparkSession
    import org.apache.spark.ml.linalg.{Vector, Vectors}
    import org.apache.spark.sql.functions
    
    case class data_schema(features:Vector,label:String)
    object 二项逻辑回归__二分类 {
      val spark=SparkSession.builder().master("local").getOrCreate()
      import spark.implicits._  //支持把一个RDD隐式转换为一个DataFrame
      def main(args: Array[String]): Unit = {
        val df =spark.sparkContext.textFile("file:///home/soyo/桌面/spark编程测试数据/soyo.txt")
          .map(_.split(",")).map(x=>data_schema(Vectors.dense(x(0).toDouble,x(1).toDouble,x(2).toDouble,x(3).toDouble),x(4))).toDF()
          df.show(130)
          df.createOrReplaceTempView("data_schema")
         val df_data=spark.sql("select * from data_schema where label !='soyo2'") //这里soyo2需要加单引号,不然报错
         // df_data.map(x=>x(1)+":"+x(0)).collect().foreach(println)
            df_data.show()
         val labelIndexer=new StringIndexer().setInputCol("label").setOutputCol("indexedLabel").fit(df_data)
         val featureIndexer=new VectorIndexer().setInputCol("features").setOutputCol("indexedFeatures").fit(df_data)  //目的在特征向量中建类别索引
         val Array(trainData,testData)=df_data.randomSplit(Array(0.7,0.3))
         val lr=new LogisticRegression().setLabelCol("indexedLabel").setFeaturesCol("indexedFeatures").setMaxIter(10).setRegParam(0.5).setElasticNetParam(0.8)//setRegParam:正则化参数,设置elasticnet混合参数为0.8,setFamily("multinomial"):设置为多项逻辑回归,不设置setFamily为二项逻辑回归
         val labelConverter=new IndexToString().setInputCol("prediction").setOutputCol("predictionLabel").setLabels(labelIndexer.labels)
    
         val lrPipeline=new Pipeline().setStages(Array(labelIndexer,featureIndexer,lr,labelConverter))
         val lrPipeline_Model=lrPipeline.fit(trainData)
         val lrPrediction=lrPipeline_Model.transform(testData)
        lrPrediction.show(false)
        // lrPrediction.take(100).foreach(println)
         //模型评估
        val evaluator=new MulticlassClassificationEvaluator().setLabelCol("indexedLabel").setPredictionCol("prediction")
        val lrAccuracy=evaluator.evaluate(lrPrediction)
         println("准确率为: "+lrAccuracy)
        val lrError=1-lrAccuracy
        println("错误率为: "+lrError)
        val LRmodel=lrPipeline_Model.stages(2).asInstanceOf[LogisticRegressionModel]
        println("二项逻辑回归模型系数的向量: "+LRmodel.coefficients)
        println("二项逻辑回归模型的截距: "+LRmodel.intercept)
        println("类的数量(标签可以使用的值): "+LRmodel.numClasses)
        println("模型所接受的特征的数量: "+LRmodel.numFeatures)
        //对模型的总结(summary)目前只支持二项逻辑斯蒂回归,多项式逻辑回归并不支持(用的是spark 2.2.0)
       println(LRmodel.hasSummary)
        val trainingSummary = LRmodel.summary
        //损失函数,可以看到损失函数随着循环是逐渐变小的,损失函数越小,模型就越好
        val objectiveHistory =trainingSummary.objectiveHistory
        objectiveHistory.foreach(println)
        //强制转换为BinaryLogisticRegressionSummary
        val binarySummary= trainingSummary.asInstanceOf[BinaryLogisticRegressionSummary]
        //ROC曲线下方的面积,越接近1说明模型越好
        val area_ROC=binarySummary.areaUnderROC
        println("ROC 曲线下的面积为: "+area_ROC)
        //fMeasureByThreshold:返回一个带有beta = 1.0的两个字段(阈值,f - measure)曲线的dataframe
         val fMeasure=binarySummary.fMeasureByThreshold
        println("fMeasure的行数: "+fMeasure.collect().length)
        fMeasure.show(100)
        val maxFMeasure=fMeasure.select(functions.max("F-Measure")).head().getDouble(0)
        println("最大的F-Measure的值为: "+maxFMeasure)
        //最优的
        val bestThreashold=fMeasure.where($"F-Measure"===maxFMeasure).select("threshold").head().getDouble(0)
        println("最优的值为:"+bestThreashold)
        /* 这样求的不是最优的值
         val s=fMeasure.select(functions.max("threshold")).head().getDouble(0)
        println(s)
        */
        LRmodel.setThreshold(bestThreashold)
    
      }
    }

    结果:


    +-----------------+-----+------------+------------------+--------------------------------------------+----------------------------------------+----------+---------------+
    |features         |label|indexedLabel|indexedFeatures   |rawPrediction                               |probability                             |prediction|predictionLabel|
    +-----------------+-----+------------+------------------+--------------------------------------------+----------------------------------------+----------+---------------+
    |[4.4,2.9,1.4,0.2]|soyo1|0.0         |[4.4,2.9,1.4,1.0] |[0.0690256519103008,-0.0690256519103008]    |[0.5172495646670774,0.48275043533292256]|0.0       |soyo1          |
    |[4.4,3.0,1.3,0.2]|soyo1|0.0         |[4.4,3.0,1.3,1.0] |[0.07401171769156373,-0.07401171769156373]  |[0.518494487869238,0.481505512130762]   |0.0       |soyo1          |
    |[4.6,3.1,1.5,0.2]|soyo1|0.0         |[4.6,3.1,1.5,1.0] |[0.06403958612903785,-0.06403958612903785]  |[0.5160044273015656,0.48399557269843435]|0.0       |soyo1          |
    |[4.6,3.2,1.4,0.2]|soyo1|0.0         |[4.6,3.2,1.4,1.0] |[0.0690256519103008,-0.0690256519103008]    |[0.5172495646670774,0.48275043533292256]|0.0       |soyo1          |
    |[4.6,3.6,1.0,0.2]|soyo1|0.0         |[4.6,3.6,1.0,1.0] |[0.08896991503535255,-0.08896991503535255]  |[0.5222278183980882,0.4777721816019118] |0.0       |soyo1          |
    |[4.8,3.0,1.4,0.1]|soyo1|0.0         |[4.8,3.0,1.4,0.0] |[0.0690256519103008,-0.0690256519103008]    |[0.5172495646670774,0.48275043533292256]|0.0       |soyo1          |
    |[4.9,2.5,4.5,1.7]|soyo3|1.0         |[4.9,2.5,4.5,9.0] |[-0.08554238730885033,0.08554238730885033]  |[0.47862743439605193,0.5213725656039481]|1.0       |soyo3          |
    |[5.0,3.0,1.6,0.2]|soyo1|0.0         |[5.0,3.0,1.6,1.0] |[0.059053520347774904,-0.059053520347774904]|[0.5147590911988562,0.48524090880114373]|0.0       |soyo1          |
    |[5.1,3.5,1.4,0.3]|soyo1|0.0         |[5.1,3.5,1.4,2.0] |[0.0690256519103008,-0.0690256519103008]    |[0.5172495646670774,0.48275043533292256]|0.0       |soyo1          |
    |[5.1,3.8,1.6,0.2]|soyo1|0.0         |[5.1,3.8,1.6,1.0] |[0.059053520347774904,-0.059053520347774904]|[0.5147590911988562,0.48524090880114373]|0.0       |soyo1          |
    |[5.3,3.7,1.5,0.2]|soyo1|0.0         |[5.3,3.7,1.5,1.0] |[0.06403958612903785,-0.06403958612903785]  |[0.5160044273015656,0.48399557269843435]|0.0       |soyo1          |
    |[5.4,3.7,1.5,0.2]|soyo1|0.0         |[5.4,3.7,1.5,1.0] |[0.06403958612903785,-0.06403958612903785]  |[0.5160044273015656,0.48399557269843435]|0.0       |soyo1          |
    |[5.4,3.9,1.7,0.4]|soyo1|0.0         |[5.4,3.9,1.7,3.0] |[0.05406745456651198,-0.05406745456651198]  |[0.5135135717949689,0.486486428205031]  |0.0       |soyo1          |
    |[5.7,3.8,1.7,0.3]|soyo1|0.0         |[5.7,3.8,1.7,2.0] |[0.05406745456651198,-0.05406745456651198]  |[0.5135135717949689,0.486486428205031]  |0.0       |soyo1          |
    |[5.8,2.8,5.1,2.4]|soyo3|1.0         |[5.8,2.8,5.1,16.0]|[-0.11545878199642795,0.11545878199642795]  |[0.4711673274353307,0.5288326725646694] |1.0       |soyo3          |
    |[5.8,4.0,1.2,0.2]|soyo1|0.0         |[5.8,4.0,1.2,1.0] |[0.07899778347282668,-0.07899778347282668]  |[0.5197391814925231,0.480260818507477]  |0.0       |soyo1          |
    |[6.1,3.0,4.9,1.8]|soyo3|1.0         |[6.1,3.0,4.9,10.0]|[-0.10548665043390212,0.10548665043390212]  |[0.4736527642876721,0.5263472357123279] |1.0       |soyo3          |
    |[6.3,2.7,4.9,1.8]|soyo3|1.0         |[6.3,2.7,4.9,10.0]|[-0.10548665043390212,0.10548665043390212]  |[0.4736527642876721,0.5263472357123279] |1.0       |soyo3          |
    |[6.3,2.9,5.6,1.8]|soyo3|1.0         |[6.3,2.9,5.6,10.0]|[-0.14038911090274264,0.14038911090274264]  |[0.46496025354157383,0.5350397464584261]|1.0       |soyo3          |
    |[6.5,3.0,5.5,1.8]|soyo3|1.0         |[6.5,3.0,5.5,10.0]|[-0.13540304512147971,0.13540304512147971]  |[0.4662008623530858,0.5337991376469143] |1.0       |soyo3          |
    +-----------------+-----+------------+------------------+--------------------------------------------+----------------------------------------+----------+---------------+
    only showing top 20 rows

    准确率为: 1.0
    错误率为: 0.0
    二项逻辑回归模型系数的向量: [0.0,0.0,0.0498606578126294,-0.0]
    二项逻辑回归模型的截距: -0.13883057284798195
    类的数量(标签可以使用的值): 2
    模型所接受的特征的数量: 4
    true
    0.6927819059876479
    0.6921535505946383
    0.6902127176671448
    0.6898394130469451
    0.689535794969328
    0.6894009255584304
    0.6893497986701255
    0.689265433291139
    0.6887228224555286
    0.6895877386375889
    0.6872109190567809
    ROC 曲线下的面积为: 1.0
    fMeasure的行数: 26
    +-------------------+-------------------+
    |          threshold|          F-Measure|
    +-------------------+-------------------+
    | 0.5511227178429281|0.05128205128205127|
    | 0.5486545095952616|                0.1|
    |  0.547419499422364|0.14634146341463414|
    | 0.5449477416103359| 0.1904761904761905|
    | 0.5412359859690851| 0.2727272727272727|
    | 0.5399976958289747|0.34782608695652173|
    | 0.5387589116841329|0.38297872340425526|
    | 0.5375196486465557| 0.4799999999999999|
    | 0.5362799218518347| 0.5098039215686275|
    | 0.5350397464584261| 0.6428571428571429|
    | 0.5337991376469143| 0.6896551724137931|
    | 0.5325581106192748| 0.7333333333333334|
    | 0.5313166805981351| 0.7741935483870968|
    | 0.5300748628260323| 0.8125000000000001|
    | 0.5288326725646694| 0.9142857142857143|
    | 0.5275901250941695|  0.958904109589041|
    | 0.5263472357123279|  0.972972972972973|
    | 0.5251040197338624|                1.0|
    | 0.4889779551275146| 0.9743589743589743|
    |  0.486486428205031| 0.9500000000000001|
    |0.48524090880114373| 0.8941176470588235|
    |0.48399557269843435| 0.7916666666666666|
    |0.48275043533292256| 0.7307692307692308|
    |  0.481505512130762| 0.6909090909090909|
    |  0.480260818507477| 0.6846846846846847|
    |0.47901636986720014| 0.6785714285714285|
    +-------------------+-------------------+

    最大的F-Measure的值为: 1.0
    最优的阀值为:0.5251040197338624

    转载于:https://www.cnblogs.com/soyo/p/7787607.html

    展开全文
  • 二项分布

    千次阅读 2013-04-01 15:12:26
    当随机事件是只具有两种互斥结果的离散型随机事件时,称为二项分类变量(dichotomous variable),如对病人治疗结果的有效与无效,某种化验结果的阳性与阴性,接触某传染源的感染与未感染等。二项分布(binomial ...

    二项分布的概念

    当随机事件是只具有两种互斥结果的离散型随机事件时,称为二项分类变量(dichotomous variable),如对病人治疗结果的有效与无效,某种化验结果的阳性与阴性,接触某传染源的感染与未感染等。二项分布(binomial distribution)就是对这类只具有两种互斥结果的离散型随机事件的规律性进行描述的一种概率分布。

     二项分布的推导

    假设某事件A在一次试验中发生的概率为p,现在把这个试验独立地重复n次,以X记A在这n次试验中发生的次数,则X可能取0、1、...、n等。考虑事件{X=i},要这个事件发生,必须在这n次试验的原始记录AAA’A...A’AA’中有i个A,n-i个A’,每个A有概率p,每个A’有概率1-p。由于每次试验是独立的,由乘法定理可知每个这样的原始序列发生的概率是pi(1-p)n-i,又因为在n个位置中A可以占据任意i个位置,由排列组合的知识可知共C(n,i)种试验序列,因此有

    p(X=i)= b(i; n,p) = C(n,i)pi(1-p)n-i, (i=0,1,...,n)

    X服从的分布就叫做二项分布(或伯努利分布),并记为B(n,p)。

    二项分布的条件

    1.各次试验的条件是稳定的,以保证事件A发生的概率p在各次试验中保持不变;

    2.各次试验是独立进行的。

    二项分布的性质

    1.X的均值u=np

    2.X的方法=np(1-p)

    二项分布图形

    二项分布的形状取决于p和n的大小,高峰在m=np处。当p接近0.5时,图形是对称的;p离0.5愈远,对称性愈差,但随着n的增大,分布趋于对称。当n→∞时,只要p不太靠近0或1,特别是当nP和n(1-P)都大于5时,二项分布近似于正态分布。


    Reference

    1.陈希孺,《概率论与数理统计》

    展开全文
  • 转载于:https://www.cnblogs.com/winslam/p/10203296.html
  • 二项分布的概念与特征

    千次阅读 2011-03-25 14:17:00
     二项分布的概念与特征  一、二项分布的概念 在医学领域中,有一些随机事件是只具有两种互斥结果的离散型随机事件,称为二项分类变量(dichotomous variable),如对病人治疗结果的有效与无效,某种...
  • 发现代码中计算分类条件概率的公式与一般书上写的不一样。浏览评论的时候发现有人跟我有一样的疑问. 正庆幸找到一个明白了,突然LX的回答又给我泼了一瓶冷水。 神马,伯努利贝叶斯! 听都没说过。...
  •  * 逻辑回归 随机梯度下降 批梯度下降 二分类问题  * @author Administrator  *  */ public class LR {  List samples;  List paramers;  static class Sample{  Double label;  List feature; ...
  • 由于游戏非常多使用阻断,因此,我们创建了一个单独的类中Block。 于Blcok.h声明了两个初始化函数: ... static Block* createWithArgs(Color3B color, Size size, std::string label, float fontSize, Color4B ...
  • 交叉熵损失-二分类与多分类的关系

    千次阅读 2020-09-02 11:41:17
    貌似不一样,二分类为什么多一?主要是one-hot向量搞得鬼! 如果按多分类中的one-hot,其实是: 0:[1,0] 1:[0,1] 但是二分类,一个维度的数就可以直接区别两个类别,不需要两个维度。所以使用多分类的交叉熵,将第...
  • 二项逻辑回归到多项逻辑回归

    千次阅读 2017-10-09 22:08:49
    逻辑回归是统计学中经典的分类算法,与...1.二项逻辑回归原理及其参数的求解如下: 2.多项逻辑回归的原理 参考链接:http://www.cnblogs.com/yinheyi/p/6131262.html 参考链接:http://www.jianshu.com/
  • “二项分布即重复n次独立的伯努利试验。在每次试验中只有两种可能的结果,而且两种结果发生...在医学领域中,有一些随机事件是只具有两种互斥结果的离散型随机事件,称为二项分类变量(dichotomous variable),如对
  • 二项分布(Binomial Distribution)对Bernoulli试验序列的n次序列,结局A出现的次数x的概率分布服从二项分布- 两分类变量并非一定会服从二项分布- 模拟伯努利试验中n次独立的重复,每次试验成功的概率为pi ...
  • 从这种二分类总体中抽取的所有可能结果,要么是对立分类中的这一类,要么是另一类,其频数分布称为二项分布。调用SPSS中的二项分布检验(Binomial)可对样本资料进行二项分布分析。  SPSS二项分布检验就是根据收集...
  • 作为一名机器学习的爱好者,最近在跟着Andrew Ng 的 Machine Learning 学习。在讲义的第一部分中,Ng首先讲解了什么叫做监督学习,其次讲了用最小二乘法求解的线性模型,用sigmod函数表示响应函数的logistics回归,...
  • zblog分类/tag实现增强CMS 该插件增加了更多的CMS功能:包括 1)分类级tag、分类pathbar...置顶文章摘要、别名调用分类属性、分类页调用分类属性这几可以独立使用。 分类置顶文章摘要调用,如图:
  • 各列的意义为addr为匹配数据,wsm为第几个匹配,city_id、city_path、loc不解释,sn为匹配序号,match为匹配内容,index为匹配结果所在位置,mlen为匹配结果字符串长度 很明显,这些数据需要处理后才能得到我们...
  • 从这种二分类总体中抽取的所有可能结果,要么是对立分类中的这一类,要么是另一类,其频数分布称为二项分布。调用SPSS中的二项分布检验(Binomial)可对样本资料进行二项分布分析。SPSS二项分布检验就是根据收集到的...
  • 文本分类二

    2014-03-07 23:22:24
    3、分类训练 4、测试 现在只做到了形成字典和特征选取。不过效果感觉不理想,选出来的特征有一些不好的。下周有机会去问下老师~~ 下面是形成字典的代码: 字典的结构是:map > myDic 例子: 中国 0 5 1 23 2 34 5 ...
  • 小程序分类

    千次阅读 2020-03-09 09:11:52
    <view class="asii" wx:if="{{isdiqi}}"> <view class="main"> <...-- 当前的id等于item的id或者当前的下标等于item的下标时,那个就是当前状态- --> <view wx:for=...
  • 此外,MedMNIST分类全能旨在对所有10个数据集的AutoML算法进行基准测试。 有关更多详细信息,请参阅我们的论文: MedMNIST分类全能:医学图像分析的轻量级AutoML基准( ) 主要特点 教育性的:我们的多...
  • 二项回归属于广义线性回归(GLM)的分支,与Logistic回归、Poisson回归等都属于计数数据模型的范畴,主要用于以分类变量、定序变量为因变量的回归分析之中。 负二项回归家族庞大,逐渐应用于社会科学领域各个学科...
  •     索引—— 基本概念 连续变量的统计描述 分类变量的统计描述 ... 二项分布 ...五、二项分布 ...1、二项分布的基本特征 ...PS:两分类变量并非一定会服从二项分布 Bernoulli试验:出现的结果只有两...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,664
精华内容 1,065
关键字:

二项分类