The Investing Squirrel is a financial information chatbot served through a DialogFlow frontend, powered by a webhook in NodeJS. Originally, I built it to provide financial definitions for beginners.

I later realised that incorporating API functionality would make it more powerful. I could perform quick checks on share prices, or pack in interactive content to function as behavioural nudges.


The chatbot functions as follows: based on the user’s inputs, DialogFlow will detect the appropriate intent. If an intent requesting for share price is detected, the backend webhook will make a POST request to the AlphaVantage API which provides financial information.


Over time, I was able to improve the backend logic to include 2 more functions: 1) a news function:


And 2) a technical indicator function, serving 3 simple indicators for my needs (MACD, RSI and stochastics).


The Investing Squirrel is integrated with Facebook for beta testers. A raw version of it is available on Telegram (but due to limited API calls and choppy dynos from free Heroku hosting, you may experience some lag). Give it a shot and have fun!

"Richard" was the name of a neighbour I had when I was young. No prizes for correctly guessing his occupation.

The idea for “Richard” came about because many of my friends who were couples were sourcing for a HDB flat. They wanted a quick, back-of-envelop way to verify that the valuations they were quoted were reasonable.

Since HDB publishes clean data on resale transactions, I thought: why not train a model with this data and try to predict prices based on users' inputs of their flat's info? I then conceptualised the app's structure:


Based on this structure, the first step was to procure the data, then to train it, and finally evaluate the models. Out of 4 models I’ve tried, the XGBoost regressor provided the best accuracy. I stored the XGBoost weights in a pickle file:



The weights were connected by means of a Flask app to the user. The Flask script manages RESTful API requests and user's inputs, essentially allowing what the user keys in to feed into the mathematical calculations.
Lastly, for a smoother front end experience, the chatbot agent was then trained to identify different ways a user would key in the parameters such as storey, lease remaining, town, floor area and flat type. Stylistic elements to give it a local feel were also included.


Richard is available as a DialogFlow agent. Based on feedback from the initial test run (n=15 users), about 8 have said that the valuations were accurate. My future plans include converting the frontend into a web form, and allowing users to give feedback on whether the valuation was accurate, so that the model can reinforce its accuracy over time.

This IPYNB notebook was written for the final assignment of my Specialist Diploma in Data Science (Artificial Intelligence). I enrolled in this course at Singapore Polytechnic in 2018 as I wanted to sharpen the skills I have earlier gained from General Assembly.

The task was a classic one: fit a neural network to the MNIST dataset and train the computer to identify handwritten digits correctly. However, to challenge myself, I did some things differently: a) I experimented with 3 neural networks and re-built all 3 from scratch by reading through their papers rather than just importing ready-made versions, and b) I augmented the size of my train set instead of using the dataset as-is.

The first architecture I built was the LeNet5 architecture. I read the original paper written by Yann LeCunn et al in 1998 and realised the network was certainly less complex due to the (lack of) compute power back then. I reproduced it and got an error rate of about 4.8%.



Thereafter, I tried building two other more modern architectures. The first, ZFNet, turned out to be rather massive as it was meant to recognise colour images. MNIST however was a 1-channel grayscale dataset and this meant the architecture had to be scaled down. Again, I accessed the original paper to get a sense of their structure, and applied proportion to scale down some convolution and pooling layers. I repeated this process for VGG-16.



Finally, I learnt how to artificially increase the train set size by rotating the MNIST digits to form new images and played around with the learning rate to get the best results. This allowed me to drop my error from nearly 5% to a whopping 0.97%. The link to the notebook is provided below.

In this notebook, I assessed the effectiveness of various clustering algorithms applied to the classic Iris dataset. 4 algorithms were tested: a) K-Means Clustering, b) Spectral Clustering, c) Agglomerative Clustering, and d) DBSCAN. Various evaluation metrics were used to assess each algorithm.



Through this unsupervised learning task, I developed a personal workflow to triangulate and get a rough sense of where the optimal k value lies. This was backed up by DBSCAN, which computes its own k without requiring the user’s specification. I then “subbed” this range of k values back into the 4 selected algorithms to see which one performed the best.


Using this workflow, I determined Spectral Clustering with a k-value of 3 to be the most effective algorithm. This workflow has now entered my toolkit as a useful reference for future unsupervised learning tasks. The link to the notebook is provided below.

I used the VGG16 neural network architecture to classify a set of food pictures. This was a project in the fast.ai v1 run.

I first instantiated the network and then fit the data to it.



I was thoroughly amazed at the simplicity of the implementation and efficacy despite the small train set. The results were actually pretty accurate!



The fast.ai syllabus really brought machine learning down from the realms of the "technical Levites" to something that could be learnt and applied by mere mortals. It was one of the key turning points of my journey in learning data science. You can check out the code below -- yes, it really is just a few lines of code in a notebook!

Using Bootstrap 4 and JS, I made a mock landing page for my own imagining of the Moments of Life App. The landing page aims to explain the idea of the app in a simple way to an imagined visitor.



The mock screens on the app were made using, surprisingly, Powerpoint! Also, do note that I'll not be sharing the code here, as this is my own imagining of an existing product. If you wish to share thoughts or bounce ideas on it, drop me a message and let's have coffee!

SchemesSG is a mobile app built with React Native. It is a directory of various help schemes available in Singapore, inclusive of both government schemes as well as those by private bodies or NGOs.

Although many government apps already exist to provide info on assistance, I felt that there was a gap in information regarding schemes disbursed at the private or local level, say by charitable organisations, individuals or even Members of Parliament. Hence I built a proof-of-concept directory as follows:




The app also sports a simple "Add to Favourites" function made with Redux. This allows the user to go back to saved schemes for further follow-up.




I am exploring the possibility of integrating the app with a database which can be updated regularly with new scheme listings and information. Currently I am toying around with Firebase, but if you know of a better solution, please reach out to me!

----------------------

Update on 25/1/2021: Based on further user research, I have pivoted from mobile to web. You can access the MVP via the button below. It currently has more than 100 listings and is serving a few social work teams. The initial listing of schemes was created using a selenium script, and is currently open to update by crowdsourcing. I also have plans to build further features, including more advanced filters and an multi-label language AI model to help users pull out relevant schemes via free text input. Really excited about this, ping me if you have ideas or wish to chat!

The UX Diaries is a journal where I record my experience and reflections of using government apps. It also details how I, as a user, would like to see these apps evolve.

Built using ReactJS, I have recorded my thoughts of about 12 apps:


In the journal, I address 3 key areas for each app: 1) what I think users want to do through the app, 2) what the organisation is trying to achieve, and 3) how behavioural science can inform the roadmapping of features. These thought experiments help me establish design sensibilities and become more acute of my own needs as a user.


While I could have used a ready-made site editor, building this journal from scratch also helped me appreciate the complexities that go behind planning even a simple page. Mad kudos to dedicated React developers!

You can access the UX diaries via the button below :)