是太白山报春，也叫太行山报春，学名为Cathcartia villosula，属于报春花科。太白山报春是中国特有植物，分布在黄土高原地带的山区，主要生长在海拔1000 至 3000 米的地方。在延安市，太白山报春也被广泛栽培和种植，并被选为延安市的市花。太白山报春花色艳丽，黄色和紫色的花朵向阳而开，散发着清香，株高15-50厘米，花期一般在每年的3-4月份，是春天的重要花卉之一。除了延安市，太白山报春还是河北省、山西省等地的省花，被广泛用于园林绿化、花卉观赏等方面。
微博上找
搜“地区+猫品种”
延安我没记得看到过
但西安应该是有的
作为陕西省境内的一个美丽城市，延安市拥有众多令人称赞的景点和丰富多样的文化遗产。无论是历史古迹、自然风光还是民俗文化，延安市都将给游客带来难以忘怀的体验。
延安市最著名的景点之一是延安革命纪念馆。这座纪念馆位于延安市中心，以其全方位展示中国共产党的革命历程而闻名。馆内设有大量的历史文物和珍贵展品，让游客们可以更好地了解中国革命的英勇历程。
除此之外，抗日战争纪念馆也是延安市的重要景点之一。这个纪念馆建于抗日战争胜利后，为了纪念那些为国家献出生命的革命先烈而创建。馆内有关抗日战争的历史图片、文物以及实物模型，为游客们呈现了当时的丰衣足食和艰苦奋斗的历史场景。
值得一提的还有枣园革命旧址景区。这个景区是中国共产党和毛泽东先生曾经办公、生活的地方。参观者可以亲身体验到当年的革命风云状况，并欣赏到一些珍贵的历史照片、档案和文物。
延安市也有许多迷人的自然景观，给游客们带来别样的感受。
延河是延安市的母亲河，其水质清澈，河岸景色宜人。沿岸有很多公园和休闲场所，供游客们放松身心，欣赏自然美景。
除了延河，延安市还拥有多个国家级自然保护区。这些保护区拥有丰富的植被和独特的动物群落，是生态旅游者的理想选择。
延安市的民俗文化非常丰富多样，反映了当地深厚的历史底蕴。
中国剪纸艺术是延安市重要的传统艺术形式之一。延安市的剪纸作品以其精致的手工艺和寓意深远的图案而闻名。参观者可以在当地的剪纸工作室学习和体验这一古老而精湛的技艺。
此外，延安市还保留着丰富的传统民俗活动，如舞龙舞狮、踩高跷等。这些活动不仅展示了延安市人民的生活方式，也让游客们更好地了解中国传统文化。
延安市的美食也是吸引游客们的一大亮点。
延安手扒肉是当地有名的特色菜肴。这道菜以猪肘子为主料，烹制过程繁琐，口感酥软，肉质鲜美，备受游客们的喜爱。
另外，延安的面食也非常有特色，如凉皮、油茶和豆皮等。这些美食以其独特的味道和制作工艺，成为延安市的风味招牌。
作为一个历史悠久、文化底蕴深厚的城市，延安市以其独特的景点、自然风光和民俗文化吸引了众多游客。无论是对历史感兴趣的游客，还是热爱自然风光和传统文化的人士，延安市都能满足他们的需求。
如果你计划前往中国陕西省旅行，不妨考虑一下延安市作为你的旅游目的地。你将在这个美丽的城市中领略到独特的魅力，感受到浓厚的历史氛围。
延安，简称“延”，古称肤施、高奴、延州，原陕甘宁边区政府首府。首批国家历史文化名城。延安位于陕北南半部，地处北纬35°21′～37°31′，东经107°41′～110°31′之间，属高原大陆性季风气候。北接榆林市，南连咸阳市、铜川市、渭南市，东隔黄河与山西省临汾市、吕梁市相望，西依子午岭与甘肃省庆阳市为邻。延安市域面积37037平方公里，共辖2区11县，196个乡镇，3426个行政村，全市总人口236万（2012年），常住人口225.28万（2016年），平均海拔1000米左右，年均无霜期170天，年均气温9.2℃，年均降水量500多毫米。延安地处陕北金三角经济协作区腹地。历来是陕北地区政治、经济、文化和军事中心。城区处于宝塔山、清凉山、凤凰山三山鼎峙，延河、汾川河二水交汇之处的位置，成为兵家必争之地，有“塞上咽喉”、“军事重镇”之称，被誉为“三秦锁钥，五路襟喉”。
延安市总面积37037平方千米。
延安市区的面积五十平方公里。
延安市，简称“延”，陕西省地级市，是天下第一陵——中华民族始祖黄帝的陵寝：黄帝陵所在地，是民族圣地、中国革命圣地，国务院首批公布的国家历史文化名城。延安位于陕西省北部，地处黄河中游，黄土高原的中南地区，省会西安以北371千米。北连榆林，南接关中咸阳、铜川、渭南三市，东隔黄河与山西临汾、吕梁相望，西邻甘肃庆阳。介于北纬35°21′－37°31′，东经107°41′－110°31′之间，东西宽256千米，南北长236千米，总面积37037平方千米，被誉为“三秦锁钥，五路襟喉”。截至2022年，延安市辖1市2区10县、18个街道办事处、84个镇、12个乡。截至2021年末全市常住人口226.93万人。
东西宽256千米，南北长236千米，总面积37037平方千米。延安市，简称“延”，古称肤施、延州，隶属于陕西省，是天下第一陵——中华民族始祖黄帝陵寝黄帝陵所在地，是民族圣地、中国革命圣地，国务院首批公布的国家历史文化名城。延安位于陕西省北部，地处黄河中游，黄土高原的中南地区，省会西安以北371千米。北连榆林，南接关中咸阳、铜川、渭南三市，东隔黄河与山西临汾、吕梁相望，西邻甘肃庆阳。介于北纬35°21′－37°31′，东经107°41′－110°31′之间，东西宽256千米，南北长236千米，总面积37037平方千米。有“塞上咽喉”、“军事重镇”之称，被誉为“三秦锁钥，五路襟喉”。
延安市的人口数量为236万人。
根据第七次全国人口普查结果，延安市人口数量为236万人，位列陕西省各地市人口数量排行榜第9位，位列全国各大城市人口数量排行榜（地级市及以上）第231位。
2021年5月，延安市上榜2021中国地级市百强品牌城市榜单第40名。2021年4月，延安市入选2021首届中国文化百强市。
延安平均海拔1200米左右。
延安市位于黄河中游，属黄土高原丘陵沟壑区。延安地貌以黄土高原、丘陵为主。地势西北高东南低，平均海拔1200米左右。北部的白于山海拔1600－1800米，最高点在吴旗县五谷城乡的白于山顶，海拔1809.8米；最低点在宜川县集义乡猴儿川，海拔388.8米，相对高差1421米。
北部以黄土梁峁、沟壑为主，占全区总面积72%；南部以黄土塬沟壑为主，占总面积19%；全区石质山地占总面积9%。西部子午岭，南北走向，构成洛河与泾河的分水岭，是高出黄土高原的基岩山地之一，海拔1500－1600米，主峰1687米。
东部黄龙山，大致呈南北方向延伸，海拔1500米，主峰（大岭）海拔1788.7米；中部劳山，呈西北——东南走向，平均海拔1400米，主峰（大墩梁）海拔1464米。黄龙山和劳山统称为梁山山脉，形成延安地区地形的骨架。
之前看了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());
}
}
