万物皆可卷，一夜之间，“内卷”这个词遍地开花。
 
 
 
一、内卷到底是什么意思？
 
由青塔发的微信推文，清北硕博生，也难逃「内卷」，这一文让我意思到最近听到的很多遍的“内卷”，思考“内卷”到底是什么意思？
 
我觉得知乎上说的很好，内卷。
 
通俗易懂的解释内卷，并列举一些例子：
 
 
 
看电影，为了获得更好的视野，一个人先站起来看了，被他挡住的人不得不也站起来，最后大家都不得不站起来看电影，只有第一排的人坐着。
 
 
 
 
玩游戏，为了更好地娱乐，一个人先充钱吊打别人去了，被他虐的人不得不也充钱，最后所有的人要么使劲充钱要么被吊打，只有管理员不用充钱还能吊打所有人。
 
 
 
 
追女生，为了更好地表示心意，一个男人钻石恒永远一颗永流传了，其他人不得不跟着钻石永久传，所有人都花了更多的钱，只有卖钻石的赚了。
 
 
 
 
抢火车票，一个人先用抢票软件，逼得其他人也用抢票软件，因为票没有变多，最后大家都回到了起跑线，但是开发抢票软件的赚了。
 
 
 
 
孩子上学，一个孩子上辅导班，逼得大家都去上辅导班，最后排名还是没变，但开辅导班的赚了
 
 
 
 
本来大家都是工作8小时，有人开始加班，最后逼得所有人都加班，所有人挣得还是那点钱，但是老板的3系换5系了。
 
 
内卷是啥，就是大家都损失了，只有一小撮人赚了。
 
那一小撮人赚的原因，很可能只是买了第一排的电影票而已。
 
但他们不这么讲，而是会告诉你，你没坐在第一排是因为你不努力。
 
我是努力才坐到第一排的。久而久之，大家就会忘了，假如没人站起来，看电影最好的位置是在中间的……
 
简而言之就是：日复一日，越混越掉坑里。
 
通俗地说，内卷就是内部竞争。
 
所谓内卷化，指一种社会（文化模式）某一发展阶段达到某种确定的形式之后，这种形式便停止不前，难以转化为另一种高级模式的现象，从而把自我锁死在低水平状态上，周而复始地循环。
 
二、 关于高校学历“内卷”一些看法
 
之前在网上看到一个这样的推文，里面写到，你上课研究生你就是已经是同龄人的前3.71%，如下图。
 
 
但是，真的是这样吗？
 
你上了211的研究生你就真的是那百分之一了吗？你在两电一邮就真的是那千分之几 了吗？由于今年的疫情，我不能说今年大家找工作都不顺利，也不能说大家都很顺利吧。
 
大学扩招：高学历正成为“标配”
 
没有什么东西是平地起波澜毫无预兆的，水面总有涟漪。在内卷这个生动且形象的词出现前，高等教育领域的“内卷”是：随着教育扩招，原本本科生就能胜任的工作，现在需要硕博学历才能勉强抢到“入场券”。
 
现在2020年研究生的扩招，传统的高学历正在逐渐成为“标配”，2019年全国教育事业发展统计公报数据显示，全国各类高等教育在学总规模4002万人，其中，在学博士生42.42万人，在学硕士生243.95万人。
 
高校扩招的20余年，也是学历贬值的20年，中国正在经历一场前所未有的学历泡沫。
 
扩招力度大！超百所“双一流”高校公布2021年硕士招生人数
 
自1999年第一次扩招至今，扩招的脚步一直不曾停下。教育部副部长翁铁慧透露，2020将扩大硕士研究生招生预计同比增加18.9万。
 
学历贬值
 
从这推文中，可以看出博士研究生招生规模适度超前布局，硕士研究生招生规模稳步扩大，听到现在很多大叔说，现在的大学生就像以前的初中生，研究生就好比以前的高中生，可能没有那么的夸张，但是我想几年后，可能真的就好比这种情况了。
 
学历贬值的问题，意味着呈指数增长的“内卷”速度，上个世纪，考上大学意味着能当“干部”，吃“城镇粮”，一个大学生甚至能带动整个家族实现鲤鱼跃龙门的阶级跨越；而现在，博士学历才勉强拥有留校的资格。
 
 
 是时代发展，社会对学历的要求提高了吗？未必。
 
 
博士扎堆想进高校却没有坑位，只能退而求其次，选择与硕士生争抢工作岗位，而硕士生竞争不过博士生，只能选择和本科生争夺工作岗位。
 
 
学历贬值意味着，本科生在求职市场中的竞争力将当然无存。那有人会说，那就考研读研，“堵了总比不读强，研究生更好找工作”。这种思想，就造成了内卷时代的到来，不断自我鞭打的旋转陀螺。
 
内卷时代：不断自我鞭打的旋转陀螺
 
