专栏首页机器学习与统计学NVIDIA工程师小姐姐的Python隐藏技巧合集,推特2400赞,代码可以直接跑

NVIDIA工程师小姐姐的Python隐藏技巧合集,推特2400赞,代码可以直接跑

栗子 发自 凹非寺 量子位 报道 | 公众号 QbitAI

常常发资源的英伟达工程师小姐姐Chip Huyen,又发射了一套Python隐藏功能合集

里面都是她“从前没发现,或者从前不太敢用”的机器学习技巧,有notebook可以直接跑。

合集名叫python-is-cool,推特宣布之后不到半天,已经收获了2400+赞。

那么,这份令人奔走相告的资源,到底长什么样子?

隐藏技巧五大类

就像开头提到的:这里的功能,要么是小姐姐花了很久才找到的,要么是曾经让她瑟瑟发抖到不敢尝试的。

不过现在,她的技巧已经成功支配了这些功能,于是分享了出来。

目前一共有5个版块,专注机器学习,日后还会持续更新:

1、Lambda、Map、Filter、Reduce函数

lambda 关键字,是用来创建内联函数 (Inline Functions) 的。square_fn 和 square_ld 函数,在这里是一样的。

def square_fn(x):
    return x * x

square_ld = lambda x : x * x

for i in range(10):
    assert square_fn(i) == square_ld(i)

lambda 函数可以快速声明,所以拿来当回调 (Callbacks) 函数是非常理想的:就是作为参数 (Arguments) 传递给其他函数用的,那种函数。

和 map、filter 和 reduce 这样的函数搭配使用,尤其有效。

map(fn,iterable) 会把 fn 应用在 iterable 的所有元素上,返回一个map object。

nums = [1/3, 333/7, 2323/2230, 40/34, 2/3]
nums_squared = [num * num for num in nums]
print(nums_squared)

==> [0.1111111, 2263.04081632, 1.085147, 1.384083, 0.44444444]

这样调用,跟用有回调函数的 map 来调用,是一样的。

nums_squared_1 = map(square_fn, nums)
nums_squared_2 = map(lambda x : x * x, nums)
print(list(nums_squared_1))

==> [0.1111111, 2263.04081632, 1.085147, 1.384083, 0.44444444]

map 也可以有不止一个 iterable。

比如,你要想计算一个简单线性函数 f(x)=ax+b 的均方误差 (MSE) ,两种方法就是等同的。

a, b = 3, -0.5
xs = [2, 3, 4, 5]
labels = [6.4, 8.9, 10.9, 15.3]

# Method 1: using a loop
errors = []
for i, x in enumerate(xs):
    errors.append((a * x + b - labels[i]) ** 2)
result1 = sum(errors) ** 0.5 / len(xs)

# Method 2: using map
diffs = map(lambda x, y: (a * x + b - y) ** 2, xs, labels)
result2 = sum(diffs) ** 0.5 / len(xs)

print(result1, result2)

==> 0.35089172119045514 0.35089172119045514

要注意的是,map 和 filter 返回的是迭代器 (Iterator) ,这就是说它们的值不是存储的,是按需生成的。

当你调用了sum(diffs) 之后,diffs 就空了。如果你想要保留 diffs 里面所有的元素,就用 list(diffs) 把它转换成一个列表。

filter(fn,iterable) 也是和 map 一样道理,只不过 fn 返回的是一个布尔值,filter 返回的是,iterable 里面所有 fn 返回True的元素。

bad_preds = filter(lambda x: x > 0.5, errors)
print(list(bad_preds))

==> [0.8100000000000006, 0.6400000000000011]

reduce(fn,iterable,initializer) 是用来给列表里的所有元素,迭代地应用某一个算子。比如,想要算出列表里所有元素的乘积:

product = 1
for num in nums:
    product *= num
print(product)

==> 12.95564683272412

上面这串代码,和下面这串代码是等同的:

from functools import reduce
product = reduce(lambda x, y: x * y, nums)
print(product)

==> 12.95564683272412

2、列表操作

小姐姐说,Python的列表太炫酷了。

2.1、解包 (Unpacking)

想把一个列表解包成一个一个元素,就这样:

