Life Of Navin

2016 has been an amazing year at the movies, with some amazing work making it to the big screen through the year. The expected hits were mostly misses (oh Batman vs Superman!), save a few exceptions (I honestly liked movies ranging from the silly Suicide Squad,  right up to the masala-fied Dangal). But looking back at the year, I can safely say that this year had many gems. Here are my top recommendations (in descending order).

Note: These may not be movies released in 2016, but contemporary movies I watched through the year. I think it's safe to say all these movies released post 2014.

Wild Tales (Trailer)
Let's be honest. As humans, anger is almost certainly the one emotional response which we all share. And we all react differently to it. Anyone who says they don't get angry is straight out lying (Munnabhai, you lying schmuck)! Wild Tales is an Argentinean movie which features 6 short stories, all centered around the central concept of anger, and different responses to it. A peach of a movie, with beautiful stories which are all relatable. Dark humour all through the movie, and an especially amazing performance in the final story (which also happens to be the longest). Argentinean cinema rarely gets it's dues but hopefully this movie puts some more light on an amazing filmmaking community.

Kimi no Na wa. (Trailer)
Anime movies are usually very hit or miss. They're extremely intricate, very beautiful visually (Go watch Paprika if you don't believe me), and deeply intertwined with Japanese culture. Kimi no Na wa is a all of those, and more! A perfect love story, a perfect fantasy story, well, just perfect. If you don't believe me, then just know that this movie is being nominated (and winning) Best Movie in innumerable film festivals. Yes, Best Movie, not Best Animated Movie. That in itself says a lot. The director Makoto Shinkai is being hailed as the next Hayao Miyazaki, and I think that's a title he truly deserves. Kimi no Na wa makes you realize how beautiful life is and touches you in ways very few movies can.

Kimi no Na wa.

Victoria (Trailer)
Remember when Birdman came out last year and everyone went ga-ga over the single shot nature of the movie? And then were disappointed when they found out it was all thanks to innumerable camera tricks and extremely clever editing? Well, what if you could really make a movie in a single take? That's what Victoria is. An entire movie in one take. Brilliant direction, brilliant story, a cinematographer who deserves every accolade that has been thrown at him/her, and a set of performances by the entire cast (Especially notice the cast members in the background). Apparently the director said he'd do 3 takes of the movie before going to plan B, which was a normal edited movie. What we see is take 3. I've watched the movie multiple times, just trying to count the number of things that could go wrong in this, and it's mind boggling how this movie even exists in the form that it does.

A Hard Day (Trailer)
I have a friend who loves to remind everyone that the Koreans really know how to make good thrillers, while Indian directors know how to make bad ripoffs of the same. A Hard Day follows in that tradition. An intense, elaborate, smart thriller which never lets off from start to the end, and leaves you gasping for breath. Yes, the title is a reference to the fact that the movie is based on 24 hours in the life of the protagonist. And boy is it a ride! Every character has shades of grey, and every plot device, from the very believable to the downright nonsensical, all drive this movie towards a strong climax. This one for fans of Tarantino.

A Hard Day

10000 KM (Trailer)
Ah, long distance relationships. This movie is very personal to me for multiple reasons. Anyone who says long distance is easy is kidding themselves. I think we've all come across the way in which distance messes up things, be it in friendships, or love, or anything else. And this film does a great job of showcasing the same. It's never the big things that change. It's the big changes that happen one tiny change at a time. Beautiful performances by the lead cast, and a simple story told beautifully, is what makes this movie what it is. This movie is similar to Kimi no Na wa in a thousand ways, and different in a million ways. Truly a movie with heart.

Thithi (Trailer)
Indian cinema, with it's Sultans and RaOnes and Happy New Years, makes you want to lose faith in the moviemaking in the country. But then a movie like Thithi comes around, and you're instantly out of things to complain about. A non-professional cast, a young director, a quirky story, and fearlessly honest filmmaking is what this movie is all about. Telling the story of men from 3 generations of a family in a rural village in Karnataka, each having their own expectations from life, Thithi manages to do the near impossible: Create a relatable story from a situation that almost none of us have or will ever be in. You'll laugh, and you'll cry, and you'll spend a much longer time thinking about how life differs for those of us outside of our cozy little cities. This movie brought back fond memories of the iconic The Gods Must Be Crazy.