在内卷时代，导致大家不得不成为不断自我鞭打的旋转陀螺，从大一就开始想着考研，“大一是否能进实验室？”“本科需要发论文？”等一系列问题。。。
 
 
甚至从浙大对学生的课程作业中可以看出，现在的学生们面临的巨大竞争压力。
 
曾经一篇CNS可以参评副教授，现在需要手攥更多论文才能保证不被出局。有青椒在网上分享了自己的内卷经历：为了评职称，把一篇好论文拆成了八篇水文。
 
作者在文中这样自诉：“一开始大家都在认真做科研，认真写文章，**虽然文章数量少，但是质量高。**后来，有人发现做短平快的工作，灌一些水文章可以对其他人形成数量碾压，从而在评职称时占据极大优势。于是剩下的人也被迫参与灌水以求在文章数量上不落人后。最后人手一把水文，大家又回到了同一起跑线，都没赚到便宜。”
 
在职位数量一定的情况下，争取职位的竞争对社会而言是一个零和博弈。所有人付出了更多的努力，却没能产生更大的社会效益，这就是内卷。
 
高等教育领域的内卷，是一场消耗精力的死循环。
 
三、不允许退出，不允许失败
 
高强度的竞争使人精疲力尽，越来越多人对此感到疲倦和困惑：为什么我那么努力，却连最基本的期望都没有达到？
 
知识改变命运，一直以来，教育都肩负着“命运上升”的重要使命。高学历却没有获得与之匹配的体面工作和高价薪酬，在某种社会层面上就被定义成了loser，背负着强大的道德压力。
 
所有人都挤在一个赛道上，压力逼迫着你要往上走，不允许你往下落，不被允许退出的内卷让每一个人都成为了不断自我鞭打的、停不下来的旋转陀螺。
 
经过激烈的竞争拼杀，收获的却是一场空， 而身处于内卷的环境之中，明知道竞争无用，还是要竞争，这才是最让人感到绝望的。
 
一边是社会用工荒，一边是大学生就业难，学历成了屠龙之技，无处发挥，却又必不可少。
 对未来的迷茫、对当下的困惑，让不少大学生主动“内卷”：只顾着着超车，却没想清楚自己的目的地到底在哪里，比提升自己更重要的，是竞争过别人。
 
面对内卷，除了“被卷”，更重要的是想明白：我想成为什么样的人？赛道终点的奖品到底是不是我想要的？
 
如果注定要被“内卷”裹挟着往前走，至少不要温驯的走向那良夜。

Pytorch一小时入门教程
 
前言
 
    机器学习的门槛并没有想象中那么高，我会陆续把我在学习过程中看过的一些文章和写过的代码以博客的形式分享给大家，和大家一起交流，这个是本系列的第一篇，pytoch入门教程，翻译自pytoch官方文档：Pytorch一小时入门教程。
 
pytorch是什么
 
    它是一个基于python的科学计算库，致力于为两类用户提供服务：
 
一些想要找到Numpy搭建神经网络替代品的用户；
寻找一个可提供极强的可拓展性和运行速度的深度学习研究平台；
 
让我们开始干活吧！
 
1. 张量的概念和生成
 
    张量和Numpy中ndarrays的概念很相似，有了这个作为基础，张量也可以被运行在GPU上来加速计算，下面介绍如何创建张量。
 
from __future__ import print_function
import torch
# 这个是用来生成一个为未初始化的5*3的张量，切记不是全零
x = torch.empty(5, 3)
print(x)
"""
tensor([[2.7712e+35, 4.5886e-41, 7.2927e-04],
        [3.0780e-41, 3.8725e+35, 4.5886e-41],
        [4.4446e-17, 4.5886e-41, 3.9665e+35],
        [4.5886e-41, 3.9648e+35, 4.5886e-41],
        [3.8722e+35, 4.5886e-41, 4.4446e-17]])
"""

# 这个是生成一个均匀分布的初始化的，每个元素从0~1的张量，与第一个要区别开，另外，还有其它的随机张量生成函数，如torch.randn()、torch.normal()、torch.linespace()，分别是标准正态分布，离散正态分布，线性间距向量
x = torch.rand(5, 3)
print(x)
"""
tensor([[0.9600, 0.0110, 0.9917],
        [0.9549, 0.1732, 0.7781],
        [0.8098, 0.5300, 0.5747],
        [0.5976, 0.1412, 0.9444],
        [0.6023, 0.7750, 0.5772]])
"""

# 这个是初始化一个全零张量，可以指定每个元素的类型。
x = torch.zeros(5, 3, dtype=torch.long)
print(x)
"""tensor([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])"""

#从已有矩阵转化为张量
x = torch.tensor([5.5, 3])
print(x)
"""
tensor([5.5000, 3.0000])
"""

# 从已有张量中创造一个张量，新的张量将会重用已有张量的属性。如：若不提供新的值，那么每个值的类型将会被重用。
x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes
print(x)

