Понимание входов лямбда-функции в Spark для СДР

Question

Я делаю курс по Spark, и я немного запутался.

Итак, есть код ниже. Я понимаю, что строка 1 создает кортежи (word, 1). Затем строка 2 группируется по слову и суммирует счет.

Что я не понимаю, так это то, что X и Y находятся в строке 2. У нас есть только один числовой вход для функции lamda, то есть счетстолбец (все 1) из wordcounts, так почему y?

wordCounts = words.map(lambda x: (x, 1)) #outputs [('self', 1), ('employment', 1), ('building', 1)...
wordCounts2 = wordCounts.reduceByKey(lambda x, y: x + y) # outputs [('self', 111), ('an', 178), ('internet', 26)

Тогда у нас есть этот фрагмент кода, который идет сразу после. Я понимаю, что это сортирует RDD. Чтобы подтвердить мое понимание, X [1] слово и X [2] общее количество? Я бы догадался, но я не на 100%

Извините за глупые вопросы, но я не смог найти четкого объяснения!

wordCountsSorted = wordCounts2.map(lambda x: (x[1], x[0])).sortByKey()

Answer 1

Надеюсь, это поможет

Первая лямбда - лямбда x: (x, 1)

Во время первых шагов вход будет выглядеть ниже

['self', 'employment', 'building',
'self', 'employment', 'building',
'self', 'employment', 'building', 
'self', 'employment' ]

Здесь,Ваша первая лямбда-функция берет каждый элемент из вышеприведенного списка и охватывает нижеследующие элементы в соответствующем месте.

data = [('self', 1), ('employment', 1), ('building', 1),
('self', 1), ('employment', 1), ('building', 1),
('self', 1), ('employment', 1), ('building', 1),
('self', 1), ('employment', 1) ]

Эта лямбда такая же, как показано ниже

def convert_word_to_key_value(word):
    return (word, 1)

Пример:

'self' преобразуется в ('self',) `

Цель этой лямбды - преобразовать каждое слово в кортеж (ключ, значение).

Вторая лямбда -лямбда х, у: х + у

Целью этой лямбды была группировка слов, т.е. накопление значений с одинаковыми ключами.

Обратите внимание, что мы используем reduceByKey, что означаетуменьшить значения с одинаковыми именами ключей. Таким образом, x и y будут представлять значения ключей двух элементов, и эта операция выполняется только для элементов с одинаковыми key

Например, если есть два кортежа, как показано ниже

('self', 1),('self', 1) станет ('self', 2)

Второй пример

('self', 2),('self', 1) станет ('self', 1)

Третий пример

('self', 12),('self', 15) станет('self', 27)

Последняя часть вашего вопроса

wordCountsSorted = wordCounts2.map(lambda x: (x[1], x[0])).sortByKey()

Во-первых, здесь вы меняете свои ключи и значения.

(key, value) становится (value, key)

Пример (скажем)

('self', 1231) становится (1231, 'self')

Теперь вы сортируете элементы по ключу в этом новом формате 1231 или сгруппированном значенииэтого ключа (то есть частота слова).

Answer 2

@ kikee1222,

@ Sampath и @pissal предоставили вам подробное объяснение по всем вашим вопросам, и я думаю, что нам не хватает ключевой точки одного (x) параметра, который действует как аккумулятор

Что я не понимаю, так это то, что X и Y находятся в строке 2. У нас есть только один числовой вход для функции lamda, который является столбцом подсчета (все 1) из словесных счетов, так почему y?

wordCounts2 = wordCounts.reduceByKey(lambda x, y: x + y) # outputs [('self', 111), ('an', 178), ('internet', 26)

Здесь вы можете думать о х как о аккумуляторе, а у считать. Аккумулятор инициализируется с 0 и складывается со счетчиком для каждого ключа и производит окончательный счет для ключа

[('a', 1), ('b', 1), ('c',1), ('b',1), ('a',1), ('a',1)]

после применения reduceByKey ( lambda accum, count : accum + count)

, о котором вы можете думатьитерация, подобная этой

#1 : accum = 0 , count = 1 =>(returns) 1
#2 : accum = 1, count = 1  => 2
#3 : accum = 2, count = 1  => 3

Надеюсь, это поможет

Answer 3

1. Почему x и y?

Создайте пару ключ-значение, например (word, 1). Теперь вашим ключом будет слово, а значением будет 1

. Когда вы сделаете limitByKey, он сложит все значения для того же ключа

reduceByKey(lambda x, y: x + y) сгруппирует элементы RDDEпо ключу, который является первым элементом word, и суммируем значения. В этом конкретном утверждении x - это один элемент, накапливающий все значения СДР, а y - любой другой элемент для того же ключа / слова. Уменьшите значения, добавив их значения для того же слова или того же ключа. Может выглядеть примерно так:

# [('This', 1), ('is', 2), ('a', 3), ('random', 1), ('sample.', 2), ('And', 2), ('world', 1), ('count', 2), ('word', 1), ('sample,', 1), ('that', 1), ('it', 1)]

2. Давайте разберем ваш следующий вопрос о wordCountsSorted = wordCounts2.map(lambda x: (x[1], x[0])).sortByKey()

Следующая строка поменяет местами (обменивает позиции) элементы кортежей. По сути, элемент в позиции 0 должен быть перемещен в позицию 1, а элемент в позиции 1 должен быть перемещен в позицию 0.

reversed_tup = wordCounts2.map(lambda x: (x[1], x[0]))

Вывод будет выглядеть так:

# [(1, 'This'), (2, 'is'), (3, 'a'), (1, 'random'), (2, 'sample.'), (2, 'And'), (1, 'world'), (2, 'count'), (1, 'word'), (1, 'sample,'), (1, 'that'), (1, 'it')]

Теперь, когда вы сделаете sortByKey, эти кортежи будут отсортированы с использованием ключа, который, как упоминалось выше, первого элемента кортежа. Таким образом, rdd будет отсортировано по количеству слов.

wordCountsSorted = reversed_tup.sortByKey()
wordCountsSorted.collect()
# [(1, 'This'), (1, 'random'), (1, 'world'), (1, 'word'), (1, 'sample,'), (1, 'that'), (1, 'it'), (2, 'is'), (2, 'sample.'), (2, 'And'), (2, 'count'), (3, 'a')]

Answer 4

x и y - временные переменные, как и для цикла в Java. Таким образом, вы можете иметь любое имя переменной. Когда вы делаете sortByKey, он сортирует результаты по ключу.