计算实体识别准确率
 
perl conlleval.pl -d '\t' < ./output/result_dir/label_test.txt
 
txt的格式为：文本   标签     预测标签 三列（以一个制表符隔开）

（一）将二次代价函数改为交叉熵可以提高手写数字识别准确率
 
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets('MNIST_data',one_hot=True)#载入数据集

batch_size = 100#每个批次的大小
n_batch = mnist.train.num_examples//batch_size#计算一共有多少个批次

x = tf.placeholder(tf.float32,[None,784])#定义两个变量
y = tf.placeholder(tf.float32,[None,10])

#构建一个简单的神经网络
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
prediction = tf.nn.softmax(tf.matmul(x,W)+b)

#二次代价函数
# loss = tf.reduce_mean(tf.square(y-prediction))
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
#使用梯度下降法
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存放在布尔型列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(21):
        for batch in range(n_batch):
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})

        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print("Iter" + str(epoch) + ",Testing Accuracy" + str(acc))
 
运行结果：
 
Iter0,Testing Accuracy0.8254
Iter1,Testing Accuracy0.8675
Iter2,Testing Accuracy0.8989
Iter3,Testing Accuracy0.905
Iter4,Testing Accuracy0.9085
Iter5,Testing Accuracy0.9097
Iter6,Testing Accuracy0.9114
Iter7,Testing Accuracy0.9132
Iter8,Testing Accuracy0.9154
Iter9,Testing Accuracy0.916
Iter10,Testing Accuracy0.9182
Iter11,Testing Accuracy0.9196
Iter12,Testing Accuracy0.9181
Iter13,Testing Accuracy0.9189
Iter14,Testing Accuracy0.9203
Iter15,Testing Accuracy0.9213
Iter16,Testing Accuracy0.9206
Iter17,Testing Accuracy0.9206
Iter18,Testing Accuracy0.9214
Iter19,Testing Accuracy0.9218
Iter20,Testing Accuracy0.9216
 
运行结果不仅最终准确率提升为0.9216，而且速度更快
 
（二）通过增加隐含层，使用dropout也可以提高准确率
 
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets('MNIST_data',one_hot=True)#载入数据集

batch_size = 100#每个批次的大小
n_batch = mnist.train.num_examples//batch_size#计算一共有多少个批次

x = tf.placeholder(tf.float32,[None,784])#定义两个变量
y = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32)

#构建一个简单的神经网络
W1 = tf.Variable(tf.truncated_normal([784,2000],stddev=0.1))
b1 = tf.Variable(tf.zeros([2000])+0.1)
L1 = tf.nn.tanh(tf.matmul(x,W1)+b1)
L1_drop = tf.nn.dropout(L1,keep_prob)

W2 = tf.Variable(tf.truncated_normal([2000,2000],stddev=0.1))
b2 = tf.Variable(tf.zeros([2000])+0.1)
L2 = tf.nn.tanh(tf.matmul(L1_drop,W2)+b2)
L2_drop = tf.nn.dropout(L2,keep_prob)

W3 = tf.Variable(tf.truncated_normal([2000,1000],stddev=0.1))
b3 = tf.Variable(tf.zeros([1000])+0.1)
L3 = tf.nn.tanh(tf.matmul(L2_drop,W3)+b3)
L3_drop = tf.nn.dropout(L3,keep_prob)

W4 = tf.Variable(tf.truncated_normal([1000,10],stddev=0.1))
b4 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L3_drop,W4)+b4)

#二次代价函数
# loss = tf.reduce_mean(tf.square(y-prediction))
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
#使用梯度下降法
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化变量
init = tf.global_variables_initializer()

#结果存放在布尔型列表中
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
#求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(31):
        for batch in range(n_batch):
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})

        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy, feed_dict={x: mnist.train.images, y: mnist.train.labels, keep_prob: 1.0})
        print("Iter" + str(epoch) + ",Testing Accuracy" + str(test_acc) + ",Training Accuracy" + str(train_acc))
 
运行结果：
 
