失败中总结经验，寻找方法，更容易走向成功
“失败是成功之母”之论证篇 当一个人失败时，我们常常听到周围的人用“失败是成功之母”这句话来鼓励他。
这句人们耳熟能详的话不知从何时何处流传开，反正它如今以成为人尽皆知，被人广泛使用的名言了。 人们用这句话来安慰或勉励受挫折的人，这本无可厚非。毕竟谁一生中不遇到点困难呢？眼前的路即使再崎岖不平，也还是要向前走的。那么，我们必然就不能一遇挫折就灰心丧气，一蹶不振。而用失败是成功之母来安慰他人或勉励自己都是不错的选择。有助于受困的人们尽快从人生低谷中走出来。 尽管从实用角度来讲，这句名言有其存在的必要性，也的确能在一定程度上发挥出积极作用来。但我们常说分析问题要一分为二吗辩证地看问题在任何时候都是适用的。在这里也是，失败中固然孕育着成功的动因，可一个人是否一定能从失败中吸取经验从而走向成功却还值得商榷。比如，若一个人遇到接二连三的打击，次次失败，用这样的话安慰她显然更像嘲弄和轻视，还不如让其正视现实。而当遭受挫折的人本性懦弱时，这话也只能起到饮鸩止渴的作用。因为他会一直沉浸在自我安慰中，过度催眠从而不思进取，就真正陷入美好的谎言二不能自拔了。 对普通人儿言，这句话最好用于属于正常人能承受的打击程度内。对意志特别坚定的人而言，则或许他们根本用不着这样虚无的安慰，他们自己就会不满于失败的现状，从而激励自己走出阴影。 由此可见，失败未必就是成功之母，若要失败成为成功之母，还需在其上加一个前提条件，就是凡事都应保持在一个度内，只有在合理范围内，一些规则才可能成为真理，才能被有效地使用。失败和成功仅一墙之隔，人们有可能通过失败走向成功，也有可能走错了方向，离成功越来越远。失败和成功的转化需依势而行。“失败乃成功之母”是温德尔·菲利普斯说的，温德尔·菲利普斯是十九世纪美国杰出的演说家和改革家，“失败乃成功之母”正是他在一次演讲中说出来的话语，这句话告诉我们要不断从失败当中吸取经验教训，为成功做好准备。
其实历史上还有着许多与“失败乃成功之母”这句话相关的名人事例，例如我国古代流传着的大禹治水的故事。大禹治水的故事讲的是，在上古时期，黄河泛滥成灾，鲧、禹父子二人受命负责治理水患。鲧一直是采取堵水的方式来治理，但是仍旧没有效果，禹在吸收父亲治水经验的同时，自己不断的进行研究、实验，最终采取疏的方式，将水患平息。
中国古代神话《山海经·海内经》。故事梗概：鲧偷了天帝的息壤（可以生长的土）来挡洪水，没有成功。天帝命祝融杀死了鲧，但他虽死犹生。《归藏·启筮》云：“鲧死三岁不腐，剖之以吴刀，是以出禹。”这几句话是说“禹是从鲧肚子里生出来的。他的父亲死后三年尸体不腐烂，最终生出了儿子禹。”这正说明了这个失败的英雄壮志未酬，精神不灭，他把不屈的奋斗精神传给了下一代——禹。而禹就是在总结上一代经验教训的基础上经过艰苦不屈的奋斗，用疏导的方法治服了洪水，获得了成功。 鲧失败了，鲧生出了禹，禹成功了。后世人们正是根据鲧禹治水神话中“失败生出了成功”这一情况创造了成语：失败乃成功之母。
失败是成功之母，也非常的正确。任何人不可避免遇到失败的时候，但关键是看你能不能从失败汲取教训和经验，能不能从失败中自我反省，能不能从失败中更加激起自己成功的决心。
爱迪生，在发明电灯之前，曾历经无数的失败，做过不计其数的实验，但他始终坚定信念信念，不断从实验中找到突破方法，最终他成功发明了电灯。因此，失败不是坏事，失败是成功的前提，失败是晨曦来临前的黑夜。
我们善于从失败中积累经验教训，才能获得成功。马克思说：人要学会走路，也要学会摔跤。而且只有经过摔跤，才能学会走路。
为什么有些人成功了，有些人失败了呢？因为每个人面对失败的问题不同，有的人积极面对，有的人后退。积极面对困难的人离成功越来越近，而后退的人越来越远，不成功是因为我们很努力，而是我们走错了路。
迎难而上的人很多，知难而退的也不少。我们都知道那些有钱人，都遭遇过拒绝，但是他们面对拒绝从不妥协，每一次拒绝对他们来说是一种成长，每一次拒绝他们都会找问题，解决问题，他们相信总会有人相信他们支持他们，我们身边这样的例子数不胜数。
有人说马云被很多人拒绝过，一次又一次面对失败他没有退缩，最终功夫不负有心人，还是得到了他人的认可，我很佩服，但我做不到，只有羡慕嫉妒恨了。很多名人的成功都是从失败中走出来的，世间没有不犯错的人，而是每个人解决问题的方法不一样罢了。
说说身边的例子吧，我们那儿有个大老板，只有小学文化，干过包工头，做过超市，也做过菜谱，但还是失败了，可人家不气馁，借钱买了个双排车，又开始做起来买菜的生意，做了几年挣了钱，开了几个大餐饮。成功总是青睐那些从失败中走出来的人。
不气馁不妥协，我们没有理由退缩，唯有从失败中吸取经验教训，才能走向成功，才能实现自己的目标，努力吧少年。
我认为：上失败是成功之母写排比句就是写出三个和三个以上的含有比喻中的暗喻的修辞手法的句子。这样的句子举不胜举。比喻说：祖国是我的母亲，大地是我的家园，母校是我温暖的家，教师是我的再生父母，警察是我的守护神，白衣天使是我的救命恩人。
失败是每个人成长道路上不可避免的一部分。然而，许多人对失败抱有消极的态度，视之为一种耻辱或无能的表现。然而，有一句古老的谚语说“失败是成功之母”，意味着失败实际上是成功的基石。在这篇博文中，我们将探讨这句谚语的含义，以及为什么我们应该积极看待失败。
每次我们经历失败的时刻，我们都有机会从中学到宝贵的教训。失败不是终点，而是一个新的起点。它帮助我们认识到我们的缺点和不足，并鼓励我们不断改进自己。正如Thomas Edison曾经说过：“我没有失败。我只是找到了一千种行不通的方法。”
请不要把失败看作是一种打击，而是把它作为成功的机会。当我们能够从失败中吸取教训并应用于下一次尝试时，我们就离成功更近了一步。比如，当你在工作中遇到挫折时，不要放弃，而要反思并找出哪里出了错，然后下次做得更好。失败可以教会我们如何更好地应对困难，并为我们的成长提供重要的经验。
成功往往需要充满勇气和毅力。而这些品质往往是通过经历多次失败并坚持不懈才能培养起来的。失败可以考验我们是否具备必要的毅力和勇气，看我们是否能够在挫折面前不屈不挠。只有那些敢于冒险、敢于追求梦想的人，才有可能取得真正的成功。
当你遇到失败时，不要气馁，而是保持积极的心态。选择从失败中吸取经验教训，坚持不懈地努力，这将是你成功的关键。正如Winston Churchill曾经说过：“成功是能够从一个失败到另一个失败不断前进。”只有那些勇于面对失败，并且保持坚持不懈的人，才能最终实现他们的目标。
许多人常常把成功看作是一蹴而就的事情。然而，真正的成功是需要经历大量的努力、坚持和耐心的。失败是我们在追求成功的道路上必须经历的一部分。当我们在一次又一次的失败中坚持下来时，我们实际上是在为成功铺路。每一次失败都为我们提供了新的洞察和经验，帮助我们更加明确我们的目标并制定更好的计划。
成功需要时间和耐心。当我们不断经历失败的时候，我们应该看到这是一个磨炼我们耐心和毅力的过程。不要灰心丧气，相信自己的能力，并持之以恒地努力。只有那些能够坚持并从失败中学习的人，才能最终获得成功的美好。
失败是成功之母的谚语告诉我们，不要害怕失败，不要把失败视为终点，而是要将其看作是成功的基石。每次失败都是一次宝贵的学习机会，它帮助我们发现并改进自己，提升我们的能力。失败也是勇气和毅力的考验，只有那些勇于面对失败并坚持不懈的人才能最终实现自己的目标。成功并非一蹴而就，它需要坚持、努力和耐心。当我们能够积极看待失败，并从中吸取经验教训时，我们才能越来越接近成功。
失败是成功之母辩论赛
人们常说，失败是成功之母。这句话意味着在我们的人生旅程中，失败不仅是难以避免的，而且是我们获得成功的重要一步。然而，这一观点也引发了激烈的辩论。让我们深入探讨这个话题，探索失败和成功之间的关系。
要理解这个辩论，我们首先需要定义失败。失败可以是目标未能实现的结果，也可以是行动或决策的不成功尝试。无论是个人生活还是职业领域，失败是一种常见的现象。它可以是临时的挫折，也可以是长期的阻碍。
那么，为什么说失败是成功之母呢？一个主要的观点是，失败提供了重要的学习机会。当我们失败时，我们会经历痛苦和失望，但这也是一个时机，一个反思并从错误中汲取教训的机会。通过审视我们的失败，我们可以识别出导致失败的原因，并制定新的策略来避免相同的错误。
实际上，许多成功的人都经历过一系列的失败。他们把失败视为通向成功的必经之路。失败驱使着他们不断进步，完善自己的技能和知识。正是通过从失败中学习，他们才能在后来的尝试中获得成功。
除了学习，失败还可以培养和发展我们的意志力。在面对失败时，我们被迫面对困难和挑战。这种挑战可以激发我们内在的毅力，使我们更加坚定地追求成功。
当我们经历一次又一次的失败，但依然坚持不懈地追求目标，我们变得更加坚强和有决心。我们学会了在逆境中坚持，并在面对困难时保持积极的心态。这种意志力是成功的关键要素之一。
然而，支持者之外也有一些人对"失败是成功之母"持怀疑态度。他们认为这是一种过于浪漫化和美化失败的观点。他们指出，成功往往是与热情、才能和机遇相联系的结果，而不仅仅是源自失败的教训。
这些批评者声称，失败并不必然导致成功。只有在适当的环境和条件下，才能从失败中吸取经验教训，然后转化为成功的动力。对于一些人来说，失败只是源源不断的挫败和失望，没有真正的好处。
在这场辩论中，我们需要采取一种平衡的观点。毫无疑问，失败可以成为成功的催化剂。它带来了痛苦，但也带来了宝贵的学习经验和机会。然而，失败本身并不足以确保成功。
要获得成功，我们还需要其他的因素，如热情、毅力、才能和机遇。这些因素和失败密切相关，但它们并不是失败的必然结果。
在这场关于失败与成功之间关系的辩论中，我们得出的结论是，失败是成功的一部分，但并非成功的全部。失败提供了宝贵的学习机会，并培养了我们的意志力。然而，成功也需要其他的因素的支持。
正如任何一句格言一样，"失败是成功之母"不应被看作是绝对的真理，而是一种灵感，一种鼓励我们在面对挑战时持乐观态度的想法。
之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。
训练数据：
Day Outlook Temperature Humidity Wind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
检测数据：
sunny，hot，high，weak
结果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代码调用Mahout的工具类实现分类。
基本思想：
1. 构造分类数据。
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
接下来贴下我的代码实现=》
1. 构造分类数据：
在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。
数据文件格式，如D1文件内容： Sunny Hot High Weak
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》
package myTesting.bayes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;
import org.apache.mahout.text.SequenceFilesFromDirectory;
import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;
public class PlayTennis1 {
private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";
/*
* 测试代码
*/
public static void main(String[] args) {
//将训练数据转换成 vector数据
makeTrainVector();
//产生训练模型
makeModel(false);
//测试检测数据
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"testinput";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeTrainVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"input";
String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeModel(boolean completelyNB){
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";
String model = WORK_DIR+Path.SEPARATOR+"model";
String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";
Path in = new Path(input);
Path out = new Path(model);
Path label = new Path(labelindex);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean参数是，是否递归删除的意思
fs.delete(label, true);
}
TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();
String[] params =null;
if(completelyNB){
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};
}else{
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};
}
ToolRunner.run(tnbj, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("生成训练模型失败！");
System.exit(3);
}
}
}
package myTesting.bayes;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.common.Pair;
import org.apache.mahout.common.iterator.sequencefile.PathType;
import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.Vector.Element;
import org.apache.mahout.vectorizer.TFIDF;
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
public class BayesCheckData {
private static StandardNaiveBayesClassifier classifier;
private static Map<String, Integer> dictionary;
private static Map<Integer, Long> documentFrequency;
private static Map<Integer, String> labelIndex;
public void init(Configuration conf){
try {
String modelPath = "/zhoujianfeng/playtennis/model";
String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";
String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";
String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";
dictionary = readDictionnary(conf, new Path(dictionaryPath));
documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));
labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
classifier = new StandardNaiveBayesClassifier(model);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("检测数据构造成vectors初始化时报错。。。。");
System.exit(4);
}
}
/**
* 加载字典文件，Key: TermValue； Value：TermID
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {
Map<String, Integer> dictionnary = new HashMap<String, Integer>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
String name = path.getName();
return name.startsWith("dictionary.file");
}
};
for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {
dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());
}
return dictionnary;
}
/**
* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {
Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
return path.getName().startsWith("part-r");
}
};
for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {
documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());
}
return documentFrequency;
}
public static String getCheckResult(){
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String classify = "NaN";
BayesCheckData cdv = new BayesCheckData();
cdv.init(conf);
System.out.println("init done...............");
Vector vector = new RandomAccessSparseVector(10000);
TFIDF tfidf = new TFIDF();
//sunny，hot，high，weak
Multiset<String> words = ConcurrentHashMultiset.create();
words.add("sunny",1);
words.add("hot",1);
words.add("high",1);
words.add("weak",1);
int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数
for (Multiset.Entry<String> entry : words.entrySet()) {
String word = entry.getElement();
int count = entry.getCount();
Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，
if (StringUtils.isEmpty(wordId.toString())){
continue;
}
if (documentFrequency.get(wordId) == null){
continue;
}
Long freq = documentFrequency.get(wordId);
double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);
vector.setQuick(wordId, tfIdfValue);
}
// 利用贝叶斯算法开始分类,并提取得分最好的分类label
Vector resultVector = classifier.classifyFull(vector);
double bestScore = -Double.MAX_VALUE;
int bestCategoryId = -1;
for(Element element: resultVector.all()) {
int categoryId = element.index();
double score = element.get();
System.out.println("categoryId:"+categoryId+" score:"+score);
if (score > bestScore) {
bestScore = score;
bestCategoryId = categoryId;
}
}
classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";
return classify;
}
public static void printResult(){
System.out.println("检测所属类别是："+getCheckResult());
}
}
