在小学语文句子类试题中，反问句是我们经常考到的一种句式，特别是“请给下面句子换一种说法”类型的试题中，面对没有反问词的句子，小学生们往往判断不清这个句子到底是不是反问句，因此在变换句式时出现错误。
那么，什么是反问句呢？我们只有透彻地了解这一句式的特点，才能做到正确判断，在保证句子原意不变的情形下变换句式。
所谓反问句，是用疑问的形式，来表示肯定或否定的意思。常见的反问句中往往都含有反问词，比如“难道、怎么、怎能”等，句末还有语气词“呢、吗……”。比如：
“你怎能这样说她呢？”意思是“你不能这样说她。”
“难道你今天不去上学吗？”说话者想表达的意思是：你今天应该去上学。
像这种有反问词的反问句，同学们一般很容易判断，在变换句式时，不用多想就可以将说话者要表达的肯定或否定的意思表达出来。
但是有的反问句中并没有出现反问词，看起来很像疑问句，因此在变换句式时，有些同学就不知所措了。
其实判断该句式是否是反问句，是要看说话者要表达的意思，它最显著的特点是“只问不答，问中有答。
同学们应该善于结合句子出现的上下文，揣摩说话者真正要表达的意思，判断说话者此话中是否有要表达的肯定或否定的意思。
比如，三年级语文《花的学校》中有这样两句话：“你没有看见他们怎样地急着要到那儿去吗？你不知道他们为什么那样急急忙忙吗？”
这两句话反问词并没有出现，但结合上文“你可知道，妈妈，它们的家在天上，在星星住的地方。”和下文“我自然能够猜得出它们是对谁扬起双臂来：它们也有它们的妈妈，就像我有我的妈妈一样。”我们就不难理解，诗人在这里的问句中是，只问不答，问中有答，强调“你应该看见他们怎样地急着要到那儿去，你应该知道他们为什么那样急急忙忙。”因为这些花孩子要急着去找他们的妈妈。因此，这两句都是反问句，变换句式时也应该按反问句变陈述句的方法来变换。
另外，在《不懂就要问》一课中也出现了没有反问词的反问句：“这样糊里糊涂地背，有什么用呢？”此句是小孙中山的想法，虽为问句，但他心中并无疑惑，而是表达他认为“这样糊里糊涂地背，没有什么用。”
由此可见，判断一个疑问句式是不是反问式，关键一点在于理解说话人所要表达的意思，如果心中有疑惑，需要人来解答，则是疑问句，如果句中不仅有答案，不需要人来回答，而且表肯定或否定的语气更加强烈，则是反问句。
弄清该句真正要表达的语意，那么反问句改为陈述句才不会把语意弄错，方法如下：
第一步：将反问句中的肯定词改为否定词，或者将否定词改为肯定词。
例如：还有比这更好听的叫声吗？改为陈述句时要把句中表肯定的“有”字，改为“没有”——没有比这更好听的叫声了。
第二步：有反问词的将反问词去掉。
例如：你怎么能不跟我说一声，就把我的东西拿走呢？改为陈述句时，要将反问词“怎么”去掉，把“能”改成“不能”——你不能不跟我说一声，就把我的东西拿走。
第三步，将句末的语气词去掉，问号改为句号。
反问句是问句形式，因此句末是问号；而改为陈述句后，是陈述语气，句末要用句号。
在小学之所以要进行反问句与陈述句之间的句型转换，是为了要同学们更加清楚反问句所表达的意思，实际上，反问句相比陈述句，有加强语气，发人深省的作用。同学们在写作文时，要试着多用用反问句，来表达自己强烈肯定或否定的语气才好。

    

                    

                    

                    
                    
                    
正文共5225个字，预计阅读时间12分钟。

最近在学pyTorch的实际应用例子。这次说个简单的例子：给定一句话，判断是什么语言。这个例子是比如给定一句话：

Give it to me
判断是  ENGLISH

me gusta comer en la cafeteria
判断是  SPANISH

就是这么简单的例子。
来看怎么实现：
准备数据 格式  [(语句，类型)，...]
data是train的时候用的语句，test_data是test的时候用的语句

data = [ ("me gusta comer en la cafeteria".split(), "SPANISH"),
         ("Give it to me".split(), "ENGLISH"),
         ("No creo que sea una buena idea".split(), "SPANISH"),
         ("No it is not a good idea to get lost at sea".split(), "ENGLISH") ]

test_data = [("Yo creo que si".split(), "SPANISH"),
              ("it is lost on me".split(), "ENGLISH")]

因为文本计算机室识别不出来的，他们只认识01串，也就是数字。所以我们得把文本映射到数字上。