elems = [1, 2, 3, 4]
a, b, c, d = elems
print(a, b, c, d)

==> 1 2 3 4

也可以这样:

elems = [1, 2, 3, 4]
a, b, c, d = elems
print(a, b, c, d)

==> 1 2 3 4

2.2、切片 (Slicing)

大家可能知道,如果想把一个列表反过来排,就用 [::-1] 。

elems = list(range(10))
print(elems)

==> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(elems[::-1])

==> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

而 [x:y:z] 这种语法的意思是,从索引x到索引y,每z个元素取一个。

如果z是负数,就是反向取了。

如果x不特别指定,就默认是在遍历列表的方向上,遇到的第一个元素。

如果y不特别指定,就默认是列表最后一个元素。

所以,我们要从一个列表里面,每两个取一个的话,就是 [::2] 。

evens = elems[::2]
print(evens)

reversed_evens = elems[-2::-2]
print(reversed_evens)

==> [0, 2, 4, 6, 8]
    [8, 6, 4, 2, 0]

也可以用这种方法,把一个列表里的偶数都删掉,只留奇数:

del elems[::2]
print(elems)

==> [1, 3, 5, 7, 9]

2.3、插入 (Insertion)

把列表里的其中一个元素的值,换成另一个值。

elems = list(range(10))
elems[1] = 10
print(elems)

==> [0, 10, 2, 3, 4, 5, 6, 7, 8, 9]

如果想把某个索引处的一个元素,替换成多个元素,比如把 1 换成 20, 30, 40 :

elems = list(range(10))
elems[1:2] = [20, 30, 40]
print(elems)

==> [0, 20, 30, 40, 2, 3, 4, 5, 6, 7, 8, 9]

如果想把3个值 0.2, 0.3, 0.5 插在索引0和索引1之间:

elems = list(range(10))
elems[1:1] = [0.2, 0.3, 0.5]
print(elems)

==> [0, 0.2, 0.3, 0.5, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2.4、拉平 (Flattening)

如果,一个列表里的每个元素都是个列表,可以用sum把它拉平:

list_of_lists = [[1], [2, 3], [4, 5, 6]]
sum(list_of_lists, [])

==> [1, 2, 3, 4, 5, 6]

如果是嵌套列表 (Nested List) 的话,就可以用递归的方法把它拉平。这也是lambda函数又一种优美的使用方法:在创建函数的同一行,就能用上这个函数。

nested_lists = [[1, 2], [[3, 4], [5, 6], [[7, 8], [9, 10], [[11, [12, 13]]]]]]
flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]
flatten(nested_lists)

# This line of code is from
# https://github.com/sahands/python-by-example/blob/master/python-by-example.rst#flattening-lists

2.5、列表vs生成器

要想知道列表和生成器的区别在哪,看个例子:从token列表里面创建n-grams。

一种方法是用滑窗来创建:

tokens = ['i', 'want', 'to', 'go', 'to', 'school']

def ngrams(tokens, n):
    length = len(tokens)
    grams = []
    for i in range(length - n + 1):
        grams.append(tokens[i:i+n])
    return grams

print(ngrams(tokens, 3))

==> [['i', 'want', 'to'],
     ['want', 'to', 'go'],
     ['to', 'go', 'to'],
     ['go', 'to', 'school']]

上面这个例子,是需要把所有n-gram同时储存起来的。如果文本里有m个token,内存需求就是 O(nm) 。m值太大的话,存储就可能成问题。

所以,不一定要用一个列表储存所有n-gram。可以用一个生成器,在收到指令的时候,生成下一个n-gram,这叫做惰性计算 (Lazy Evaluation) 。

只要让 ngrams 函数,用 yield 关键字返回一个生成器,然后内存需求就变成 O(n) 了。

def ngrams(tokens, n):
    length = len(tokens)
    for i in range(length - n + 1):
        yield tokens[i:i+n]

ngrams_generator = ngrams(tokens, 3)
print(ngrams_generator)

==> <generator object ngrams at 0x1069b26d0>

for ngram in ngrams_generator:
    print(ngram)

==> ['i', 'want', 'to']
    ['want', 'to', 'go']
    ['to', 'go', 'to']
    ['go', 'to', 'school']