Iter0,Testing Accuracy0.858,Training Accuracy0.87012726
Iter1,Testing Accuracy0.9494,Training Accuracy0.96523637
Iter2,Testing Accuracy0.9627,Training Accuracy0.9809273
Iter3,Testing Accuracy0.9676,Training Accuracy0.9864727
Iter4,Testing Accuracy0.9684,Training Accuracy0.98890907
Iter5,Testing Accuracy0.9687,Training Accuracy0.99036366
Iter6,Testing Accuracy0.9706,Training Accuracy0.9914
Iter7,Testing Accuracy0.9697,Training Accuracy0.9919818
Iter8,Testing Accuracy0.9714,Training Accuracy0.99241817
Iter9,Testing Accuracy0.9722,Training Accuracy0.9929636
Iter10,Testing Accuracy0.9715,Training Accuracy0.9933091
Iter11,Testing Accuracy0.9719,Training Accuracy0.9936182
Iter12,Testing Accuracy0.9724,Training Accuracy0.9937818
Iter13,Testing Accuracy0.972,Training Accuracy0.9939273
Iter14,Testing Accuracy0.9723,Training Accuracy0.9941091
Iter15,Testing Accuracy0.9722,Training Accuracy0.9942
Iter16,Testing Accuracy0.9719,Training Accuracy0.9943454
Iter17,Testing Accuracy0.9722,Training Accuracy0.99447274
Iter18,Testing Accuracy0.9724,Training Accuracy0.9945818
Iter19,Testing Accuracy0.9723,Training Accuracy0.9946909
Iter20,Testing Accuracy0.9731,Training Accuracy0.99474543
Iter21,Testing Accuracy0.9731,Training Accuracy0.9948364
Iter22,Testing Accuracy0.9728,Training Accuracy0.9949273
Iter23,Testing Accuracy0.9734,Training Accuracy0.995
Iter24,Testing Accuracy0.973,Training Accuracy0.99505454
Iter25,Testing Accuracy0.9734,Training Accuracy0.99512726
Iter26,Testing Accuracy0.9731,Training Accuracy0.9951636
Iter27,Testing Accuracy0.9738,Training Accuracy0.99523634
Iter28,Testing Accuracy0.9739,Training Accuracy0.9953455
Iter29,Testing Accuracy0.9737,Training Accuracy0.9954182
Iter30,Testing Accuracy0.9738,Training Accuracy0.99545455
 
测试集准确率可以达到0.9738，训练集准确率可以达到0.99545455

如何提高训练模型准确率
 
 
原文链接：https://blog.csdn.net/Winteeena/article/details/78997696 
 
提升一个模型的表现有时很困难，尝试所有曾学习过的策略和算法，但模型正确率并没有改善。
 这才是考验真本领的时候！这也是普通的数据科学家跟大师级数据科学家的差距所在。
 本文将分享 8 个经过证实的方法，使用这些方法可以建立稳健的机器学习模型。
 
导语
 
 
模型的开发周期有多个不同的阶段，从数据收集开始直到模型建立。

 不过，在通过探索数据来理解（变量的）关系之前，建议进行假设生成（hypothesis generation）步骤（如果想了解更多有关假设生成的内容，
 推荐阅读（why-and-when-is-hypothesis-generation-important）。我认为，这是预测建模过程中最被低估的一个步骤。

 花时间思考要回答的问题以及获取领域知识也很重要。这有什么帮助呢？
 它会帮助你随后建立更好的特征集，不被当前的数据集误导。这是改善模型正确率的一个重要环节。

 在这个阶段，你应该对问题进行结构化思考，即进行一个把此问题相关的所有可能的方面纳入考虑范围的思考过程。

 现在让我们挖掘得更深入一些。让我们看看这些已被证实的，用于改善模型准确率的方法。
 
正文
 
 
1.增加更多数据
 
持有更多的数据永远是个好主意。相比于去依赖假设和弱相关，更多的数据允许数据进行“自我表达”。数据越多，模型越好，正确率越高。

 我明白，有时无法获得更多数据。比如，在数据科学竞赛中，训练集的数据量是无法增加的。
 但对于企业项目，我建议，如果可能的话，去索取更多数据。这会减少由于数据集规模有限带来的痛苦。
 
2.处理缺失值和异常值
 
训练集中缺失值与异常值的意外出现，往往会导致模型正确率低或有偏差。这会导致错误的预测。
 这是由于我们没能正确分析目标行为以及与其他变量的关系。所以处理好缺失值和异常值很重要。

 仔细看下面一幅截图。在存在缺失值的情况下，男性和女性玩板球的概率相同。
 但如果看第二张表（缺失值根据称呼“Miss”被填补以后），相对于男性，女性玩板球的概率更高。

 从上面的例子中，我们可以看出缺失值对于模型准确率的不利影响。所幸，我们有各种方法可以应对缺失值和异常值：
 
