全文共2235字，预计学习时长7分钟
来源：Pexels
初学Python编程的人，面临的是各种未知的挑战。
下面是一个几乎让所有更有抱负的数据科学家都感到意外的场景：
你正在处理一个从多个源收集数据的项目。在进入探索和模型构建部分之前，你需要首先连接这些多个数据集(以表、数据帧等形式)。怎么能做到这一点而不丢失任何信息？
这听起来可能是一个简单的场景，但对于许多新来的人来说，这可能是一个威胁，特别是那些不熟悉Python编程的人。
进一步深入研究，我可以大致将其分为两种情况：
1.首先，具有相似属性的数据可以分布到多个文件中。例如，假设向你提供了多个文件，每个文件都存储一年中某一周内发生的销售信息。因此，全年将有52个文件。每个文件的列数和名称都相同。
2.其次，你可能需要合并来自多个来源的信息。例如，假设你想获得购买产品的人的联系信息。这里有两个文件，第一个有销售信息，第二个有客户信息。
理解手头的问题
本文列举一个通俗易懂的例子。
想一下在一个特定的学校里考试。每个科目都有不同的老师授课。他们更新关于学生成绩和整体表现的档案。这些档案就是多个文件！
本文使用创建的两个这样的文件来演示Python中函数的工作。第一个文件包含关于12班学生的数据，另一个文件包含10班的数据。还将使用第三个文件来存储学生的姓名和学生ID。
注意：虽然这些数据集是从零开始创建的，但鼓励将所学应用于选择的数据集。
在Python中逐步合并数据帧的过程
下面是解决这个问题的方法：
1.用Python加载数据集
2.合并两个相似的数据帧(append)
3.合并来自两个数据帧的信息(merge)
步骤1：用Python加载数据集
本文将使用三个独立的数据集。首先，将这些文件加载到单独的数据帧中。
import pandas as pd
marks10th=pd.read_csv('10thClassMarks.csv')
marks12th=pd.read_csv('12thClassMarks.csv')
IDandName=pd.read_csv('StudentIDandName.csv')
前两个数据框包含学生的百分比及其学生ID。在第一个数据框中，有10班学生的分数，而第二个数据框包含第12个标准中学生的分数。第三个数据框包含学生的姓名以及各自的学生ID。
来源：btime
使用“head”函数检查每个数据帧的前几行：
marks10th.head()
marks12th.head()
IDandName.head()
步骤2：合并两个相似的数据帧(Append)
把10、12班的档案合并起来，找出学生的平均分。这里使用Pandas库中的“append”函数：
allMarks=marks10th.append(marks12th)
marks10th.shape, marks12th.shape, allMarks.shape
输出((50,3),(50,3),(100,3))
从输出中可以看到，在append函数中垂直添加两个数据帧。
结果数据帧是allMarks。上面比较了所有三个数据帧的形状。
接下来看看“allMarks”的内容并计算平均值：
allMarks['Exam Points'].mean() #Average Marks
输出:49.74
步骤3：合并来自两个数据帧的信息(Merge)
现在，假设想找出在这两个批次中排名第一的学生的名字。这里不需要垂直添加数据帧。为了给学生的名字再加一列，我们将不得不水平缩放。
要做到这一点，我们会发现最高得分：
allMarks['Exam Points'].max() # Maximum Marks
输出:100
学生的最高成绩是100分。现在，使用“merge”函数查找此学生的姓名：
mergedData=allMarks.merge(IDandName, on='student id')
mergedData.head()
最后，生成的数据框有学生的名字和他们的标记。
merge函数需要一个必要的属性，两个数据帧将在该属性上合并。需要传递此列的名称在“on”参数中。
merge函数的另一个重要论点是“如何”。这指定要在数据帧上执行的联接类型。以下是可以执行的不同连接类型(SQL用户将非常熟悉这一点)：
· 内部连接(如果不提供任何参数，则默认执行)
· 外部连接
· 右连接
· 左连接
还可以使用“sort”参数对数据帧进行排序。这些是合并两个数据帧时最常用的参数。
来源：Pexels
现在，我们将看到数据框包含100个“检查点”的行：
mergedData.loc[mergedData['Exam Points']==100]
三个学生得了100分，其中两个在10班。做得好！
接下来，我的建议是接受包含3个不同文件的食物预测挑战。
很直截了当，对吧？
你再也不必为此而自责了！你可以继续并将其应用于选择的任何数据集。
留言点赞关注
我们一起分享AI学习与发展的干货
如转载，请后台留言，遵守转载规范

