ทำไมข้อมูลขนาดใหญ่จำเป็นต้องใช้งานได้?

ฉันเริ่มทำงานในโครงการใหม่ที่เกี่ยวข้องกับ Big Data สำหรับการฝึกงานของฉัน ผู้จัดการของฉันแนะนำให้เริ่มการเรียนรู้การเขียนโปรแกรมฟังก์ชั่น (พวกเขาขอแนะนำสกาล่า) ฉันมีประสบการณ์ที่ต่ำต้อยโดยใช้ F # แต่ฉันไม่เห็นความสำคัญของการใช้กระบวนทัศน์การเขียนโปรแกรมนี้เนื่องจากมีราคาแพงในบางกรณี

คณบดีพูดคุยเกี่ยวกับหัวข้อนี้ที่น่าสนใจและแบ่งปันความคิดของเขาว่าทำไม "Big Data" ที่นี่: http://www.youtube.com/watch?v=DFAdLCqDbLQ แต่มันไม่สะดวกเพราะ Big Data ไม่ได้แปล Hadoop เท่านั้น

ในฐานะที่เป็น BigData แนวคิดที่คลุมเครือมาก ฉันลืมไปซักพักแล้ว ฉันพยายามหาตัวอย่างง่ายๆหนึ่งตัวอย่างเพื่อเปรียบเทียบระหว่างแง่มุมต่าง ๆ เมื่อเราจัดการกับข้อมูลเพื่อดูว่าวิธีการใช้งานมีราคาแพงหรือไม่ หากการเขียนโปรแกรมเชิงฟังก์ชั่นมีราคาแพงและใช้หน่วยความจำสำหรับข้อมูลขนาดเล็กทำไมเราต้องใช้กับ Big Data?

นอกเหนือจากเครื่องมือแฟนซีฉันพยายามสร้างวิธีแก้ปัญหาสำหรับปัญหาเฉพาะและเป็นที่นิยมโดยใช้สามวิธีคือวิธีที่จำเป็นและวิธีการใช้งาน (การเรียกซ้ำโดยใช้คอลเลกชัน) ฉันเปรียบเทียบเวลาและความซับซ้อนเพื่อเปรียบเทียบระหว่างสามแนวทาง

ฉันใช้ Scala เพื่อเขียนฟังก์ชันเหล่านี้เนื่องจากเป็นเครื่องมือที่ดีที่สุดในการเขียนอัลกอริทึมโดยใช้กระบวนทัศน์สามแบบ

def main(args: Array[String]) {
    val start = System.currentTimeMillis()
    // Fibonacci_P
    val s = Fibonacci_P(400000000)
    val end = System.currentTimeMillis()
    println("Functional way: \n the Fibonacci sequence whose values do not exceed four million : %d \n Time : %d ".format(s, end - start))
    val start2 = System.currentTimeMillis()

    // Fibonacci_I
    val s2 = Fibonacci_I(40000000 0)
    val end2 = System.currentTimeMillis();
    println("Imperative way: \n the Fibonacci sequence whose values do not exceed four million : %d \n Time : %d ".format(s2, end2 - start2))
}

วิธีการทำงาน:

def Fibonacci_P(max: BigInt): BigInt = {
    //http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Stream
    //lazy val Fibonaccis: Stream[Long] = 0 #:: 1 #:: Fibonaccis.zip(Fibonaccis.tail).map { case (a, b) => a + b }
    lazy val fibs: Stream[BigInt] = BigInt(0)#::BigInt(1)#::fibs.zip(fibs.tail).map {
        n = > n._1 + n._2
    }
    // println(fibs.takeWhile(p => p < max).toList)
    fibs.takeWhile(p = > p < max).foldLeft(BigInt(0))(_ + _)
}

วิธีแบบเรียกซ้ำ:

def Fibonacci_R(n: Int): BigInt = n match {
    case 1 | 2 = > 1
    case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}

วิธีที่จำเป็น:

def Fibonacci_I(max: BigInt): BigInt = {
    var first_element: BigInt = 0
    var second_element: BigInt = 1
    var sum: BigInt = 0

    while (second_element < max) {
        sum += second_element

        second_element = first_element + second_element
        first_element = second_element - first_element
    }

    //Return 
    sum
}

ฉันสังเกตเห็นว่าการเขียนโปรแกรมฟังก์ชั่นหนัก! ใช้เวลานานและใช้พื้นที่ในหน่วยความจำมากขึ้น ฉันสับสนเมื่อใดก็ตามที่ฉันอ่านบทความหรือดูการพูดคุยพวกเขาบอกว่าเราควรใช้การเขียนโปรแกรมการทำงานในด้านวิทยาศาสตร์ข้อมูล จริงมันง่ายขึ้นและมีประสิทธิภาพมากขึ้นโดยเฉพาะในโลกของข้อมูล แต่มันต้องใช้เวลามากขึ้นและใช้พื้นที่หน่วยความจำมากขึ้น

