Today I'd like to show you the future of the way we make things. I believe that soon our buildings and machines will be self-assembling, replicating and repairing themselves. So I'm going to show you what I believe is the current state of manufacturing, and then compare that to some natural systems.
วันนี้ผมอยากจะนำเสนอ วิธีที่เราจะสร้างสิ่งของต่างๆ ในอนาคต ผมเชื่อว่าอีกไม่นาน ตึก และ เครื่องจักร จะสามารถสร้างตัวมันเอง ถอดแบบและซ่อมแซมตัวเองได้ ก่อนอื่นผมจะแสดงให้คุณดู ว่าวิธีการผลิตที่เราใช้กันอยู่ในปัจจุบันเป็นอย่างไร และเปรียบเทียบกระบวนการดังกล่าวกับระบบของธรรมชาติ
So in the current state of manufacturing, we have skyscrapers -- two and a half years [of assembly time], 500,000 to a million parts, fairly complex, new, exciting technologies in steel, concrete, glass. We have exciting machines that can take us into space -- five years [of assembly time], 2.5 million parts.
วิธีการที่เราใช้สร้างสิ่งต่างๆ ในปัจจุบัน เช่น ตึกระฟ้า ใช้เวลาสร้าง 2 ปีครึ่ง มีชิ้นส่วนห้าแสนจนถึงล้านชิ้น และค่อนข้างซับซ้อน เรามีเทคโนโลยีใหม่ที่น่าตื่นเต้นในงานเหล็ก, คอนกรีต, แก้ว เรามีเครื่องมือที่น่าตื่นตาตื่นใจ ที่สามารถนำเราไปสู่อวกาศ ใช้เวลาประกอบห้าปี กับชิ้นส่วน 2.5 ล้านชิ้น
But on the other side, if you look at the natural systems, we have proteins that have two million types, can fold in 10,000 nanoseconds, or DNA with three billion base pairs we can replicate in roughly an hour. So there's all of this complexity in our natural systems, but they're extremely efficient, far more efficient than anything we can build, far more complex than anything we can build. They're far more efficient in terms of energy. They hardly ever make mistakes. And they can repair themselves for longevity.
ทีนี้ ถ้าคุณลองดูระบบธรรมชาติ เรามีโปรตีน นับสองล้านชนิด ที่สามารถพับตัวใน 10,000 นาโนวินาที, หรือ DNA ซึ่งมีสามพันล้านคู่พื้นฐาน ที่สามารถทำสำเนาตัวเองได้ในประมาณหนึ่งชั่วโมง มันมีความซับซ้อนมากมายเลยนะ ระบบในธรรมชาติเนี่ย แต่มันก็มีประสิทธิภาพมาก ยิ่งกว่าอะไรทั้งหมดที่เราสามารถสร้างได้ ซับซ้อนมากกว่าสิ่งใดๆ ที่เราสามารถสร้างได้ และมีประสิทธิภาพมากกว่าในแง่ของการใช้พลังงาน มันแทบไม่เคยทำผิดพลาด และยังสามารถซ่อมแซมตัวเองเพื่อยืดอายุต่อไปได้
So there's something super interesting about natural systems. And if we can translate that into our built environment, then there's some exciting potential for the way that we build things. And I think the key to that is self-assembly.
ดังนั้น ระบบของธรรมชาติจึงน่าสนใจมากๆ และถ้าเราสามารถถ่ายทอดความสามารถนี้ มาใส่ในสภาพแวดล้อมที่มนุษย์สร้างขึ้น วิธีการที่เราสร้างสิ่งต่างๆ ก็จะมีศักยภาพที่น่าทึ่ง ซึ่งผมคิดว่ากุญแจสำคัญไปสู่จุดนั้นก็คือ ความสามารถในการสร้างตัวมันเอง
So if we want to utilize self-assembly in our physical environment, I think there's four key factors. The first is that we need to decode all of the complexity of what we want to build -- so our buildings and machines. And we need to decode that into simple sequences -- basically the DNA of how our buildings work. Then we need programmable parts that can take that sequence and use that to fold up, or reconfigure. We need some energy that's going to allow that to activate, allow our parts to be able to fold up from the program. And we need some type of error correction redundancy to guarantee that we have successfully built what we want.
ถ้าเราต้องการนำความสามารถในการสร้างมันตัวเองมาใช้ ผมคิดว่า มีปัจจัยหลัก 4 อย่าง ประการแรก เราจำเป็นต้องถอดรหัส ความซับซ้อนทั้งหมดของสิ่งที่เราต้องการจะสร้าง เช่นอาคารและเครื่องจักร เราต้องถอดรหัสพวกนี้ออกมาเป็นลำดับขั้นตอนพื้นฐาน เรียกง่ายๆ ว่าถอดรหัส DNA การสร้างอาคารต่างๆ แล้วเราก็ต้องมีชิ้นส่วนที่ตั้งโปรแกรม ให้สามารถทำงานตามลำดับขั้นดังกล่าวได้ แล้วใช้ชิ้นส่วนที่ว่านั้นในการก่อร่างหรือปรับแต่ง เราต้องการแหล่งพลังงานที่กระตุ้นให้กระบวนการนี้เริ่มทำงาน เพื่อให้ชิ้นส่วนของเราสามารถประกอบกันตามโปรแกรม และเราต้องการโปรแกรมที่มาแก้ไขข้อผิดพลาดบางอย่าง เพื่อให้แน่ใจว่าเราจะสร้างสิ่งที่เราต้องการได้สำเร็จสมบูรณ์
So I'm going to show you a number of projects that my colleagues and I at MIT are working on to achieve this self-assembling future. The first two are the MacroBot and DeciBot. So these projects are large-scale reconfigurable robots -- 8 ft., 12 ft. long proteins. They're embedded with mechanical electrical devices, sensors. You decode what you want to fold up into, into a sequence of angles -- so negative 120, negative 120, 0, 0, 120, negative 120 -- something like that; so a sequence of angles, or turns, and you send that sequence through the string. Each unit takes its message -- so negative 120 -- it rotates to that, checks if it got there and then passes it to its neighbor.
ดังนั้น ผมจะให้คุณดูโครงการต่างๆ ที่ผมกับเพื่อนร่วมงานของผมที่ MIT กำลังศึกษาอยู่ เพื่อสร้างสิ่งที่สามารถสร้างตัวเองได้ในอนาคต สองโครงการแรกคือ MacroBot และ DeciBot มันคือหุ่นยนต์ขนาดใหญ่ที่สามารถปรับโครงสร้างตัวเองได้ เหมือนกับห่วงโซ่โปรตีนยาว 8 ฟุต, 12 ฟุต ภายในเต็มไปด้วยอุปกรณ์กลไกไฟฟ้าและเซ็นเซอร์ คุณถอดรหัสสิ่งที่คุณต้องการสร้างขึ้นมา เป็นลำดับของการพับตัวเป็นมุมขนาดต่างๆ ติดลบ 120, ติดลบ 120, 0, 0, 120, ลบ 120 -- อะไรประมาณนั้น ลำดับของมุม หรือ จุดเปลี่ยนต่างๆ พวกนี้ ถูกส่งเข้ามาผ่านสายส่งสัญญาณ แต่ละหน่วยจะได้ข้อความของมัน-- เช่น ลบ 120 มันก็จะหมุนไป แล้วตรวจสอบว่าได้มุมที่ต้องการหรือยัง แล้วก็ส่งผ่านต่อไปยังใกล้จุดเคียง
So these are the brilliant scientists, engineers, designers that worked on this project. And I think it really brings to light: Is this really scalable? I mean, thousands of dollars, lots of man hours made to make this eight-foot robot. Can we really scale this up? Can we really embed robotics into every part? The next one questions that and looks at passive nature, or passively trying to have reconfiguration programmability. But it goes a step further, and it tries to have actual computation. It basically embeds the most fundamental building block of computing, the digital logic gate, directly into your parts.
นี้คือสุดยอดนักวิทยาศาสตร์ วิศวกร, นักออกแบบที่ทำงานในโครงการนี้ และผมคิดว่ามันทำให้มีคำถามผุดขึ้นมาว่า งานนี้ขยายผลออกไปได้จริงหรือเปล่า? เราใช้เงินหลายพันดอลลาร์ และจำนวนชั่วโมงทำงานมหาศาล เพื่อสร้างเจ้าหุ่นยนต์แปดฟุตตัวนี้ เราสามารถขยายผลออกไปได้จริงๆ หรือ? จะนำหุ่นยนต์นี้ไปใช้ในทุกๆ เรื่องได้จริงหรือ? คำถามถัดไปคือ ตอนนี้ธรรมชาติของเจ้าหุ่นนี้ ยังทำงานตามโปรแกรมการปรับโครงสร้างตัวเองที่ถูกป้อนเข้าไป แต่มันจะก้าวไปสู่ขั้นต่อไป นั่นคือ การพยายามทำให้มันคิดคำนวณได้เองจริงๆ มันคือการฝังวงจรที่เป็นองค์ประกอบขั้นพื้นฐานที่สุดของคอมพิวเตอร์ นั่นคือดิจิตอล ลอจิกเกต (digital logic gate) ลงไปในชิ้นส่วนต่างๆ โดยตรง
So this is a NAND gate. You have one tetrahedron which is the gate that's going to do your computing, and you have two input tetrahedrons. One of them is the input from the user, as you're building your bricks. The other one is from the previous brick that was placed. And then it gives you an output in 3D space. So what this means is that the user can start plugging in what they want the bricks to do. It computes on what it was doing before and what you said you wanted it to do. And now it starts moving in three-dimensional space -- so up or down. So on the left-hand side, [1,1] input equals 0 output, which goes down. On the right-hand side, [0,0] input is a 1 output, which goes up. And so what that really means is that our structures now contain the blueprints of what we want to build.
อันนี้คือเกตแบบ NAND (NAND gate) คุณมีโครงสร้างปิรามิดฐานสามเหลี่ยม ที่จะทำหน้าที่คำนวณให้คุณ และก็มีปิรามิดฐานสามเหลี่ยม 2 ชิ้นที่ป้อนข้อมูลเข้ามา อันหนึ่งเป็นข้อมูลมาจากผู้ใช้ เหมือนเวลาคุณกำลังจะก่ออิฐ ข้อมูลอีกส่วนหนึ่งมาจากอิฐที่เคยก่อไว้ก่อนหน้านี้ แล้วมันสุดท้ายมันจะให้ผลการคำนวณเป็นรูปแบบ 3 สามมิติ นั่นหมายถึง ผู้ใช้สามารถใส่ข้อมูลอะไรก็ตามที่พวกเขาอยากให้มันทำ แล้วมันก็จะคำนวณจากสิ่งที่มันเคยทำมาก่อน และข้อมูลที่คุณบอกว่าคุณอยากให้มันทำอะไร แล้วมันก็จะเริ่มเคลื่อนไหวในพื้นที่ 3 มิติ เลื่อนขึ้นหรือเลื่อนลง ทางซ้ายมือนี่ input [1,1] จะได้ output เท่ากับ 0 ซึ่งจะเป็นการเลื่อนลง ส่วนภาพทางขวานี่ ข้อมูล input [0,0] ออกมาเป็น output เท่ากับ 1 ซึ่งจะเป็นการเลื่อนขึ้น ดังนั้น นี่หมายถึงว่า ไอ้เจ้าโครงสร้างของเรานี้ ตอนนี้มันเก็บพิมพ์เขียว ของสิ่งที่เราต้องการที่จะสร้างไว้
So they have all of the information embedded in them of what was constructed. So that means that we can have some form of self-replication. In this case I call it self-guided replication, because your structure contains the exact blueprints. If you have errors, you can replace a part. All the local information is embedded to tell you how to fix it. So you could have something that climbs along and reads it and can output at one to one. It's directly embedded; there's no external instructions.
ดังนั้น มันมีข้อมูลทั้งหมดฝังอยู่ในตัว เกี่ยวกับสิ่งที่มันเคยสร้าง นั่นหมายความว่า มันสามารถถอดแบบและสร้างตัวมันเองได้ ผมเรียกมันว่าการถอดแบบจำลองโดยมีแนวทางในตัวเอง เพราะโครงสร้างที่ว่านี้มีพิมพ์เขียวที่ชัดเจนอยู่แล้ว หากเกิดข้อผิดพลาดขึ้น คุณก็สามารถเปลี่ยนชิ้นส่วนนั้นได้ ข้อมูลวิธีการแก้ไขทั้งหมดถูกฝังไว้ในระบบแล้ว ดังนั้นคุณจึงมีโครงสร้างที่ค่อยๆ เคลื่อนไหวและอ่านพิมพ์เขียวนั้น แล้วส่งข้อมูลออกไปหากันและกัน ระบบนี้ถูกฝังโดยตรงอยู่ภายในโครงสร้าง; มีไม่มีคำสั่งภายนอก
So the last project I'll show is called Biased Chains, and it's probably the most exciting example that we have right now of passive self-assembly systems. So it takes the reconfigurability and programmability and makes it a completely passive system. So basically you have a chain of elements. Each element is completely identical, and they're biased. So each chain, or each element, wants to turn right or left. So as you assemble the chain, you're basically programming it. You're telling each unit if it should turn right or left. So when you shake the chain, it then folds up into any configuration that you've programmed in -- so in this case, a spiral, or in this case, two cubes next to each other. So you can basically program any three-dimensional shape -- or one-dimensional, two-dimensional -- up into this chain completely passively.
สุดท้าย โครงการล่าสุดที่ผมจะให้คุณดูเรียกว่า Biased Chains น่าจะเป็นตัวอย่างที่น่าตื่นเต้นที่สุดที่เรามีในตอนนี้ ของระบบที่สร้างประกอบตัวเองตามโปรแกรมที่ได้รับ ความสามารถในการปรับเปลี่ยนโครงสร้าง และการที่เราสามารถตั้งโปรแกรมให้มันได้ ทำให้มันเป็นระบบที่ทำตามคำสั่งได้โดยสมบูรณ์ เอาล่ะ อธิบายง่ายๆ คือคุณมีห่วงโซ่ขององค์ประกอบ แต่ละองค์ประกอบจะเหมือนกันเป๊ะ แล้วก็มีความโน้มเอียง คือ ห่วงโซ่แต่ห่วงมีความโน้มเอียงที่จะเลี้ยวขวาหรือซ้าย ดังนั้นเมื่อคุณประกอบห่วงโซ่ ก็เหมือนคุณเขียนโปรแกรมให้มัน คุณบอกแต่ละหน่วยว่ามันควรจะเลี้ยวขวาหรือซ้าย แล้วเมื่อคุณเขย่าห่วงโซ่ มันก็พับขึ้น เป็นรูปแบบตามที่คุณได้ตั้งโปรแกรมไว้ อย่างอันนี้ กลายเป็นเกลียว ส่วนอันนี้ เป็นลูกบาศก์สองอันติดกัน ดังนั้นคุณจึงสามารถเขียนโปรแกรม รูปร่างสามมิติอะไรก็ได้ หรือจะหนึ่งมิติสองมิติก็ได้ เพราะห่วงโซ่นี้มันทำตามคำสั่งที่เราตั้งโปรแกรมให้หมด
So what does this tell us about the future? I think that it's telling us that there's new possibilities for self-assembly, replication, repair in our physical structures, our buildings, machines. There's new programmability in these parts. And from that you have new possibilities for computing. We'll have spatial computing. Imagine if our buildings, our bridges, machines, all of our bricks could actually compute. That's amazing parallel and distributed computing power, new design possibilities. So it's exciting potential for this. So I think these projects I've showed here are just a tiny step towards this future, if we implement these new technologies for a new self-assembling world.
เอาล่ะ แล้วสิ่งเหล่านี้บอกอะไรเราเกี่ยวกับอนาคต? ผมคิดว่ามันบอกเราว่า มีความเป็นไปได้ ที่เราจะมีสิ่งที่สร้าง จำลองแบบ และซ่อมแซมตัวเอง ในโครงสร้างทางกายภาพ อาคาร และเครื่องจักรที่เราใช้ เราสามารถตั้งโปรแกรมในชิ้นส่วนของสิ่งเหล่านี้ได้มากขึ้น ซึ่งนั่นทำให้เรามีความเป็นไปได้ใหม่ๆ ในการคำนวณและประมวลผล เราจะมีการคำนวณเชิงพื้นที่ ลองคิดดูสิ หากอาคาร, สะพาน, เครื่องจักร และก้อนอิฐทั้งหมดสามารถคิดคำนวณเองได้ นั่นเป็นพลังการคำนวณและประมวลผลที่น่าทึ่ง มันคือความเป็นไปได้ใหม่ๆ ในการออกแบบ เป็นศักยภาพที่น่าตื่นเต้นสำหรับงานชิ้นนี้ ผมคิดว่าโครงการเหล่านี้ที่ผมแสดงให้คุณดู เป็นเพียงขั้นตอนเล็ก ๆ ไปสู่อนาคต ถ้าเรานำเทคโนโลยีใหม่เหล่านี้ไปใช้ เพื่อสร้างโลกใหม่ที่สร้างตัวมันเองได้ด้วยตัวมันเอง
Thank you.
ขอบคุณครับ
(Applause)
(เสียงปรบมือ)