CS231n Convolutional Neural Networks for Visual Recognition------Python Tutorial

最新推荐文章于 2022-11-01 03:55:08 发布

自动驾驶小学生

最新推荐文章于 2022-11-01 03:55:08 发布

阅读量268

点赞数

分类专栏： Python

Python 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

源链接为：http://cs231n.github.io/python-numpy-tutorial/。

这篇指导书是由Justin Johnson编写的。

在这门课程中我们将使用Python语言完成所有变成任务！Python本身就是一种很棒的通用编程语言，但是在一些流行的库帮助下（numpy，scipy，matplotlib）它已经成为科学计算的强大环境。
我们希望你们中的许多人都有一些Python和numpy的使用经验; 对你们其他人来说，这个section将作为Python用于科学计算和使用的快速速成课程。
你们中的一些人可能已经掌握了Matlab的知识，在这种情况下我们也推荐使用numpy。

你也可以阅读由Volodymyr Kuleshov和Isaac Caswell（CS 228）编写的Notebook版笔记。

本教程使用的Python版本为Python3.

原文共分为4部分，分别介绍了Python、Numpy、Scipy和Matplotlib的使用。本次翻译为第一部分：Python的使用指导！

Python是一种高级动态类型的多范式编程语言。经常说Python代码几乎像伪代码，因为它允许你在很少的代码行中表达非常强大的想法。作为一个例子，这里是经典的快速排序算法的实现。

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))

[1, 1, 2, 3, 6, 8, 10]

Basic data types

和其它语言一样，Python也有许多基本数据类型，包括整数，浮点数，布尔类型，和字符类型。这些数据类型的行为和其它语言十分相似。
Numbers:整数和浮点数的运算和其它一样。
注意：和其它语言不同的是，Python没有递增（++）和递减（--）运算符。

%matplotlib inline
x = 3
print(type(x)) # Prints "<class 'int'>"
print(x)       # Prints "3"
print(x + 1)   # Addition; prints "4"
print(x - 1)   # Subtraction; prints "2"
print(x * 2)   # Multiplication; prints "6"
print(x ** 2)  # Exponentiation; prints "9"
x += 1
print(x)  # Prints "4"
x *= 2
print(x)  # Prints "8"
y = 2.5
print(type(y)) # Prints "<class 'float'>"
print(y, y + 1, y * 2, y ** 2) # Prints "2.5 3.5 5.0 6.25"

Python还有许多内置的复杂数字类型，你可以在这里找到所有的细节。

Booleans:Python实现了布尔逻辑的所有常用运算符，但使用的是英语单词而不是符号（&&，||等）：

t = True
f = False
print(type(t)) # Prints "<class 'bool'>"
print(t and f) # Logical AND; prints "False"
print(t or f)  # Logical OR; prints "True"
print(not t)   # Logical NOT; prints "False"
print(t != f)  # Logical XOR; prints "True"

Strings:Python对字符串有很大的支持

hello = 'hello'    # String literals can use single quotes
world = "world"    # or double quotes; it does not matter.
print(hello)       # Prints "hello"
print(len(hello))  # String length; prints "5"
hw = hello + ' ' + world  # String concatenation
print(hw)  # prints "hello world"
hw12 = '%s %s %d' % (hello, world, 12)  # sprintf style string formatting
print(hw12)  # prints "hello world 12"

字符串对象有很多实用的方法：例如

s = "hello"
print(s.capitalize())  # Capitalize a string; prints "Hello"
print(s.upper())       # Convert a string to uppercase; prints "HELLO"
print(s.rjust(7))      # Right-justify a string, padding with spaces; prints "  hello"
print(s.center(7))     # Center a string, padding with spaces; prints " hello "
print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another;
                                # prints "he(ell)(ell)o"
print('  world '.strip())  # Strip leading and trailing whitespace; prints "world"

Containers

Python包含几种内置容器类型：列表，字典，集合和元组。

Lists

列表是Python中的数组，但是可以调整大小并且可以包含不同类型的元素：

xs = [3, 1, 2]    # Create a list
print(xs, xs[2])  # Prints "[3, 1, 2] 2"
print(xs[-1])     # Negative indices count from the end of the list; prints "2"
xs[2] = 'foo'     # Lists can contain elements of different types
print(xs)         # Prints "[3, 1, 'foo']"
xs.append('bar')  # Add a new element to the end of the list
print(xs)         # Prints "[3, 1, 'foo', 'bar']"
x = xs.pop()      # Remove and return the last element of the list
print(x, xs)      # Prints "bar [3, 1, 'foo']"

像往常一样，您可以在文档中找到有关列表的所有详细信息。

切片：除了一次访问一个列表元素外，Python还提供了访问子列表的简明语法; 这被称为切片：

nums = list(range(5))     # range is a built-in function that creates a list of integers
print(nums)               # Prints "[0, 1, 2, 3, 4]"
print(nums[2:4])          # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print(nums[2:])           # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print(nums[:2])           # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print(nums[:])            # Get a slice of the whole list; prints "[0, 1, 2, 3, 4]"
print(nums[:-1])          # Slice indices can be negative; prints "[0, 1, 2, 3]"
nums[2:4] = [8, 9]        # Assign a new sublist to a slice
print(nums)               # Prints "[0, 1, 8, 9, 4]"