ดังนั้นทำไมเราต้องใช้ฟังก์ชั่นการเขียนโปรแกรมใน Big Data? แนวทางปฏิบัติที่ดีที่สุดในการใช้ฟังก์ชั่นการเขียนโปรแกรม (Scala) สำหรับ Big Data คืออะไร?

นี่คือวิธีที่ฉันเห็น:

• ลองเพิกเฉยคำว่า "ข้อมูลขนาดใหญ่" ซักพักเพราะมันเป็นแนวคิดที่คลุมเครือ

• คุณพูดถึง Hadoop Hadoop ทำ 2 สิ่ง: ช่วยให้คุณมีไดรฟ์ "เสมือน" ซึ่งกระจายอยู่ในหลาย ๆ เครื่องพร้อมความซ้ำซ้อนซึ่งสามารถเข้าถึงได้ผ่าน API ของ Hadoop ราวกับว่าเป็นไดรฟ์เดียวที่รวมกัน มันเรียกว่า HDFS เช่นเดียวกับในHadoop Distributed File System อีกอย่างที่ Hadoop ทำคืออนุญาตให้คุณเรียกใช้งาน Map-Reduce (เป็นกรอบสำหรับ Map-Reduce) หากเราตรวจสอบหน้า Wikipedia ของ MapReduceเราจะเห็นว่า:

MapReduce เป็นรูปแบบการเขียนโปรแกรมสำหรับการประมวลผลชุดข้อมูลขนาดใหญ่ที่มีอัลกอริทึมแบบขนานกระจายในคลัสเตอร์

...

โปรแกรม MapReduce ประกอบด้วยขั้นตอน Map () ที่ดำเนินการกรองและเรียงลำดับ (เช่นการเรียงลำดับนักเรียนตามชื่อในคิวหนึ่งคิวสำหรับแต่ละชื่อ) และกระบวนการลด () ที่ดำเนินการสรุป (เช่นการนับจำนวน ของนักเรียนในแต่ละคิวให้ความถี่ชื่อ)

...

'MapReduce' เป็นกรอบสำหรับการประมวลผลปัญหาแบบขนานได้ในชุดข้อมูลขนาดใหญ่โดยใช้คอมพิวเตอร์จำนวนมาก

นอกจากนี้ในหน้านี้ Hadoop ก็อธิบายว่า

Hadoop การใช้งาน MapReduce ของ Apache และโอเพนซอร์สฟรี

ตอนนี้ Hadoop เขียนด้วยภาษาจาวาซึ่งไม่ใช่ภาษาที่ใช้งานได้ นอกจากนี้ถ้าเรามองในหน้า Hadoop ของเรายังได้พบกับตัวอย่างของวิธีการสร้างงาน MapReduce ในชวาและปรับใช้ในคลัสเตอร์

นี่คือตัวอย่าง Java ของงาน Fibonnaci MapReduce สำหรับ Hadoop

ฉันหวังว่านี่จะตอบคำถามของคุณคือ BigData และโดยเฉพาะอย่างยิ่งงาน MapReduce ที่สร้างจาก Fibonacci ไม่ "ต้องการ" เพื่อใช้งานได้หรือคุณสามารถนำไปใช้ในภาษา OO ได้หากคุณต้องการ (เช่น)

แน่นอนว่านั่นไม่ได้หมายความว่า BigData "ต้องการ" เป็น OO เท่านั้น คุณสามารถใช้ภาษาที่ใช้งานได้ดีในการใช้งาน MapReduce เช่นงาน คุณสามารถยกตัวอย่างเช่นใช้ Scala กับ Hadoop ถ้าคุณต้องการที่จะผ่านการลวก

ประเด็นอื่นที่ฉันคิดว่าน่าพูดถึง

เมื่อทำ recursion ใน Scala ถ้ารหัสของคุณช่วยให้มัน Scala จะทำหางเรียกร้องการเพิ่มประสิทธิภาพ อย่างไรก็ตามตั้งแต่JVM ที่ไม่ได้ (ยัง) สนับสนุนหางโทรเพิ่มประสิทธิภาพ , Scala นี้ประสบความสำเร็จโดยการเปลี่ยนที่รวบรวมเวลาโทร recursive ของคุณด้วยรหัสเทียบเท่ากับลูปตามที่อธิบายไว้ที่นี่ สิ่งนี้โดยทั่วไปหมายถึงว่าการทำเกณฑ์มาตรฐานเทียบกับแบบไม่เรียกซ้ำแบบเรียกซ้ำโดยใช้ Scala นั้นไม่มีจุดหมายเพราะทั้งคู่ต่างก็ทำสิ่งเดียวกันในเวลาทำงาน

ตราบใดที่คุณสามารถเรียกใช้บนเครื่องเดียวไม่ใช่ "ข้อมูลขนาดใหญ่" ปัญหาตัวอย่างของคุณไม่เหมาะสมอย่างยิ่งที่จะแสดงอะไรเกี่ยวกับเรื่องนี้