作者|Rahul Varma
编译|VK
来源|Towards Data Science
训练和测试一个有效的机器学习模型最重要的一步是收集大量数据并使用这些数据对其进行有效训练。小批量（Mini-batches）有助于解决这个问题，在每次迭代中使用一小部分数据进行训练。

但是，随着大量的机器学习任务在视频数据集上执行，存在着对不等长视频进行有效批处理的问题。大多数方法依赖于将视频裁剪成相等的长度，以便在迭代期间提取相同数量的帧。但在我们需要从每一帧获取信息来有效地预测某些事情的场景中，这并不是特别有用，特别是在自动驾驶汽车和动作识别的情况下。
我们可以创建一个可以处理不同长度视频的处理方法。
在Glenn Jocher的Yolov3中(https://github.com/ultralytics/yolov3)，我用**LoadStreams**作为基础，创建了LoadStreamsBatch类。
类初始化
def __init__(self, sources='streams.txt', img_size=416, batch_size=2, subdir_search=False):
        self.mode = 'images'
        self.img_size = img_size
        self.def_img_size = None

        videos = []
        if os.path.isdir(sources):
            if subdir_search:
                for subdir, dirs, files in os.walk(sources):
                    for file in files:
                        if 'video' in magic.from_file(subdir + os.sep + file, mime=True):
                            videos.append(subdir + os.sep + file)
            else:
                for elements in os.listdir(sources):
                    if not os.path.isdir(elements) and 'video' in magic.from_file(sources + os.sep + elements, mime=True):
                        videos.append(sources + os.sep + elements)
        else:
            with open(sources, 'r') as f:
                videos = [x.strip() for x in f.read().splitlines() if len(x.strip())]

        n = len(videos)
        curr_batch = 0
        self.data = [None] * batch_size
        self.cap = [None] * batch_size
        self.sources = videos
        self.n = n
        self.cur_pos = 0

        # 启动线程从视频流中读取帧
        for i, s in enumerate(videos):
            if curr_batch == batch_size:
                break
            print('%g/%g: %s... ' % (self.cur_pos+1, n, s), end='')
            self.cap[curr_batch] = cv2.VideoCapture(s)
            try:
                assert self.cap[curr_batch].isOpened()
            except AssertionError:
                print('Failed to open %s' % s)
                self.cur_pos+=1
                continue
            w = int(self.cap[curr_batch].get(cv2.CAP_PROP_FRAME_WIDTH))
            h = int(self.cap[curr_batch].get(cv2.CAP_PROP_FRAME_HEIGHT))
            fps = self.cap[curr_batch].get(cv2.CAP_PROP_FPS) % 100
            frames = int(self.cap[curr_batch].get(cv2.CAP_PROP_FRAME_COUNT))
            _, self.data[i] = self.cap[curr_batch].read()  # guarantee first frame
            thread = Thread(target=self.update, args=([i, self.cap[curr_batch], self.cur_pos+1]), daemon=True)
            print(' success (%gx%g at %.2f FPS having %g frames).' % (w, h, fps, frames))
            curr_batch+=1
            self.cur_pos+=1
            thread.start()
            print('')  # 新的一行

        if all( v is None for v in self.data ):
            return
        # 检查常见形状
        s = np.stack([letterbox(x, new_shape=self.img_size)[0].shape for x in self.data], 0)  # 推理的形状
        self.rect = np.unique(s, axis=0).shape[0] == 1
        if not self.rect:
            print('WARNING: Different stream shapes detected. For optimal performance supply similarly-shaped streams.')
在__init__函数中，接受四个参数。虽然img_size与原始版本相同，但其他三个参数定义如下：

sources：它以目录路径或文本文件作为输入。
batch_size：所需的批大小
subdir_search：可以切换此选项，以确保在将目录作为sources参数传递时搜索所有子目录中的相关文件

我首先检查sources参数是目录还是文本文件。如果是一个目录，我会读取目录中的所有内容（如果subdir_search参数为True，子目录也会包括在内），否则我会读取文本文件中视频的路径。视频的路径存储在列表中。使用cur_pos以跟踪列表中的当前位置。
该列表以batch_size为最大值进行迭代，并检查以跳过错误视频或不存在的视频。它们被发送到letterbox函数，以调整图像大小。这与原始版本相比没有任何变化，除非所有视频都有故障/不可用。
def letterbox(img, new_shape=(416, 416), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True):
    # 将图像调整为32个像素倍数的矩形 https://github.com/ultralytics/yolov3/issues/232
    shape = img.shape[:2]  # 当前形状 [height, width]
    if isinstance(new_shape, int):
        new_shape = (new_shape, new_shape)

    # 比例
    r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
    if not scaleup:  # 只按比例缩小，不按比例放大（用于更好的测试图）
        r = min(r, 1.0)

    # 计算填充
    ratio = r, r  # 宽高比
    new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
    dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]  #填充
    if auto:  # 最小矩形
        dw, dh = np.mod(dw, 64), np.mod(dh, 64)  # 填充
    elif scaleFill:  # 伸展
        dw, dh = 0.0, 0.0
        new_unpad = new_shape
        ratio = new_shape[0] / shape[1], new_shape[1] / shape[0]  # 宽高比

    dw /= 2  # 将填充分成两侧
    dh /= 2

    if shape[::-1] != new_unpad:  # 改变大小
        img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
    img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)  # 添加边界
    return img, ratio, (dw, dh)