x = torch.randn_like(x, dtype=torch.float)    # override dtype!
print(x)                                      # result has the same size
"""
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
tensor([[ 0.3327, -0.2405, -1.3764],
        [-0.1040, -0.9072,  0.0069],
        [-0.2622,  1.8072,  0.0175],
        [ 0.0572, -0.6766,  1.6201],
        [-0.7197, -1.1166,  1.7308]])
        """

# 最后我们学习如何获取张量的形状，一个小Tip,torch.Size是一个元组，所以支持元组的操作。
print(x.size())
"""torch.Size([5, 3])"""

 
2. 张量的操作
 
    实际上有很多语法来操作张量，现在我们来看一看加法。
 
y = torch.rand(5, 3)
# 加法方式1
print(x + y)
"""
tensor([[ 1.2461,  0.6067, -0.9796],
        [ 0.0663, -0.9046,  0.8010],
        [ 0.4199,  1.8893,  0.7887],
        [ 0.6264, -0.2058,  1.8550],
        [ 0.0445, -0.8441,  2.2513]])
"""
# 加法方式2
print(torch.add(x, y))
"""
tensor([[ 1.2461,  0.6067, -0.9796],
        [ 0.0663, -0.9046,  0.8010],
        [ 0.4199,  1.8893,  0.7887],
        [ 0.6264, -0.2058,  1.8550],
        [ 0.0445, -0.8441,  2.2513]])
"""
# 还可以加参数
result = torch.empty(5, 3)
torch.add(x, y, out=result)
print(result)
"""
tensor([[ 1.2461,  0.6067, -0.9796],
        [ 0.0663, -0.9046,  0.8010],
        [ 0.4199,  1.8893,  0.7887],
        [ 0.6264, -0.2058,  1.8550],
        [ 0.0445, -0.8441,  2.2513]])
"""
# 方法二的一种变式，注意有一个‘_’，这个符号在所有替换自身操作符的末尾都有，另外，输出的方式还可以象python一样。
y.add_(x)
print(y)
"""
tensor([[ 1.2461,  0.6067, -0.9796],
        [ 0.0663, -0.9046,  0.8010],
        [ 0.4199,  1.8893,  0.7887],
        [ 0.6264, -0.2058,  1.8550],
        [ 0.0445, -0.8441,  2.2513]])
"""
print(x[:, 1])
"""
tensor([-0.2405, -0.9072,  1.8072, -0.6766, -1.1166])
"""
 
    我们现在看一看如何调整张量的形状。
 
x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
print(x.size(), y.size(), z.size())
"""
torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
"""
 
    我们现在看一看如何查看张量的大小。
 
x = torch.randn(1)
print(x)
print(x.item())
"""
tensor([-1.4743])
-1.4742881059646606
"""
 
到这里，基本的操作知识就已经讲完了，如果了解更详细的部分，请点击这个链接.
 
3. 张量和Numpy的相互转换
 
    张量和Numpy数组之间的转换十分容易。
 
Tensor到Nump，在使用Cpu的情况下，张量和array将共享他们的物理位置，改变其中一个的值，另一个也会随之变化。
 
a = torch.ones(5)
print(a)
"""
tensor([1., 1., 1., 1., 1.])
"""
b = a.numpy()
print(b)
"""
[1. 1. 1. 1. 1.]
"""
a.add_(1)
print(a)
print(b)
"""
tensor([2., 2., 2., 2., 2.])
[2. 2. 2. 2. 2.]
"""
 
Numpy到Tensor ，在使用Cpu的情况下，张量和array将共享他们的物理位置，改变其中一个的值，另一个也会随之变化。
 
import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)
"""
[2. 2. 2. 2. 2.]
tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
"""
 
Gpu下的转换。
 
# let us run this cell only if CUDA is available
# We will use ``torch.device`` objects to move tensors in and out of GPU
if torch.cuda.is_available():
    device = torch.device("cuda")          # a CUDA device object
    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU
    x = x.to(device)                       # or just use strings ``.to("cuda")``
    z = x + y
    print(z)
    print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!
"""
tensor([-0.4743], device='cuda:0')
tensor([-0.4743], dtype=torch.float64)
"""
 
自动微分
 
    在pytorch中，神经网络的核心是自动微分，在本节中我们会初探这个部分，也会训练一个小型的神经网络。自动微分包会提供自动微分的操作，它是一个取决于每一轮的运行的库，你的下一次的结果会和你上一轮运行的代码有关，因此，每一轮的结果，有可能都不一样。接下来，让我们来看一些例子。
 