ข้อมูลขนาดใหญ่หมายความว่าขนาดของปัญหาใหญ่เกินไปที่การกระจายการประมวลผลไม่ใช่การเพิ่มประสิทธิภาพ แต่เป็นข้อกำหนดขั้นพื้นฐาน และฟังก์ชั่นการเขียนโปรแกรมช่วยให้การเขียนรหัสการกระจายที่ถูกต้องและมีประสิทธิภาพง่ายขึ้นเนื่องจากโครงสร้างข้อมูลและไร้สัญชาติที่ไม่เปลี่ยนแปลง

ฉันไม่ทราบว่าสกาล่าดังนั้นฉันไม่สามารถแสดงความคิดเห็นเกี่ยวกับวิธีการทำงานของคุณได้ แต่รหัสของคุณดูเหมือน overkill

ฟังก์ชั่นวนซ้ำของคุณในอีกทางหนึ่งนั้นไม่มีประสิทธิภาพ เนื่องจากฟังก์ชั่นเรียกตัวเองสองครั้งมันเป็นลำดับ 2 ^ n ซึ่งไม่มีประสิทธิภาพสูง หากคุณต้องการเปรียบเทียบทั้งสามวิธีคุณต้องเปรียบเทียบการปรับใช้ที่เหมาะสมสามแบบ

ฟังก์ชัน Fibonacci สามารถใช้งานซ้ำโดยเรียกฟังก์ชันเพียงครั้งเดียว เรามานิยามนิยามที่กว้างกว่า

F(0) = f0
F(1) = f1
F(n) = F(n-1) + F(n-2)

กรณีพิเศษมาตรฐานคือ:

f0 = 0
f1 = 1

ฟังก์ชันเรียกซ้ำทั่วไปคือ:

function fibonacci($f0, $f1, $n){
    if($n < 0 || !isInt($n)) return false;
    if($n = 0) return $f0;
    if($n = 1) return $f1;
    return fibonacci($f1, $f0 + $f1, $n - 1);
}

หากการเขียนโปรแกรมเชิงฟังก์ชั่นมีราคาแพงและใช้หน่วยความจำสำหรับข้อมูลขนาดเล็กทำไมเราต้องใช้กับ Big Data?

โดยเฉพาะฉันสามารถเห็นแอปพลิเคชั่นบางตัวที่มีประโยชน์มาก อดีต สถิติคือการคำนวณฟังก์ชั่นเกาส์เซียนในทันทีด้วยพารามิเตอร์ที่แตกต่างกันหรือชุดของพารามิเตอร์สำหรับการวิเคราะห์ข้อมูล นอกจากนี้ยังมีการแก้ไขสำหรับการวิเคราะห์เชิงตัวเลข ฯลฯ

แนวทางปฏิบัติที่ดีที่สุดในการใช้ฟังก์ชั่นการเขียนโปรแกรม (Scala) สำหรับ Big Data คืออะไร?

เพื่อตอบคำถามเกี่ยวกับประสิทธิภาพนอกจากนี้ยังมีเทคนิคที่ช่วยเพิ่มประสิทธิภาพของคุณในพื้นที่หรือเวลาโดยเฉพาะการเรียกซ้ำ, การเรียกซ้ำแบบหาง , การส่งต่อแบบต่อเนื่อง , ฟังก์ชันการเรียงลำดับที่สูงขึ้นฯลฯ บางภาษามีข้อดีและข้อเสีย สิ่งที่ง่ายเหมือนลำดับ Fibonnacci ฉันอาจใช้วิธีที่จำเป็นตามที่ฉันพบในบางครั้งเพื่อนร่วมงานของฉันลังเลและอาจไม่สะดวกกับการเขียนโปรแกรมที่ใช้งานได้และใช้เวลาในการพัฒนามากขึ้น ... (ฉันยังต้องการ ใช้การเขียนโปรแกรมใช้งานได้เมื่อฉันสามารถ [แอปพลิเคชันที่ฉันรับผิดชอบ]) เนื่องจากฉันพบว่ามันรวดเร็วสะอาดและ "อ่านง่าย" (แม้ว่าฉันจะพบรหัสส่วนตัว)

Wikipedia มีลำดับฟีโบนักชีแบบ "เร็ว" ที่โพสต์ไว้ https://en.wikipedia.org/wiki/Functional_programming#Scala

def fibTailRec(n: Int): Int = {
  @tailrec def f(a: Int, b: Int, c: Int): Int = if (a == 0) 0 else if(a < 2) c else f(a-1, c, b + c)
  f(n, 0, 1)
}

การใช้สตรีม / hof

val fibStream:Stream[Int] = 0 #:: 1 #:: (fibStream zip fibStream.tail).map{ t => t._1 + t._2 }