龙华区有175.6平方千米。
龙华区，隶属于广东省深圳市，位于深圳地理中心和城市发展中轴，毗邻“六区一市”，北邻东莞市和光明区，东连龙岗，南接福田、罗湖、南山，西靠宝安。总面积175.6平方千米
龙华区常住人口253.51万人。
2021年，龙华区实现地区生产总值2828.45亿元，其中，第一产业增加值0.59亿元，第二产业增加值1446.99亿元，第三产业增加值1380.87亿元。
龙华区隶属于广东省深圳市，位于深圳地理中心和城市发展中轴，毗邻“六区一市”，北邻东莞市，东接龙岗区，南连福田区、罗湖区，西靠南山区、宝安区，是深圳的“后花园”。
龙华区，不属于广州，隶属海南省海口市。
地处海口市西北部，介于东经110°14'54"~110°24'47"，北纬19°43'07"~20°03'10"之间，总面积300.6平方千米。截至2020年6月，龙华区辖6个街道、5个镇，区政府驻滨海街道龙昆北路19号。龙华区地处台地和平原，属于热带季风气候，有水域面积15.25平方千米。
龙华区下辖6个街道。截至2018年，龙华区6个街道办事处分别为：观湖街道办事处、民治街道办事处、龙华街道办事处、大浪街道办事处、福城街道办事处、观澜街道办事处。
龙华区有几个街道
龙华区隶属于广东省深圳市，位于深圳地理中心和城市发展中轴，毗邻“六区一市”。
在龙华区，客家文化、红色文化、时尚文化交汇，还拥有白石龙中国文化名人大营救旧址。
龙华区的著名景点有：观澜版画村、观澜古墟、麒麟博物馆、观澜湖、观澜山水田园等。
1.深圳湾公园：位于南山区和龙华区交界处，占地面积约26万平方米，是一个集休闲、娱乐、运动于一体的滨海公园。
2.香蜜湖公园：位于龙华区民治街道，占地面积约42万平方米，是深圳市最大的城市湖泊公园，以湖光山色、花鸟鱼虫为特色。
3.北站公园：位于龙华区北站附近，占地面积约4.3万平方米，是一个以铁路文化为主题的公园。
4.民治花谷公园：位于龙华区民治街道，占地面积约11万平方米，是一个充满花卉景观的公园。
5.观湖公园：位于龙华区观湖街道，占地面积约16万平方米，拥有湖泊、山林等自然景观。
6.阳台山国家森林公园：位于龙华区大浪街道，占地面积约9平方公里，是一个集自然、历史、人文于一体的森林公园。
深圳龙华区电话区号为0755。因为深圳市共划分为10个行政区，每个行政区都有自己的电话区号，而龙华区是深圳市较新设立的行政区之一，电话区号为0755。除了电话区号，深圳市还有手机号码前缀，目前是以6、7、8、9开头，具体分别为66、67、68、69。这些前缀号码也成为大家经常所说的“深圳手机号”。
0898
龙华区，隶属海南省海口市，地处海口市西北部，介于东经110°14'54"110°24'47"，北纬19°43'07"20°03'10"之间，总面积300.6平方千米。截至2020年6月，龙华区辖6个街道、5个镇，区政府驻滨海街道龙昆北路19号。龙华区地处台地和平原，属于热带季风气候，有水域面积15.25平方千米。根据全国第七次人口普查数据显示，截至2020年11月1日零时，龙华区常住人口797684人。起源于汉代，开埠于宋末元初。从汉代起，属广西。唐贞观元年(627年)，海口始隶属于琼山县。明洪武三年(1370年)，划归广东。1982年10月，成立副县级新华区人民政府(市政府派出机构)。2002年10月16日，撤销新华区，设立龙华区。龙华区境内有骑楼历史文化街区、羊山地区古郡治古村古庙古文化群、新坡冼夫人纪念馆、观澜湖风情小镇、冯小刚电影公社、羊山湿地等历史人文资源。2020年，龙华区完成地区生产总值619.8亿元，同比增长8.6%，在全市增速名列第一；全口径财政收入和地方一般公共预算收入分别达155.13亿元、27.8亿元，增长2.64%和1.6%，在四个区中增速第一；城镇和农村常住居民人均可支配收入分别增长2.6%、7.9%。
智慧城市是指运用物联网、大数据、云计算、人工智能等新一代信息技术，与城市基础设施深度融合，实现城市管理智能化、产业发展智能化、公共服务智能化、社会治理智能化的城市形态。近年来，随着科技的快速发展，智慧城市建设已经成为城市发展的重要方向，将各行各业都带入了数字化时代。
作为深圳市的一个重要组成部分，龙华区一直致力于推动智慧城市建设。龙华区位于深圳市中心区，交通便利，拥有得天独厚的区位优势和产业基础。龙华区智慧城市建设的目标是通过信息化技术的应用，提升城市的管理水平、提高居民生活品质、促进产业发展，实现经济社会可持续发展。
龙华区智慧城市建设主要包括以下几个方面：
龙华区智慧城市建设不仅关乎城市管理和居民生活，也对产业发展有着重要意义。通过数字化转型，龙华区的产业将更加智能化、高效化，为区域经济发展注入新动力。
智慧城市建设对城市和社会的影响是全方位的。首先，智慧城市建设可以提升城市的整体形象和知名度，吸引更多的人才和资金流入。其次，智慧城市建设可以提高城市的运行效率，降低城市管理成本，改善城市环境。再次，智慧城市建设可以推动产业升级，培育新的经济增长点，促进城市经济的可持续发展。
对于居民而言，智慧城市建设提升了生活质量，提供了更便捷、更高效的公共服务，改善了居住环境，增强了生活幸福感。在智慧城市中，人们可以通过手机App实现在线办公、在线购物、在线医疗等，生活更加便利。
同时，智慧城市建设也带来一些挑战和问题。隐私保护、数据安全、信息泄露等问题亟待解决。在推动智慧城市建设的过程中，需要加强相关法律法规的制定和完善，营造公平竞争环境，保障居民的合法权益。
随着科技的不断进步和城市化进程的加快，智慧城市建设将迎来更广阔的发展空间和更多的机遇。未来，智慧城市将更加智能化、绿色化、共享化。人工智能、5G技术、物联网等新技术将得到更广泛的应用，智慧城市系统将更加完善，服务将更加便捷。
在龙华区智慧城市建设中，政府、企业、居民等各方将共同努力，推动智慧城市建设取得更大成就。龙华区将积极探索智慧城市建设的路径，不断完善智慧城市建设的体系，为打造宜居宜业的现代化城市作出积极贡献。
智慧城市建设是城市发展的必然选择，也是社会进步的需要。只有不断创新、不断探索，才能实现城市的可持续发展，为人民群众创造更加美好的生活。
之前看了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());
}
}