1. 张量
 
    torch.Tensor是这个包的核心类，如果你设置了它的参数 ‘.requires_grad=true’ 的话，它将会开始去追踪所有的在这个张量上面的运算。当你完成你得计算的时候，你可以调用’backwward()来计算所有的微分。这个向量的梯度将会自动被保存在’grad’这个属性里面。
     如果想要阻止张量跟踪历史数据，你可以调用’detach()'来将它从计算历史中分离出来，当然未来所有计算的数据也将不会被保存。或者你可以使用’with torch.no_grad()‘来调用代码块，不光会阻止梯度计算，还会避免使用储存空间，这个在计算模型的时候将会有很大的用处，因为模型梯度计算的这个属性默认是开启的，而我们可能并不需要。
     第二个非常重要的类是Function，Tensor和Function,他们两个是相互联系的并且可以搭建一个非循环的运算图。每一个张量都有一个’grad_fn’的属性，它可以调用Function来创建Tensor，当然，如果用户自己创建了Tensor的话，那这个属性自动设置为None。
     如果你想要计算引出量的话，你可以调用’.backward()'在Tensor上面，如果Tensor是一个纯数的话，那么你将不必要指明任何参数；如果它不是纯数的话，你需要指明一个和张量形状匹配的梯度的参数。下面来看一些例程。
 
import torch
x = torch.ones(2, 2, requires_grad=True)
print(x)
"""
tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
"""
y = x + 2
print(y)
"""
tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)
"""
print(y.grad_fn)
"""
<AddBackward0 object at 0x7fc6bd199ac8>
"""
z = y * y * 3
out = z.mean()
print(z, out)
"""
tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)
"""
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)
"""
False
True
<SumBackward0 object at 0x7fc6bd1b02e8>
"""
 
2. 梯度
 
    现在我们将进行反向梯度传播。因为输出包含一个纯数，那么out.backward()等于out.backward(torch.tensor(1.))；梯度的计算如下（分为数量和向量）
 
数量的梯度，即各个方向的导数的集合
 
print(x.grad)
"""
tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])
"""
 
向量的全微分，即雅可比行列式。
 $\begin{array}{r}J=\left(\begin{array}{ccc}\frac{\partial y_1}{\partial x_1}& \cdots & \frac{\partial y_1}{\partial x_n}\\ ⋮& \ddots & ⋮\\ \frac{\partial y_m}{\partial x_1}& \cdots & \frac{\partial y_m}{\partial x_n}\end{array}\right)\end{array}$
最后的例子。
 
v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)

print(x.grad)
"""
tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])
"""
#停止计算微分
print(x.requires_grad)
print((x ** 2).requires_grad)

with torch.no_grad():
   print((x ** 2).requires_grad)
"""
True
True
False
"""
 
神经网络
 
    神经网络可以用torch.nn构建。现在我们可以来看一看autograd这个部分了，torch.nn依赖于它它来定义模型并做微分，nn.Module包含神经层，forward(input)可以用来返回output.例如，看接下来这个可以给数字图像分层的网络。
 
 
    这个是一个简单前馈网络，它将输入经过一层层的传递，最后给出了结果。一个经典的神经网络的学习过程如下所示：
 
定义神经网络及其参数；
在数据集上多次迭代循环；
通过神经网络处理数据集；
计算损失（输出和正确的结果之间相差的距离）；
用梯度对参数反向影响；
更新神经网络的权重，weight = weight - rate * gradient；
 
   让我们来一步步详解这个过程。
 
1.定义网络
 
import torch
import torch.nn as nn
import torch.nn.functional as F


# 汉字均为我个人理解，英文为原文标注。
class Net(nn.Module):

    def __init__(self):
        # 继承原有模型
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        # 定义了两个卷积层
        # 第一层是输入1维的（说明是单通道，灰色的图片）图片，输出6维的的卷积层（说明用到了6个卷积核，而每个卷积核是5*5的）。
        self.conv1 = nn.Conv2d(1, 6, 5)
        # 第一层是输入1维的（说明是单通道，灰色的图片）图片，输出6维的的卷积层（说明用到了6个卷积核，而每个卷积核是5*5的）。
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        # 定义了三个全连接层，即fc1与conv2相连，将16张5*5的卷积网络一维化，并输出120个节点。
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        # 将120个节点转化为84个。
        self.fc2 = nn.Linear(120, 84)
        # 将84个节点输出为10个，即有10个分类结果。
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        # 用relu激活函数作为一个池化层，池化的窗口大小是2*2，这个也与上文的16*5*5的计算结果相符（一开始我没弄懂为什么fc1的输入点数是16*5*5,后来发现，这个例子是建立在lenet5上的）。
        # 这句整体的意思是，先用conv1卷积，然后激活，激活的窗口是2*2。
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        # 作用同上，然后有个需要注意的地方是在窗口是正方形的时候，2的写法等同于（2，2）。
        # 这句整体的意思是，先用conv2卷积，然后激活，激活的窗口是2*2。
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # 这句整体的意思是，调用下面的定义好的查看特征数量的函数，将我们高维的向量转化为一维。
        x = x.view(-1, self.num_flat_features(x))
        # 用一下全连接层fc1，然后做一个激活。
        x = F.relu(self.fc1(x))
        # 用一下全连接层fc2，然后做一个激活。
        x = F.relu(self.fc2(x))
        # 用一下全连接层fc3。
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        # 承接上文的引用，这里需要注意的是，由于pytorch只接受图片集的输入方式（原文的单词是batch）,所以第一个代表个数的维度被忽略。
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

"""
Net(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)
"""

