发散思维是指一种非线性的思考方式，能够帮助个人或团队从不同的角度出发，拓展思路，寻找创新点。在现代社会中，发散思维被认为是培养创新能力的重要手段之一，因为它可以打破传统的思维定式，带来新的视角和解决问题的方法。
然而，要发挥发散思维的作用，一定程度上需要一定的条理性。所谓条理性，是指思维过程具有逻辑性、连贯性和系统性，确保想法不是孤立存在的，而是有机地连接在一起，构成完整的思维框架。
发散思维和条理性并不矛盾，相反，二者可以相互促进、相互补充。在创造性思维过程中，发散思维可以帮助人们跳出固有的思维模式，从不同的角度探索问题，产生新的观点和想法。
而条理性则可以帮助人们将这些新的想法有机地连接在一起，形成一个完整的逻辑链条，使得创新不再停留在零散的点子，而是能够转化为可行的解决方案。
要提高发散思维的条理性，首先需要培养系统思维能力。系统思维能够帮助人们将看似杂乱无章的信息有条理地整合和梳理，找出彼此之间的内在联系，形成更为全面和深入的理解。
其次，需要培养归纳与演绎能力。归纳是从个别到普遍的思维过程，能够帮助人们从具体的实例中总结出普遍的规律和原则；而演绎则是从普遍到个别的思维过程，可以帮助人们根据已有规律推断出未知情况的结论。
在当今竞争激烈的社会中，发散思维和条理性都是非常重要的思维方式和素质。只有将二者有机结合，才能更好地应对各种复杂问题和挑战，提高自身的创新能力和解决问题的能力。
条理性是有规矩、有逻辑、不混乱的性质。
条理泛指：事物的规矩性，条条是理（讲究章法，法则。），条条是道（讲道理）。
工作、做事要有条理性，这是我们经常听到的话语，它是工作、做事的一种状态，有条理性会让我们更好地进行工作，更好地完成工作，会让事情变得清晰明了、不混乱。
条理性是种思维方式，利于更好工作、更好学习。
条理性强是做事有逻辑思维，有步骤，有规矩、不混乱的性质。条理泛指：事物的规矩性，条条是理（讲究章法法则）、条条是道（讲道理）。
工作、做事要有条理性，这是我们经常听到的话语，它是工作、做事的一种状态，有条理性会让我们更好地进行工作，更好地完成工作，会让事情变得清晰明了、不混乱。条理性是种思维方式，利于更好工作、更好学习。
1．我将现有的一切做好，若还是被人误解，我只能说不好意思，我尽力了。以后做事绝不拖拉了！
2．我做事真是挺没有效率的，没什么时间概念，没什么条理性，总是拖拖拉拉，不能合理安排时间，分不清主次。
3．心情不好就想做事拖拖拉拉，也没人理我。
语言表达能力是现代人才必备的基本素质之一。在现代社会，由于经济的迅猛发展，人们之间的交往日益频繁，语言表达能力的重要性也日益增强，好口才越来越被认为是现代人所应具有的必备能力。
在人们的日常交往中，具有口才天赋的人能把平淡的话题讲得非常吸引人，而口笨嘴拙的人就算他讲的话题内容很好，人们听起来也是索然无味。有些建议，口才好的人一说就通过了，而口才不好的人即使说很多次还是无法获得通过。
1.坚持物归原处
“物归原处”看似简单，但是能够做到，也不是一件简单的事情，将这个动作作为一种习惯坚持下来就更不简单了。养成物品用后放回原处的习惯，不仅可以让身边的环境整洁有序，还能方便自己和家人对物品的使用。
2．多动手锻炼
有些事情其实很简单，并不是自己不会做、做不来，而是因为懒惰或依赖思想让我们失去了锻炼的机会。不要事事依靠父母，自己的事情最好自己做，像整理自己的书包、床铺等，慢慢来，从不会到会、从乱无头绪到井然有序，这是个动手锻炼的过程。
3．制订主次有序的计划
按照急切、重要、次要这三个层次，对要做的事情进行有效分类，再按照主次有序的原则将事情记到本子上，以达到对自己最好的提醒效果。
4.合理安排时间
把每天起床、睡觉、做游戏、看动画片、学习及家务劳动的时间都固定下来。什么时候该做什么、花多长时间去做、剩余的时间做什么、未能完成的工作什么时候做，都要有合理的安排。只有合理安排好时间，才能使学习和生活更有条理、更加顺利。
5．事后检查
如果养成良好的事后检查习惯，那么就可以弥补因为粗心造成的错误和疏漏，然后进行修改。这也是培养自己负责、独立自主精神的方式之
6．向长辈学习
平时多观察长辈是如何安排生活的，比如看妈妈洗衣服，都是先洗浅色的，再洗深色的，并且还会把容易掉色的衣服挑拣出来单洗等，这就是条理性。
在当今信息爆炸的时代，我们经常感到思维很发散没有条理性。这种情况不仅在日常生活中存在，更在工作中带来了一定困扰。如何培养思维的条理性成为了值得探讨的话题。本文将为您分享一些有效的方法和技巧，帮助您提高思维的条理性。
制定计划和目标是培养思维条理性的第一步。缺乏思维条理性往往源于没有清晰的目标和计划。通过设定明确的目标，您可以更有条理地思考和行动。可以使用笔记本或手机应用记录下自己的计划和目标，并定期回顾和更新。
将思维整理成框架有助于提高思维的条理性。可以使用思维导图工具，将复杂的思维内容组织成层次清晰的结构。思维导图可以帮助您将各个思维点连接起来，并更清楚地展示思维的逻辑关系。
缺乏逻辑思维是导致思维发散没有条理性的一个主要原因。逻辑思维是指根据理性推理和相关证据对事物进行分析和判断的能力。可以通过阅读哲学、逻辑学相关书籍，参加逻辑思维培训班等方式来培养自己的逻辑思维能力。
分类和归纳是思维条理性的关键。当我们面对大量的信息和想法时，学会分类和归纳可以帮助我们更好地理清思维的脉络。可以尝试使用总结思维的方式，将相似的思维点进行分类，并找出彼此之间的共性和区别。
集中注意力是思维条理性的基础。如果我们无法集中注意力，思维就会容易偏离主题，导致思维发散。可以通过冥想、专注训练等练习，提高自己的注意力水平。同时，也要注意减少干扰因素，创造良好的学习和工作环境。
缺乏问题解决能力是思维发散没有条理性的另一个原因。当我们遇到问题时，往往没有条理地进行思考和分析。培养问题解决能力可以帮助我们更好地展开思维和找到解决问题的路径。可以参加问题解决训练营、阅读相关书籍等方式来提高自己的问题解决能力。
规划时间和任务是提高思维条理性的有效方法之一。缺乏时间规划和任务安排往往导致我们思维的无序和混乱。可以使用时间管理工具，自己的任务进行分类和优先级排序，并合理安排时间。
反思和调整是不断提高思维条理性的关键。在日常生活中，我们需要不断地反思自己的思维方式和行为，发现问题并加以调整。可以定期回顾和总结自己的思维，并及时做出改变。
有时候，我们对自己的思维问题可能无法做出客观的评判。这时，可以寻求他人的帮助和意见。他人可能帮助我们发现自己的盲点和不足，给出有价值的建议。
通过以上这些方法和技巧，相信您可以逐渐培养自己思维的条理性。请记住，培养思维的条理性需要持之以恒的努力和实践。希望您在不断提高思维条理性的过程中取得好的效果。
如果思维条理性，迷糊状态不好的话，无非就是意识薄弱环节好多，知识内容不够灵活丰富啊！
意识无非就是意思识得，假如好多事物的东西意思不懂，即是知道识得的内容淡薄单一不够灵活全面，自然而然就思维逻辑推理能力弱点多多吧？
好多的事物关联性需要一个个联系点，假如不能够打通这些关键的联系点，那么思维逻辑推理能力受阻则弄不明白啊！
当然这里面是有先决条件:经常性往某个『意识/知识』去思考问题啊！唯有如此简单的问题思维逻辑推理能力慢慢变得强大起来了。
至于文化思维范畴不讲了，大同小异一样存在普遍性的道理。
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());
}
}
