WAN子网与lan子网冲突?

时间:2024-11-06 05:07 人气:0 编辑:招聘街

一、WAN子网与lan子网冲突?

修改IP地址,把LAN口地址改为192.168.2.1,上网方式选择自动获取IP就可以了。一般就是IP冲突的原因。

二、子网掩码,子网号怎么算?

将网络地址和子网掩码均换算成2进制格式,那么32位的地址,从左往右数均是全1的部分,就是子网不变的部分,也就是子网号。

举个例子,假设网络中某个IP地址为192.168.174.86,子网掩码255.255.240.0。换成二进制IP地址为11000000.10101000.10101100.01010110子网掩码为11111111.11111111.11111000.00000000掩码全1部分为21位,那么网络号就是21,对应IP地址,前21位是不变的,那么子网号就为32-21=11。11位的子网。该网络就为192.168.168.0

三、怎么写出子网的子网号及每个子网的主机范围?

额,我最近也在自学计算机网络方面的知识,我的理解是这样的,子网掩码呢实际上就是规定一个子网的ip范围。想我们经常看到的,ip是192.168.1.9。子网掩码为:255.255.255.0,你知道什么意思吧?也就是说该子网的范围就是192.168.1.0到192.168.1.255,就是256个ip,但是每个子网都必须保留两个ip,最小的ip192.168.1.0作为子网号,最大的ip192.168.1.255作为广播地址。所以可用ip等于总范围的该子网内所有ip数量-2等于254。额这么说你明白吗?不明白继续问!我会尽力吧我理解的跟你说!

四、子网号如何知道子网掩码?

看是那一类网,A类子网掩码是255.0.0.0

B类子网掩码是255.255.0.0

C类子网掩码是255.255.255.0

五、子网掩码和子网号的区别?

当然有区别,子网就是来区分不同网络区域。子网掩码就是来划分子网的。

就像192.168.1.1这个地址。没有掩码是不能看子网是什么的。192.168.1.1/255.255.255.128就是分为了2个子网。所以192.168.1.2和1.130就不在一下子网。就是说是不是在一个子网是由掩码确定的

六、子网划分的,子网号怎么算的?

比如172.16.2.160/255.255.255.0: 【1】在没有划分子网的情况下: 这个IP地址的【网络号】就是172.16.2.0 【主机号】为 0.0.0.160 【2】划分子网情况如: 172. 16. 2. 160/255.255.255.192(IP地址/掩码) 1010 1100 0001 0000 0000 0010 1010 0000 (二进制) 1111 1111 1111 1111 1111 1111 1100 0000 (子网掩码) ------------------------------------------相"与"(理解成相乘) 1010 1100 0001 0000 0000 0010 1000 0000(172.16.2.128这就是子网号) 1010 1100 0001 0000 0000 0010 1000 0001(172.16.2.129是第一个主机) 1010 1100 0001 0000 0000 0010 1011 1110(172.16.2.190最后一个主机) 1010 1100 0001 0000 0000 0010 1011 1111 广播地址 172.16.2.191 1010 1100 0001 0000 0000 0010 1100 0000 172.16.2.192 下一个子网 因为掩码是255.255.255.192 ,因此它们之间的网段间隔是256-192=64 所以这个网段只有(2的平方-2)2个子网 172.16.2.128 172.16.2.192 -------------------------------------------------

七、瓜子网是坑吗?

首先声明,以下为本人看法,不代表任何立场,如有雷同,不胜荣幸。

因为一些原因,需要购置汽车一辆,然后就逛逛汽车之家之类的APP,从最先准备的买新车,变为了买一台合适的二手车,本人又恰巧属于半个汽车行业的工作者~所以有了接下来的故事。

最先去本地的二手车市场,逛了一遍,价格偏高,而且没有比较适合自己的车,所以就经常到网上看一些车源。逐渐发现其中瓜子网还相对靠谱一些,于是就还价准备购车。接下来就好玩了~