# 现在我们已经构建好模型了，但是还没有开始用bp呢，如果你对前面的内容有一些印象的话，你就会想起来不需要我们自己去搭建，我们只需要用某一个属性就可以了，autograd。

# 现在我们需要来看一看我们的模型，下列语句可以帮助你看一下这个模型的一些具体情况。

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

"""
10
torch.Size([6, 1, 5, 5])
"""

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

"""
tensor([[ 0.0114,  0.0476, -0.0647,  0.0381,  0.0088, -0.1024, -0.0354,  0.0220,
         -0.0471,  0.0586]], grad_fn=<AddmmBackward>)
"""

#最后让我们清空缓存，准备下一阶段的任务。
net.zero_grad()
out.backward(torch.randn(1, 10))

 
2. 损失函数
 
  先介绍一下损失函数是干什么的：它可以用来度量输出和目标之间的差距，那度量出来有什么意义呢？还记得我们的反向传播吗？他可以将误差作为一个反馈来影响我们之前的参数，更新参数将会在下一节中讲到。当然度量的方法有很多，我们这里选用nn.MSELoss来计算误差，下面接着完善上面的例程。
 
# 这个框架是来弄明白我们现在做了什么，这个网络张什么样子。
"""
input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss
"""
# 到目前为止我们学习了Tensor（张量），autograd.Function（自动微分），Parameter（参数），Module（如何定义，各个层的结构，传播过程）
# 现在我们还要学习损失函数和更新权值。

# 这一部分是来搞定损失函数
output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

# 看一看我们的各个点的结果。
print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

"""
<MseLossBackward object at 0x7efbcad51a58>
<AddmmBackward object at 0x7efbcad51b38>
<AccumulateGrad object at 0x7efbcad51b38>
"""

# 重点来了，反向传播计算梯度。
net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

"""
conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([ 0.0087, -0.0073,  0.0013,  0.0006, -0.0107, -0.0042])
"""

 
  另外官方文档给了一个各个模型和损失函数的地址，有兴趣的可以看一看，或者收藏一下，做个备份。
 
2. 损失函数
 
  激动人心的时刻终于来了，如何更新权值？如果你对上面我们翻译的文章了解的话，你就知道，我们现在搞定了模型的搭建，也得到了预测值与真实值的差距是多少，在哪里可能造成了这个差距，但是还是短些什么，短什么呢（先自己想一下）？
   还剩如何修正这个差距。也就是我们所说的权值更新，我们这个所采用的方法是SGD,学名称为随机梯度下降法 Stochastic Gradient Descent 。
 $$weight=weight-learnin{g}_{r}ate\ast gradient$$
 
# 相应的python代码
learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)
 
  如果你想用更多的其它方法的话，你可以查看$torch.optim$。
 
import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update
 
  至此，我们的基本知识就差不多结束了，接下来我们会动手在CPU和GPU上训练我们的图像分类器。
 
训练分类器
 
1. 首先进行数据处理
 
  我们知道，要想有一个好的模型你必须有一些好的数据，并将他们转化为模型可以理解的语言，这个工作非常重要。对于前者我将来会写一个博客介绍我所知道的几种方法，现在我们来看后者。
   我们知道，要想有一个好的模型你必须有一些好的数据，并将他们转化为模型可以理解的语言，这个工作非常重要。对于前者我将来会写一个博客介绍我所知道的几种方法，现在我们来看后者如何解决。
   众所周知，当我们需要处理图像，文本，音频或者视频数据的时候，你可以使用标准的python库来将这些书v就转化为numpy array，然后你可以其再转化为Tensor。下面列出一些相应的python库：
 
For images, packages such as Pillow, OpenCV are useful
For audio, packages such as scipy and librosa
For text, either raw Python or Cython based loading, or NLTK and SpaCy are useful
 
  特别是对于视觉领域，我们写了一个叫做torchvision的包，他可以将很多知名数据的数据即涵盖在内。并且，通过torchvision.datasets 和 torch.utils.data.DataLoader 进行数据的转化。在本里中我们将会使用 CIFAR10 数据集，它有以下各类： ‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。在这个数据集中的图像尺寸都是33232的。
 
2. 开始训练模型
 
先说一下训练步骤.
 
首先装载数据，并将其统一化；
定义CNN；
定义损失函数；
训练神经网络；
测试网络；
 
接下来开始干活(cpu版本的)：
 
import torch
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()

for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data

        # zero the parameter gradients
        criterion = nn.CrossEntropyLoss()
        optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

dataiter = iter(testloader)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

outputs = net(images)

_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))
 
还没完，还有活干(gpu版本的)：
 
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Assuming that we are on a CUDA machine, this should print a CUDA device:

print(device)

net.to(device)

inputs, labels = inputs.to(device), labels.to(device)
 
还没完，还有活干（gpu版本的最终代码成品)：
 
import torch.optim as optim
import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.cpu().numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Assuming that we are on a CUDA machine, this should print a CUDA device:

print(device)

net.to(device)