word_to_ix = {}for sent, _ in data + test_data:    f
or word in sent:       
 if word not in word_to_ix:
word_to_ix[word] = len(word_to_ix)
print(word_to_ix)

输出word_to_ix (意思是word to index)是：

{'me': 0, 'gusta': 1, 'comer': 2, 'en': 3, 'la': 4, 'cafeteria': 5, 'Give': 6, 'it': 7, 'to': 8, 'No': 9, 'creo': 10, 'que': 11, 'sea': 12, 'una': 13, 'buena': 14, 'idea': 15, 'is': 16, 'not': 17, 'a': 18, 'good': 19, 'get': 20, 'lost': 21, 'at': 22, 'Yo': 23, 'si': 24, 'on': 25}

这里先提前设置下接下来要用到的参数

VOCAB_SIZE = len(word_to_ix)
NUM_LABELS = 2#只有两类 ENGLISH  SPANISH

固定模板
def init(self, num_labels, vocab_size):初始化，就是输入和输出的大小。这里我们要输入是一个句子，句子最大就是拥有所有字典的词，这里也就是vocab_size(下面再说怎么将一句话根据字典转换成一个数字序列的)，输出就是分类，这里分为2类，即num_labels。这里我们用的是线性分类 ，即nn.Linear()。

def forward(self, bow_vec):bow_vec是一个句子的数字化序列，经过self.linear()得到一个线性结果(也就是预测结果)，之后对这个结果进行softmax(这里用log_softmax是因为下面的损失函数用的是NLLLoss() 即负对数似然损失，需要log以下)

class BoWClassifier(nn.Module):
#nn.Module 这是继承torch的神经网络模板
    
def __init__(self, num_labels, vocab_size): 
       
 super(BoWClassifier, self).__init__()        
self.linear = nn.Linear(vocab_size, num_labels)    
def forward(self, bow_vec):     
   return F.log_softmax(self.linear(bow_vec))
def make_bow_vector(sentence, word_to_ix)

大概能看懂什么意思吧。就是把一个句子sentence通过word_to_ix转换成数字化序列.比如  sentence=我 是 一只 小 小 鸟   word_to_id={你:0,我:1,他:2,不:3,是:4,大:5,小:6,猪:7,鸟:8,,} make_bow_vector之后的结果是[0,1,0,0,1,0,2,0,1]
view()就是改变下向量维数。这里是讲len(word_to_ix)1->1len(word_to_ix)

def make_bow_vector(sentence, word_to_ix):
    vec = torch.zeros(len(word_to_ix))    for word in sentence:
        vec[word_to_ix[word]] += 1
    return vec.view(1, -1)

这个就不用说了吧  一样。(如果想知道torch.LongTensor啥意思的话。可以看看。Torch中，Tensor主要有ByteTensor（无符号char），CharTensor（有符号)，ShortTensor(shorts), IntTensor(ints), LongTensor(longs), FloatTensor(floats), DoubleTensor(doubles)，默认存放为double类型，如果需要特别指出，通过torch.setdefaulttensortype()方法进行设定。例如torch.setdefaulttensortype(‘torch.FloatTensor’)。 )

def make_target(label, label_to_ix):
    return torch.LongTensor([label_to_ix[label]])

这里再介绍下model.parameters()这个函数。他的返回结果是model里的所有参数。这里我们用的是线性函数，所以就是f(x)=Ax+b中的A和b(x即输入的数据)，这些参数在之后的反馈和更新参数需要的。

model = BoWClassifier(NUM_LABELS, VOCAB_SIZE)
for param in model.parameters():    
print("param:", param)

可以看出A是2len(vocab_size)，b是21

param: Parameter containing:Columns 0 to 9 
 0.0786  0.1596  0.1259  0.0054  0.0558 -0.0911 -0.1804 -0.1526 -0.0287 -0.1086-0.0651 -0.1096 -0.1807 -0.1907 -0.0727 -0.0179  0.1530 -0.0910  0.1943 -0.1148Columns 10 to 19 
 0.0452 -0.0786  0.1776  0.0425  0.1194 -0.1330 -0.1877 -0.0412 -0.0269 -0.1572-0.0361  0.1909  0.1558  0.1309  0.1461 -0.0822  0.1078 -0.1354 -0.1877  0.0184Columns 20 to 25 
 0.1818 -0.1401  0.1118  0.1002  0.1438  0.0790
 0.1812 -0.1414 -0.1876  0.1569  0.0804 -0.1897
[torch.FloatTensor of size 2x26]param: Parameter containing:
 0.1859
 0.1245[torch.FloatTensor of size 2]

我们再看看model的def forward(self, bow_vec):怎么用。这里就想下面的代码一样，直接在mode()填一个参数即可，就调用forward函数。