Thithi

Saat Uchakkey (Trailer)
Every once in a while there comes about a movie that is so un-abashedly desi, so unabashedly crude, so slapstick, yet so beautifully brought together that you can't help but applaud the execution. When Delhi Belly came out I was the most disappointed because most of the humor was shitty (pun intended), and most of the swearing (which was the USP of the movie) was very forced. Saat Uchakkey fixes all of that. If you have close friends from the North, then watch this movie with them. Yes, it's vulgar. Yes, it's silly. And yes, it's proud of it's shortcomings. But then again, doesn't vulgar, silly and proud of it's shortcomings describe a large majority amongst us? You have the expected brilliant performances by Kay Kay Menon, Manoj Baypayee. And Aditi Sharma shines as well. The ending was a little disappointing, and Anupam Kher was extremely underused, but overall it's the kind of movie that Bollywood really should make more often.

Honourable Mentions (in no particular order):
Dangal, Mountains May Depart, Phobia, Visaraanai, Aquarius, Timbuktu and Theeb

Go on, get yourself a tub of popcorn and set yourself down for a movie marathon. :)

Get a modern browser.

You are now part of a collaborative neural network painting project. What you see is a neural network's approximation of Leonardo da Vinci's masterpiece. If you're on this page, the network begins to use your browser resources to further train itself. The network itself is saved as a checkpoint after a predetermined number of training steps. Anyone visiting the page starts off from the network of the last saved checkpoint.

The network has been setup to train itself very slowly, so it should not eat up too many resources, but in case it does, I apologize in advance. :)

In Part 1, we set up our Android Studio workspace and project to use the OpenCV4Android SDK. But what if some of my OpenCV code is not in Java but in C/C++? What we need to do is ensure that the C/C++ code is also loaded as part of your APK, and is linked correctly. We already set up the NDK in Part 1, so now we can use it to accomplish the task at hand. This is how you can do that:

1. Open up app -> build.gradle and add the following just before buildtypes
   
   
• Basically this overwrites the default ndkBuild task and instead asks it to build from src/main/jni . Also, it defines a build script (Android.mk) and a NDK app Makefile (Application.mk) and outputs stuff into src/main/jniLibs. Remember jniLibs? That's where we had previously added the architecture specific opencv_java3.so files. Turns out that .so files written to that directory are included in the final build for a given architecture. So what we'll do is build our code into .so files and add them into the jniLibs directory for the given architecture
2. Create a directory jni inside app -> src - > main. This location should contain our native C++ source code. Go ahead and create 3 files. A C++ file here named native-lib.cpp, and 2 files named Application.mk and Android.mk respectively.
   
   
   