for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        # zero the parameter gradients
        criterion = nn.CrossEntropyLoss()
        optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

dataiter = iter(testloader)
images, labels = dataiter.next()
images, labels = inputs.to(device), labels.to(device)

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

outputs = net(images)

_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                              for j in range(4)))

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        images, labels = inputs.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        images, labels = inputs.to(device), labels.to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

 
此篇完结

RPA 软件是一种机器人流程自动化技术，它允许通过配置自动化软件 (也叫“机器人”) 模拟和人类在软件系统中交互的动作来执行业务流程。 RPA 软件机器人在应用程序界面上识别数据并像人类一样操纵应用程序。RPA 软件根据规则与其他系统交互，根据需要执行各种重复性任务。它比人类做的更好，一个 RPA 软件机器人不会睡觉，不犯错误，成本比员工少很多。
 
RPA 软件相对传统技术有哪些优点呢？
 
相对其他传统软件解决方案相比，RPA 软件让组织能够以少量的资金，和较短的时间实现自动化。企业的 IT 系统通常非常庞大、复杂，如果是要更换或改造，会既困难又昂贵。RPA 软件是非侵入性的，它利用现有的 IT 基础设施，而不会对系统造成干扰，使用 RPA 软件技术不光能完成流程自动化，而且可以自动获得节省成本及运营合规等好处。
 
RPA 软件技术有哪些优势呢？
 
快速自动实施，快速实现投资回报率
 
某人力资源服务提供商每月处理 2,500 份病假证明，每件物品的平均处理时间为 4 分钟。在三周内，实施了 RPA 软件解决方案，实现了 90％的流程自动化。RPA 自动化软件从 SAP 中的事务中提取数据，将信息插入客户的系统并进行打印。资源服务提供商在六个月内实现了投资回报，错误率降至 0％，手动工作量降至 5％，处理时间缩短 80％。
 
减少后台工作量，节省人力成本
 
一家全球零售商正在使用其商店盘点报告来验证数百家商店中每个商店的盘点信息。该商店的员工之前使用手动过程来提取这些报告，这一过程繁琐且不高效。通过 RPA 软件自动化流程，员工现在能够更多专注于以客户为中心的活动。 RPA 软件机器人现在将结束报告移动到一个服务器，然后读取并合并商店盘点报告所需的信息。
 
改善客户服务与体验，提高转化率
 
一家在全球拥有 50,000 多家客户的信用保险公司实现了信用额度请求承保流程。承销商之前曾手动收集信息，从内部（风险与政策）到外部（客户网站，谷歌新闻）来源。通过 RPA 软件技术，他们每月节省了 2,440 小时的人力工作。员工利用这段时间直接与客户合作，为顾客提供更加完善与贴心的服务，从而在 RPA 软件的帮助下提高客户的转化率。
 
工业生产的自动化，降低生成成本
 
一家在中国的汽车发动机制造商，发动机的电子控制器在生产过程中需要通过软件写入初始内容。写入操作通过生产工人操作软件完成。6 台写入设备需要相应的工人值守并手动操作完成。通过部署 RPA 软件 + 摄像头自动识别系统，能够实现全自动的器件识别和写入。不需要工人值守。每月节省了近 1000 小时的人力。大大降低了生产成本。
 
为什么你要选择 RPA 软件技术？
 
在所有可能的领域，机器人自动化替代人是不可逆转的潮流。您越早采用自动化，您为企业创造竞争优势就越明显。机器人流程自动化提供直接的效益，同时提高组织和行业的准确性。软件机器人易于设定，可以针对特定需求快速定制，无缝集成到任何系统中，并不断报告他们的进度。启用 RPA 软件技术来处理业务流程不仅可以转换和简化组织的工作流程。还能让企业提高可伸缩性和灵活性。RPA 软件通过提升运营和业务可预测性让您的公司做得更大更好，同时战略性地提升公司的竞争力。
 
  本文转自http://support.i-search.com.cn/article/1556504320248
  更多PRA相关信息请访问艺赛旗社区

做了很多题，背了很多词，上过各种的补习班，却，依旧考不好托福……
 
分数总是不见上涨，仿佛不管怎么努力都很难学好。
 
那么，问题出在哪里呢？
 
今天，给大家分享两则小经验，让学霸教你如何每天一小时就可让英语水平在短短半年内突飞猛进。（还有个应试小技巧哦~）
 
 
背景：
 
我来新加坡有两年了，报过班，自己也弄过不少资料，但一直都没有突破性的成效。可以说花过冤枉钱，走过冤枉路。甚至，放弃过一段时间，干脆就不刻意去学英语了，连英文文章都很少主动去读。
 
直到在一个party上，和几个印度、马来西亚人聊天，才找到了一个比较靠谱的方法。
 
很多马来西亚、印度、印尼的朋友，包括国内的朋友，都从这个方法中受益匪浅。
 
我的方法就是：
 
读报纸！ 读报纸！ 还是读报纸！！！
 
