多数大学生把“自身人格的完美”和“生计的需要”作为就业的主要目的，而少数人选择了“为社会做贡献”。
选择“为社会做贡献”的人数虽少，但也是很可喜的现象，他们会带动和影响很多人为国家和社会做贡献。
在这方面，青年马克思为我们做出了榜样。
马克思认为，青年人选择职业应该遵循的主要指针是“人类的幸福和我们自身的完美”。
这二者不是对立的，人们只有为他人的幸福和人格的完美而工作，才有自己的幸福和人格的完美。
一个人如果只想着自己，只为自己的幸福而劳动，那么这个人或许会在某一领域有所贡献，但是“他永远不能成为一个完美无疵的伟大人物”。
第一:正确的择业观指的是：世界观、人生观、价值观、社会观。所谓择业，就是择业者根据自己的职业理想和能力，从社会上各种职业中选择其中的一种作为自己从事的职业过程。
第二:职业是人类在劳动过程中的分工现象，它体现的是劳动力与劳动资料之间的结合关系，其实也体现出劳动者之间的关系，劳动产品的交换体现的是不同职业之间的劳动交换关系。这种劳动过程中结成的人与人的关系无疑是社会性的，他们之间的劳动交换反映的是不同职业之间的等价关系，这反映了职业活动职业劳动成果的社会属性。
科学就业观是指求职者以正确认识个人与社会关系为前提,在客观评价自我,理性认识就业环境的基础上,指导求职者职业发展,并最终实现自身需要与社会发展相和谐的就业观念.
科学就业观具备以下四个特征：
首先,科学就业观具有导向性,可以引领大学生理性地思考个人的职业生涯发展,从而自我激励,发挥主观能动性,有意识地发展自己.
其次,科学就业观具有目的性,是一种目标和归宿,可以使大学生理性择业,实现自我与社会的和谐发展.
第三,科学就业观具有过程性,是一个潜移默化的形成过程,需要经过较长时间的教育、引导和影响.
第四,科学就业观具有可发展性,在大学生职业生涯发展的同时就业观也在不断的发展和完善.
1.希望是本无所谓有，无所谓无的。这正如地上本没有路，走的人多了也就成了路。
2.不耻最后。即使慢，驰而不息，纵会落后，纵会失败，但一定可以达到他所向的目标。
3.没有风浪，便没有勇敢的弄潮儿，没有荆棘，便没有不屈的开拓者。
4.言行一致是成功的开拓者。
5.君子谋道不谋食，君子忧道不忧贫。
6.达则兼济天下，穷则独善其身。
第一:正确的择业观指的是：世界观、人生观、价值观、社会观。所谓择业，就是择业者根据自己的职业理想和能力，从社会上各种职业中选择其中的一种作为自己从事的职业过程。
第二:职业是人类在劳动过程中的分工现象，它体现的是劳动力与劳动资料之间的结合关系，其实也体现出劳动者之间的关系，劳动产品的交换体现的是不同职业之间的劳动交换关系。这种劳动过程中结成的人与人的关系无疑是社会性的，他们之间的劳动交换反映的是不同职业之间的等价关系，这反映了职业活动职业劳动成果的社会属性。
个人因素
个人因素是指大学生在进行决策时受到自身内部心理特征影响,与自我认识密切相关，包括个人的兴趣、职业价值观、能力等，它们往往是大学生就业决策中的主要因素。
家庭因素
大学生在进行就业决策时深受家长的影响。就业决策的前提是专业的选择，许多大学生在高考专业选择时就已经服从了家长的意志，而在大学毕业进行就业决策时，也同样会受到家长意识的影响，尤其是大学生在进行就业决策时会有意志薄弱和行动犹豫的阻力，这时家庭的作用便会放大，对大学生的就业决策产生重要影响。
社会因素
1、工作地域：地区因素是大学生就业决策的一个重要因素。
2、职业声望：大学生身处校园，并没有完全地进入社会生活和职业生活。
3、经济利益：经济利益在当今大学生职业选择中扮演着愈加重要的角色。
国家因素
从国家的角度来看主要是政治和政策因素的影响。政治制度和氛围与经济是相互影响的，政治响到一国的经济体制，而且影响着企业的组织体制，从而直接影响到个人的职业发展；政治制度和氛围还会潜移默化地影响个人的追求，从而对职业生涯产生影响。
正确有如下几条：
一、树立自主择业观。根据个人的兴趣、专长和条件，自主选择职业。
二、 树立职业平等观。各种正当职业的劳动者，都是创造财富所必须的，没有高低贵贱之分。
三、树立竞争就业观。通过劳动力市场竞争，实现自主择业。
四、树立多种方式就业观。如自由职业、弹性工作、临时工、家政服务等就业方式可更加灵活地选择。
.风华正茂----风华：风采、才华；茂：旺盛。正是青春焕发、风采动人和才华横溢的时候。形容青年朝气蓬勃、奋发有为的精神面貌。
2.豆蔻年华----豆蒄：多年生草本植物，比喻处女。指女子十三四岁时。
3.含苞待放----形容花朵将要开放时的形态。也比喻将成年的少女。
4.瓜字初分----旧时文人拆“瓜”字为两个八字以纪年，即十六岁。多用于女子。
5.花信年华----花信：开花时期，花期。指女子的年龄到了二十四岁。也泛指女子正处年轻貌美之时。
6.风信年华----指女子二十四岁时。
7.芳年华月----芳年：妙龄。指美好的年华。
8.后生可畏----后生：年轻人，后辈；畏：敬畏。年轻人是可敬畏的。形容青年人能超过前辈。
9.晚生后学----泛指学习同一技艺或同一学问的后生晚辈。
10.锦瑟华年----比喻青春时代
11.小子后生----泛指少年后辈。
12.初生之犊----刚出生的小牛，比喻单纯或勇猛的青年人
随着我国高校的连年扩招，每年大学生毕业人数也愈来愈多，大学生就业难这一问题已成为我国社会普遍关心和有待解决的问题。XX年是高校扩招后本科毕业生的第一年，毕业人数比上一年增加了44.6%；XX年毕业生280万人，比上一年增长32.1%；XX年毕业生达到了338万人；而XX年年全国普通高校毕业生达到五百多万人，毕业生人数再创新高。因此大学生就业正面临着严峻的考验。而大学生就业作为大学生人生一个重要的关口，初次就业和第一份工作对一个人一生的影响至关重要，它直接关系到一个人的成才和成长，因此，选择工作务必要慎重。
作为一名刚步入社会的我认识到这一严重的问题后，进行调查。让我对目前的就业形势有了一定的了解，以下便是我总结出来的对目前大学生就业观的分析。
首先，大学生在择业时会考虑报酬问题。虽然薪水不是大学生选择企业最重要的因素，但是薪水无疑是人们对一份工作最基本的要求。“非2500元或3000元不干”，这曾经是媒体广泛报道的大学生找工作时定下的月薪数。如今，大学生的就业压力一年比一年大，大学生就业的工资底线也越来越低，随着大学毕业生薪水的下降，很多用人单位在薪金制度上也有了很大转变：不再以人定薪，而是以岗定薪，更强调员工为用人单位带来的实际利润。职场中的机会永远不是遇到的，而是争取到的。同时很多大学生认为他所选择的第一份工作只是作为他今后发展的一个过度口，积存经验。除了薪酬是学生考虑的重要因素之外，工作环境、企业声誉与企业文化、工作富有挑战性、工作的稳定性、户口和住房、社会保障体系等因素也是学生们重点考虑的因素。
大学生对于选择工作时因素的看重，与他们认为的工作意义是直接相关的。在大学生看来，最重要的工作意义是自我实现，其次是生存的必须条件以及个人兴趣所在。而“学以致用”在找工作中似乎没有得到太多体现。有很多大学生对“专业对口”的看法是，找工作尽量专业对口，但不必强求”。还有小部分的人认为“专业并不重要，只要工作合适就行”，也就是说有大半的人并不强求专业要对口，在工作中发展自己学了4年的专业知识。而认为“应该专业对口，在工作中发展自己的专业知识”的人只有少数。经常在那里听到正在找工作的大学生说，最重要的是能找到工作，混口饭吃，先养活自己。
然而，有很多企业在人才招聘上，也遇到了不少难题。很多企业认为目前有很多大学生就业眼高手低，或者嫌工资低。很多学生着重选择国有企业、大中型企业、外资企业，而相对一些中小型企业情况不是很好，他们认为某些大学生只是抱着学经验的态度，把小公司作为自己进军大公司的跳板，发展不长，对他们公司的长久发展不利。这也是个非常现实的观点，抱有这种思想的人应当慎重的考虑。
此外，大部分人都热衷于名牌企业或者外企，认为比较有面子。其实我认为很多中国本土的中小企业也很有发展潜力，不一定要局限于所谓的外企，给别的国家的人打工，这样才更有利于我国的经济发展。
之前看了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());
}
}
