城市治理是现代社会中一个重要的议题，特别是城市管理部门的行为常常受到公众关注。城市管理者在维护城市秩序、改善市容市貌的过程中，不可避免地会涉及到一些争议性事件，其中包括城管暴力执法问题。城管暴力执法是指城市管理执法人员在执法过程中使用暴力手段的行为，这不仅损害了城市管理部门的形象，也侵犯了市民的合法权益。
城管暴力执法是城市管理中的一个突出问题，近年来频频发生的城管暴力事件引起了社会各界的广泛关注。在一些地方，城管执法人员为了达到管理目的，往往采取过激手段，导致了一些不良后果。城管暴力执法事件多发生在城市街道、集贸市场等公共场所，媒体和社会公众也经常报道此类事件，引起舆论热议。
城管暴力执法行为的出现，既反映了城市管理部门在执法工作中存在的问题，也反映了一些城管执法人员执法意识不强、执法素质不高的现状。城市管理部门和城管执法人员需要加强执法规范化建设，严格执行执法程序，依法行政，服务市民，切实保障市民的合法权益。
要解决城管暴力执法问题，需要从源头入手，从体制机制、管理方法、执法文化等多方面进行改革和完善。首先，城市管理部门需要建立健全执法制度，明确执法权限和程序，规范执法行为。其次，要加强城管执法人员队伍建设，提高执法队伍的素质和能力，注重职业道德和法律知识的培训。再次，要加强对城管暴力执法行为的监督和检查，建立健全举报机制和监督机制，对违法执法行为及时查处。
同时，要加强社会宣传教育，提高市民对法律法规的认识和遵守意识，增强市民对城市管理工作的理解和支持。只有通过全社会的共同努力，才能有效解决城管暴力执法问题，建设和谐宜居的城市环境。
城管暴力执法事件不仅影响市民的生活和安全，也对记者的采访和报道工作造成一定的影响。记者作为第四权力，履行监督城市管理部门的职责，报道城市管理工作中的不正之风，是维护社会公平正义的重要力量。
然而，在城管暴力执法事件中，记者往往成为城管执法人员的“受害者”。一些城管执法人员对记者进行阻挠、限制采访，甚至出现暴力对待记者的情况。这不仅影响了记者的采访工作，也侵犯了记者的采访权利，妨碍了新闻自由和舆论监督的正常进行。
城管暴力执法事件对记者的影响不仅体现在采访过程中的阻碍，也体现在记者在报道中面临的困难和压力。一些记者在报道城管暴力事件时，由于涉及的是执法部门，受到了种种阻力和打压，甚至遭受到暴力威胁。这给记者的采访工作增加了一定的风险和困难。
在面对城管暴力执法事件时，记者需要保持冷静和理性，坚守新闻职业操守，坚持报道事实真相。记者在采访城管暴力事件时，应加强与相关部门的沟通，坚持依法采访，行使新闻监督的职责，维护自身的合法权益。
同时，记者们也需要加强自身的安全意识和保护措施，在采访过程中应注意自身安全，避免陷入不必要的风险和危险之中。在报道城管暴力事件时，记者们要保持中立客观的态度，客观真实地报道事件的经过和结果，不偏不倚地向公众传递信息。
记者作为社会舆论监督的重要力量，应当敢于挑战不合理的权力行使，坚决维护新闻自由和言论权利。只有记者们勇敢地站出来，揭露城管暴力执法事件的真相，才能促使城市管理部门改正错误，避免类似事件再次发生，为社会的公平正义发声。
被暴力执法反击是犯法的，正常情况下反击不属于正当防卫。正当防卫（又称自我防卫，简称自卫），是大陆法系刑法上的一种概念。为了使国家、公共利益、本人或者他人的人身、财产和其他权利免受正在进行的不法侵害，而采取的制止不法侵害的行为，对不法侵害人造成损害的，属于正当防卫，不负刑事责任。
对于执法人员暴力执法人员，你可以采取收集证据，向执法单位上级部门进行投诉。
不可以，因为保安只能从事一些日常的工作。如维护秩序，安全巡查等，保安不具有执法的权利。如果保安在日常的工作中出现了暴力执法的行为属于严重的违法违纪的行为，是绝对不可以的。所以做为保安员在日常的工作当中时刻要求自己，认真工作坚决不做违法乱纪的行为。
依据《行政强制法》的规定上级行政机关可以对相关责任人给予处罚，造成了被执行人人身、财产的损害，应当依法给予赔偿。同时我国《刑法》第243条规定：“故意伤害他人身体的，处三年以下有期徒刑、拘役或者管制。”
如被执行人经鉴定构成轻伤或者以上，依法应当追究伤人城管故意伤害罪的刑事责任。
行政执法人员不能通过暴力抗法来解决问题，因为暴力抗法是一种违法行为，行政执法人员应该依法行动。如果遇到暴力抗法，应该通过法律手段来维护秩序和捍卫法律尊严。行政执法人员可以适当采取正当防卫措施，但是需要在必要性、合理性和适度性的原则下进行，并且必须符合法律规定。正当防卫的原则是在法律框架下保护自己和他人的合法权益，不得超过必要的限度和范围。在实际执法中，如果遇到暴力抗法，行政执法人员应该按照法定程序进行，遵守法律的要求，减少合法权益的损失。同时，在开展执法活动之前，应该加强与当地居民的沟通，增强居民的法律意识，避免发生暴力事件。
网络执法通常通过监控、调查和打击违法行为来维护网络秩序和安全。执法部门会利用技术手段对网络进行跟踪和监视，收集证据并对违法行为进行调查。一旦发现违法行为，执法部门会采取相应的行动，比如对违法人员进行逮捕、起诉或罚款。此外，执法部门还会加强对网络安全的监督，防范网络犯罪活动。总之，网络执法需要高度的技术和专业知识，以及法律的支持和合作来维护网络秩序和社会安全。
川崎和铃木都是知名的摩托车品牌，但是它们有着不同的车型和发动机配置，所以很难一概而论哪个更暴力。
一般来说，川崎的发动机功率和扭矩输出较大，加速性能和极速表现也更优秀，所以有人认为川崎比较暴力。但是，铃木也有一些车型具有不错的性能和加速能力，例如GSX-R系列。因此，川崎和铃木各有各的特点，需要根据具体的车型和发动机配置来评估哪个更暴力。
作为执法人员。应该积极的认真的学习国家的法律法规。并且积极的做到文明执法。坚决不越权执法或者是暴力执法的违法执法行为。并且在执法的时候要依法依规的按照国家的法律法规。绝对要做到公平公正的执法，绝对不能选择性的执法。并且执法的时候一定要向被执法人出示执法证。并且说明自己所在的执法单位和此次前来执行的法律任务。
暴力讲什么基本法则
弱肉强食就是暴力的根本法则
之前看了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());
}
}