总的来说：一天两篇文章，坚持100天，就能有实质性的改变。阅读、听力、写作都可以提高，只要你愿意口语也可以从此得到突破。
 
具体方法如下：
 
 
 
一、报纸的选择
 
 
不是随便一份英文报纸就可以的，对于国内的朋友找英文报纸还是不太方便的(新加坡早上很多免费发放报纸的，多数是英文类报纸)。
 
报纸要选择时事新闻类的报纸，最好是选择有一些知名度和影响力的报刊。像学习报，文艺报之类的英文报纸都不可以。因为，时事新闻类报纸，贴近生活、时鲜性强、趣味性强.......但这都不是重点，重点是报纸上的用词构句都是很正式但又不呆板，日常用词比较多，实用性自然就强。
 
 
 
二、文章的选择
 
 
订好一份报纸，你不必每篇都读完。选择几篇1000单词左右的文章，剪裁下来，以便阅读和复习。其它的丢掉也不可惜，你想啊，两块钱一份报纸，你能认真研读几篇1000字的文章，就已经是赚大了。俗话说省了盐瞎了酱，省了馒头吃不胖。
 
 
 
三、如何进行阅读？
 
 
干货来了！！！
 
1.第一遍阅读，不借助任何工具，全凭自己现有英语水平完成第一遍阅读，尽量理解文章大意，并且标记下来不认识的单词词组。
 
(这个一开有点难，因为生词会有点多。可是只要你不开始，困难永远都会困着你)
 
2.第一遍阅读完之后，逐个去查单词、词组。查单词这一点和我们惯用的查单词的方法不一样。
 
首先，准备一个笔记本(专门记单词、词组和储存对应的文章)。每一页都对折，前一半抄单词，后一半写注释。
 
但需要注意的是，一个单词会有很多注释，你只需记下这个单词文中的那个意思就行。注释越短越好，尽量一个词或三两个字就能解决，能用英语注释生词会更好(汉字出现的越少，汉语对你学英语的干扰就越少，避免汉化思维学英语)。
 
至于地名，专有名词要不要查？查！必须查！！！学语言的目的就是接受信息、表达信息，每一个单词或字母组合都代表一个信息。学英语的目的是运用、交流，不是去考四六级，词汇不在考纲内就可以不学。应试英语，功利性强。我们坚持每天学英语不只是为了考试，更是为了日后的交流、运用。
 
这时候你要潜意识留意那些生词所处在的语境，暗示性地默记，以便下次复习单词时能回忆起这个语境。
 
(这一点是记单词的捷径，很多单词软件，你一小时就能猛刷好一二百单词，但最终绝大多数都会忘，脱离语境记单词，不但记忆不牢靠，运用也是基本不会)
 
4.最后浏览一遍生词、注释。回忆一下文章。这一篇文章今天到此结束。
 
(也就是说，一篇文章至少要3-4遍的阅读，才能完成以上所说的任务。)
 
 
 
四、如何进行复习？
 
 
先看笔记的前半页(没有注释的半页，之前对折过，这个很容易)，根据你看到的单词，回想它的注释，回忆他出现的语境。回忆不起来的要加强记忆一下。根据音标出声地读上两三遍。
 
复习文章，就是复习单词、词汇。其实，一篇新闻并没有什么可复习的。所以单词要达到能读出来，大概知道怎么拼写(不必精确到一个字母不错的拼写成度)。词组要达到知道如何运用，是在不会迁移运用，但文中的运用方法要记住。
 
 
 
五、听力从哪里提高？
 
 
你脑子里存储的单词、词组多了，并且很多词汇词组都已无限次出现过你的脑海。当你在听的时候，大脑检索自然就会快很多，你听起来自然轻松。尤其英语介词泛滥，你若不熟相应的介词构造方式，听力提高比登天还难。
 
(当然要想更高要求的提高，听力还是要进行适当听力训练的)。
 
 
 
六、写作从哪里提高？
 
 
阅读时记录的词组，这时候就派上用场了。翻译一句话，每个词我们都会翻译，但整句组合却不会。那是因为不熟悉英文表达习惯，不能熟练运用关联词、介词等去润色一个句子。
 
不要去看什么语法书，那都是为了应试准备的。对综合英语的提高没有实质性帮助。我问过很多母语是英语的朋友，他们根本不熟悉什么语法，正如我们不熟悉汉语语法一样。虽然不熟悉语法，但对语言的表达、听力、写作、阅读都能达到很高水平。
 
 
 
七、口语从哪里提高？
 
 
中国人不能开口说英语，是因为脑子里存在一个中英文转换的过程。这样你的口语表达就大打折扣。
 
无论你选的文章多简单，一开始尽量放慢速度，一个单词一个单词的读。然后再一个词组一个词组的读，最后在一句一句的读，直到你能流利地读完整篇文章。
 
需要注意的是：不必去背任何文章，这样朗读的目的是训练脑子到嘴巴的速度和熟练成度。以至于达到张口就来的目的。
 
 
 
