2.结束了忙碌的一天，你的灵魂也该回家了
应该服从护士长安排，有困难要克服，
1.每天的生活都是一种无穷无尽的加班，为了完成收费任务，每天都在加班，让我感叹一切都是生活当中的不尽人意，到处为了自己的工作去碰钉子！
2.生活当中没有让自己得到更多的完美，为了让自己完成收费任务，真的是每天都在拼命的加班，期待着自己早日完成任务，不辜负领导对我们所有的信任，让我们早日完成自己的工作！
一些部门的加班申报时数会在当月10号之前签核完成，
一些会delay在25号之后，
最终的实际加班考勤时数，
以最终签核档为准，
需要大家注意的是，
月底不要忘记提报补录，
有经常过时效性的案例，
与切身薪资相关，
大家切勿忘记。
对于我们所有的打工人而言，都是为了完成目标而坚持加班很多的时候，其实我们也已经到了一个极限，也感觉身心疲惫，但是为了最终的这个目的，每一个人都在咬牙坚持，可能这就是我们努力的样子，趁着年轻我们想要去拼搏，努力，这样才能给我们创造更优越的条件。
所以才有了现在996～10107的恶习。
加班是每个职场人士都会面临的现实问题。许多公司为了鼓励员工加班，会提供加班补贴和加班工资。在本篇文章中，我们将深入了解加班补贴和加班工资，以及与之相关的一些重要事项。
加班补贴是指公司根据员工加班的时间和数量，额外支付给员工的补贴费用。加班补贴的数额可能会因公司政策、员工级别以及加班时段的不同而有所变化。
加班补贴的目的是激励员工积极参与加班工作。对于员工来说，加班补贴不仅是对努力工作的一种奖励，也能缓解一些因加班而带来的额外负担。
加班工资是员工在超出正常工作时间工作时所获得的额外工资。根据劳动法的规定，加班工资一般为正常工资的一定倍数，通常是1.5倍或2倍。
加班工资的计算方式是将超出正常工作时间的每小时工资按照相应倍数进行计算。例如，如果员工的正常工资为每小时100元，根据公司政策，加班工资为正常工资的1.5倍，那么员工每小时的加班工资为150元。
加班补贴和加班工资是两种不同的概念，但它们在鼓励员工加班方面有着一定的联系。
加班补贴主要是针对员工加班所支付的费用，是一种固定的金额或按比例计算的费用。而加班工资是对员工额外劳动所支付的工资，是根据具体的加班时长和工资倍数进行计算。
通常情况下，公司会同时提供加班补贴和加班工资，以鼓励员工参与加班工作。加班补贴可以作为一种额外的补偿方式，而加班工资则是对员工劳动所应得的报酬。
加班补贴和加班工资对于员工来说都具有重要的意义。
对于员工来说，加班补贴是对他们付出的努力和时间的一种认可和奖励。完成工作目标并且为公司做出贡献需要员工付出额外的努力，加班补贴可以提高员工的工作动力和满意度。
同时，加班补贴也可以帮助员工缓解因加班而带来的一些额外负担。加班通常会影响员工的生活、休息时间和家庭生活，适当的加班补贴可以帮助员工调整工作和生活的平衡。
而对于公司来说，提供加班补贴和加班工资可以激励员工积极投入工作，增强员工的工作态度和效率。在紧急情况下，员工的加班工作也能够保证公司的正常运转。
虽然加班补贴和加班工资有着重要的作用，但在实际操作中还存在一些问题需要注意。
加班补贴和加班工资是许多公司为了鼓励员工加班而提供的激励措施。加班补贴是对员工加班时间和数量额外支付的费用，而加班工资是员工在超出正常工作时间所获得的额外工资。
这两者虽然有所区别，但都对员工和公司具有重要的意义。加班补贴和加班工资可以激励员工积极工作，提高员工的工作动力和满意度。
然而，在提供加班补贴和加班工资时需要注意制定合理的标准和及时支付，同时也要确保加班时长和加班工资的统计和记录的准确性和透明度。
加班是一种常见的工作情况，加班补贴和加班工资不仅是员工的权益，也是公司管理的重要方面。通过合理的政策和制度，能够保障员工的权益，增强员工的工作积极性，推动公司的发展。
刚入职没完成业绩，可以加班，也可以不加班。
如果对这份工作比较重视，非他不可，那业绩对自己的去留是有影响的，为了能在单位站住脚，需要比别人更努力工作，周六可以选择加班来促进业务提升。
如果对这份工作无所谓，可有可无，本身也不是很喜欢，那即使没完成业绩，也可以不加班。
加班和不加班辩论赛
加班一直以来都是一个备受争议的话题。在这个快速发展的社会中，许多人面临着工作压力和时间限制，并常常需要加班才能完成任务。然而，有些人坚决反对加班，并主张工作和生活应该保持平衡。为了探讨这个问题，我们将进行一场加班和不加班辩论赛。
首先，加班可以增加工作效率。有时候，工作难以在规定工作时间内完成。通过加班，员工可以有更多的时间专注于工作，从而提高工作质量和效率。
其次，加班可以展现员工的敬业精神和责任心。在竞争激烈的职场中，加班可能是升职加薪的一种方式。通过额外的努力和时间投入，员工可以展示他们对工作的热情和忠诚，从而为自己争取更好的职业发展机会。
另外，加班还可以加强团队合作和沟通。当团队面对紧急工作时，加班可以减少延误和错误。同事们可以一起努力，相互支持，加快工作进度并取得更好的结果。
然而，反对加班的人认为工作和生活应该保持平衡。过度的加班会导致员工身心疲惫，影响健康和家庭生活。
他们认为，高质量的工作不仅仅取决于时间投入，更取决于工作质量和创造力。过多的加班可能导致员工疲惫和缺乏创造力，从而降低工作质量。
此外，反对加班的人强调工作和生活的平衡对个人幸福和满意度的重要性。过度加班可能意味着牺牲与家人、朋友和个人兴趣的时间。一个快乐和健康的生活是成功的关键。
综上所述，在加班和不加班的辩论中，双方观点都有一定的道理。加班可以提高工作效率、展示个人敬业精神和团队合作能力，但也可能导致身心疲惫、影响健康和生活平衡。
关键在于找到适合自己的工作和生活平衡点。每个人都应该根据自己的情况和价值观来决定是否加班。重要的是，无论选择加班还是不加班，都要认识到工作只是生活的一部分，我们应该追求更全面的幸福和成功。
之前看了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());
}
}
