Saya tidak bisa memikirkan contoh bagus selain tugas "bagaimana cara menghitung kata dalam teks panjang dengan MapReduce". Saya menemukan ini bukan contoh terbaik untuk memberi kesan kepada orang lain tentang betapa kuatnya alat ini.

Saya tidak mencari cuplikan kode, hanya contoh "tekstual" saja.

Pengurangan peta adalah kerangka kerja yang dikembangkan untuk memproses sejumlah besar data secara efisien. Sebagai contoh, jika kita memiliki 1 juta catatan dalam dataset, dan disimpan dalam representasi relasional - sangat mahal untuk mendapatkan nilai dan melakukan segala macam transformasi pada ini.

Sebagai Contoh Dalam SQL, Diberi Tanggal Lahir, untuk mencari tahu Berapa banyak orang dengan usia> 30 untuk satu juta catatan akan butuh waktu, dan ini hanya akan meningkat dalam urutan magnitute ketika kompleksitas kueri meningkat. Pengurangan Peta menyediakan implementasi berbasis cluster di mana data diproses secara terdistribusi

Berikut adalah artikel wikipedia yang menjelaskan tentang apa map-reducesemua ini

Contoh lain yang baik adalah Menemukan Teman melalui pengurangan peta bisa menjadi contoh yang kuat untuk memahami konsep, dan kasus penggunaan yang digunakan dengan baik.

Secara pribadi, menemukan tautan ini cukup bermanfaat untuk memahami konsep

Menyalin penjelasan yang disediakan di blog (Jika tautannya basi)

Menemukan Teman

MapReduce adalah kerangka kerja yang awalnya dikembangkan di Google yang memungkinkan untuk komputasi skala besar yang mudah didistribusikan di sejumlah domain. Apache Hadoop adalah implementasi open source.

Saya akan mengabaikan detailnya, tetapi harus mendefinisikan dua fungsi: fungsi peta dan fungsi pengurangan. Fungsi peta mengambil nilai dan kunci keluaran: pasangan nilai. Misalnya, jika kita mendefinisikan fungsi peta yang mengambil string dan menampilkan panjang kata sebagai kunci dan kata itu sendiri sebagai nilai maka peta (steve) akan mengembalikan 5: steve dan peta (savannah) akan mengembalikan 8: savannah . Anda mungkin telah memperhatikan bahwa fungsi peta adalah stateless dan hanya membutuhkan nilai input untuk menghitung nilai outputnya. Ini memungkinkan kita untuk menjalankan fungsi peta terhadap nilai-nilai secara paralel dan memberikan keuntungan besar. Sebelum kita sampai ke fungsi pengurangan, kerangka mapreduce mengelompokkan semua nilai bersama dengan kunci, jadi jika fungsi peta menghasilkan kunci berikut: pasangan nilai:

3 : the
3 : and
3 : you
4 : then
4 : what
4 : when
5 : steve
5 : where
8 : savannah
8 : research

Mereka dikelompokkan sebagai:

3 : [the, and, you]
4 : [then, what, when]
5 : [steve, where]
8 : [savannah, research]

Masing-masing baris ini kemudian akan diteruskan sebagai argumen ke fungsi pengurangan, yang menerima kunci dan daftar nilai. Dalam contoh ini, kami mungkin mencoba mencari tahu berapa banyak kata dengan panjang tertentu yang ada, jadi fungsi pengurangan kami hanya akan menghitung jumlah item dalam daftar dan mengeluarkan kunci dengan ukuran daftar, seperti:

3 : 3
4 : 3
5 : 2
8 : 2

Pengurangan juga bisa dilakukan secara paralel, sekali lagi memberikan keuntungan besar. Kita kemudian dapat melihat hasil akhir ini dan melihat bahwa hanya ada dua kata dengan panjang 5 di korpus kami, dll ...

Contoh paling umum dari mapreduce adalah untuk menghitung berapa kali kata-kata muncul dalam sebuah corpus. Misalkan Anda memiliki salinan internet (saya cukup beruntung telah bekerja dalam situasi seperti itu), dan Anda ingin daftar setiap kata di internet serta berapa kali itu terjadi.

Cara Anda mendekati ini adalah dengan tokenize dokumen yang Anda miliki (pisahkan menjadi kata-kata), dan berikan setiap kata ke mapper. Mapper kemudian akan memuntahkan kata itu kembali bersama dengan nilai 1. Fase pengelompokan akan mengambil semua kunci (dalam hal ini kata-kata), dan membuat daftar 1. Fase pengurangan kemudian mengambil kunci (kata) dan daftar (daftar 1 untuk setiap kali kunci muncul di internet), dan menjumlahkan daftar. Peredam kemudian menampilkan kata, beserta hitungannya. Ketika semua dikatakan dan dilakukan Anda akan memiliki daftar setiap kata di internet, bersama dengan berapa kali itu muncul.

Mudah kan? Jika Anda pernah membaca tentang mapreduce, skenario di atas bukanlah sesuatu yang baru ... itu adalah "Halo, Dunia" dari mapreduce. Jadi di sini adalah kasus penggunaan dunia nyata (Facebook mungkin atau mungkin tidak benar-benar melakukan hal berikut, itu hanya sebuah contoh):