首先是北京总部的电话,已经被一群人标记为了骚扰电话,基本就是问下你准备不准备按揭啊?(如果你按揭,恭喜你,单独的服务费,GPS费等等你一样少不了)上哪里户啊?就完了,接下来车辆所属地的业务员就会给你打电话,这里我不得不吐槽一下,这个业务员各地水平真相差挺大的~今早还价约看个观致3,业务员打电话来,我告诉他,这个车现在优惠两万起,所以车主标价纯属乱卖,他不信~我也就呵呵了~

其次,瓜子网上的新上架的汽车,分分钟,秒变价格(当然我是指上架几分钟后突然就加价几千,难道是因为我关注 还价了?尴尬脸0.0)

这里我认为各个业务员能力有差距很正常,不代表我对所有瓜子网业务员的看法。不过,我还是想弱弱的问一句,瓜子网,你还招业务员吗?能BB不动脑的那种,我也来混份工资0.0

随着看车和选择车的范围不断扩大,突然发现,瓜子网这里面的水,越来越深了~

首先是服务费,我不想提你的广告词怎么怎么,不赚钱,谁干这个啊?车价3%,最低2000元服务费,这个好像是去年的收费,现在,呵呵呵呵呵~最低收费3500~真特么打脸~(据说服务费可以讲价)

没有中间商赚差价,车主多卖钱,买家少花钱。车主多没多卖钱,不知道,毕竟没卖过车,买家少花钱,哈哈哈哈哈哈哈哈哈哈~普遍瓜子网的车价格都比二手车贵一点,加上服务费,我就呵呵呵呵呵了~(我指的是售价5-15万之前的车,其余没怎么关注)

当然这也只能欺骗欺骗萌新~后面的自欺欺人更是无敌~

照片中,车辆旁边的就是售价,然后你懂得~拿观致5来说,10.5万我就不卖,我只买10.1万~买家也很傲娇,10.1万我就不买,我就要买10.5万的~~~~~哈哈哈哈哈,啪啪啪啪啪的打脸~

最后我想对瓜子网的工作人员说一句,买家想买便宜的车很正常,卖家想卖高价也无可厚非,请找到中间的那个度,别把卖家当上帝,买家当傻子,你要弄清楚,谁付的 服务费养你们的?也请动动脑子和手指多收集相关资料回答买家问题,解决问题,促成买卖达成。

想起再更新吧,洗澡去了。。。

八、子网掩码240有几个子网?

子网掩码是255.255.255.240,掩码二进制位共有连续28个1,可简记为IP/28。则主机位是IP二进制的最后4位,一个子网内地址是2⁴=16个,子网可划分为256/16=16个。

子网1: 192.168.0.0/28~192.168.0.15/28;

子网2: 192.168.0.16/28~192.168.0.31/28;

子网3: 192.168.0.32/28~192.168.0.47/28;

......

子网16: 192.168.0.240/28~192.168.0.255/28。

九、子网地址和子网掩码的区别?

子网地址包括网络地址,主机地址和广播地址。

子网掩码是用来区分网络地址和主机地址的,举个例子来说,子网192.168.1.0,子网掩码是255.255.255.0。网络地址:192.168.1.0,该地址用在路由器的路由表中; 主机地址:192.168.1.1到192.168.1.254,用来识别不同的主机; 广播地址:192.168.1.255,用于在该网段的所有主机设备发送报文。再来说掩码: 255用二进制表示是8个1,11111111,3个255用二进制表示是24个1,对应IP地址的网络地址部分:192.168.1,这个部分对所有在这个网段的主机都是一样的,掩码最后一个0对应二进制的8个0,不同主机该部分是不同的,在该网段对应1~254。IP地址与掩码通过二进制“与”运算来得到IP地址的网络部分和主机部分。

十、mahout面试题?

之前看了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());

}

}

相关资讯
热门频道

Copyright © 2024 招聘街 滇ICP备2024020316号-38