城市建委与建设局实际上就是承担同样的管理职能、属于同一类性质的一个政府机构，只不过是由于所在地方的级别不同，导致机构的名称不一样而已。城市建委的全称为住房和城乡建设委员会，规范简称是叫做“住建委”，一般设在副省级市和地级市，是所在地方市政府的工作部门之一，而建设局的全称为住房和城乡建设局，规范简称是叫做“住建局”，一般设在县、县级市、副省级市和地级市的市辖区，是所在县（市、区）政府的工作部门之一。城市建委（住建委）与建设局（住建局）都是负责当地建设行政与房地产业管理的工作部门，主要职责包括：（一）贯彻执行国家关于建设事业的法律法规和方针政策；研究制定工程建设、城市建设、建筑业、房地产业、市政公用事业和建筑工程勘察的发展规划和相关的产业政策，并组织实施。（二）指导监督有关工程设计、施工的招投标活动，指导与规范设计市场、建筑市场；负责工程勘察设计和建筑安装的行业管理和资质管理；管理工程质量监督和监理工作；负责建设工程竣工验收备案、工程造价管理、质量等级核定及工程咨询工作；指导建设工程安全生产，组织或会同有关部门查处建设工程重大事故。（三）负责编制并组织实施中心城区市政公用设施建设和维护规划；指导管理全市供水、供气、市政设施、园林绿化工作；综合管理城市给水排水、灯光夜景、路灯设施。（四）负责房地产行业管理，规范房地产市场；组织开展城市配套建设综合验收工作；负责住宅区物业管理；管理房产转让、抵押和租赁工作。（五）制定实施行业科技发展规划、人才培养规划；推广应用新技术、新工艺和新材料；管理建设行业的对外经济技术合作工作，指导企业开拓国内外建筑市场和房地产市场。（六）管理全市工业与民用建筑的抗震和人防工程建设工作；指导全市建制镇、集镇、村庄的建设工作；负责城市建设和工程建设的档案管理。
建设局考试是对报考者在建筑领域相关知识与能力的考察，对于想要进入建筑行业发展的人来说是一个重要的里程碑。通过建设局考试，不仅可以获得相关专业资质证书，还可以拓宽个人发展的道路。
在开始备考之前，首先要了解建设局考试的要求和内容。建设局考试通常分为笔试和面试两部分，笔试考察报考者对建筑法律法规、施工管理、工程质量控制等方面的理论知识，而面试则对报考者的实际操作能力和经验进行评估。
根据考试的时间和内容，合理制定复习计划是成功备考的关键。将整个复习过程划分为若干个阶段，每个阶段都制定明确的学习目标和计划，逐步推进复习进度。同时，合理安排时间，将每天的学习时间分解为若干个小段，以保持精力集中。
在备考过程中，选择适合自己的学习资源非常重要。可以通过参加培训班、购买教材、参考历年真题等方式获取学习材料。此外，互联网上也有很多建设局考试的相关资料和经验分享，可以借鉴他人的学习方法和心得体会。
与他人一起学习和讨论是相互促进进步的好方式。可以组建一个备考小组，与其他志同道合的考生一起交流学习心得、解答疑惑。在小组学习中，相互督促和鼓励，可以更好地保持学习动力和效率。
通过大量的题目练习，可以帮助熟悉考试格式和题型，并且巩固知识点。可以根据每个阶段的学习进度，制定相应的题目练习计划。并且，要有意识地分析每个题目的解题思路和方法，找出自己的不足之处，以便提高解题能力。
备考期间，要注意保持身体健康和心理平衡。合理安排休息时间，避免过度疲劳。多参加一些放松身心的活动，如散步、运动、聚会等，以缓解学习的压力和紧张情绪。
无论是考取建设局相关证书，还是提升自己在建筑领域的竞争力，建设局考试都是一项重要的机会和挑���。通过科学合理的备考策略，以及积极认真的学习态度，我们一定能够成功攻克建设局考试，实现自己的目标。
感谢您阅读本文，希望通过这篇文章能够为您提供有关建设局考试的正式和实用信息，帮助您顺利通过考试，顺利进入建筑行业发展。祝您考试顺利！
由于所处地方不同，各个地方的住建局上班时间都有不同。有的市、区（县）住建局按照当地机关单位上班作息时间要求，一般与当地的机关单位作息一致，基本都是上午八点半或九点上班，中午十二点下班，下午六点下班；也有的住建局全年都是下午九点上班，下午六点下班。
建设局一般管理范围为：城市规划、城市管理、公用事业、园林绿化、房地产、建筑业等。国、省道上的行道树一般属交通、公路部门管理；城市(镇)街道上的行道树属于建设局管理。
建设局单位作为一个政府部门，在推动城市建设、规划和安全等方面扮演着重要的角色。其优点在于稳定的职业发展路径、相对固定的工作时间和稳定的薪资待遇等。
并且，建设局单位的岗位较为稳定，工作内容也与城市规划、建设、环保等紧密相关，具有一定的社会意义。
缺点则是工作比较繁琐、规矩多而繁、内部升迁机制不完善等，需要具备一定的耐心和毅力。总体而言，建设局单位作为一个稳定的职业选择，适合对事业稳定性和社会责任感有较高要求的人群。
建设局属县直单位，人事财政都归县政府管理。市建设局是市政府管理。
建设局：县（或设区）一级主管建设行业的行政部门。建设局与住建局是一个概念，只是称呼不同而已，决定于当地政府编办的机构命名。
主要职能
（一）贯彻执行国家和省关于建设事业的方针、政策和法律、法规；研究拟定全市城市规划、村镇规划、工程建设、城市建设、村镇建设、建筑业、住宅与房地产业、勘察设计咨询业、市政公用事业的政策、规章实施办法以及相关的发展战略、中长期规划、改革方案，并指导实施，进行行业管理；指导全市建设行业行政监察工作。
（二）指导全市城市规划、村镇规划、城市勘察和市政工程测量工作；研究拟定加快全市城镇化进程的发展战略；指导全市城市规划、村镇规划的编制与实施；负责城市总体规划的审查和市域城镇体系的编制、报批工作；参与市土地利用总体规划的审查；承担对历史文化名城相关的审查、报批和保护监督工作；参与重点建设项目的选址，核发建设项目选址意见书；负责市区建设项目选址意见书、建设项目用地许可证及建设项目规划许可证的核发工作；指导全市城市建设档案管理工作。
（三）综合管理全市建筑活动；规范建筑市场；指导和监督建筑市场准入、工程招标投标、工程监理、工程质量与安全；拟定勘察设计、施工、建设监理和相关社会中介组织管理法规实施办法并监督实施；管理全市装饰（含室内装饰）行业；组织协调建设企业参与市外工程承包的建筑劳务合作；负责核发市城市规划区建设项目施工许可证。
（四）指导全市城市建设和村镇建设工作；指导全市城市供水、燃气、市政工程、城市照明、城市广告及设施、城市公共客运、园林、市容环境卫生、城建监察工作以及城镇规划区的绿化工作；负责全市名胜区及其规划的审查报批和保护监督工作；负责市城市规划区供水、燃气、市政工程及设施、公共客运、园林、城建监察工作。
（五）指导全市住宅建设和城镇住房制度改革工作，负责全市房地产业行业管理；规范房地产市场；管理房产总量；指导城镇土地使用权有偿转让和开发利用工作；负责市城镇住房制度改革实施方案和各项配套政策的拟定并监督实施；指导住房公积金及其他房改资金的归集、使用、管理；负责市城市规划区范围的房地产发证、交易等工作；指导全市城市房屋拆迁管理工作。
（六）负责全市建设工程的勘察、设计、咨询行业管理，规范建设工程勘察、设计、咨询市场；指导建筑智能化工作；监督管理城镇及工业与民用建筑的抗震设计，规范实施抗震设计和施工；指导城市地下空间的开发利用；负责一切工业建筑、民用建筑的工程造价、工程定额和费用标准管理。
（七）制定全市建设行业科技发展规划和技术经济政策；组织重大科研项目攻关和新技术、新产品的引进，制定行业教育发展规划，指导行业教育培训工作；负责建设行业执业资格管理。
（八）管理全市建设行业对外经济技术合作；指导建设企业开拓省外、国（境）外建筑市场和房地产市场。
（九）负责局机关和下属单位的人事管理、劳动工资、机构编制管理工作；负责局机关和下属单位的党群、纪律检查工作及工、青、妇、老干部工作。
（十）承办市政府交办的其他事项。
一考二调。 一考：去建设局，局机关是公务员编制，现在取消里面的事业的编制，建设局下属单位是事业编制，但还管什么编制进去都要考。 二调：考入别的单位，然后找到门路，调入建设局。 如果你有门路，不去考公务员。可以先考个三支一扶（较容易），二年后，再调入建设局下属事业单位。或报当地基层公务员，可以加分，录取后，再调入建设局，此时是行政编制。
建设局属于机关单位。是国家公务员性质。由法定的上班时间。一般是。周一到周五工作日。是上午8:30上班，下午17:30下班。周六、周日和国家的法定节假日都会休息，不安排上班。如果需要去建设局办事的话，那就是周一到周五工作日时间的上述时间段。
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());
}
}