3. Add the following content into Android.mk, Application.mk and native-lib.cpp respectively.
• You'll have to provide the path to the OpenCV4Android SDK on line 7 of Android.mk
• Also, in Application.mk , we mention which architecture we are building for (in my case, armeabi-v7a). You can change it as per your architecture. 
• The code in native-lib.cpp  simply takes an OpenCV Mat object (referenced by it's address) and runs Canny Edge detection on it, and saves the result back in the same address.
• If you want to know why the esoteric naming of methods in native-lib.cpp, it's because JNI needs to be given methods in that format. Read this to know more about this.
4. Okay, so we have native C++ code, and a way to build it. Finally, we just need to load this native code through Android and call it's methods. We first load the native library by loading the library statically. This can be done by using System.loadLibrary. Our static block will now look like this
   
   
5. We do this by first defining the native method in MainActivity.java just before the closing parenthesis.
   
• Note that the name of the method in Java and C++ are strongly correlated. C++ names are basically named as Java_packagename_classname_methodname. Make sure you are following this convention, otherwise things WILL break.
6. Finally, all we have to do is make the call to the native method we've defined. Replace the onCameraFrame method we have with the following:
   
   
• As can be seen, this code reads an image from the camera, converts it to greyscale, passes it to the native C++ code (explained above) and then returns the result back to the display. 
7. Now simply run MainActivity. If the build goes correctly, you should see libnative-lib.so is added to the jniLibs directory under the architecture you're building for, and when the app is pushed to your device, it shows you realtime edge detection.

   libnative-lib.so added to jniLibs

   Running the app. The thumbs up says it all!

That's it! So now we have Android + OpenCV4Android SDK + native C/C++ code working together to perform realtime computer vision tasks. In fact, there are ways in which you can further improve performance of JNI, but let's talk about that some other time.

codex pulchra est

Anyone who has even the slightest understanding of computer vision has at some point worked with OpenCV. It's a super cool (and fast) general purpose CV library. At a recent hackathon we were at, our hack required getting OpenCV running on an Android device, but because the documentation for doing this is very vague, we spent a lot of time just on the setup itself. What further complicated everything was that we had some code in C++ and some in Java and needed to bring all of this together, with rewriting the code of one language into the other not an option. We succeeded in the end, but we knew that our build flow was super hacky. But we're engineers and we don't like hacky code (not even at hackathons) so I thought it would be good to document how to do it the right way. So this is how you go about running OpenCV on Android:

Step 1: The Setup

1. Download the following
• The latest Android Studio (I use v. 2.2)
• The latest OpenCV for Android SDK (I use v.3.1.0)
2. On first launch of Android Studio, it'll download all the latest SDK Components (Assuming you downloaded it without the SDK), platform-tools, build-tools etc. These are the components it offered to download for me. Note the build-tools version (Mine is 24.0.2, yours may differ), but you'll need it later on.
   
3. Start a new project. Uncheck the checkbox that says "include C++ support". Next.
4. On Target Android Devices, choose Phone and Tablet with Minimum SDK Version as 15 (That's Ice Cream Sandwich!!). Next.
   
5. Add an Empty Activity. Next. On the Customize the Activity screen, just click Next.
6. Your workspace is now ready! Go to Android -> SDK Manager.  Under SDK Platforms, check Android 6.0 Marshmallow, which is API Level 23 [1]. Under SDK Tools, check NDK (My version shows 12.1.2977051). Click on apply and it'll download the components.

   Open up the SDK Manager

   Download NDK

7. Once this is done, go to File -> Project Settings and click on Select default NDK for Android NDK location. This will populate the text field with the path to the NDK you just downloaded.
   
8. Unzip the OpenCV for Android zip file into some location.

Step 2: Adding OpenCV for Android SDK

1. Go to File -> New -> Import Module and then add <OpenCV for Android Unzipped Path>/sdk/java as a module. 
   
• You will probably get an error. Let's fix that. In the left menu listing the files of the project, you can switch from Android view to Project view (using the dropdown right at the top).  Open the build.gradle file for the module you just imported (openCVLibrary310 -> build.gradle) and edit values to what's shown below. Make sure the buildToolsVersion is the same as what you noted down in step 2 of setting up. Then select Sync Now and all errors should disappear.
  
2. Right click on app in the left menu, and select Open Module Settings. Select the module app, click on Dependencies, and then add the openCVLibrary310 as a module dependency onto app.

   Open module settings for app

   After adding the dependency.

3. Create a directory names jniLibs inside app -> src -> main. In this directory we add the architecture dependent .so file for OpenCV. You'll find all the architectures supported in <OpenCV for Android Unzipped Path>/sdk/native/libs/ . Choose your architecture (usually armeabi-v7a) and copy the directory into jniLibs.  We only need the libopencv_java3.so file so go ahead and delete all the other files.

   How it should look

Step 3: Test it out!

We're all set to write our OpenCV code in our Android Application. Let's write a simple application which takes camera input, converts it to greyscale, performs a Gaussian on it and returns it to the screen.

1. Create a file named camera.xml in src -> main -> res -> layout. Add the following in it.
   
   
2. Open up src -> main -> AndroidManifest.xml and add the following lines just before the </manifest>
   
   
   • Also change the android:theme to @style/Theme.AppCompat.DayNight.NoActionBar to ensure no bar is seen at the top of the application
3. Go to src -> main -> java and open MainActivity.java. Replace it's contents by:
   
   
• The OpenCV code is actually all on the onCameraFrame method. As you can see, it takes a total of 2 lines of code to do what we want!
4. Click the run icon to rebuild and push the application to your device. It should ask for Camera Permissions, which we just added. Give it access, and you should see a realtime Grayscale Gaussian-ed view of whatever the Camera sees!

   Success!

----

TL;DR: Use this gist and you're all set! The remainder of this post is a step-by-step for a newbie to Deep Learning/AWS

The Deep Learning ecosystem has matured tremendously over the last few months or so. I've been playing around with some of these applications over the same time period as well, and it's amazing how much the field has moved ahead in such a short time. Today, terms like Word2Vec, CNN and LSTMs have became part of the lingo of nearly every researcher, hobbyist or otherwise.



And of course, AWS makes running deep-learning applications possible at almost no cost. Especially if you lack a good GPU on your personal system, AWS is a godsend.  I've been working with some of these amazing frameworks so thought it might be good to automate the process of setting up a brand new EC2 instance with everything required to get up and running with deep learning. This includes:

• TensorFlow 
• Theano
• Keras
• CUDA
• CuDNN
• Misc. tools like tmux which are a godsend for remote development.

So, let's get started:

1) Get yourself an AWS EC2 instance.
Go ahead and get yourself a new instance with an Ubuntu AMI (14.04/16.04 should be fine). Since we obviously we want to use the GPU instances, pick either g2.2xlarge or g2.8xlarge instance type. (Lost?)

2) SSH into the machine and either:
a) Download this zip file and extract it into the machine using:

$ curl "http://link_to_zip" -o dl_setup.zip 

and unzip the file using

$ unzip dl_setup.zip

b) Simply create the 3 files and copy the contents from the gist using your favorite editor. The 3 files are:

i) deep_learning_bootstrap.sh

This is a shell script which installs all the required dependencies and libraries required.


ii) test_install.sh

This is a shell script which tests to ensure that the install is successful.


iii) theano_test.py

This is a small python script which tests to ensure Theano is using the GPU for it's computations.


3) Next up run the following to ensure the shell scripts are executable:

chmod +x *.sh

4) Run the bootstrap script using:

./deep_learning_bootstrap.sh

 This will take some time (~5-10 minutes) to download and install all the dependencies.

If a pink screen pops up mentioning "A new version of /boot/grub/menu.lst is available", choose "Keep local version" and select OK.

Once everything is done, you should see the following message:

Reboot System (sudo shutdown -r 0) and run ./test_install.sh

5) Follow the instruction and run:

sudo shutdown -r 0

Your SSH connection will disconnect while your machine reboots. Wait for ~30 seconds and SSH back into the machine. You should see the prompt changed to:

ubuntu@D33P_L34RN $

6) Now run the test script to ensure everything has correctly installed:

./test_install.sh

Just look for the messages in green and ensure the output matches it.

And... that's it! You're all set to start developing your own deep learning applications on AWS EC2. Here's a set of examples you can get started with.

Happy coding! :)


Notes: Why both Theano and Tensorflow? Because choice. Honestly, thanks to Keras, using either as a backend is as simple as a string change. Also, most early to mid level posts in the field use one of the two with no strong monopoly, so it simply made sense to have both of them.  

