中华人民共和国公安部的地址:北京市东
城区东长安街14号;邮编:100741;电
话:010-66262114。也可直接登陆下方
的网址访问公安部官网。
公安局有事业编制人员。公安局的正式事业编制的工勤人员属于待入警人员，并不是公务员，不享有执法权。一般都在非执法岗位，如110接警中心等。工勤人员无警衔和警服，享受人民警察待遇，工资相比少了个警衔津贴。公安局工勤编制就是公安里的职工，不是公务员编制。比协警强点，可以享受公安人员的工资和其它待遇，比如养老和住房工基金，理论上说是没有警衔的，如同国企里的工人，称之为事业单位在编人员，不是干部或公务员。
公安网分为内网和外网。内网只有公安机关工作人员可以浏览。
普通公民只能浏览公安部及其下属公安局网站。如，公安部的官方网站为http://www.mps.gov.cn。在公安系统查询个人信息：1,支付宝首页打开市民中心。2在市民中心办事大厅里，选择公安交管，然后点击个人信息查询。3仔细阅读公安系统的查询须知，然后点击同意。4.输入个人信息查询的申请信息，点击提交就可以了，结果会在几个工作日内发到你的邮箱。
根据《公安部关于加强支付离休干部报销及工资支付工作的规定》（公安部令第32号），公安部规定，工资应及时正常支付，未及时发放工资的，应当正常发放补发工资，不得征收不正当手续费，也不得把未发工资算作未发补贴、公积金等。
有因为公安部设有“110接警平台”和“公安部网络违法犯罪举报网站”，可供民众使用。 110接警平台是公安机关接受警情和求助的电话平台，是全国统一的警务电话，拨打110可以报警和求助；同时，公安部网络违法犯罪举报网站也提供了方便快捷的网络举报渠道，民众可以通过该网站进行网络违法犯罪的举报和投诉，包括网络诈骗、色情等行为。为民众提供了一个安全、便捷的报案渠道，让民众可以更及时有效地保护自己的合法权益。
在中国，公安部门是负责维护社会安全和治安秩序的重要组织。作为执行国家法律和保护人民生命财产安全的机构，公安部门的工作任务非常繁重和关键。而公安部门的工资待遇也一直备受关注，因为它直接关系到公安机关的工作积极性和效率。
作为国家机关工作人员，公安部门的工资待遇由一系列因素决定，主要包括职位等级、工作年限和绩效表现。公安部门中分为许多职位，从普通警员到高级警官，每个职位对应的工资水平都有所不同。
在公安部门，警员的职位等级可以根据其实际职位、职责和资历来划分。普通警员大多数是从基层干部逐渐晋升而来，他们的工资水平相对较低。而随着职位的晋升，警员将逐渐获得更高的职位等级和相应的工资待遇。
高级职位的公安人员，如警督、警司等，通常需要具备更高的学历和丰富的经验。他们在公安工作中承担着更多的责任和管理职责，因此他们的工资待遇相对较高。
工作年限也是影响公安部门工资的重要因素之一。随着工作年限的增加，警员的经验和实际工作能力会得到提高，因此工资待遇也会逐步增加。
同时，公安部门通常设有一些晋升渠道，通过参加培训和考试，公安人员可以获得更高的职位和更高的工资待遇。
绩效表现是公安部门工资待遇的重要考量因素之一。公安人员的工作表现将直接关系到工资的增长和晋升的机会。
公安部门通常会根据警员的勤勉程度、案件侦破率、荣誉表彰等因素评估绩效。表现优秀的警员将有较高的机会得到晋升和加薪。
公安部门工资待遇的透明性是一个受到关注的问题。对于公众来说，了解公安人员的工资待遇情况有助于增强对公安部门的信任。
一些地方政府已经开始提倡公安工资的公开透明化。通过公开公安人员的工资等信息，可以方便公众监督和评估公安工作。
提高公安人员工资待遇是一个关系到公安工作质量和效率的重要问题。公安人员承担着维护社会稳定和保护公民安全的重任，应该得到合理的回报和激励。
适当提高公安人员的工资待遇可以激励他们更加投入地履行职责，提高工作积极性和干劲。
另外，与其他行业相比，公安部门的工作压力较大，工作环境较为复杂和危险。因此，提高公安人员的工资待遇可以提升其工作积极性和幸福感，避免高压环境下的人才流失。
公安部门工资待遇是公安人员关注的焦点之一，它直接影响到公安机关的工作效率和公民对公安部门的信任。因此，政府应该重视公安人员的工资待遇问题，并采取措施提高其工资水平。
公安部门也应该通过透明化公安工资待遇，增加公众对公安工作的理解和支持。
一、警察退休年龄新规定
公安民警的退休政策应和普通公务员有所区别，可实施弹性退休政策，民警从警年限满25年的，本人自愿提出申请，可以提前退休。
国家规定的退休年龄：
《国务院关于安置老弱病残干部的暂行办法》和《国务院关于工人退休、退职的暂行办法》（国发〔1978〕104号）文件所规定的退休年龄。即：全民所有制企业、事业单位和党政机关、群众团体的工人：
（一）男年满六十周岁，女年满五十周岁，并且连续工龄满十年的；
（二）男年满五十五周岁、女年满四十五周岁，连续工龄满十年的，从事井下、高空、高温、特别繁重体力劳动或其他有害身体健康的工作；
（三）男年满五十周岁，女年满四十五周岁，连续工龄满十年，由医院证明，并经劳动鉴定委员会确认，完全丧失劳动能力的应当准予退休。
二、警察退休金怎么计算
人民警察基本退休金计算办法如下：
基本退休金=基础养老金+过渡性养老金+个人账户养老金+人民警察警衔津贴
1、基础养老金=退休时全省上年度在岗职工月平均工资×(1+本人平均缴费工资指数)÷2×缴费年限×1%。
其中，本人平均缴费工资指数=(视同缴费指数×视同缴费年限+实际平均缴费指数×实际缴费年限)÷缴费年限。
2、个人账户养老金=退休时本人基本养老保险个人账户累计储存额÷计发月数。
3、过渡性养老金=退休时全省上年度在岗职工月平均工资×本人视同缴费指数×视同缴费年限×过渡系数(1.2%)。
4、人民警察警衔津贴标准是按衔级执行相应的津贴标准。各衔级每月的警衔津贴标准为：二级警员64元，一级警员68元;三级警司72元，二级警司76元，一级警司80元;三级警督85元，二级警督90元;一级警督95元;三级警监100元，二级警监105元，一级警监110元;副总警监116元，总警监123元。
等公安部招考的时候，符合条件即可去报名，若能够通过笔试、面试、体检就行了。
网站公安备案的目的就是受当地网警监管，一起维护互联网信息安全。
附上备案网址：http://www.beian.gov.cn/portal/index.do
网站备案的速度和网站类型有关。
一、非交互型的网站，如：企业官网等只是为了展示的网站，由于没有提供用户「发言」等交互的入口，是相对安全的，备案很快。
二、交互型的网站，特别是含有：发帖、发文章、发表评论等功能的网站，备案就会相对严格些。
因为交互型网站的运营需要有严格的章程，来保证这个网站不会展示和帮助非法信息传播。
交互型网站公安备案的流程如下：
1、建立网络安全管理制度（制度文件打印签字盖章）
2、负责人写互联网信息安全承诺书（承诺书文件打印签字盖章）
3、保证网管24小时监管网站
4、保证网站已导入下发的屏蔽关键词
5、在线提交互联网安全评估报告
6、在线提交备案申请
完成以上，一般在线申请的就会通过了。最直接的办法是，如果当地网警短信通知，未通过，又不知道原因的情况没，就在其工作时间回电话过去询问即可，一般都会告知的。因为他们也不是每天都有很多很多的备案申请，是记得当天拒绝的这份申请的原因是什么的。
之前看了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());
}
}