还有一种生成n-grams的方法,是用切片来创建列表:[0, 1, …, -n], [1, 2, …, -n+1], …, [n-1, n, …, -1],然后把它们zip到一起。

def ngrams(tokens, n):
    length = len(tokens)
    slices = (tokens[i:length-n+i+1] for i in range(n))
    return zip(*slices)

ngrams_generator = ngrams(tokens, 3)
print(ngrams_generator)

==> <zip object at 0x1069a7dc8> # zip objects are generators

for ngram in ngrams_generator:
    print(ngram)

==> ('i', 'want', 'to')
    ('want', 'to', 'go')
    ('to', 'go', 'to')
    ('go', 'to', 'school')

注意,创建切片用的是 (tokens[…] for i in range(n)) ,不是 [tokens[…] for i in range(n)]。

[] 返回的是列表,() 返回的是生成器。

3、类,以及魔术方法

在Python里面,魔术方法 (Magic Methods) 是用双下划线,作为前缀后缀的。

其中,最知名的可能就是 _init_ 了。

class Node:
    """ A struct to denote the node of a binary tree.
3    It contains a value and pointers to left and right children.
4    """
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

不过,如果想输出 (Print) 一个节点 (Node) ,就不是很容易了。

root = Node(5)
print(root) # <__main__.Node object at 0x1069c4518>

理想情况,应该是输出它的值,如果它有子节点的话,也输出子节点的值。

所以,要用魔术方法 _repr_ ,它必须返回一个可输出的object,如字符串。

class Node:
    """ A struct to denote the node of a binary tree.
 3    It contains a value and pointers to left and right children.
 4    """
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

    def __repr__(self):    
        strings = [f'value: {self.value}']
        strings.append(f'left: {self.left.value}' if self.left else 'left: None')
        strings.append(f'right: {self.right.value}' if self.right else 'right: None')
        return ', '.join(strings)

left = Node(4)
root = Node(5, left)
print(root) # value: 5, left: 4, right: None

如果想对比两个节点 (的各种值) ,就用 _eq_ 来重载 == 运算符,用 _lt_ 来重载 < 运算符,用 _ge_ 来重载 >= 。

class Node:
    """ A struct to denote the node of a binary tree.
 3    It contains a value and pointers to left and right children.
 4    """
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

    def __eq__(self, other):
        return self.value == other.value

    def __lt__(self, other):
        return self.value < other.value

    def __ge__(self, other):
        return self.value >= other.value


left = Node(4)
root = Node(5, left)
print(left == root) # False
print(left < root) # True
print(left >= root) # False

想要了解更多魔术方法,请前往: https://www.tutorialsteacher.com/python/magic-methods-in-python

或者使用官方文档,只是有一点点难读: https://docs.python.org/3/reference/datamodel.html#special-method-names

这里,还要重点安利几种魔术方法:

一是 _len_ :重载 len() 函数用的。 二是 _str_:重载 str() 函数用的。 三是 _iter_:想让object变成迭代器,就用这个。有了它,还可以在object上调用 next() 函数。

对于像节点这样的类,我们已经知道了它支持的所有属性 (Attributes) :value、left和right,那就可以用 _slots_ 来表示这些值。这样有助于提升性能,节省内存。

class Node:
    """ A struct to denote the node of a binary tree.
3    It contains a value and pointers to left and right children.
4    """
    __slots__ = ('value', 'left', 'right')
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

想要全面了解 _slots_ 的优点和缺点,可以看看Aaron Hall的精彩回答: https://stackoverflow.com/a/28059785/5029595

4、局部命名空间,对象的属性

locals() 函数,返回的是一个字典 (Dictionary) ,它包含了局部命名空间 (Local Namespace) 里定义的变量。

class Model1:
    def __init__(self, hidden_size=100, num_layers=3, learning_rate=3e-4):
        print(locals())
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.learning_rate = learning_rate

model1 = Model1()

==> {'learning_rate': 0.0003, 'num_layers': 3, 'hidden_size': 100, 'self': <__main__.Model1 object at 0x1069b1470>}

一个object的所有属性,都存在 _dict_ 里面。

print(model1.__dict__)

==> {'hidden_size': 100, 'num_layers': 3, 'learning_rate': 0.0003}

