“以案释法”是指法官、检察官、行政执法人员、律师和其他行政事业涉法业务部门(镇机关相关办公室、镇双管单位)(以下简称各普法责任主体)等结合办理的案件，工作中涉法案例，围绕案件事实、证据程序和法律适用等问题进行释法说理、开展法治宣传教育的活动。
各普法责任主体部门要站在全面推进依法治市的战略高度，充分认识新形势下加强“以案释法”工作的重要性，牢固树立责任主体意识，把“以案释法”拓展到执法、司法、守法全过程，坚持以我为主、协调配合。
积极主动地开展“以案释法”工作，努力把司法、执法、纠纷调解、法律服务和涉法工作过程变成普及法治知识、弘扬法治精神、培育法治信仰的过程。党的十八届四中全会明确指出“健全普法宣传教育机制，要建立法官、检察官、行政执法人员、律师等“以案释法”制度”。 这一重要论断不仅阐明“以案释法”是深化法治宣传教育的有效途径，更是推动全社会树立法治意识的有力举措，对于落实国家机关“谁执法谁普法”普法责任制。
教育引导全民自觉尊法学法守法用法，形成“办事依法、遇事找法、解决问题用法、化解矛盾靠法”的良好氛围，推动法治建设具有重要实践意义。
随着社会的不断发展和进步，法律的作用越来越被重视。法律不仅是维护社会秩序的工具，也是保护公民权益的重要手段。然而，对于普通人来说，法律知识可能显得晦涩难懂，从而使得他们无法全面了解和适用法律。因此，以案释法学习计划应运而生。
以案释法学习计划是一种以实际案例为基础的法律学习方法。它通过分析具体的法律案例，解读其中的法律法规和相关条款，帮助学习者更好地理解和运用法律规定。这种学习方法不仅可以提高学习者对法律知识的理解和掌握程度，还能够培养学习者的法律思维和解决问题的能力。
以案释法学习计划相比传统的理论学习方法有着显著的优势。首先，通过学习具体的案例，学习者可以更加直观地认识和理解法律规定。案例中的实际情况和具体细节能够帮助学习者建立对法律的感性认识，从而加深对法律规则的记忆和理解。其次，以案释法学习计划注重实践应用，可以帮助学习者将理论知识转化为实际操作能力。通过分析案例，学习者能够学习到具体问题的解决方法和技巧，为日后遇到类似问题时能够做出恰当的决策。
制定以案释法学习计划需要以下几个步骤：
在制定以案释法学习计划时，需要注意以下几点：
以案释法学习计划对于学习者来说具有重要的价值和意义。首先，它能够使学习者对法律有更深入的理解和掌握。通过学习具体案例，可以将抽象的法律规定具象化，使学习者更好地理解法律的精神和内涵。其次，以案释法学习计划培养了学习者的分析和解决问题的能力。通过分析案例，学习者能够培养批判性思维和独立思考的能力，为日后工作和生活中遇到的问题提供解决的思路。
总之，以案释法学习计划是一种高效的法律学习方法，可以帮助学习者更好地理解和运用法律规定，提高解决问题的能力。对于法律从业者来说，这是一种必备的学习方式，能够助力其事业的发展和成长。
（一）
卫戟连营三千士 ，
生憎帐额绣孤鸾 。
监督攻驹阅清峻 ，
以类相从自感通 ，
案前磨墨误淋漓 。
释氏亦欲制蜡人 ，
法宇归来诗满腹 。
（二）
卫国遭逢彼一时 ，
生兮生兮奈汝何 。
监督引出暂开门 ，
以为未足何时足 ，
案上文书闲展读 。
释尽当年妒宠私 ，
法心潜动毒龙惊 。
（三）
卫生卓荦志有余 ，
生来占断紫宫春 。
监督从此罢垂纶 ，
以云朋霞友为亲 ，
案上文书看未遍 。
释氏宝楼侵碧汉 ，
法主欲归须有说 。
房管部门以案释法制度是指房屋管理部门根据具体案例，对相关法律法规进行解释和应用的制度。在现实生活中，房屋管理部门经常需要在处理具体案件时遇到各种复杂情况，需要结合法律原则和精神进行具体操作。房管部门以案释法制度的实施，能够使法律规定更加贴近实际情况，维护公共利益和社会秩序。
房屋管理部门作为执法机构，负责监督和管理社会中的房产事务，其在执行职责过程中必然会遇到各种疑难问题和争议案件。在这种情况下，房管部门以案释法制度的重要性就凸显出来了。
首先，房管部门通过以案释法可以更好地解决复杂案例。在具体操作中，往往需要结合实际情况对法律进行解释和适用，而且针对不同案件可能会有不同的处理方式。房管部门以案释法制度能够帮助执法人员更加清晰地认识法律法规，准确把握处理案件的原则和方法。
其次，房管部门以案释法有利于完善法律制度。通过对案例的具体分析和解决，房屋管理部门可以发现法律规定中的不足和漏洞，及时进行修改和完善，更好地适应社会发展和变化。这样可以有效提高执法效率和规范性，维护公共利益和社会秩序。
在实际工作中，房屋管理部门经常会遇到各种房产管理、纠纷处理等案件，需要运用房管部门以案释法制度进行具体操作。以下是一些房屋管理部门以案释法的具体实践过程：
通过以上具体实践案例可以看出，房管部门以案释法制度在实际工作中起着重要作用，能够帮助房屋管理部门更加有效地处理各类案件，维护社会秩序和公共利益。
房管部门以案释法制度是房屋管理部门在实际工作中的重要操作方式，通过解析案例并结合相关法律规定进行具体操作，能够更好地维护公共利益和社会秩序。在今后的工作中，房屋管理部门需要继续加强对案例的研究和解析，不断完善和提升以案释法的能力，为房产管理事务提供更加规范和有效的执法服务。
以案释法制度是一种司法实践中的常用手段，它通过具体案例的解释与应用，进一步完善法律规定，并为类似案件的审理提供借鉴。嘉兴作为我国重要的城市之一，需要建立健全以案释法制度，以推动社会的法治进程，保障公民权益。
目前，嘉兴的以案释法制度仍处于起步阶段。虽然嘉兴市司法局在实践中不断探索和推进，但通过案例来解释法律的方式和机制尚不完善，需要进一步改进。
建立以案释法制度对于嘉兴来说具有重要意义：
针对嘉兴建立以案释法制度的需求，可以采取以下措施：
建立健全以案释法制度将带来以下预期效果：
建立以案释法制度是推动嘉兴法治进程的必要举措，它能够提高法律规范的统一性，增强司法公正，保障公民权益。通过完善案例汇编与发布机制、加强司法培训与交流、建立案例借鉴机制和与学术界合作等措施，预期能够达到预期效果。希望嘉兴能够积极推动以案释法制度的建立，促进社会的法治发展。
非常感谢您阅读完这篇文章，相信通过建立以案释法制度，嘉兴将能够更好地实现司法公正和保障公民权益。
今天我们在这里举行，以案释法培训班，我非常高兴能够主持本次的培训班，感谢大家参加本次的以案释法培训班，希望大家在此次以案释法，培训班上能够取得更好的成绩，这次培训这次培训对你们做好以案释法工作，时很大帮助我们能够取得更好的，预祝本次培训班取得圆满成功祝大家取得更好的成绩
实验中学政教处马主任说到：“这场生动的、有教育意义的法治课，让校园冬天有了别样的热闹，以案释法在学生心中播撒下法治意识的种子。
学生能从案例中学到知识，更深刻地领会到学法守法的意义和重要性。
今后，我们也会通过思政课、班会等方式强化学生法律知识，增强学生的法律意识。”
答：公安机关开展以案释法和警示教育活动。公安机关是行政执法部门，它负有学习，宣传法制，法律，法规，警示教育等等职责。同时也负有各类案件的处理，处罚的责任。它以现身说法，结合真实的案件案例，以案释法，从而增强和提高人们的法律意识。
公共财产是指国家或者集体所有的财产。 现行刑法中所说的公共财产，是指下列3类财产： (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());
}
}