固定间隔检索帧函数
update函数有一个小的变化，我们另外存储了默认的图像大小，以便在所有视频都被提取进行处理，但由于长度不相等，一个视频比另一个视频提前完成。当我解释代码的下一部分时，它会更清楚，那就是__next__ 函数。
def update(self, index, cap, cur_pos):
        # 读取守护进程线程中的下一个帧
        n = 0
        while cap.isOpened():
            n += 1
            # _, self.imgs[index] = cap.read()
            cap.grab()
            if n == 4:  # 每4帧读取一次
                _, self.data[index] = cap.retrieve()
                if self.def_img_size is None:
                    self.def_img_size = self.data[index].shape
                n = 0
            time.sleep(0.01)  # 等待
迭代器
如果帧存在，它会像往常一样传递给letterbox函数。在frame为None的情况下，这意味着视频已被完全处理，我们检查列表中的所有视频是否都已被处理。如果有更多的视频要处理，cur_pos指针用于获取下一个可用视频的位置。
如果不再从列表中提取视频，但仍在处理某些视频，则向其他处理组件发送一个空白帧，即，它根据其他批次中的剩余帧动态调整视频大小。
def __next__(self):
        self.count += 1
        img0 = self.data.copy()
        img = []

        for i, x in enumerate(img0):
            if x is not None:
                img.append(letterbox(x, new_shape=self.img_size, auto=self.rect)[0])
            else:
                if self.cur_pos == self.n:
                    if all( v is None for v in img0 ):
                        cv2.destroyAllWindows()
                        raise StopIteration
                    else:
                        img0[i] = np.zeros(self.def_img_size)
                        img.append(letterbox(img0[i], new_shape=self.img_size, auto=self.rect)[0])
                else:
                    print('%g/%g: %s... ' % (self.cur_pos+1, self.n, self.sources[self.cur_pos]), end='')
                    self.cap[i] = cv2.VideoCapture(self.sources[self.cur_pos])
                    fldr_end_flg = 0
                    while not self.cap[i].isOpened():
                        print('Failed to open %s' % self.sources[self.cur_pos])
                        self.cur_pos+=1
                        if self.cur_pos == self.n:
                            img0[i] = np.zeros(self.def_img_size)
                            img.append(letterbox(img0[i], new_shape=self.img_size, auto=self.rect)[0])
                            fldr_end_flg = 1
                            break
                        self.cap[i] = cv2.VideoCapture(self.sources[self.cur_pos])
                    if fldr_end_flg:
                        continue
                    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
                    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
                    fps = cap.get(cv2.CAP_PROP_FPS) % 100
                    frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
                    _, self.data[i] = self.cap[i].read()  # 保证第一帧
                    img0[i] = self.data[i]
                    img.append(letterbox(self.data[i], new_shape=self.img_size, auto=self.rect)[0])
                    thread = Thread(target=self.update, args=([i, self.cap[i], self.cur_pos+1]), daemon=True)
                    print(' success (%gx%g at %.2f FPS having %g frames).' % (w, h, fps, frames))
                    self.cur_pos+=1
                    thread.start()
                    print('')  # 新的一行

        # 堆叠
        img = np.stack(img, 0)

        # 转换
        img = img[:, :, :, ::-1].transpose(0, 3, 1, 2)  # BGR 到 RGB, bsx3x416x416
        img = np.ascontiguousarray(img)

        return self.sources, img, img0, None