1.缺失值：对于连续变量，可以把缺失值替换成平均值、中位数、众数。对于分类变量，可以把变量作为一个特殊类别看待。
 你也可以建立模型预测缺失值。KNN为处理缺失值提供了很好的方法。想了解更多这方面内容，推荐阅读《Methods to deal and treat missing values》。
2.异常值：你可以删除这些条目，进行转换，分箱。如同缺失值，你也可以对异常值进行区别对待。
 想了解更多这方面内容，推荐阅读《How to detect Outliers in your dataset and treat them?》。
 
3.特征工程学（Feature Engineering）
 
这一步骤有助于从现有数据中提取更多信息。新信息作为新特征被提取出来。
 这些特征可能会更好地解释训练集中的差异变化。因此能改善模型的准确率。

 假设生成对特征工程影响很大。好的假设能带来更好的特征集。
 这也是我一直建议在假设生成上花时间的原因。特征工程能被分为两个步骤：
 
 
特征转换：许多场景需要进行特征转换：
 
 
A)把变量的范围从原始范围变为从0到1。这通常被称作数据标准化。
 比如，某个数据集中第一个变量以米计算，第二个变量是厘米，第三个是千米，在这种情况下，在使用任何算法之前，必须把数据标准化为相同范围。
 
 
B)有些算法对于正态分布的数据表现更好。所以我们需要去掉变量的偏向。
 对数，平方根，倒数等方法可用来修正偏斜。
 
 
C)有些时候，数值型的数据在分箱后表现更好，因为这同时也处理了异常值。
 数值型数据可以通过把数值分组为箱变得离散。这也被称为数据离散化。
 
 
创建新特征：从现有的变量中衍生出新变量被称为特征创建。这有助于释放出数据集中潜藏的关系。
 比如，我们想通过某家商店的交易日期预测其交易量。在这个问题上日期可能和交易量关系不大，
 但如果研究这天是星期几，可能会有更高的相关。在这个例子中，某个日期是星期几的信息是潜在的。我们可以把这个信息提取为新特征，优化模型。
 
 
4.特征选择
 
特征选择是寻找众多属性的哪个子集合，能够最好的解释目标变量与各个自变量的关系的过程。

 你可以根据多种标准选取有用的特征，例如：
 
所在领域知识：根据在此领域的经验，可以选出对目标变量有更大影响的变量。
可视化：正如这名字所示，可视化让变量间的关系可以被看见，使特征选择的过程更轻松。
统计参数：我们可以考虑p值，信息价值（information values）和其他统计参数来选择正确的参数。
PCA：这种方法有助于在低维空间表现训练集数据。这是一种降维技术。降低数据集维度还有许多方法：如因子分析、低方差、高相关、前向后向变量选择及其他。
 
5.使用多种算法
 
使用正确的机器学习算法是获得更高准确率的理想方法。但是说起来容易做起来难。

 这种直觉来自于经验和不断尝试。有些算法比其他算法更适合特定类型数据。因此，我们应该使用所有有关的模型，并检测其表现。
 
6.算法的调整
 
我们都知道机器学习算法是由参数驱动的。这些参数对学习的结果有明显影响。参数调整的目的是为每个参数寻找最优值，以改善模型正确率。
 要调整这些参数，你必须对它们的意义和各自的影响有所了解。你可以在一些表现良好的模型上重复这个过程。

 例如，在随机森林中，我们有 max_features,number_trees, random_state, oob_score 以及其他参数。优化这些参数值会带来更好更准确的模型。

 想要详细了解调整参数带来的影响，可以查阅《Tuning the parameters of your Random Forest model》。下面是随机森林算法在scikit learn中的全部参数清单：

 RandomForestClassifier(n_estimators=10,criterion=‘gini’,max_depth=None,min_samples_split=2,
 min_samples_leaf=1,min_weight_fraction_leaf=0.0,max_features=‘auto’,max_leaf_nodes=None,
 bootstrap=True,oob_score=False,n_jobs=1,random_state=None,verbose=0,warm_start=False,class_weight=None)
 
7.集成模型
 
在数据科学竞赛获胜方案中最常见的方法。这个技术就是把多个弱模型的结果组合在一起，获得更好的结果。它能通过许多方式实现，如：
 
Bagging(Bootstrap Aggregating)
Boosting
 想了解更多这方面内容，可以查阅《Introduction to ensemble learning》。

 使用集成方法改进模型正确率永远是个好主意。主要有两个原因：1）集成方法通常比传统方法更复杂；2）传统方法提供好的基础，在此基础上可以建立集成方法。

 注意：到目前为止，我们了解了改善模型准确率的方法。但是，高准确率的模型不一定（在未知数据上）有更好的表现。有时，模型准确率的改善是由于过度拟合。
 
