1）司法公正是指司法权运作过程中各种因素达到的理想状态，是现代社会政治民主、进步的重要标志，也是现代国家经济发展和社会稳定的重要保证。它是法律的自身要求，也是依法治国的要求，其基本内涵是要在司法活动的过程和结果中体现公平、平等、正当、正义的精神。其主体是以法官为主的司法人员。司法公正的对象包括各类案件的当事人及其他诉讼参与人。司法公正包括实体公正和程序公正，前者是司法公正的根本目标，后者是司法公正的重要保障。整体公正与个体公正的关系反映了司法公正的价值定位和取向。
2）司法公正既要求法院的审判过程坚持正当平等的原则，也要求法院的审判结果体现公平正义的精神。前者可以称为程序公正，后者可以称为实体公正。它们共同构成了司法公正的基本内容。
司法公正，是指司法权运作过程中各种因素达到的理想状态，是现代社会政治民主、进步的重要标志，也是现代国家经济发展和社会稳定的重要保证。
司法公正基本内涵是要在司法活动的过程和结果中体现公平、平等、正当、正义的精神。对象包括各类案件的当事人及其他诉讼参与人。司法公正包括实体公正和程序公正，前者是司法公正的根本目标，后者是司法公正的重要保障。
司法公正，或曰公正司法，其基本内涵就是要在司法活动的过程和结果中坚持和体现公平与正义的原则。从狭义上讲，司法主要指法院的审判活动；公正的含义则包括公平、平等、正当、正义等。司法公正既要求法院的审判过程遵循平等和正当的原则，也要求法院的审判结果体现公平和正义的精神。
政策主要包括以下几个方面：
1. 加强司法独立：中央政府要求各级法院和检察机关充分发挥独立审判权和检察权，保障司法工作的公正、公平和独立性。
2. 推进司法透明：中央政府鼓励各级法院和检察机关加强信息公开，提高公众对司法工作的了解度。同时，加强对司法过程的监督，确保司法程序的公开、公正和透明。
3. 构建司法保障体系：中央政府鼓励各级法院和检察机关积极推进司法改革，建设现代化司法制度和司法保障体系，加快建设法治国家。
4. 建立惩治腐败的长效机制：中央政府重视打击司法腐败行为，强化反贪腐斗争力度，并加强对司法工作人员的管理和监督。
5. 保障司法权益：中央政府重视维护律师、当事人等司法参与者的合法权益，保障他们在司法过程中的权利和利益。
需要注意的是，司法公正是一个复杂的系统性问题，需要社会各方面的共同努力才能够实现。中央政府推动司法公正的政策必须与基层机构的落实和改进相结合，以保障司法工作的公正、公平和透明。
司法公正作为一个社会正义的指标，是任何一个健康民主社会的基石之一。它确保了每个人都能够在法律面前受到公平对待，不受任何歧视。司法公正关乎法治国家的根本原则，也是法治社会的核心价值。
在现代社会中，司法公正不仅仅是一个法律概念，更是民众对公平正义的期许和追求。当人们对司法系统失去信心，就会打击社会的稳定和公众对法治的认同感。因此，确保司法公正的实施对于社会的可持续发展至关重要。
司法公正是法治社会的重要组成部分。在一个法治社会中，法律不仅仅是权威的象征，更是保护公民权益和保障社会稳定的法定准则。司法公正确保法律的透明和平等执行，进一步巩固了法治社会的基础。
司法公正对于法治社会的影响是多方面的。首先，它确保了公权力的行使受到限制和监督。司法公正使政府和其他权力机构在行使权力时受到法律约束，不得滥用职权或胁迫个人。这种制约力量有助于维护社会的平等性和公正性。
其次，司法公正提供了一个公平的司法程序，确保了每个人在面对法律时都能够享有适当的法律程序和权利保障。这有助于保护个人的权益，并避免了司法系统的偏见和不公正。
另外，司法公正也为社会带来了积极的效果。一个有司法公正的社会能够吸引更多的投资和商业机会，因为企业和个人都希望他们的利益能够在法律框架下得到保护。司法公正也激发了公民的参与感和社会责任感，促进了社会的和谐与稳定。
然而，尽管司法公正的重要性被广泛认可，但实现司法公正仍面临许多挑战。其中之一是司法系统的繁琐程序和复杂性。这可能导致案件处理时间过长和审判结果的不确定性，从而削弱了司法公正的实施。
此外，司法腐败也是司法公正面临的一大难题。当司法系统中存在贪污和滥用职权行为时，司法公正很难被真正实施。为了解决这个问题，打击腐败和提高司法机构的透明度至关重要。
此外，法律的不平等和部分人群的受害也是司法公正的一个挑战。一些边缘化和弱势群体可能面临着法律援助的不足，导致他们难以获得公正的司法处理。通过加强对弱势群体的保护和提供充足的法律支持，可以提高司法公正的可及性和效果。
为了提高司法公正的水平，我们可以采取以下措施：
通过以上措施的实施，我们可以更好地保障司法公正的实现，推动社会正义的发展。司法公正是一个复杂而关键的问题，需要社会各界的共同努力和持续关注。
在网络时代，网络舆论已经成为了一个不可忽视的力量。然而，这并不意味着我们可以忽视司法公正的重要性。司法公正与网络舆论之间存在着密切的关系，如何平衡两者之间的关系，成为了当今社会一个重要的议题。
网络舆论的力量在于其传播速度快、覆盖面广的特点。一旦某个事件在网络上引发了广泛的讨论和关注，就会形成一股强大的舆论压力。这种压力有时会对司法机关的决策产生影响，迫使其采取相应的行动。因此，网络舆论在某种程度上可以推动司法公正的实现。
然而，我们不能忽视的是，网络舆论并非万能。它不能代替司法机关做出公正的判断。司法机关必须依据法律和事实进行裁决，不受外界舆论的影响。司法公正才是社会公正的基石，是维护社会稳定和公平正义的重要保障。
要平衡司法公正与网络舆论之间的关系，需要社会各界的共同努力。首先，加强网络监管，规范网络言论，防止恶意攻击和诽谤。其次，提高公众的法律意识，引导公众以理性、客观的态度看待网络舆论。最后，司法机关应公开透明地处理案件，及时回应社会关切，增强公众对司法公正的信心。
综上所述，司法公正与网络舆论之间存在着既对立又统一的关系。我们不能忽视任何一个方面。为了构建一个更加公正、和谐的社会，我们需要平衡两者之间的关系，充分发挥网络舆论在推动司法公正方面的积极作用，同时确保司法机关独立、公正地行使职权。
通过了解澳门法律体系的运作，我们可以深入了解该地区司法公正的维护和发展情况。澳门法律作为该地区的法律框架，对于维护司法公正起着至关重要的作用。但是，在实践中，有时候会出现一些妨碍司法公正的因素，这就需要加强监督和改善法律体系来解决。
澳门的法律体系主要以《澳门基本法》为基础，同时还涵盖了一系列澳门特别行政区的相关法律法规。《澳门基本法》是澳门的基本法律文件，确立了澳门的法律地位和宪政框架，保障了澳门的司法独立和法治精神。
司法公正是法治社会的核心价值观之一，它体现了法律的公平性和威信性，确保了公民的合法权益得到尊重和保护。在司法公正的框架下，每个人都应当受到公平审判，不受特殊待遇或歧视，这是一个民主社会的重要标志。
在澳门的司法实践中，有时候也会出现一些妨碍司法公正的因素。例如，可能会存在司法腐败、滥权现象，以及法律执行环节的不透明、不公正等问题，这些因素都会影响司法公正的实现和维护。
为了解决妨碍司法公正的问题，澳门需要加强对司法机关和法律系统的监督，建立健全的司法独立和监督机制，确保法律的执行符合法治精神。此外，还需要改善法律体系，完善相关法律法规，提升司法公正的效果和水平。
总的来说，澳门的法律体系为司法公正的维护提供了重要的法律基础，但在实际实践中仍然面临一些挑战。通过加强监督和改善法律体系，可以更好地解决妨碍司法公正的问题，推动司法公正不断提升和完善。
之前看了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());
}
}