结论
随着大量的时间花费在数据收集和数据预处理上，我相信这有助于减少视频与模型匹配的时间，我们可以集中精力使模型与数据相匹配。
我在这里附上完整的源代码。希望这有帮助！
原文链接：https://towardsdatascience.com/variable-sized-video-mini-batching-c4b1a47c043b
欢迎关注磐创AI博客站：
http://panchuang.net/
sklearn机器学习中文官方文档：
http://sklearn123.com/
欢迎关注磐创博客资源汇总站：
http://docs.panchuang.net/

全文共2235字，预计学习时长7分钟




来源：Pexels

 

初学Python编程的人，面临的是各种未知的挑战。

 

下面是一个几乎让所有更有抱负的数据科学家都感到意外的场景：

 

你正在处理一个从多个源收集数据的项目。在进入探索和模型构建部分之前，你需要首先连接这些多个数据集（以表、数据帧等形式）。怎么能做到这一点而不丢失任何信息？

 

这听起来可能是一个简单的场景，但对于许多新来的人来说，这可能是一个威胁，特别是那些不熟悉Python编程的人。

 



 

 

进一步深入研究，我可以大致将其分为两种情况：

 

1.首先，具有相似属性的数据可以分布到多个文件中。例如，假设向你提供了多个文件，每个文件都存储一年中某一周内发生的销售信息。因此，全年将有52个文件。每个文件的列数和名称都相同。

 

2.其次，你可能需要合并来自多个来源的信息。例如，假设你想获得购买产品的人的联系信息。这里有两个文件，第一个有销售信息，第二个有客户信息。

 

理解手头的问题

 

本文列举一个通俗易懂的例子。

 

想一下在一个特定的学校里考试。每个科目都有不同的老师授课。他们更新关于学生成绩和整体表现的档案。这些档案就是多个文件！

 

本文使用创建的两个这样的文件来演示Python中函数的工作。第一个文件包含关于12班学生的数据，另一个文件包含10班的数据。还将使用第三个文件来存储学生的姓名和学生ID。

 

注意：虽然这些数据集是从零开始创建的，但鼓励将所学应用于选择的数据集。

 

在Python中逐步合并数据帧的过程

 

下面是解决这个问题的方法：

 

1.用Python加载数据集

 

2.合并两个相似的数据帧（append）

 

3.合并来自两个数据帧的信息（merge）

 

步骤1：用Python加载数据集

 

本文将使用三个独立的数据集。首先，将这些文件加载到单独的数据帧中。

import pandas as pd

marks10th=pd.read_csv('10thClassMarks.csv')

marks12th=pd.read_csv('12thClassMarks.csv')

IDandName=pd.read_csv('StudentIDandName.csv')

前两个数据框包含学生的百分比及其学生ID。在第一个数据框中，有10班学生的分数，而第二个数据框包含第12个标准中学生的分数。第三个数据框包含学生的姓名以及各自的学生ID。



来源：btime

 

使用“head”函数检查每个数据帧的前几行：

 

marks10th.head()

marks12th.head()

IDandName.head()



 

 

步骤2：合并两个相似的数据帧（Append）

 

把10、12班的档案合并起来，找出学生的平均分。这里使用Pandas库中的“append”函数：

 

allMarks=marks10th.append(marks12th)

