Модуль concurrent.futures¶
В этом модуле описано 2 класса, с помощью которых удобно запускать параллельные вычисления.
import concurrent.futures
Класс concurrent.futures.ThreadPoolExecutor¶
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
for i in range(100):
executor.submit(print, i, end=", ")
# Taken from Python Docs.
import urllib.request
URLS = ['http://www.foxnews.com/',
'http://www.cnn.com/',
'http://europe.wsj.com/',
'http://www.bbc.co.uk/',
'http://some-made-up-domain.com/']
# Retrieve a single page and report the URL and contents
def load_url(url, timeout):
with urllib.request.urlopen(url, timeout=timeout) as conn:
return conn.read()
# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
# Start the load operations and mark each future with its URL
future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
for future in concurrent.futures.as_completed(future_to_url):
url = future_to_url[future]
try:
data = future.result()
except Exception as exc:
print(f"{url} generated an exception: {exc}")
else:
print(f"{url} page is {len(data)} bytes")
Класс concurrent.futures.ProcessPoolExecutor¶
with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
for i in range(100):
executor.submit(print, i, end=", ")
# Taken and modified from Python Docs.
import math
PRIMES = [
112272535095293,
112582705942171,
112272535095293,
115280095190773,
115797848077099,
1099726899285419]
def is_prime(n):
if n == 2:
return True
if n < 2 or n % 2 == 0:
return False
sqrt_n = int(math.floor(math.sqrt(n)))
for i in range(3, sqrt_n + 1, 2):
if n % i == 0:
return False
return True
with concurrent.futures.ProcessPoolExecutor() as executor:
for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
print(f"{number} is {'' if prime else 'not '}prime")
В чем разница между Process и Thread?
Попробуем понять из примера:
numbers_thread = list()
def append_thread(item):
numbers_thread.append(item)
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
for i in range(20):
executor.submit(append_thread, i)
numbers_thread
А что происходит с процессами?
numbers_process = list()
def append_process(item):
numbers_process.append(item)
with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
for i in range(20):
executor.submit(append_process, i)
numbers_process
Каждый процесс (Process) предоставляет все ресурсы для запуска программы.
Это значит, что каждому из них выделены свое пространство адресов, свой идентификатор, своя память и т.д. и предоставлен как минимум один поток.
Поток выполнения (Thread) же является сущностью внутри процесса, которую тот может запускать. Потоки имеют общее пространство адресов и общие системные ресурсы (память и т.п.).
Thread работает в рамках вашей сессии и может менять переменные внутри нее.
Process работает в отдельной сессии: для любого изменения вашей переменной необходимо ее скопировать в другую сессию.
Как вы думаете, что из этого работает быстрее?
Давайте проверим:
Создадим функцию, которая будет работать примерно секунду.
def long_sum():
s = 0
for i in range(20_000_000 + 1):
s += i
return s
%%time
long_sum()
%%time
for _ in range(10):
long_sum()
Теперь попробуем посчитать эту сумму несколько раз параллельно:
%%time
with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
for _ in range(10):
executor.submit(long_sum)
%%time
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
for _ in range(10):
executor.submit(long_sum)
Какая-то ерунда; почему в случае Thread расчет идет еще дольше, чем в простом цикле?
Ответ заключается в архитектуре CPython.
Идея состоит в том, что в Python реализован механизм Global Interpreter Lock (GIL), запрещающий отдельным потокам внутри процесса Python выполняться одновременно.
Как выполняются три потока одновременно. Источник - Wikipedia Commons.
Зачем тогда вообще нужны потоки?
Потоки медленнее только при активных вычислениях; быстрее потоки могут:
a) Ждать:
import time
%%time
for _ in range(10):
time.sleep(2)
%%time
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
for _ in range(10):
executor.submit(time.sleep, 2)
Зачем вообще может понадобиться ждать?
Когда вы запускаете множество подпроцессов, вам приходится ждать их завершения (как десятки картирований на геном, сотни докингов и т.п.). Потоки прекрасно справятся с такой задачей.
b) Работать с операциями, на которые не распространяется GIL.
Обычно это потенциально блокирующие или очень длительные операции, как ввод-вывод (на экран и в файлы), обработка изображений или NumPy "number crunching".
a = numpy.arange(1_000_000)
a
%%time
sum(a)
%%time
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
for _ in range(100):
executor.submit(sum, a)
%%time
numpy.sum(a)
%%time
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
for _ in range(100):
executor.submit(numpy.sum, a)
c) Когда требуется одновременная работа двух разных алгоритмов.
Наиболее простой пример - responsive user interface.
Ваша программа не должна полностью зависать во время подсчета; именно это и реализуется потоками.
Когда что использовать?¶
Простое правило:
- Когда у вас длительные параллельные вычисления в Python, используйте
multiprocessing; - Когда у вас параллельный запуск других программ из Python, используйте
threading; - Когда вы проводите параллельные вычисления с NumPy, используйте
threading; - Когда вам доступно одно ядро процессора, используйте
threading.
Библиотека NumPy¶
NumPy [/ˈnʌmpaɪ/ (NUM-py)] - библиотека языка Python, добавляющая поддержку многомерных массивов и матриц, а также целую коллекцию формул и высокоуровневых математических функций для работы с массивами и матрицами.
import numpy as np
np.__version__
Давайте подумаем, зачем нужен целый модуль для математики, массивов и матриц?
Мне будет достаточно списков! - they said.
Что есть в numpy?¶
Зачем же нужен numpy?¶
Сколько программистов нужно, чтобы заменить лампочку?
Ни одного - проблема тут по части железа.
Numpy нужен для векторизованных вычислений!
mln = 10 ** 6
a = list(range(mln))
%%timeit
[e * e for e in a]
a = np.arange(mln)
%%timeit
a * a
Какая операция здесь самая медленная?
Конечно же, цикл!
Ещё дольше выполняются вложенные циклы:
rows, cols = 1000, 1000
a = [list(range(i, i + cols)) for i in range(0, rows)]
b = [[0 for j in range(cols)] for i in range(rows)]
%%timeit
for i in range(rows):
for j in range(cols):
b[i][j] = 2 * a[i][j]
Сравним с векторизованными циклами:
a = np.asarray([list(range(i, i + cols)) for i in range(0, rows)])
%%timeit
2 * a
Выигрыш во времени примерно в 50 раз!
Массив numpy.array¶
В чем его отличие от списка?¶
Почему в массиве важно иметь один и тот же тип данных?
Создание массива¶
Самый простой способ создать массив numpy.array - из стандартного списка list.
mydata = np.array([1, 2, 3])
mydata
Массив может быть и многомерным!
mydata_2d = np.array([[1, 2],
[3, 4]])
mydata_2d
Важнейшая информация о массиве¶
mydata = np.array([[1, 2, 3, 4, 5],
[6, 7, 8, 9, 0],
[7, 0, 8, 8, 1]], dtype=float)
mydata
mydata.dtype
Типы данных в numpy¶
| Тип данных | Описание |
|---|---|
| bool | Boolean (True or False) stored as a byte |
| int | Platform integer (normally either int32 or int64) |
| int8 | Byte (-128 to 127) |
| int16 | Integer (-32768 to 32767) |
| int32 | Integer (-2147483648 to 2147483647) |
| int64 | Integer (-9223372036854775808 to 9223372036854775807) |
| uint8 | Unsigned integer (0 to 255) |
| uint16 | Unsigned integer (0 to 65535) |
| uint32 | Unsigned integer (0 to 4294967295) |
| uint64 | Unsigned integer (0 to 18446744073709551615) |
| float | Shorthand for float64 |
| float32 | Single precision float: sign bit, 8 bits exponent, 23 bits mantissa |
| float64 | Double precision float: sign bit, 11 bits exponent, 52 bits mantissa |
| complex | Shorthand for complex128 |
| complex64 | Complex number, represented by two 32-bit floats (real and imaginary components) |
| complex128 | Complex number, represented by two 64-bit floats (real and imaginary components) |
mydata.astype(np.int8)
Ещё важнейшая информация о массиве¶
mydata = np.array([[1, 2, 3, 4, 5],
[6, 7, 8, 9, 0],
[7, 0, 8, 8, 1]], dtype=np.int8)
mydata
len(mydata)
mydata.ndim
mydata.shape
mydata.strides
numpy.array.shape¶
Array reshaping¶
data = np.array([1, 2, 3, 4, 5, 6], dtype=np.int8)
data.reshape(2, 3)
data.reshape(3, 2)
Array reshaping¶
data
data.reshape(2, -1)
data.reshape(-1, 3)
data.reshape(3, 3)
Array reshaping¶
data = np.array([[1, 2, 3],
[4, 5, 6]], dtype=np.int8)
data2 = data.reshape(-1)
data2
data[0,2] = -1
data2
Что это означает? :^)
Array reshaping¶
data = np.array([[1, 2, 3],
[4, 5, 6]], dtype=np.int8)
a = data.ravel()
a
b = data.flatten()
b
data[0,0] = -1
a, b
Транспонирование¶
Что значит "транспонировать матрицу"?
Как транспонировать в стандартном Python?
list_data = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
list_T = list(zip(*list_data))
list_T
data = np.array(list_data)
data.T
data.transpose()
Другие способы инициализации numpy.array...¶
Но сначала... Кто знает, что называют индусским кодом? :^)
int a0 = 0;
int a1 = 0;
int a2 = 0;
int a3 = 0;
int a4 = 0;
int a5 = 0;
int a6 = 0;
int a7 = 0;
int a8 = 0;
int a9 = 0;
Допустим, мы хотим сделать массив numpy.array из нулей.
Сделаем способом, который помним!
x = 10
y = 3
zeros = []
for i in range(y):
sub_zero = []
for j in range(x):
sub_zero.append(0)
zeros.append(sub_zero)
zeros = np.array(zeros)
zeros
Как сделать это нормально?¶
В стандартном Python:
x = 10
y = 3
zeros = [[0 for _ in range(x)] for _ in range(y)]
zeros
[[0] * x] * y
np.zeros(shape=(3, 10), dtype=int)
Чтобы создавать простые массивы numpy.array, можно воспользоваться специальными функциями:
np.ones(3)
np.ones(shape=(3,))
np.random.random(3)
np.full(3, fill_value=-8.0)
Аналогично с многомерными массивами:
np.zeros(shape=(3, 2))
np.random.random((2, 3))
np.full((2, 4), fill_value="F")
Массив такого же размера, но из нулей:
data
np.zeros_like(data)
E - единичный массив
np.eye(5)
Аналоги range, сразу возвращающие массив numpy.array:
np.arange(1, 10)
np.arange(1, 10, 2)
np.arange(1, 10, 0.5)
np.linspace(0, 1, 5, endpoint=True)
В чем разница?
Алгебраические операции¶
— Какие храбрые поступки вы совершали в своей жизни?
— Однажды на алгебре я руку поднял.
Базовая арифметика¶
data = np.array([[1, 2],
[3, 4],
[5, 6]], dtype=np.int8)
data + 2
data - 5
1 - data
data * 2
data / 3
data ** 2
2 ** data
То же самое функциями¶
np.add(data, 2)
np.subtract(data, 5)
np.subtract(1, data)
np.multiply(data, 2)
np.divide(data, 3)
np.power(data, 2)
np.power(2, data)
А если складывать не с числом?¶
Как вы думаете, что произойдет, если попытаться сложить 2 массива?
data = np.array([1, 2])
ones = np.ones(2)
data + ones
С другими операциями это тоже работает:
data - ones
data * data
data / data
А что получится с многомерными массивами?
data = np.array([[1, 2],
[3, 4]], dtype=int)
ones = np.ones(shape=(2, 2))
Всё так же!
data + ones
Можно складывать и разные по размерностям массивы.
data = np.array([[1, 2],
[3, 4],
[5, 6]])
ones_row = np.ones(2)
data + ones_row
data.shape
data + np.ones(2)
data + np.ones(3)
data + np.ones(shape=(3, 1))
Почему для 2D-массивов 1D-массив прибавляется по axis=1, но не прибавляется по axis=0?
Еще раз; как идут измерения:
Как понять, можно ли произвести бинарную операцию (типа сложения) для пары массивов?
Посмотрим на пример:
data = np.arange(30).reshape(3, -1)
data
adder = np.arange(data.shape[1])
adder
print(f"data.shape = {data.shape}")
print(f"adder.shape = {adder.shape}")
data + adder
data
adder = np.arange(data.shape[0])
adder
print(f"data.shape = {data.shape}")
print(f"adder.shape = {adder.shape}")
data + adder
data
adder = np.arange(data.shape[0]).reshape(-1, 1)
adder
print(f"data.shape = {data.shape}")
print(f"adder.shape = {adder.shape}")
data + adder
На самом деле существуют специальное правило приведения размерностей:
- Предположим, что
a.shape = (a_1, a_2, ..., a_n)иb.shape = (b_1, b_2, ..., b_n). Надaиbможно произвести поэлементую бинарную операцию, если $\forall \; i \in (1...n)$ выполнено хотя бы одно из условий:a_i == b_i;a_i == 1;b_i == 1.
- Если размерности не совпадают, то к массиву меньшей размерности добавляются ведущие фиктивные размерности.
Документация: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
(из материалов Техносферы@Mail.Ru)
Проверить явное приведение размерности можно через функции np.broadcast_to и np.broadcast_arrays.
Такие же правила применяются к вычитанию.
data = np.array([1, 3])
ones = np.ones(2)
data - ones
data = np.array([[1, 2],
[3, 4]])
ones = np.ones(shape=(2, 2))
data - ones
А как будет происходить умножение?
data1 = np.array([[1, 2],
[3, 4]])
data2 = np.array([[0, 10],
[20, -1]])
data1 * data2
Но что делать, если нам нужно матричное умножение?
data = np.array([1, 2, 3])
powers_of_ten = (10 ** np.arange(6)).reshape(3, 2)
powers_of_ten
data.dot(powers_of_ten)
Для тех, кто забыл, что такое матричное умножение:
А теперь перейдем от базовой арифметики к чуть более cложным функциям.
Подождите, это все была базовая арифметика?
data = np.array([[1, 2, 3],
[4, 5, 8]])
np.sqrt(data)
np.exp(data)
np.log(data)
np.log2(data)
Агрегирующие операции¶
np.random.seed(777)
a = np.random.randint(0, 6, size=(8,))
a[3] = 10
a
a.min(), a.max(), a.argmax(), a.sum(), a.prod(), a.mean()
np.min(a), np.max(a), np.argmax(a), np.sum(a), np.prod(a), np.mean(a)
Старайтесь не использовать с массивами numpy.array нативные функции min, max и sum.
Какая у этого причина?
a = np.random.randint(-2, 8, size=(6,))
max(a), a
a = np.random.randint(-2, 8, size=(4, 3))
max(a), a
Почему агрегирующие операции?
Просто потому что они выполняют агрегацию (редукцию) по определенной оси!
Разберем, что делает numpy.array.???(axis=axis) – агрегирующая операция вдоль оси axis:
- выполняет редукцию (агрегирующую операцию) по оси
axis; - удаляет ось
axisиз исходного массива.
Что все это значит? Как это применять?
Разберем пример:
data = np.array([[1, 2],
[5, 3],
[4, 6]], dtype=int)
data.max(axis=0)
data.max(axis=1)
np.random.seed(777)
data = np.random.randint(0, 10, size=(3, 7))
data[1, 3] = 15
data
data.argmax()
data.ravel()[data.argmax()]
i = np.argmax(data)
i, j = i // data.shape[1], i % data.shape[1]
print(f"value = {data[i, j]}")
print(f"index = {(i, j)}")
np.unravel_index(np.argmax(data), data.shape)
Логические операции¶
data = np.arange(6)
data
data = data > 2
data
data.any(), np.any(data), any(data)
data.all(), np.all(data), all(data)
~data
Логические операции в многомерных массивах¶
data = np.arange(12).reshape(3, 4) >= 3
data
data.all()
data.all(axis=0), data.all(axis=1)
all(data)
Бинарные логические операции¶
a = np.array([1, 1, 0, 0, 1], dtype=bool)
b = np.array([1, 0, 0, 1, 0], dtype=bool)
a and b
a & b
a | b
a ^ b
Индексация numpy.array¶
Общее правило: массив[первый индекс:последний индекс:шаг].
Значения по умолчанию:
- первый индекс = 0;
- последний индекс = len(массив);
- шаг = 1;
data = np.array([1, 2, 3], dtype=np.int8)
print(f"data[0] = {data[0]}")
print(f"data[1] = {data[1]}")
print(f"data[0:2] = {data[0:2]}")
print(f"data[1:] = {data[1:]}")
Для многомерных массивов индексация немного отличается от default Python.
Вспомним, как индексируются обычные вложенные списки?
data = [[ 10, 12],
[ 28, "Oh, fish!"]]
data[1][1]
data = np.array(data)
data[1, 1]
data = np.array([[1, 2],
[3, 4],
[5, 6]])
data[0,1], data[1,0]
data[1:3]
data[0:2,0]
Булева индексация¶
data = np.arange(10)
ind = np.array([1, 0, 0, 1, 0, 1, 1, 1, 1, 0], dtype=bool)
data, ind
data[ind]
Возможно, это одна из самых крутых "фишек" NumPy!
Почему? Чем это полезно?
Можно очень легко делать фильтры! Например:
np.random.seed(777)
a = np.random.randint(-2, 7, 34)
a
Пусть мы хотим найти все отрицательные элементы.
a < 0
a[a < 0]
Найдем все элементы, кратные 3 (сравнимые с нулем по модулю 3):
a
a[a % 3 == 0]
a[np.logical_not(a % 3)]
a[~((a % 3).astype(bool))]
Найдем все элементы, кратные 3 или 5:
a
del35 = (a % 3 == 0) | (a % 5 == 0)
del35
a[del35]
Функция np.where позволит преобразовать булев массив в индексы.
np.random.seed(777)
a = np.random.randint(-10, 10, size=(3, 5))
a
bool_array = a > 0
bool_array
where = np.where(bool_array)
where
np.random.seed(777)
np.random.rand(10)
np.random.randint(0, 10, 10)
np.random.permutation(10)
np.random.choice(10, size=10)
Объединение массивов¶
np.random.seed(777)
a = np.random.randint(1, 10, 12).reshape(4, 3)
a
b = np.random.randint(-5, 0, 9).reshape(3, 3)
b
np.concatenate((a, b))
А как склеить по другой оси?
a.T
b
np.concatenate((a.T, b), axis=1)
np.hstack((a.T, b)) # concatenate with axis=1
np.vstack((a, b)) # concatenate with axis=0
Сортировка массивов¶
np.random.seed(777)
data = np.random.randint(1, 20, 10)
data
np.sort(data), data
data.sort(), data
Сортировка индексов
data = np.random.randint(1, 20, 10)
data
np.argsort(data)
data[np.argsort(data)]
Подождите, в NumPy можно индексировать по массиву индексов?
Да, это называется "Fancy indexing".
Fancy indexing¶
np.random.seed(1337)
a = np.random.randint(-5, 5, size=(5, 5))
a
Как получить 2, 4 и 3 строки?
a[[2, 4, 3]]
a
Как получить элементы в строках 2, 4, 3 и в 0 и последнем столбце?
a[[2, 4, 3], [0, -1]]
a[[2, 4, 3], [0, -1, 2]]
a[[2, 4, 3]][:,[0, -1]]
Fancy indexing может применяться и так:
a
where = np.where(a >= 0)
where
a[where]
Можно сделать еще и так:
a
took = a.take([2, 4, 3], axis=1)
took
a[0,4] = 100
took
Последняя тема:
Отличие view от copy¶
Что есть что?
view - разные объекты ссылаются на одно и то же пространство в памяти.
copy - пространство в памяти от "старого" объекта было скопировано, "новый" объект ссылается на копию.
Как отличить одно от другого?
data = np.random.randint(-5, 5, size=(2, 5))
data
v = data[:,1:4]
v
v.base is data
v - это view*¶
*не vendetta.
data
c = data[:,[1, 2, 3]]
c
c.base is data
c - это copy.¶
Чем отличаются view и copy?¶
- При изменении
viewизменяется и исходный массив. - Создание
copyзанимает обычно в ~2 раза больше времени (чем больше массив, тем хуже). viewимеет ту же базу (numpy.array.base), что и исходный массив;copyимеет в качестве базы другой объект.viewрасположен в том же участке памяти, что и исходный массив,copyже занимает дополнительную память.
Соответственно, если вам нужен и исходный массив и его измененная версия, то вам нужно использовать copy.
Если же ваш массив занимает очень много памяти или если вам нужно создать очень много срезов массива, то следует использовать view.
В большинстве остальных случаев нет существенной разницы.
Когда вы получите view, а когда - copy?¶
| View | Copy | |
|---|---|---|
| Slices | Indexing, e.g. a[0,:] |
Fancy indexing, e.g. a[[0],:] |
Changing dtype |
- | a.as_type(np.float32) |
| Converting to 1D array | a.ravel() |
a.flatten() |
Вы всегда получите копию, если скопируете объект :^)
unambiguous_copy = data.copy()
unambiguous_copy.base is data
На этом всё!¶
Полную документацию NumPy смотрите на сайте:
https://docs.scipy.org/doc/numpy
В NumPy есть еще множество потенциально полезных для вас функций, так что не поленитесь зайти и посмотреть :^)