8.交叉验证
 
如果想解决这个问题，我们必须使用交叉验证技术（cross validation）。交叉验证是数据建模领域最重要的概念之一。
 它是指，保留一部分数据样本不用来训练模型，而是在完成模型前用来验证。

 这种方法有助于得出更有概括性的关系。想了解更多有关交叉检验的内容，
 建议查阅《Improve model performance using cross validation》。
 
结语
 
 
预测建模的过程令人疲惫。但是，如果你能灵活思考，就可以轻易胜过其他人。
 简单地说，多考虑上面这8个步骤。获得数据集以后，遵循这些被验证过的方法，你就一定会得到稳健的机器学习模型。
 不过，只有当你熟练掌握了这些步骤，它们才会真正有帮助。
 比如，想要建立一个集成模型，你必须对多种机器学习算法有所了解。

1.召回率和正确率计算
 
对于一个$K$元的分类结果，我们可以得到一个$K\ast K$的混淆矩阵,得到的举证结果如下图所示。
 
 
从上图所示的结果中不同的元素表示的含义如下：
 $m_{ij}$ ：表示实际分类属于类$i$，在预测过程中被预测到分类$j$
 
对于所有的$m_{ij}$可以概括为四种方式不同类型的数据:
 
$TP$（真正）:真正的分类结果属于$i$预测的结果也属于$i$，此时对于 $m_{ij}$ 而言$i=j$
 
$FN$（假负）:真正的分类结果不属于分类$i$预测的分类结果也属于分类$i$
 
$TN$ (真负) :真正的分类结果属于分类$i$预测的结果不属于分类$i$
 
$FP$ (假正) :真正的分类结果不属于分类$i$预测的结果属于分类$i$
 那么召回率的计算公式如下：
 $$recall=\frac{TP}{TP+TN}$$
 $$precision=\frac{TP}{TP+FP}$$
 其中：
 
$T{P}_p=m_{pp}$:表示对于类$p$而言预测正确的个体的数目。
 
$T{N}_p={\sum }_{i=1,i\ne p}^k{m}_{pi}$:表示对本来属于分类$p$，预测的结果不属于分类$p$的个数。
 
$F{P}_p={\sum }_{i=1,i\ne p}^k{m}_{ip}$:表示对于本来不属于分类$p$的个体，预测的结果属于分类$p$的个数。
 
2 随机森林中召回率和正确率的计算
 
import org.apache.log4j.{Level, Logger}
import org.apache.spark.mllib.evaluation.MulticlassMetrics
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.mllib.tree.RandomForest
import org.apache.spark.mllib.tree.model.RandomForestModel
import org.apache.spark.mllib.util.MLUtils
import org.apache.spark.rdd.RDD

/**
  * Created by august on 17-6-1.
  */
object Main {

  var beg = System.currentTimeMillis()
  //设置日志文件为错误显示
  Logger.getLogger("org").setLevel(Level.ERROR)

  //设置application名称，并创建入口对象
  val conf = new SparkConf().setAppName("rf")
  val sc = new SparkContext(conf)

  //加载hadoop中的数据信息,这里将IP地址信息隐去
  val data = MLUtils.loadLibSVMFile(sc,"hdfs://***.***.***.***:8020/august/random_forest/Day2.txt")

  // 将数据信息划分为70%的测试集和30%的训练集
  val splits = data.randomSplit(Array(0.7, 0.3))
  val (trainingData, testData) = (splits(0), splits(1))

  //将数据一共分成12个类
  val numClasses = 13
  val categoricalFeaturesInfo = Map[Int, Int]()
  val numTrees = 100
  val featureSubsetStrategy = "auto" // Let the algorithm choose.
  val impurity = "entropy"
  val maxDepth = 10
  val maxBins = 32
  val model = RandomForest.trainClassifier(trainingData, numClasses, categoricalFeaturesInfo,
    numTrees, featureSubsetStrategy, impurity, maxDepth, maxBins)
  val metrics = getMetrics(model,testData)
  //计算精确度(样本比例)
  val precision = metrics.accuracy;
  //计算每个样本的准确度(召回率)
  val recall = (1 to 11).map(     //DecisionTreeModel模型的类别号从1开始
    cat => (metrics.precision(cat), metrics.recall(cat))
  )
  val end = System.currentTimeMillis()
  //耗时时间
  var castTime = end - beg