Another weekend, another hackathon attended. But again, as has become common with the last few ones I've been to, something felt wrong. It's difficult to say what exactly, but something definitely felt off. End of the day, I returned home halfway through the hackathon, following my gut (or rather my team's gut), as always.

For those who don't know, a hackathon is an event where teams of coders developers hackers* sit for periods ranging from 12-48 hours and work on coding something cool from scratch. Hackathons are awesome, because they present a good way to test how well you can apply what you know in a small timeframe. The word hack itself, which today unfortunately generates a negative connotation, actually implies "an appropriate application of ingenuity".

your typical hackathon... hoodies + laptop stickers included

I've been participating in different hackathons for about 4 years now, and have been lucky enough to have been part of some of the best hackathons in the country. Especially over the last 8-10 months, we (Myself, Baka, Bhatta and CEO ... You either know them or you don't :P) have been super active on the Bangalore hackathon scene, having won quite a few big shot hackathons as well. In fact, IIIT-Bangalore (my M.Tech college) students are extremely active on the scene, and you'd be hard pressed to find a hackathon with zero representation from there.

In theory, hackathons have an unlimited upside:

• You get to meet tonnes of like-minded people (Even in Bangalore, this is hard!)
• You have a hard timeline (As a fresh graduate, I still suck at  doing things without timelines)
• You get to work with cool stuff that interests you (Enuf said)
• You get ideas/yourself validated (Judges are usually the who's who of the tech world)
• Free food!! (Having to pay for stuff still feels weird :P)
• And if you're looking for it, hackathons are a great place to find a job as well! 

...or is it?

Then what's wrong? Why that bad taste in the mouth in recent times. Well, I think it comes down to the following:

I am NOT here to do YOUR job
Picture this scene. Rising startup which aims to disrupt industry X raises capital. Couple weeks later, they have a hackathon, where the problem statements are very specific niches of industry X. While the team spends time mentoring participants, the actual participants do everything from design to coding. At the end, startup announces winners, but stakes claim to all the IP created during the hackathon. Winners walk away with T-shirts and the equivalent of a week of pay. Others walk away having coded for free. This sounds funny, but I could think of at least 2 hackathons that had the exact same terms (down to the T-shirts). In fact at one hackathon, I was requested by a senior developer to not use a NoSQL database for my hack because that's not what they use!

Mentoring session in progress!

Hackathons, Hackathons, Everywhere! 
One of the early hackathons I attended was Yahoo! OpenHack. And I must say, I have fond memories of the event. The grand scale, the quality of the hacks, the exclusivity, the bean bags (every participant walked away with a bean bag), everything. Once the event got over, you waited an entire year for an event like that. Nowadays though, hackathons have gotten extremely commercialized. You have entire companies centered around running hackathons on behalf of other companies (and a league as well for some reason). It's not odd to have multiple hackathons every weekend, differentiated only by the toppings on the pizza they serve for dinner. This has taken away from the actual spirit of hackathons because it's no longer about getting something done. In fact I overheard someone say recently "We can code at the hackathon next weekend, we should network this weekend"... Sigh. Not only do we have more hackathons than can be handled, but the prize money at stake has also grown exponentially. And we know what happens when that happens...

You tell em, Greek dude!

Cheater, Cheater, Pumpkin Eater 
Maybe it's just me, but the beauty of a hackathon hack is that you start with a completely clean slate and code something fun over the course of the hackathon. That something may involve simply bringing together different APIs, or figuring out a nice way to visualise stuff, or something more in depth. Sadly, as time goes on, I seem to be going into a stark minority. It's not an odd sight for people to show up to hackathons with complete running applications, which are then simply demoed at the end of the hackathon. Heck, I've even seen the exact same application being demoed (and winning!) at multiple hackathons by the same team. I'll give you an example of a recent hackathon I went to **. The Runner up team had a nice web app, where they took in some inputs, performed some magic(tm), and came out with some output. The output seemed too good to be true, which usually implies it is. Turns out, their output page was completely hardcoded. It didn't depend at all on the input. They got past this limitation during the demo by providing the only valid input which would generate the output page they had written. Given the format of the demo (3 minutes for demo + 1 minute for questions), no one realised this. And these guys are still not the worst offenders. The team that won had actually submitted the exact same app, with the exact same name, to another offline hackathon a week before this hackathon, and won there as well. And these guys are still not in the all-time hackathon offenders hall of fame. I know a team who has demoed the same application with the same name and the same story (the pitch, if you will) at at least 5 hackathons, and won prizes in at least 4 of them. This is definitely not what I signed up for and goes completely against the hacker spirit.

Pizza + Redbull + Coffee + Pizza =/= 10x Developer 
The first time I went to a hackathon, I was amazed at the fact there was free pizza and redbull... and unlimited coffee! What more could a code monkey ask for? And then it happened again, and again, and again. Until at one point, you simply realise that this may not be a way to live, let alone a way to live healthy. As time goes on, I seem to understand more and more what people mean by the term: healthy lifestyle. Sure, it sounds like an old fart trying to tell young people that it's wrong to "live fast and die young" or to "get rich or die trying" or the quintessential "YOLO", but after a point you really need a break. Maybe this ties back into the point of commercialization of hackathons, but attending too many of these things at a stretch can take a serious toll on your body. For sure, I enjoy nightouts spent coding, leaving aside all your worries for for a while, just as much as the next guy (what do you mean by go to bed?), but I'd much rather learn to respect by body before it decides to show me why I should!

Typical scenes 18-20 hours into a hackathon

Hackathons in Bangalore have a stirring resemblance to the EDM festivals in Goa in the sense that what started out as a bunch of people simply geeking out has today become a massive industry, and brought along with it lots of unwanted elements. How do we keep these elements out? I'm honestly not sure. I'm not even sure if we should keep these elements out, as this is what defines hackathons now. Perhaps there will soon be a indie scene for hackers to meet up and hack at. Or perhaps the only option left now is to hack the hackathon itself. But until something overtly dramatic happens, I can confidently say, we live to hack another day... maybe just not at this hackathon! :)



