清华大学管理学院的MPA（公共管理硕士）项目是中国乃至全球顶尖的公共管理硕士项目之一。每年都有数千名学子志愿报考，而面试是入选清华大学MPA项目的关键环节之一。面试是考察学生综合素质和能力的重要手段，因此，为了在清华大学MPA面试中脱颖而出，成功迈向理想的公共管理之路，准备工作至关重要。
准备面试的重要性
面试是考察申请者综合素质的重要环节，通过面试，面试官可以直接了解申请者的沟通能力、逻辑思维、团队合作能力以及个人品质等方面的表现。准备面试时，申请者需要全面考虑面试的各个方面，从知识储备到表达能力，甚至包括形象和自信心的展示。
清华大学MPA面试题的范围和特点
清华大学MPA面试题主要从以下几个方面进行考察：
如何准备清华大学MPA面试题
准备清华大学MPA面试题需要充分考虑以上几个方面，并进行有针对性的准备工作。
1. 学术背景和研究兴趣
准备面试时，申请者应充分了解自己的学术背景和研究兴趣，并在面试时能够清晰、准确地表达。申请者可以回顾自己的学术经历，总结已有的研究成果，并思考未来的研究方向和目标。
2. 领导能力和团队合作
为了在面试中展示自己的领导能力和团队合作精神，申请者可以准备一些相关的案例和经历，在面试时进行详细描述。申请者可以回顾自己在学习和工作中的领导经验，包括带领团队完成项目、解决团队内部的冲突等。
3. 社会责任和公共服务意识
在面试中，申请者可以通过展示自己的社会责任感和公共服务意识来吸引面试官的注意。申请者可以回顾自己参与过的社会实践活动或公益项目，并总结自己的收获和影响。
4. 逻辑思维和问题解决
逻辑思维和问题解决能力是公共管理岗位中不可或缺的能力。申请者可以通过阅读相关的书籍和案例，提升自己的逻辑思维能力，并进行模拟面试来锻炼自己的问题解决能力。
面试的注意事项
除了准备面试题，申请者还需要注意以下几个方面：
结语
准备清华大学MPA面试题需要全面的准备工作，涉及面广，考察内容丰富。申请者应从学术背景、领导能力、社会责任和逻辑思维等方面进行准备，并关注面试的注意事项。通过充分的准备，申请者能够在清华大学MPA面试中有更好的发挥，提高成功的机会，迎接理想的公共管理之路。
1Mpa=1×10^6Pa，1标准大气压=0.101325MPa
Pa（帕）、MPa（兆帕）都是气压的国际制单位。通常所用的气压单位有帕(Pa)、毫米水银柱高(mm·Hg)、毫巴(mb)。它们之间的换算关系为：100帕=1毫巴≈3/4毫米水银柱高。气象观测中常用的测量气压的仪器有水银气压表、空盒气压表、气压计。温度为0℃时760毫米垂直水银柱高的压力，标准大气压最先由意大利科学家托里拆利测出。
扩展资料：
1、气压的大小与海拔高度、大气温度、大气密度等有关，一般随高度升高按指数律递减。气压有日变化和年变化。一年之中，冬季比夏季气压高。气压变化与风、天气的好坏等关系密切，因而是重要气象因子。
2、单位换算
1MPa（兆帕）=1000kPa(千帕）=1000000Pa（帕斯卡）
1bar（巴） = 0.1MPa
1atm（标准大气压）=0.1013MPa=1.013bar=760mmHg=10.33mH2O
1kgf/cm2（工程公斤力）=0.981bar=0.0981Mpa
1psi（Lb/in2 ）=0.07031kgf/cm2=0.06893 bar=6.893kpa
1MPa=145psi
央行明确提到MPA所涉及到的七大方面，包括资本和杠杆情况、资产负债情况、流动性、定价行为、资产质量、外债风险、信贷政策执行。
其中，广义信贷指标则将此前信贷规模延展到整个社会融资。
根据流传内容显示，对广义信贷的统计范围，将在原有各项贷款、债券投资、股权及其他投资、买入返售资产、存放非存款类金融机构款项等五个项目基础上，增加表外理财资金运用项目。
表外理财资金的数据，从央行调查统计部门的人民币表外理财资产负债表中取数。其中，表外理财资金运用余额=该表中的资产余额-现金余额-存款余额。
粘度的法定度量单位-毫帕/秒(mPa·s)。
国标气压量程Mpa是标准的国标压力单位之一读作兆帕
MPA是公共管理硕士(Master of Public Administration) 专业学位的英文简称，是以公共管理学科及其他相关学科为基础的研究生教育项目，其目的是为政府部门及非政府公共机构培养高层次、应用型专门人才。
秋季MPA 学历、学位双证班，每年12月份参加管理类专业学位联考，9月份入学,毕业后获公共管理硕士学位证书和研究生学历证书。
Mpa的全称是Master of Public Administration，公共管理硕士，又译公共行政硕士（台），是为适应社会公共管理现代化、科学化和专业化的要求而设立的学科，其培养目标是为政府部门及公共机构培养德才兼备、适应社会主义现代化建设需要的高层次、应用型、复合型的管理人才。要求毕业生成为掌握先进分析方法及技术，熟悉具体公共管理或政策领域的领导者，管理者以及其他公共服务人才。
公共管理学是一门运用管理学、政治学、经济学等多学科理论与方法，专门研究公共组织尤其是政府组织的管理活动及其规律的学科体系。
MPA是公共管理硕士(Master of Public Administration) 专业学位的英文简称，是以公共管理学科及其他相关学科为基础的研究生教育项目，其目的是为政府部门及非政府公共机构培养高层次、应用型专门人才。
在国外市场经济发达的国家里, 公共管理硕士、工商管理硕士(MPA)以及法律硕士被称为文科高层次职业研究生教育的三大支柱。MPA 教育已成为这些国家培养高级公务员的主要途径。
MPA是央行为维护金融稳定推出的新的监管机制。它由央行于去年12月公布，今年开始实施。此前，央行通过差别准备金动态调整和合意贷款管理机制来控制银行风险。随着金融创新快速发展，资产类型更为多样，狭义的信贷管理越来越难以有效实现宏观审慎管理目标。央行因此将原有安排升级至覆盖面更广的MPA考核：
MPA是一个综合评估体系。MPA考核是基于预先设定的14项指标，涉及资本和杠杆情况、资产负债情况、流动性、定价行为、资产质量、外债风险和信贷政策执行等7大方面。
之前看了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());
}
}