  def main(args: Array[String]) {
    println("========================================================================================")
    //精确度(样本比例)
    println("精确度: " + precision)
    println("========================================================================================")
    //准确度(召回率)
    println("准确度: ")
    recall.foreach(println)
    println("========================================================================================")
    println(" 运行程序耗时: " + castTime/1000 + "s")
  }
  def getMetrics(model: RandomForestModel, data: RDD[LabeledPoint]): MulticlassMetrics = {
    val predictionsAndLabels = data.map(example => (model.predict(example.features), example.label))
    new MulticlassMetrics(predictionsAndLabels)
  }
}
 
在上述代码中，实现了对于随机森林分类后的结果计算召回率和每一个类的准确率。
 ##2.1 数据获取并生成训练集和测试集
 在下述代码中我们主要进行了以下工作:
 
(1)设置spark日志输出信息为Level.ERROR，在错误状态下输出日志信息。
 
(2)设置Application的入口对象。
 
(3)从Hadoop中获取数据信息，值的注意的是这里的数据信息的数据格式为libsvm格式，从一般数据格式转换到libsvm格式的转换方式可以参考另一篇文章。
 
(4)将所有的数据信息划分为traingingData训练集和testData测试集,其中trainingData占数据集中的70%,testData占30%。
 
Logger.getLogger("org").setLevel(Level.ERROR)
val conf = new SparkConf().setAppName("rf")
val sc = new SparkContext(conf)
val data = MLUtils.loadLibSVMFile(sc, "hdfs://***.***.***.***:8020/august/random_forest/Day2.txt")
val splits = data.randomSplit(Array(0.7, 0.3))
val (trainingData, testData) = (splits(0), splits(1))
 
##2.2 设置随机森林参数并训练模型
 在RandomForest.trainClassifier中对随机森林模型进行训练，将训练后模型的结果返回到model里面。在训练随机森林模型前对参数的设置如下:
 
 
 
numClasses：表示一共分为多少个类。
 categoricalFeaturesInfo:为空，表示所有的特征为连续型变量
 numTrees:表示随机森林里面包含的决策树的个数
 featureSubsetStrategy:表示特征子集的选取方式。
 impurity:“entropy”表示纯度的计算方式采用信息熵的方式计算。
 maxDepth:表示数的最大深度为10
 maxBins:表示最大装箱数为32
 
 
val numClasses = 13
val categoricalFeaturesInfo = Map[Int, Int]()
val numTrees = 100
val featureSubsetStrategy = "auto" // Let the algorithm choose.
val impurity = "entropy"
val maxDepth = 10
val maxBins = 32
val model = RandomForest.trainClassifier(trainingData, numClasses, categoricalFeaturesInfo,
  numTrees, featureSubsetStrategy, impurity, maxDepth, maxBins)
 
##2.3 计算正确率和召回率
 函数功能:在Spark API中给出的MulticlassMetrics文档显示，建立一个MulticlassMetrics使用RDD作为参数传入，在RDD中是保存了一个两个Double类型的数据，其中第一个表示预测的结果，第二个表示标签的结果。
 
传入参数:model: RandomForestModel, data: RDD[LabeledPoint]其中model表示训练出来的随机森林模型，data用来表示测试数据集合。
 
返回结果:返回一个MulticlassMetrics的实例对象，用来计算整个数据集合的准确度和不同类的准确度。
 
  def getMetrics(model: RandomForestModel, data: RDD[LabeledPoint]): MulticlassMetrics = {
    val predictionsAndLabels = data.map(example => (model.predict(example.features), example.label))
    new MulticlassMetrics(predictionsAndLabels)
  }

 
在下述的代码中，我们通过对每一个类求出precision的值recall的值存放在recall中。
 
  val metrics = getMetrics(model,testData)
  //计算精确度(样本比例)
  val precision = metrics.accuracy;
  //计算每个样本的准确度(召回率)
  val recall = (1 to 11).map(     //DecisionTreeModel模型的类别号从0开始
    cat => (metrics.precision(cat), metrics.recall(cat))
  )
 
#3. 实验结果
 我们通过下述代码输出实验结果。
 
def main(args: Array[String]) {
    println("========================================================================")
    //精确度(样本比例)
    println("精确度: " + precision)
    println("========================================================================")
    //准确度(召回率)
    println("准确度: ")
    recall.foreach(println)
    println("========================================================================")
    println(" 运行程序耗时: " + castTime/1000 + "s")
  }
 
运行程序得到的实验结果如下图所示。