最后总结
 
 
一天两篇文章，加上复习，朗读。一天一个小时很紧张。建议一天一篇或一长一短两篇。
 
读报纸是最廉价最简洁的学英语的方法了。他不需要任何其他干扰你的介质，你完全可以通过自己一个人，完成一次英语水平质的飞跃。
 
(手机电脑很容易分散注意力，根本不适合学英语。)
 
如果坚持半年，即便你阅读、写作、听力、口语不是非常好。但不要过于担心，一旦你处在英语环境中，两三个月你能找到母语的感觉了，轻松自如。
 
毕竟读报纸只是个单向的学习的过程，缺乏双向交流。 很多国内来新加坡国立大学(世界排名前40强)和新加坡南洋理工大学(世界排名前70强)读书的学生，毕业一开始也是羞于表达，操练这一口蹩脚的英语。不是因为他们能力不行，学校毕竟是个双向交流缺乏的环境。
 
所以，他们一开始也是不自信，但这种局面不会持续太久。基础好，上手自然快，也就一两个月就轻松自如了。 有了英语知识层面的积淀，才能在两三个月达到这种水平。别说什么在英语环境中脸皮厚一点就可以，没有这些积淀，脸皮再厚也没用。除了丢人还是丢人，一年半载也不会有实质的提高，最多就是只会说几句日常见面用语而已。
 
 
 
TED视频系列
 
 
如果你觉得看报太单调，缺乏双向交流，那就尝试每天看视频的方法。
 
需要注意的是看视频需要借助电子产品，自制能力差，容易分心走神的朋友，要谨慎。免得每天忙活个把小时，什么也没学到，不到几天就坚持不下去了。
 
下面详答：
 
一、视频的选择——TED视频
 
长期看视频学英语，当然是选TED视频，本人认为不可替代。其必要性：
 
1. 素材广涉及众多领域，素材数量之多上万，视频长短兼备。
 
(能够一个人看上好几年的，不必为找资料而愁。)
 
2. 演讲者均是各自领域具有杰出贡献、先进思想、前沿观点的前辈或智者。(TED很多演讲观点很独特，是扩展眼界、增加知识不二选则)
 
3. 与其视频相比：简化了搜索素材的过程 ；TED视频便于搜索，故便于复习。
 
( 其他视频当然也可以，TED除了英语还能给我们独特的观点和视角，这一点很重要，一举两得。此处推荐替代视CNN Student News ，这是一个面向美国学生的语言类新闻节目，一天次，每次时长10分钟，节假日除外。 本文还是以TED为例交流方法心得，其他视频均可类比。)
 
二、如何观看视频？
 
(视频最好下载下来以便复习，初学学可以选择3-8分钟长的视频，慢慢8-15分钟，逐渐增加15-23分钟......只带英文字幕，千万不可以中英文字幕)
 
1. 看前两遍时，不要看任何字幕，只看画面，耐心去听，听不懂的地方，回放继续试听。(来回2-3遍，基本能领会的都领会差不多了，没必要苦苦再听，长时间会削减你的信心、耐心和恒心)
 
2. 接着就是，拿出笔记本，一句一句看字幕跟读，顺便查写生单词、词组。(经过这一遍下来，演讲内容应该比较熟悉了)
 
3. 到此，这个视频的硬性指标就算完成了。然后就是再追加1-2遍跟读，细心体会演讲者的语气、语调，并试着模仿。
 
4. 最后强化记忆一下所记录的生词、词汇，并复习一遍前一天所学内容。 最后，应该说视频系列和报纸系列侧重点有所不同，但都能全面综合提高英语。两种方法交叉效果更明显。因为视频系列能练就好口才，让你更自信;报纸系列锻炼读写能力。
 
唯一要嘱咐的是：每天到了看视频的时间，你的电脑或手机只能为看视频而用，否则就一事无成。
 
 
 
 
学生应试党系列
 
 
没啥好说的，为了应试只能死磕题目。
 
因为中国学生用这种方法去应试，效果最明显。(如果想更全面的提高英语，可以适量读读报纸，看看视频。估计也不会有太多的时间。) 学生应试党听我在这里胡喷，还不如去多做几篇阅读理解呢。
 
学英语要不要借助语法，关于这个问题我实在不想多说，但很多人都来辩论这个问题。所以下面来浅谈一下个人观点。 首先，我把语法视为鸡肋，食之无味，弃之可惜。从答题的角度，这个鸡肋弃之也不可惜。每天坚持一小时左右，持续一年半载，你去考究语法修辞，不如由浅到深地读一些英语材料来的更加实惠。
 
零星时间学英语，都是通过不断重复，不断积累，培养语感。反复背一些句子短文，长期积累，增强语感。英语语法要花大量集中时间去学习，去复习，去运用，去巩固。 我们这里讨论的是，每天花少量时间学英语，并不是什么培训班加强班。所以不推荐去搞语法。 还有，是先有的语言还是先有的语法，这一点能够提醒我们，重新认知法