循环：您可以循环遍历列表的元素，如下所示：

animals = ['cat', 'dog', 'monkey']
for animal in animals:
    print(animal)
# Prints "cat", "dog", "monkey", each on its own line.

如果要访问循环体内每个元素的索引，请使用内置枚举函数：

animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: cat", "#2: dog", "#3: monkey", each on its own line

列表解析：编程时，我们经常要将一种数据转换为另一种。举个简单的例子，考虑以下计算平方数的代码：

nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
    squares.append(x ** 2)
print(squares)   # Prints [0, 1, 4, 9, 16]

你可以使用列表解析来减少代码量：

nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)   # Prints [0, 1, 4, 9, 16]

列表解析也可以包含一些特定条件：

nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares)  # Prints "[0, 4, 16]"

Dictionaries

字典存储（键，值）对，类似于Java中的Map或Javascript中的对象。你可以像这样使用它：

d = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data
print(d['cat'])       # Get an entry from a dictionary; prints "cute"
print('cat' in d)     # Check if a dictionary has a given key; prints "True"
d['fish'] = 'wet'     # Set an entry in a dictionary
print(d['fish'])      # Prints "wet"
# print(d['monkey'])  # KeyError: 'monkey' not a key of d
print(d.get('monkey', 'N/A'))  # Get an element with a default; prints "N/A"
print(d.get('fish', 'N/A'))    # Get an element with a default; prints "wet"
del d['fish']         # Remove an element from a dictionary
print(d.get('fish', 'N/A')) # "fish" is no longer a key; prints "N/A"

你可以在文档里找到所有你需要知道的。

循环：在字典里通过键来迭代很容易。

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal in d:
    legs = d[animal]
    print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

如果要访问键及其对应的值，请使用items方法：

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

字典解析：这些与列表解析类似，但允许您轻松构建字典。例如：

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)  # Prints "{0: 0, 2: 4, 4: 16}"

Sets

集合是不同元素的无序集合。举个简单的例子：

animals = {'cat', 'dog'}
print('cat' in animals)   # Check if an element is in a set; prints "True"
print('fish' in animals)  # prints "False"
animals.add('fish')       # Add an element to a set
print('fish' in animals)  # Prints "True"
print(len(animals))       # Number of elements in a set; prints "3"
animals.add('cat')        # Adding an element that is already in the set does nothing
print(len(animals))       # Prints "3"
animals.remove('cat')     # Remove an element from a set
print(len(animals))       # Prints "2"

同样的，任何关于集合你想知道的事都可以在这里找到。

循环：对集合进行迭代与迭代列表具有相同的语法; 但是由于集合是无序的，因此您无法对访问集合元素的顺序进行假设：

animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: fish", "#2: dog", "#3: cat"

集合解析：和列表和字典一样，我们可以使用集合解析来构造集合。

from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print(nums)  # Prints "{0, 1, 2, 3, 4, 5}"

Tuples：

元组是（不可变的）有序值列表。元组在很多方面类似于列表; 其中一个最重要的区别是元组可以用作字典中的键和集合的元素，而列表则不能。这是一个简单的例子：

d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys
t = (5, 6)        # Create a tuple
print(type(t))    # Prints "<class 'tuple'>"
print(d[t])       # Prints "5"
print(d[(1, 2)])  # Prints "1"

这篇文档有更多关于元组的信息。

Functions

Python的函数是使用def来定义的，如下：

def sign(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

for x in [-1, 0, 1]:
    print(sign(x))
# Prints "negative", "zero", "positive"

我们经常定义函数来获取可选的关键字参数：

def hello(name, loud=False):
    if loud:
        print('HELLO, %s!' % name.upper())
    else:
        print('Hello, %s' % name)

hello('Bob') # Prints "Hello, Bob"
hello('Fred', loud=True)  # Prints "HELLO, FRED!"

这里有关于Python函数的更多信息。

Classes

在Python中定义类的语法很简单：

class Greeter(object):

    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # Instance method
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)

g = Greeter('Fred')  # Construct an instance of the Greeter class
g.greet()            # Call an instance method; prints "Hello, Fred"
g.greet(loud=True)   # Call an instance method; prints "HELLO, FRED!"

这里有关于Pythonclasses的更多信息。

自动驾驶小学生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CS231n Convolutional Neural Networks for Visual Recognition------Python Tutorial

源链接为：http://cs231n.github.io/python-numpy-tutorial/。这篇指导书是由Justin Johnson编写的。在这门课程中我们将使用Python语言完成所有变成任务！Python本身就是一种很棒的通用编程语言，但是在一些流行的库帮助下（numpy，scipy，matplotlib）它已经成为科学计算的强大环境。我们希望你们中的许多人都有一些P...
复制链接

扫一扫