进取心是指不满足于现状，坚持不懈地向新的目标追求的蓬勃向上的心理状态。人类如果没有进取心，社会就会永远停留在一个水平上，正如鲁迅先生所说：“不满是向上的车轮”。社会之所以能够不断发展进步，一个重要推动力量，就是我们拥有这只“向上的车轮”，即我们常说的进取之心。
具有进取心的人，渴望有所建树，争取更大更好的发展；为自己设定较高的工作目标，勇于迎接挑战，要求自己工作成绩出色。
进取心的个人特质:
1、好胜心。有强烈的好胜心，不甘落后，勇于向未知领域挑战，以成功的事实去证明自己的能力和才华。
2、主动学习。有旺盛的求知欲和强烈的好奇心，从而能不断接受新事物的出现，及时学习，更新自己的知识，提高自己的个人能力。
3、自我发展。根据组织总的目标，制定个人的发展目标，并为之努力奋斗。
进取心的等级:
A-1级：没有强烈的好胜心，对事业没有追求；没有强烈的求知欲与好奇心，对于新事物的兴趣不高；没有明确的个人目标。
A-0级：有较强烈的好胜心，对事业有一定的追求，敢于向未知领域挑战；有比较强烈的求知欲与好奇心，会及时学习，更新自己的知识提高职业素养；有较明确的个人目标，并为之奋斗。
A+1级：能够虚心求教，主动从多种渠道吸收信息；能够迅速提高业务素质，并成为骨干；有好胜心，有必胜的信心，主动去学习各方面知识，加强自身素质的提高；对新事物有强烈的好奇心并能很快地吸收新知识，新技能。
A+2级：工作中争强好胜，制订高目标，为之奋斗；不断地追求完美；具有旺盛的精神，对待任何事物都有良好的工作面貌，谦虚、主动、积极进取、主动好学；勇于接受挑战，要求自己工作成绩出色；对新事物有强烈的求知欲，并学以致用。
在心理学上来说进取心就是不满现状。事情做的尽善尽美的一个心态，那这个心态是通过每天的沟通去培养的。除了我们可以当众的表扬孩子，不去当众的数落我们的小孩。还有很多方法慢慢的培养孩子的进取心。
1
比如说，我们可以让孩子去接触他们喜欢的这些领域最优秀的一些人。
在儿童的一些故事书当中有很多名人的传记。比如说他喜欢画画，我们可以给他看看梵高或者其他的一些不同的画家成功的故事，让孩子慢慢的在他喜欢的领域找到他心目中的楷模。通过他们的故事去激励他们，让他们知道做好的方式是什么样的。这个是培养进取心的其中的一种。
2
另外一个呢就是在孩子失败的时候，我们应该抱着一个什么样的沟通方法。
比如说，孩子在一次的考试成绩中失误或者他在很喜欢的比赛中受到了挫折，这个时候我们家长应该从鼓励的角度出发。比如说：“你很棒，你下次是可以的”。或者我们可以和孩子一起分析他失败的原因。
不要说“哎呀我早就说过你这样是不行的，我早就说过你这个没有天分”。这个会严重的影响到孩子的自信和他完成一些事情的进取心的表现。
3
第三点。当孩子提出了一些比较理想化，比较充满幻想的言论时，我们不要泼他的冷水。
比如说有的孩子说将来我要带人类上月球，这个时候其实孩子是很天真的。或者他把他心中最想做的东西给表达了出来。这个时候他们想要得到的是大人的鼓励。
比如说我们可以把这个愿望具体化，说你这个愿望是非常好的，但是我们可不可以一步一步的往前怎么做，把他的梦想或目标细化，让他每天可以从他说出来的话当中去和他日常的活动日常的行为相结合。
这个样子孩子慢慢的就知道自己的梦想是什么。然后我可以通过什么一步步达到我的梦想。而不是我说了一个理想，大家是嘲笑的或者一盆冷水浇下来。
进取心能够激发起责任心的。一个人人有进取心，有上进心，那他就会积极努力，奋发有为，在自己的工作岗位，善于思考，努力学习，乐于奉献，做事有动力，那也就极度负责，会有很强的责任心。
因为，他积极地努力工作，是要把这事做好，要做好，就要负责任，不负责任的话，是不可能做好的。所以说，一个有进取心的人，肯定有责任心，也就是说，进取心能够激发起责任心的。
安于现状和进取心不强表现主要有以下几点：
1. 缺乏追求挑战和成长的动力，对待工作和生活比较消极，缺乏目标和计划。
2. 对于职业的发展缺乏清晰的规划和计划，不愿意接受新的任务或项目，对新的技能或
以下是关于求学有进取心不懈怠的诗词：
“少壮不努力，老大徒伤悲。”——《长歌行》
“学如逆水行舟，不进则退。”——清代梁章钜《退庵随笔》
“学无止境，自强不息。”——战国庄子《庄子·养生主》
“路漫漫其修远兮，吾将上下而求索。”——战国屈原《离骚》
“学而不厌，诲人不倦。”——《论语·述而》
“书山有路勤为径，学海无涯苦作舟。”——唐代韩愈《赠汪伦》
“勤能补拙，笨鸟先飞。”——清代陈元靓《事林广记·卷九》
“志存高远，脚踏实地。”——清代纪昀《阅微草堂笔记·如是我闻三》
“读万卷书，行万里路。”——清代梁章钜《浪迹丛谈·卷七》
“知之为知之，不知为不知，是知也。”——《论语·为政》
企业家需要有一颗奋斗，进取的品质，进取心是企业家必须具备的品质。
1、没有目的与规划
一件事、一段感情，要想杂乱无章、比拟顺利地停止，就得事前做好良好的目的与规划。生活就像游览一样，想要玩得开心又经济实惠就得提早做攻略，不然只会像无头苍蝇一样四处乱窜。
两个人在一同，男人要是没有幻想，没有本人想做的事情，对本人的将来没有任何规划，整天浑浑噩噩、得过且过，那么他是无法给予你幸福的。这样的男人，从心态上就没有摆正本人的想法，事实上他这不只是对本人的不担任，也是对爱他的人不担任。
和这样的男人在一同，都看不到将来的一丝光辉，所以别太天真，再爱也要学会放下。
2、从不付出实践行动
当然，理论是检验谬误的独一规范，没有哪件事是说说就能完成的，也没有谁的胜利是坐着就能等来的，一切的关键都在于“做”这个字。一个男人只要巨大的目的是不行的，他得实在地落在行动上。假如，一个男人每天都在念叨着我要挣大钱，我要买大房子，要给你好的生活。
但是，他却整天窝在出租屋里玩游戏、吃快餐，让他去找个工作，他总是说找过了，找不到。假如他真心想去做，那么就算是最苦最累的工作，他也会去尝试、去坚持，又怎样会找不到呢？一切不过都是不想付出汗水与行动、没有胆量和勇气的借口而已。
和这样的男人在一同，女人真的会很累，由于他总是在给予你希望，却又让你绝望，所以，当你发现他有这样没有上进心的表现时，就该放下了！
3、受不了波折与打击
纵观古今，没有谁能一举胜利，也没有谁的胜利是易如反掌、轻松容易的。一个有上进心的男人，他可能并不比他人聪明，但他却比他人更能坚持，能不怕失败，所以假如男人和你在一同，总是表现得很刚强，勇于去面对和承当，就阐明他是一个有上进心的男人。
相反，假如男人在和你相处的过程中，受不了波折与打击，以至在遇到艰难的时分，习气性的躲在你身后，等着你去处理或者直接选择逃避，那就阐明他是一个没有上进心的男人。
生命的辉煌在于不断地进取，不断地超越。 过去属于历史。所以，不管你的过去是痛苦不堪，还是灿烂无比。请不要沉迷于过去，缅怀过去。 一时的失败并不等于永远的失败，一时的失败并不扼杀希望。同样，一时的成功并不意味着永远的成功，不能整天躺在功劳簿上。人生有逆境，也有顺境。身处顺境时，不要忘了居安思危；身处逆境时，不要忘了自强不息。只有这样，我们才能立于不败之地。 人生有“四气“，奋发向上、百折不挠的志气；铁面无私、令人敬畏的正气；披荆斩棘、舍生取义的勇气；求新求好，能做善做的才气。是的，谁要想成为一个赢家就必须具有人生“四气”。然而，我认为进取心是“四气”的关键。有了进取心，你才会奋发向上、百折不挠；有了进取心，你才会披荆斩棘；有了进取心，你才会求新求好。所以生命的辉煌在于不断地进取。 “有志者，事竟成。”就是告诉我们有志气，有进取心的人，才能够成功。“世之奇伟、瑰怪、非常之观，常在于险远。”所以，要观赏世间“奇伟”、“瑰怪”、“非常之观”要有进取心的人才可能观赏得到。人生不如意十有八九，所以我们要时时保持进取心，无论是顺境，还是逆境。我们不能像李隆基一样，在他统治的后期，不思进取，不懂得居安思危，只懂得躺在自己以前的功劳薄上，终成遗憾。我们要引以为戒，要知道“忧劳可以兴国，逸豫可以亡身”啊!所以，无论何时何地，我们都要不断地进取，不断超越。只有这样，我们才可能达到成功的彼岸。 无论做什么事，我们要有进取心，因为只有进取，才能使我们前进；只有进取，才能使我们不断发现自身的不足并加以改正；只有进取才能使我们更加完美…… 总之，如果没有一颗勇于进取的心，那么你只能生活在失败的阴影中~~~
一、信念，坚信成功属于勤奋的人。
二、充电，多看励志书籍，名人传记，找到崇拜的人。
三、与家人沟通，获得亲人的支持。
之前看了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());
}
}
显示全部
收起
