孜孜不倦——孜孜：勤勉,不懈怠.指工作或学习勤奋不知疲倦.孜孜不辍——勤勉从事,努力专一,不肯停息.废寝忘食——废：停止.寝：睡觉.忘：忘记,食：吃饭.顾不得睡觉,忘记了吃饭.形容很刻苦,专心致志.宵衣旰食——宵：夜间；衣：穿衣；旰：天已晚.天不亮就穿起衣来,时间晚了才吃饭.形容为处理国事而辛勤地工作.勤学不辍——不间断学习,形容学习努力刻苦.不辞劳苦——辞：推托；劳苦：劳累辛苦.不逃避劳累辛苦.形容人不怕吃苦,毅力强.专心致志——致：尽,极；志：意志.把心思全放在上面.形容一心一意,聚精会神.夜以继日——晚上连着白天.形容加紧工作或学习.业精于勤——业：学业；精：精通；于：在于；勤：勤奋.学业精深是由勤奋得来的.宵衣旰食——宵：夜间；衣：穿衣；旰：天已晚.天不亮就穿起衣来,时间晚了才吃饭.形容为处理国事而辛勤地工作.枵腹从公——枵腹：空腹,肚饥.指饿着肚子办公家的事.形容一心为公.专心致志——致：尽,极；志：意志.把心思全放在上面.形容一心一意,聚精会神.兢兢业业——兢兢：形容小心谨慎；业业：畏惧的样子.形容做事谨慎、勤恳.夜以继日——晚上连着白天.形容加紧工作或学习.孳孳不息——孳孳：同“孜孜”,努力不懈的样子.形容工作勤奋,努力不懈持之以恒——持：坚持；恒：恒心.长久坚持下去.
谢谢夸奖，还有很多不足，要更努力才行
1、她工作认真，负责；工作认真负责，爱岗敬业，服从整体安排，形象良好；对本职工作兢兢业业，锐意进取，乐于助人，关心同仁，与同仁相处融洽，善于合作，起带头作用。
2、该同仁今年工作成绩进步大，工作认真，业务知识扎实，业绩发展迅速，工作态度端正，遵守公司规章制度，能积极完成公司的任务。
宝剑锋从磨砺出，梅花香自苦寒来。
踏踏实实做事，堂堂正正做人。
天道酬勤。励精图治，自强不息。
勤奋是成功之本。一分耕耘 一分收获。
业精于勤荒于嬉，行成于思毁于随。
1、从来没有白费的努力，踏实也没有成功的机会，刻苦只要你认真对待工作，工作总有一天，句子你的每一次努力都会是华丽的。
2.生活总是公平的，心态你未来的样子，正能量藏在你现在的努力中。有计划的生活真的会比稀里糊涂精彩一万倍。每一个新的一天，文案请勇敢去尝试，踏实拼命去追求。
踏实刻苦工作的句子 工作心态正能
3.和什么样的人在一起，刻苦就会有什么样的生活。与勤奋的人在一起，工作你不会懒惰；与积极的人在一起，句子你不会沮丧；与优越的人在一起，心态你可以达到顶峰。
4.不是每个贝壳都有珍珠，正能量但是珍珠一定要出现在贝壳里，文案不是每个努力的人都会成功，踏实但是成功的人一定要努力！
为君聊赋今日诗，努力请从今日始
《今日诗》
明 · 文嘉
努力尽今夕，少年犹可夸
《守岁》
宋 · 苏轼
勿为新婚念，努力事戎行
《新婚别》
唐 · 杜甫
他工作非常勤奋，每天都是第一个来工厂，然后最后一个走，非常积极上进
爱国的句子大全
1、祖国在中是崇高美丽祖国像一颗闪耀的明珠屹立在世界东方。我为祖我为祖国祝福，您永远在我心中！
2、爱国首先要时刻维护祖国的尊严，不是空口号，而是要从自己的一点一滴做起。爱国不是排外，而是要睁眼观世界。
3、青少年要为建设祖国，为中华崛起而努力。爱国要继承中华民族优秀传统，弘扬中华文化。
4、历朝历代，许多仁人志士都具有强烈的忧国忧民思想，以国事为己任，前仆后继，临难不屈，保卫祖国，关怀民生，这种可贵的精神，使中华民族历经劫难而不衰。热爱祖国的山河，热爱民族的历史，关心祖国的命运，在危难之时英勇战斗，为祖国捐躯，都是爱国主义的表现。
5、爱国，什么是爱国？爱国是用心说的，爱国又是一种崇高的感情。
6、在爬满金文的钟鼎之上，读祖国童年的灵性；在布满烽火的长城之上，读祖国青春的豪放；在缀满诗歌与科学的大地之上，读祖国壮年的成熟……
7、给我自信的祖国，给我智慧与胆略的祖国。
8、唯有民族魂是值得宝贵的，唯有他发扬起来，中国才有真进步。
9、升旗仪式结束了，我深深感到祖国与我们贴得很近。我鼓足了劲头，大步向教室跑去，又开始了一天新的“长征”……
10、五星红旗是祖国的象征，不管风云怎样变幻，我们对祖国的眷恋矢志不移，如果对着千百种选择，我们会毫不犹豫地扑人你的怀抱。
用你的风雨之声做语言，用你的自然之形做文字，以你的土地做肤色，以你的五岳做骨骼，选择你的辛劳当痛苦，选择你的幸福当快乐。国旗，我们永远的信念！
工作勤奋是人生成功的基石,也是实现梦想的关键。历代名人学者都曾对此有过深刻的阐述和总结,为我们提供了宝贵的人生智慧。让我们一起来欣赏一些关于工作勤奋的名言警句,从中汲取前进的动力和力量。
勤奋是一种积极向上的工作态度和生活状态,是通往成功的必由之路。正如富兰克林所说:"没有什么可以代替勤奋,勤奋是成功的唯一保证。"勤奋工作不仅能提高工作效率,增加收入,还能培养良好的品德,增强自信心,实现人生价值。
著名企业家马云曾说:"成功没有捷径,唯有勤奋工作才能实现梦想。"他强调,只有通过不懈的努力和奋斗,才能在激烈的竞争中脱颖而出,获得应有的成就。
对于工作,我们应该保持积极乐观、主动进取的态度。爱因斯坦说过:"我没有特殊的才能,我只是对工作充满热情而已。"这句话告诉我们,只要对工作充满热情,即使没有特殊的天赋,也一样能取得出色的成就。
同时,我们还要保持恒心和毅力。正如罗斯福所说:"成功往往需要耐心和毅力,而不是天赋。"只有坚持不懈地努力,即使遇到挫折和困难,也能最终战胜它们,实现自己的目标。
对于工作,我们不仅要付出辛勤的汗水,更要追求精益求精的境界。孔子说过:"知之者不如好之者,好之者不如乐之者。"这说明,我们不仅要热爱自己的工作,更要乐在其中,将工作视为生活的一部分,从而获得更大的成就感和幸福感。
同时,我们还要保持谦逊的态度。正如牛顿所说:"如果我看得更远,那是因为我站在巨人的肩膀上。"这说明,我们的成就离不开他人的帮助和支持,应该保持谦逊的态度,虚心向他人学习。
总之,勤奋工作是通往成功的必由之路,是实现人生价值的关键所在。让我们以这些名人的智慧为指引,以积极进取、恒心毅力、精益求精的态度,在工作中不断进取,在人生中不断成长。
感谢您阅读这篇文章,希望这些名人的名言警句能为您的工作和生活带来启发和动力,助
之前看了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());
}
}