Facebook memiliki daftar teman (perhatikan bahwa teman adalah hal dua arah di Facebook. Jika saya teman Anda, Anda milik saya). Mereka juga memiliki banyak ruang disk dan melayani ratusan juta permintaan setiap hari. Mereka telah memutuskan untuk melakukan perhitungan sebelum perhitungan ketika mereka dapat mengurangi waktu pemrosesan permintaan. Satu permintaan pemrosesan yang umum adalah fitur "Anda dan Joe memiliki 230 teman yang sama". Ketika Anda mengunjungi profil seseorang, Anda melihat daftar teman yang memiliki kesamaan. Daftar ini tidak sering berubah sehingga akan sia-sia untuk menghitung ulang setiap kali Anda mengunjungi profil (yakin Anda bisa menggunakan strategi caching yang layak, tapi kemudian saya tidak akan dapat terus menulis tentang mapreduce untuk masalah ini). Kami akan menggunakan mapreduce sehingga kami dapat menghitung semua orang Teman biasa satu kali sehari dan simpan hasilnya. Kemudian itu hanya pencarian cepat. Kami punya banyak disk, murah.

Anggap teman disimpan sebagai Orang -> [Daftar Teman], daftar teman kita adalah:

A -> B C D
B -> A C D E
C -> A B D E
D -> A B C E
E -> B C D

Setiap baris akan menjadi argumen bagi seorang mapper. Untuk setiap teman dalam daftar teman, mapper akan menampilkan pasangan nilai kunci. Kuncinya akan menjadi teman bersama orang tersebut. Nilainya akan menjadi daftar teman. Kunci akan diurutkan sehingga teman-teman berada dalam urutan, menyebabkan semua pasangan teman pergi ke reducer yang sama Ini sulit dijelaskan dengan teks, jadi mari kita lakukan saja dan lihat apakah Anda dapat melihat polanya. Setelah semua pemetaan selesai berjalan, Anda akan memiliki daftar seperti ini:

For map(A -> B C D) :

(A B) -> B C D
(A C) -> B C D
(A D) -> B C D

For map(B -> A C D E) : (Note that A comes before B in the key)

(A B) -> A C D E
(B C) -> A C D E
(B D) -> A C D E
(B E) -> A C D E
For map(C -> A B D E) :

(A C) -> A B D E
(B C) -> A B D E
(C D) -> A B D E
(C E) -> A B D E
For map(D -> A B C E) :

(A D) -> A B C E
(B D) -> A B C E
(C D) -> A B C E
(D E) -> A B C E
And finally for map(E -> B C D):

(B E) -> B C D
(C E) -> B C D
(D E) -> B C D
Before we send these key-value pairs to the reducers, we group them by their keys and get:

(A B) -> (A C D E) (B C D)
(A C) -> (A B D E) (B C D)
(A D) -> (A B C E) (B C D)
(B C) -> (A B D E) (A C D E)
(B D) -> (A B C E) (A C D E)
(B E) -> (A C D E) (B C D)
(C D) -> (A B C E) (A B D E)
(C E) -> (A B D E) (B C D)
(D E) -> (A B C E) (B C D)

Setiap baris akan diteruskan sebagai argumen ke reducer. Fungsi pengurangan hanya akan memotong daftar nilai dan mengeluarkan kunci yang sama dengan hasil persimpangan. Misalnya, mengurangi ((AB) -> (ACDE) (BCD)) akan menampilkan (AB): (CD) dan berarti bahwa teman A dan B memiliki C dan D sebagai teman biasa.

Hasil setelah reduksi adalah:

(A B) -> (C D)
(A C) -> (B D)
(A D) -> (B C)
(B C) -> (A D E)
(B D) -> (A C E)
(B E) -> (C D)
(C D) -> (A B E)
(C E) -> (B D)
(D E) -> (B C)

Sekarang ketika D mengunjungi profil B, kita dapat dengan cepat mencari (B D)dan melihat bahwa mereka memiliki tiga teman yang sama (A C E),.

Salah satu contoh terbaik dari implementasi MapReduce seperti Hadoop .

Namun perlu diingat bahwa mereka terbatas pada implementasi berbasis-nilai dari ide MapReduce (sehingga mereka membatasi penerapannya).

Satu set operasi akrab yang dapat Anda lakukan di MapReduce adalah serangkaian operasi SQL normal: SELECT, SELECT WHERE, GROUP BY, dll.

Contoh bagus lainnya adalah perkalian matriks, di mana Anda melewatkan satu baris M dan seluruh vektor x dan menghitung satu elemen M * x.

Dari waktu ke waktu saya menyajikan konsep MR kepada orang-orang. Saya menemukan tugas pemrosesan yang akrab bagi orang-orang dan kemudian memetakannya ke paradigma MR.

Biasanya saya mengambil dua hal:

1. Kelompok Menurut / Agregasi. Di sini keuntungan dari tahap pengocokan jelas. Penjelasan bahwa pengocokan juga didistribusikan urutkan + penjelasan tentang algoritma pengurutan terdistribusi juga membantu.

2. Bergabunglah dengan dua tabel. Orang yang bekerja dengan DB akrab dengan konsep dan masalah skalabilitasnya. Tunjukkan bagaimana hal itu dapat dilakukan di MR.