marks10th.shape, marks12th.shape, allMarks.shape

输出((50,3),(50,3),(100,3))

 

从输出中可以看到，在append函数中垂直添加两个数据帧。

 

结果数据帧是allMarks。上面比较了所有三个数据帧的形状。

 

接下来看看“allMarks”的内容并计算平均值：



 

 

allMarks['Exam Points'].mean() #Average Marks

输出:49.74

步骤3：合并来自两个数据帧的信息（Merge）

 

现在，假设想找出在这两个批次中排名第一的学生的名字。这里不需要垂直添加数据帧。为了给学生的名字再加一列，我们将不得不水平缩放。

 

要做到这一点，我们会发现最高得分：

allMarks['Exam Points'].max() # Maximum Marks

输出:100

学生的最高成绩是100分。现在，使用“merge”函数查找此学生的姓名：

mergedData=allMarks.merge(IDandName, on='student id')

mergedData.head()



 

 

最后，生成的数据框有学生的名字和他们的标记。

 

merge函数需要一个必要的属性，两个数据帧将在该属性上合并。需要传递此列的名称在“on”参数中。

 

merge函数的另一个重要论点是“如何”。这指定要在数据帧上执行的联接类型。以下是可以执行的不同连接类型（SQL用户将非常熟悉这一点）：

 

· 内部连接（如果不提供任何参数，则默认执行）

 

· 外部连接

 

· 右连接

 

· 左连接

 

还可以使用“sort”参数对数据帧进行排序。这些是合并两个数据帧时最常用的参数。

 



来源：Pexels

 

现在，我们将看到数据框包含100个“检查点”的行：

mergedData.loc[mergedData['Exam Points']==100]



 

 

三个学生得了100分，其中两个在10班。做得好！

 

接下来，我的建议是接受包含3个不同文件的食物预测挑战。

 

很直截了当，对吧？

 

你再也不必为此而自责了！你可以继续并将其应用于选择的任何数据集。



留言 点赞 关注

我们一起分享AI学习与发展的干货

欢迎关注全平台AI垂类自媒体 “读芯术”



（添加小编微信：dxsxbb，加入读者圈，一起讨论最新鲜的人工智能科技哦～）

作者：王婷婷

链接：https://www.zhihu.com/question/20237091/answer/15795367

来源：知乎

著作权归作者所有，转载请联系作者获得授权。

帧内压缩类似于图片压缩，跟这一帧的前面（或后面）一帧（或几帧）无关，由当前帧中，已编码的部分来推测当前待编码的这一部分数据是什么。帧间压缩是，由这一帧的前（或后）一帧（或几帧）来推测当前待压缩的这一部分数据是什么。