注意,当参数列表 (List of Arguments) 很大的时候,手动把每个参数值分配给一个属性会很累。

想简单一点的话,可以直接把整个参数列表分配给 _dict_ 。

class Model2:
    def __init__(self, hidden_size=100, num_layers=3, learning_rate=3e-4):
        params = locals()
        del params['self']
        self.__dict__ = params

model2 = Model2()
print(model2.__dict__)

==> {'learning_rate': 0.0003, 'num_layers': 3, 'hidden_size': 100}

当object是用 kwargs** 初始化的时候,这种做法尤其方便 (虽然 kwargs** 还是尽量少用为好) :

class Model3:
    def __init__(self, **kwargs):
        self.__dict__ = kwargs

model3 = Model3(hidden_size=100, num_layers=3, learning_rate=3e-4)
print(model3.__dict__)

==> {'hidden_size': 100, 'num_layers': 3, 'learning_rate': 0.0003}

前4个版块就到这里了,至于第5个版块传授了怎样的技巧,先不介绍,大家可以从传送门前往观察:

https://github.com/chiphuyen/python-is-cool

宝藏小姐姐

贡献资源的Chip Huyen小姐姐,现在是英伟达的高级深度学习工程师了。

但在2015年进入斯坦福读书之前,她还是个没接触过深度学习的作家,旅行路上的故事已经出版了两本书。

对,是个越南小姐姐

原本想读英文专业,却在选了一门计算机课之后,走上了深度学习的不归路。

毕业前,她在Netflix实习过;毕业后,她在斯坦福教过TensorFlow,课号CS20;一年前离开学校,进入英伟达。

正式选择了机器学习的她,依然像旅行的时候一样,喜欢和大家分享经历。

传送门

如果你想更顺滑地使用Python,快马克这些方法吧。

项目传送门: https://github.com/chiphuyen/python-is-cool

Notebook传送门: https://github.com/chiphuyen/python-is-cool/blob/master/cool-python-tips.ipynb

本文分享自微信公众号 - 机器学习与统计学(tjxj666)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-10-31

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 干货 | 32个常用Python功能实现,菜鸟到高手的进阶之路!

    斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13;特别指出:第0项是0,第1项是第一个1。从第三项开始,每一项都等于前两项之和。

    统计学家
  • 利用Python让你的命令行像坤坤一样会打篮球

    承接上文,作为一个经常逛b站的肥宅,近期b站上除了流行"品如”素材的视频,更多的莫过于蔡xx打球视频的了,有模仿的,有对比的,有手绘的,更过分的是竟然有人在命令...

    统计学家
  • 100天搞定机器学习|Day16 通过内核技巧实现SVM

    再简单回顾一下svm算法的思路,详细推导请看前情回顾相关内容,或在文末下载之前推荐的《理解SVM 的三层境界》PDF版。

    统计学家
  • 英伟达小姐姐的Python隐藏技巧合集,推特2400赞,代码可以直接跑

    常常发资源的英伟达工程师小姐姐Chip Huyen,又发射了一套Python隐藏功能合集。

    用户2769421
  • 英伟达小姐姐开源 Python 隐藏技巧,上了 GitHub 热榜!

    转自量子位,作者栗子 常常发资源的英伟达工程师小姐姐 Chip Huyen,又发射了一套 Python 隐藏功能合集。

    GitHubDaily
  • 英伟达小姐姐的Python隐藏技巧合集,推特2400赞,代码可以直接跑

    常常发资源的英伟达工程师小姐姐Chip Huyen,又发射了一套Python隐藏功能合集。

    量子位
  • (二十七) 初遇python OOP面向对象编程-继承

    各位读者大大们大家好,今天学习python的面向对象编程-继承,并记录学习过程欢迎大家一起交流分享。

    亚乐记
  • Python操作Mysql类

    #!/usr/bin/python # -*- coding: UTF-8 -*- import MySQLdb from warnings import fi...

    苦咖啡
  • tensorflow: tf.add_to_collection 探究

      查看源代码 tensorflow/python/framework/ops.py:

    Petrichor_
  • Swift3.0 - 元类型

    酷走天涯

扫码关注云+社区

领取腾讯云代金券

玩转腾讯云 有奖征文活动