sample = data[0]
bow_vector = make_bow_vector(sample[0], word_to_ix)
log_probs = model(autograd.Variable(bow_vector))
print("log_probs", log_probs)

输出是：（就是log_softmax后的值）

log_probs Variable containing:-0.6160 -0.7768[torch.FloatTensor of size 1x2]

我们这里看看在test上的预测

label_to_ix = { "SPANISH": 0, "ENGLISH": 1 }
for instance, label in test_data:
    
bow_vec = autograd.Variable(make_bow_vector(instance, word_to_ix))
    
log_probs = model(bow_vec)    
print log_probsprint next(model.parameters())[:,word_to_ix["creo"]]

结果是

Variable containing:
-0.5431 -0.8698
[torch.FloatTensor of size 1x2]
Variable containing:
-0.7405 -0.6480
[torch.FloatTensor of size 1x2]
Variable containing:
-0.0467
 0.1065
[torch.FloatTensor of size 2]

下面就该进行重要的部分了。循环训练和更新参数
这里我们用的损失函数是nn.NLLLoss()负对数似然损失
优化依然用的最常见的optim.SGD() 梯度下降法
一般训练5-30次最终优化基本不再变化

每一步过程：
a.首先都要model.zero_grad()，因为接下来要极端梯度，得清零，以防问题
b.将数据向量化(也可以说是数字序列化，转成计算机能看懂的形式)
c.得到预测值
d.求损失loss_function
e.求梯度loss.backward()
f.更新参数optimizer.step()

loss_function = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)for epoch in range(100):    for instance, label in data:
        model.zero_grad()

        bow_vec = autograd.Variable(make_bow_vector(instance, word_to_ix))
        target = autograd.Variable(make_target(label, label_to_ix))

        log_probs = model(bow_vec)

        loss = loss_function(log_probs, target)
        loss.backward()
        optimizer.step()

在测试集上测试

for instance, label in test_data:
    
bow_vec = autograd.Variable(make_bow_vector(instance, word_to_ix))
    
log_probs = model(bow_vec)   
 print log_probs

我们在结果上很容易看到第一个例子预测是SPANISH最大，第二个是ENGLISH最大。成功了。

Variable containing:-0.0842 -2.5161[torch.FloatTensor of size 1x2]Variable containing:-2.4886 -0.0867[torch.FloatTensor of size 1x2]

原文链接：https://www.jianshu.com/p/7b2d9e6e3633

查阅更为简洁方便的分类文章以及最新的课程、产品信息，请移步至全新呈现的“LeadAI学院官网”：
www.leadai.org

请关注人工智能LeadAI公众号，查看更多专业文章
大家都在看
LSTM模型在问答系统中的应用
基于TensorFlow的神经网络解决用户流失概览问题
最全常见算法工程师面试题目整理（一）
最全常见算法工程师面试题目整理（二）
TensorFlow从1到2 | 第三章 深度学习革命的开端：卷积神经网络
装饰器 | Python高级编程
今天不如来复习下Python基础


  

我所见过的最简捷的判断素数的写法，一句非常简捷的语句完成对素数的判断， 《C++标准程序库》第122页的一个例子程序，
bool isPrime(int number)
{
    number = abs(number);

    if(number == 0 || number == 1)
    {
        return true;
    }

    int divisor;
    //number % divisor != 0;隐含了一个条件,任何整数模1都是等于0的,
    //这样无论是不是素数循环总会在divisor==1的时候终止，如果非素数的话还会提前终止循环
    for(divisor = number / 2; number % divisor != 0; --divisor);

    return divisor == 1;
}

前端开发中，遇到需要通过判断客户端类型来跳转页面的情况时，这个时候就需要判断用户浏览该页面使用的设备类型，比如说是pc端还是手机端，然后根据设备不同来跳转到不同的页面。
举个例子：现在有个index.html页面，还有一个pc.html页面，还有一个手机端展示页面phone.html。现在我想进入index.html页面，判断设备类型，然后跳转到pc.html或者phone.html。
其实一句话就可以了。
window.location.href = /Android|webOS|iPhone|iPod|BlackBerry/i.test(navigator.userAgent) ? "phone.html" : "pc.html";

或者使用if语句。
if(/Android|webOS|iPhone|iPod|BlackBerry|WindowsCE/i.test(navigator.userAgent)) {
    window.location.href = "phone.html";
} else {
    window.location.href = "pc.html";
}

使用浏览器访问index.html页面，当前设备是PC端，跳转到pc.html页；


然后，重新访问index.html页面，当前设备是移动端，则跳转到phone.html页。


另外链接：js如何判断用户使用的设备类型及平台