①什么是宏块（Macroblock）。宏块就是，把视频的每一帧（相当于一张图片）划分成16*16的小块，一块一块的依次压缩，而不是对整张图片一起压缩。这样降低了计算的复杂度，比较节省时间。一个宏块又可以分成16*16,16*8,8*16,8*8,8*4,4*8,4*4,等大小不等的块。具体怎么划分块大小，要看画面有多复杂。一般来说，运动多，细节多的部分，划分成小块来编码；大片的平坦的无变化的，划分成16*16的大块。下图就是块划分情况，图选的不好，选成残差帧了⊙﹏⊙，分块状况还是大致能看出来的。<img
 src="https://pic2.zhimg.com/bf8e6b33d1c39b8b2aaf4b08665368bd_b.jpg" data-rawwidth="401" data-rawheight="332" class="content_image" width="401">②帧内（Intra）压缩。先看这个图片②帧内（Intra）压缩。先看这个图片<img
 src="https://pic2.zhimg.com/5b80a6c59f040ee5e9b21aa6e1bf5b5d_b.jpg" data-rawwidth="287" data-rawheight="229" class="content_image" width="287">假设现在是按顺序来编码，第一行已经完全编完，⑤也编完了，正要压缩⑥这一块。可以看出，它周围的①②③④⑤，跟⑥简直一模一样啊，如果能用①②③④⑤来推测⑥是什么图像，显然比只压缩⑥要节省空间。这就是帧内预测。一般来说，视频的第一帧是帧内预测帧（废话，它想参考其他帧的数据也没有的参考），场景切换时是帧内预测帧（比如视频里插了一段广告，这个广告跟视频里其他的内容都无关，用它来预测还不如我自己编自己省空间）。帧内预测在H.264编码标准里有以下几种预测方法，具体请查看H.264白皮书。假设现在是按顺序来编码，第一行已经完全编完，⑤也编完了，正要压缩⑥这一块。可以看出，它周围的①②③④⑤，跟⑥简直一模一样啊，如果能用①②③④⑤来推测⑥是什么图像，显然比只压缩⑥要节省空间。这就是帧内预测。一般来说，视频的第一帧是帧内预测帧（废话，它想参考其他帧的数据也没有的参考），场景切换时是帧内预测帧（比如视频里插了一段广告，这个广告跟视频里其他的内容都无关，用它来预测还不如我自己编自己省空间）。帧内预测在H.264编码标准里有以下几种预测方法，具体请查看H.264白皮书。<img
 src="https://pic2.zhimg.com/a2c909705a8d128d2b4c460938c7d8f5_b.jpg" data-rawwidth="845" data-rawheight="244" class="origin_image zh-lightbox-thumb" width="845" data-original="https://pic2.zhimg.com/a2c909705a8d128d2b4c460938c7d8f5_r.jpg">③帧间（Inter）压缩。下图是一个视频序列中连续的两帧。（我真没偷懒，这真的是俩不同的帧，不信你看书的位置和人的表情都变了）③帧间（Inter）压缩。下图是一个视频序列中连续的两帧。（我真没偷懒，这真的是俩不同的帧，不信你看书的位置和人的表情都变了）<img
 src="https://pic2.zhimg.com/0de052e2b8404d105e1dcd6483ceb02d_b.jpg" data-rawwidth="287" data-rawheight="229" class="content_image" width="287"><img
 src="https://pic1.zhimg.com/9739e9ea3b0d491363b430ab4d7815c0_b.jpg" data-rawwidth="287" data-rawheight="229" class="content_image" width="287">如果摄像头没有晃来晃去，那么，在连续的视频图像里面，前后两帧的差别真的很小，比一张图片中连续两个宏块的差别还要小，这时用帧间压缩的效果会比帧内压缩的效果好。如果摄像头没有晃来晃去，那么，在连续的视频图像里面，前后两帧的差别真的很小，比一张图片中连续两个宏块的差别还要小，这时用帧间压缩的效果会比帧内压缩的效果好。<img
 src="https://pic1.zhimg.com/b329a0f1539ae53facd0d3840ef68460_b.jpg" data-rawwidth="467" data-rawheight="208" class="origin_image zh-lightbox-thumb" width="467" data-original="https://pic1.zhimg.com/b329a0f1539ae53facd0d3840ef68460_r.jpg">Block
 Matching 就是块匹配，就是找找看前面已经编码的几帧里面，和我当前这个块最类似的一个块，这样我就不用编码当前块的内容了，只需要编码当前块和我找到的那个块的差（称为残差）就可以了。找最像的块的过程叫运动搜索（Motion Search），又叫运动估计（Motion Estimation）。用残差和原来的块就能推算出当前块是什么样儿的，这个过程叫运动补偿（Motion Compensation）。有全搜索，菱形搜索法，三步搜索算法，新三步搜索算法，梯度下降搜索算法，运动矢量场自适应搜索算法等各种算法，这也一直是研究和发论文的热点。
Block Matching 就是块匹配，就是找找看前面已经编码的几帧里面，和我当前这个块最类似的一个块，这样我就不用编码当前块的内容了，只需要编码当前块和我找到的那个块的差（称为残差）就可以了。找最像的块的过程叫运动搜索（Motion Search），又叫运动估计（Motion Estimation）。用残差和原来的块就能推算出当前块是什么样儿的，这个过程叫运动补偿（Motion Compensation）。有全搜索，菱形搜索法，三步搜索算法，新三步搜索算法，梯度下降搜索算法，运动矢量场自适应搜索算法等各种算法，这也一直是研究和发论文的热点




https://www.zhihu.com/question/20237091。