DotNet inspiration and deep dive to deep learning
I had a pleasure to attend ScotSoft, an annual software developer conference in Scotland, on 5th October in Edinburgh. There was a range of topics discussed during the conference, in three or four simultaneous sessions. My choices ended up concentrating on AI. Here’s a collection of my thoughts and notes on the talks that I attended on the day.
The Cloud and The Browser
The conference started off with an excellent talk from the open-source Microsoft sell-out, .Net guy loved by the community, Scott Hanselman. I had mostly only seen him in the ASP.Net community stand-up videos, chatting with his workmates from a home office in the middle of LEGOs and gadgets. His keynote talk definitely had more professional and rehearsed feel in it, but it was delivered with same down-to-earth tone with just enough awkwardness to make it relatable.
Another important takeaway from the talk was to appreciate the different layers of understanding when working with technology that hides complexity. The cloud gives us tools to magically create and scale infrastructure or deploy and run applications without knowing how it all is implemented. While it’s definitely not possible to understand every single detail — how an application is being run, how a VM is created within a physical computer, or how the data is being moved around in network, memory and disks — we do need to know and appreciate the fact that all this is happening under the hood when we use the abstractions.
As a good speaker, Hanselman kept the audience intrigued and entertained. The inception moment of the talk was when he demoed Netscape Navigator running on Windows Workspaces inside a VM inside a HTML page inside 3D scene (the page showing up as a screen of a computer) in a browser. Lesson learned: whatever it is, you can do it in the browser.
Artificial Intelligence, Robots and User Interfaces
The bulk part of my conference consisted of AI related talks, with the content ranging from specific data clustering algorithms to ethical dilemmas of AI decision-making. Each one of the four talks is explained below, from a keen observer’s perspective, my practical experience with AI being still rather limited.
Explainable AI and Case-based Systems
All the buzz around deep learning and neural networks leaves some aspects of AI with less attention than they might deserve. RGU professor Susan Craw explained how Case-based reasoning (CBR) differs from Model-based reasoning, and why it might sometimes be a better fit. She points out that while both novices and experts in a field can learn new information just as well, experts know better how to apply their knowledge, and that kind of intelligence is difficult to embed in an AI. CBR concentrates on what has solved the problem in past to help make the decision in a new, previously unknown situation.
According to Craw, one of the major benefit of CBR is that its decisions are explainable. Unlike decisions made by a neural network, CBR can (and does, to improve it’s accuracy) explain why a certain decision was reached from the given input. Explainability did also come up in some of the later talks, so I can see why it makes CBR more attractive.
The robustness of CBR systems was another benefit brought up by Craw. Where Mode-based systems require re-learning to be able to handle completely new situations, CBR can better utilize existing knowledge when facing “unknown unknowns”. My understanding was that this is because MBR generalizes the data it uses for learning when it builds it into the model, but CBR uses the data itself as the model, and only does the generalization locally (when making the decision). While the similarity of the unknown situation still needs to be determined to make a decision, the solutions from the original data can be used to solve the new situation without re-modeling the solution space.
During the Q&A session at the end of the talk, I heard Craw commenting that “AI strength is in decision support, not decision making”. In the world of driverless cars and rocket-landing AI, for me, that sounds a bit too… safe.
From Lab to the Real World — Robustness and Reproducibility in Robotics
The next speaker, Katrin Lohan from Heriot-Watt University, brought up the challenges in getting robots from protected lab environment into the world of natural interaction interfaces. Real world applications would require more robustness and better reproducibility of robotics research, manufacturing and behaviour.
While going through the research in the Robotics Lab and common challenges they face, Lohan mentioned open source code as a way of improving reproduciblity of studies and systems. She also told about ROS, an “operating system” for robots that makes hardware control much easier. But not all robots run ROS, and controlling the hardware is often one of the most difficult and time-consuming part of developing robots.
Lohan showed a video that demonstrates how immediate response from the robot can improve communication. Children in the autistic spectrum have been part of the robotics lab studies on social communication. Robots could help the users by improving their learning, while at the same time learning from the special user group to bridge the gap between robot and human behaviour.
When we returned from the break for the next talk, there was a lego man waiting on each seat. Sadly, I forgot to take mine with me after the talk, but I did manage to immortalize the guy with my phone:
The speaker, Ben Gilburt from Sopra Steria, used only about half the reserved time for his presentation, encouraging attendees to fill in the other half with questions and open discussion. The topic was much more abstract, including the current limits and future of AI, and the ethical problems that emerge when we delegate decision making to something that cannot be held accountable the same way as a person can.
While AI has been a hot topic in recent years and it’s rapid development is evident, we are still far away from imitating any human-like intelligence. Current use of AI is still practically always some specialized scenario, and no machine can handle the range and rate of learning compared to even a 5-year-old child. Gilburt said that general artificial intelligence is said to be “20 years in future”, and it has been that for decades now, ever since the first uses of the word ‘AI’. It will probably continue to be “20 years in the future” for a good while. Not to mention the audience’s favourite topic, singularity.
Gilburt pointed out that we need common rules for how we develop and apply artificial intelligence. Algorithms and machine learning is bound to be affected by our own biases. Research has shown that issues such as discrimination and racism are very much present in automated decision making. The new EU General Data Protection Regulation (GDPR)— enforced from 25 May 2018 — is in part laying some ground rules to avoid the most drastic ethical consequences of the rapidly increasing usage of AI. There’s an excellent, freely available paper on GDPR’s impact on machine learning, including it’s problems and shortcomings. The regulation and AI ethics in general is an extremely complex and interesting topic, and Gilburt’s talk just scratched the surface.
Another topic of the talk was the change in our behaviour because of our familiarity with computer interfaces. As an example of this, Gilburt showed two pictures of student’s facial expressions during a lecture, one recent and one from several decades ago. Reading the emotions from faces was much easier in the latter picture. Gilburt explained that in most computer interfaces we use, even when using them to communicate between each other, facial expressions have no value for the speed or quality of communication. This has caused us to give less value for expressing our emotions in everyday interactions. One way to turn this over would be to create interfaces that react to facial expressions and emotions.
Discreet Computing and AI modeling techniques
The last talk of the AI track was by the University of St Andrews professor and chair of Human Computer Interaction, Aaron Quigley. I was immediately thrown back to Uni when he started the talk by mentioning SIGCHI and ACM. The feeling just got stronger by the ever growing speed of slides that explained different ways of building representational models for machine learning. And I must admit, I liked that feeling, and started to think if I should pursue my goal of getting a PhD.
The first part of the lecture was about modeling data for visual representations by reducing its dimensions, so that it can be interpreted by human without the need for machine learning. I just about recognized some terms like principal component analysis, but when it got to specific methods of clustering (quadtree geometric clustering, k-means), and ways of generating decision trees (ensemble methods / random forest), I was making notes like a fresher before exams.
In addition to the techniques, Quigley provided some views on AI that are worth stopping to think about. He made a case that not everything needs to use deep learning that makes explainability a very difficult problem. That is especially important now that GDPR is on its way. Also, with our mobility needs and ubiquitous computing, connectivity is not always a given, and cloud is not the answer for everything.
Like any self-respecting academic, Quigley had still about 50 slides left before the last minute of the talk, so there was no much time left for discussion. The only question was about explainability of AI decision making, which had been a recurring theme in every one of the talks. Quigley mentioned that although it is much more complex question with deep learning compared to techniques like decision trees, there is ongoing research into this in universities and enterprises because of its importance, and we ought to see some results in near future.
Before the last AI talk by Quigley, I stepped outside the track to catch Scott Hanselman’s second talk on .Net Core. Even though I had been trying to keep up to date with .Net, and even watched several of the ASP.Net community standups, it was still quite inspiring to see and hear all that live without staring at a screen (especially after Ben Gilburt telling how we’re ruined by computer interfaces and can no longer show emotions 😉).
Hanselman started with some hisrory of .Net, and mentioned how the framework was actually open-sourced first time 15 years ago. Although technically open source, the lack of community input and bad licensing prevented the framework from getting the benefits of a proper open source project. With .Net Core, the intention was to fix that, and get the community involved from the very beginning. This meant that not just the code, but all the decision making was made transparent and the community was given all the possible tools to take part.
An important part in making .Net libraries portable between .Net implementations is .Net Standard. With a standard API that library authors can rely on being available in any implementation, libraries can easily be used in all platforms. This also makes porting old .Net applications to Core more feasible as the libraries they depend on can be made available for both traditional .Net and Core.
.Net Core also tries to address the problems with updating the framework by allowing multiple versions to be installed side by side. This means that the application can depend on any currently installed version. It can even include the whole framework within a self-contained package. This of course increases the package size considerably, but in the future something like tree-shaking could possibly be used to drop any unused dependencies to decrease the size.
During his talk, Hanselman also revealed some extremely well kept secrets of the command prompt. Do you know what pressing F7 does in cmd? I didn’t!
Fast and simple developer experience is something that interpreted languages have by design as they don’t require a separate build step. Hanselman talked about developer’s inner loop, basically meaning the task switching between coding and testing the code. With dotnet watch tool, the project gets implicitly built every time a source file changes, making the developer experience much nicer (I’ve used it and I definitely agree). With the next version, .Net Core 2.1, build time should also be improved.
At the end of the talk Hanselman demonstrated building a .Net Core application and publishing it for Linux from a Windows laptop. By publishing a self-contained executable, the application was able to run in any Linux machine, and Hanselman chose to show how to run it in a Rasberry Pi. That got me quite interested in buying my own Rasberry and get a feeling of extreme cross-platform in action.