* hackers = Again, simply someone who associates himself/herself with the hacker culture, which does not mean they can gain access to your Facebook account
** No names because many of the people involved happen to be friends on the hackathon circuit. Kept details scant to avoid identifying traits.

1. Cxn tzvw nf nox ixzapec oztpn. Ixza zn yxzqn 20 tffwq.
2. Kpe zn yxzqn 2 ozvwznofeq.
3. Zvnuzyys cifw visgnfcizgos vfevxgnq
4. Ueaxiqnzea zea prgyxrxen RY/ZEE vfevxgnq zea gyzs kpno bizrxkfiwq
5. Yxzie z exk gifcizrrpec yzecuzcx bifr qviznvo
6. Qnzin kfiwpec fun ztq
7. Iue 15 Wrq kpnofun qnfggpec
8. Kipnx zn yxzqn 15 tyfc gfqnq nopq sxzi
9. Gixqxen zn z vfebxixevx
10. Cf fe zn yxzqn 3 kpyaypbx nixwq
11. Jpqpn zn yxzqn 3 bfixpce vfuenipxq
12. Yxzie nf gyzs nox cupnzi
13. Fgxe qfuivx zn yxzqn 2 gxiqfezy gifdxvnq.
14. Vfeniptunx nf zn yxzqn 2 fgxe qfuivx gifdxvnq
15. Yzuevo z gifauvn nf nox gutypv.
16. Yxzie tzqpv vfejxiqznpfeq pe z bfixpce yzecuzcx
17. Kmes kskea nf Zivozez kyipe Sidt
18. Penifauvx Zivozez nf nox bzrpys
19. Znnxea z vfqgyzs xjxen pe vfqnurx
20. Cxn tzew tzyzevx nf 10Y

... and that's that. Wish me luck. I know I'll be needing lots of it for quite a few of these! :)


* items on the bucket list are all encrypted**. Decryption happens when the task has been completed successfully.

** encrypted with a slightly less laughable (albeit still ridiculously simple) encryption scheme than last time around! :P