libffm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a207ec6c4b7eee7b8649dac4d6cd1a5b1213431c8b2de64c20ed080b5311adcb
+  data.tar.gz: 3d4e37041abe6ef1c25509130e8472029fb47fa52ae004b249c6cb430b80485e
+SHA512:
+  metadata.gz: d4a0fee6252c9e6bd999404be493c8a5037f73b71ab579954de8366f5aead6ee19cfc568f3bee021a29cd42448daa34ce85d77d8203e3ce8d840c07ad90f5790
+  data.tar.gz: 4ec88cd2cd3959d7f5d579ccdf6b2d7861066c5d0f347f6fd1dd8cb297cd34a89076c49b28537f302b6ac594565837057925b494a001cc6b7d1f4d6230077d6d

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2020-11-28)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,32 @@
+
+Copyright (c) 2017 The LIBFFM Project.
+Copyright (c) 2020 Andrew Kane.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither name of copyright holders nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,91 @@
+# LIBFFM
+
+[LIBFFM](https://github.com/ycjuan/libffm) - field-aware factorization machines - for Ruby
+
+[![Build Status](https://github.com/ankane/libffm/workflows/build/badge.svg?branch=master)](https://github.com/ankane/libffm/actions)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'libffm'
+```
+
+## Getting Started
+
+Prep your data in LIBFFM format
+
+```txt
+0 0:0:1 1:1:1
+1 0:2:1 1:3:1
+```
+
+Create a model
+
+```ruby
+model = Libffm::Model.new
+model.fit("train.txt")
+```
+
+Make predictions
+
+```ruby
+model.predict("test.txt")
+```
+
+Save the model to a file
+
+```ruby
+model.save_model("model.bin")
+```
+
+Load the model from a file
+
+```ruby
+model.load_model("model.bin")
+```
+
+Pass a validation set
+
+```ruby
+model.fit("train.txt", eval_set: "validation.txt")
+```
+
+## Parameters
+
+Pass parameters - default values below
+
+```ruby
+Libffm::Model.new(
+  eta: 0.2,                # learning rate
+  lambda: 0.00002,         # regularization parameter
+  nr_iters: 15,            # number of iterations
+  k: 4,                    # number of latent factors
+  normalization: true,     # use instance-wise normalization
+  auto_stop: false         # stop at the iteration that achieves the best validation loss
+)
+```
+
+## History
+
+View the [changelog](https://github.com/ankane/libffm/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/libffm/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/libffm/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone --recursive https://github.com/ankane/libffm.git
+cd libffm
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/libffm/ext.cpp

@@ -0,0 +1,110 @@
+// stdlib
+#include <iostream>
+
+// ffm
+#include <ffm.h>
+
+// rice
+#include <rice/Array.hpp>
+#include <rice/Class.hpp>
+#include <rice/Module.hpp>
+#include <rice/Object.hpp>
+
+using Rice::Array;
+using Rice::Class;
+using Rice::Module;
+using Rice::Object;
+using Rice::String;
+using Rice::define_module;
+using Rice::define_module_under;
+using Rice::define_class_under;
+
+extern "C"
+void Init_ext()
+{
+  Module rb_mLibffm = define_module("Libffm");
+
+  Module rb_mExt = define_module_under(rb_mLibffm, "Ext");
+  define_class_under<ffm::ffm_model>(rb_mExt, "Model");
+
+  rb_mExt
+    .define_singleton_method(
+      "release_model",
+      *[](ffm::ffm_model& model) {
+        model.release();
+      })
+    .define_singleton_method(
+      "fit",
+      *[](std::string tr_path, std::string va_path, std::string tmp_prefix, ffm::ffm_float eta, ffm::ffm_float lambda, ffm::ffm_int nr_iters, ffm::ffm_int k, bool normalization, bool auto_stop) {
+        // quiet
+        ffm::cout.setstate(ffm::ios_base::badbit);
+
+        std::string tr_bin_path = tmp_prefix + "train.bin";
+        ffm::ffm_read_problem_to_disk(tr_path, tr_bin_path);
+
+        std::string va_bin_path = "";
+        if (va_path.size() > 0) {
+          va_bin_path = tmp_prefix + "validation.bin";
+          ffm::ffm_read_problem_to_disk(va_path, va_bin_path);
+        }
+
+        ffm::ffm_parameter param;
+        param.eta = eta;
+        param.lambda = lambda;
+        param.nr_iters = nr_iters;
+        param.k = k;
+        param.normalization = normalization;
+        param.auto_stop = auto_stop;
+
+        return ffm::ffm_train_on_disk(tr_bin_path, va_bin_path, param);
+      })
+    .define_singleton_method(
+      "predict",
+      *[](ffm::ffm_model& model, std::string test_path) {
+        int const kMaxLineSize = 1000000;
+
+        FILE *f_in = fopen(test_path.c_str(), "r");
+        char line[kMaxLineSize];
+
+        ffm::vector<ffm::ffm_node> x;
+        ffm::ffm_int i = 0;
+
+        Array ret;
+        for(; fgets(line, kMaxLineSize, f_in) != nullptr; i++) {
+          x.clear();
+          strtok(line, " \t");
+
+          while(true) {
+            char *field_char = strtok(nullptr,":");
+            char *idx_char = strtok(nullptr,":");
+            char *value_char = strtok(nullptr," \t");
+            if(field_char == nullptr || *field_char == '\n')
+                break;
+
+            ffm::ffm_node N;
+            N.f = atoi(field_char);
+            N.j = atoi(idx_char);
+            N.v = atof(value_char);
+
+            x.push_back(N);
+          }
+
+          ffm::ffm_float y_bar = ffm::ffm_predict(x.data(), x.data()+x.size(), model);
+          ret.push(y_bar);
+        }
+
+        fclose(f_in);
+
+        return ret;
+      })
+    .define_singleton_method(
+      "save_model",
+      *[](ffm::ffm_model& model, std::string path) {
+        ffm::ffm_save_model(model, path);
+      })
+    .define_singleton_method(
+      "load_model",
+      *[](std::string path) {
+        return ffm::ffm_load_model(path);
+      });
+}

data/ext/libffm/extconf.rb

@@ -0,0 +1,21 @@
+require "mkmf-rice"
+
+$CXXFLAGS += " -std=c++11 -DUSESSE"
+
+apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
+
+# check omp first
+if have_library("omp") || have_library("gomp")
+  $CXXFLAGS += " -DUSEOMP"
+  $CXXFLAGS += " -Xclang" if apple_clang
+  $CXXFLAGS += " -fopenmp"
+end
+
+ext = File.expand_path(".", __dir__)
+libffm = File.expand_path("../../vendor/libffm", __dir__)
+
+$srcs = Dir["#{ext}/*.cpp", "#{libffm}/{ffm,timer}.cpp"]
+$INCFLAGS += " -I#{libffm}"
+$VPATH << libffm
+
+create_makefile("libffm/ext")

data/lib/libffm.rb

@@ -0,0 +1,13 @@
+# ext
+require "libffm/ext"
+
+# stdlib
+require "tmpdir"
+
+# modules
+require "libffm/model"
+require "libffm/version"
+
+module Libffm
+  class Error < StandardError; end
+end

data/lib/libffm/model.rb

@@ -0,0 +1,45 @@
+module Libffm
+  class Model
+    def initialize(eta: 0.2, lambda: 0.00002, nr_iters: 15, k: 4, normalization: true, auto_stop: false)
+      @eta = eta
+      @lambda = lambda
+      @nr_iters = nr_iters
+      @k = k
+      @normalization = normalization
+      @auto_stop = auto_stop
+
+      @model = nil
+    end
+
+    def fit(data, eval_set: nil)
+      Dir.mktmpdir do |dir|
+        @model = Ext.fit(data, eval_set || "", File.join(dir, ""), @eta, @lambda, @nr_iters, @k, @normalization, @auto_stop)
+        add_finalizer(@model)
+      end
+    end
+
+    def predict(data)
+      raise "Not fit" unless @model
+      Ext.predict(@model, data)
+    end
+
+    def save_model(path)
+      Ext.save_model(@model, path)
+    end
+
+    def load_model(path)
+      @model = Ext.load_model(path)
+      add_finalizer(@model)
+    end
+
+    private
+
+    def add_finalizer(model)
+      ObjectSpace.define_finalizer(model, self.class.finalize_model(model))
+    end
+
+    def self.finalize_model(model)
+      proc { Ext.finalize_model(model) }
+    end
+  end
+end

data/lib/libffm/version.rb

@@ -0,0 +1,3 @@
+module Libffm
+  VERSION = "0.1.0"
+end

data/vendor/libffm/COPYRIGHT

@@ -0,0 +1,31 @@
+
+Copyright (c) 2017 The LIBFFM Project.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither name of copyright holders nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/libffm/Makefile

@@ -0,0 +1,26 @@
+CXX = g++
+CXXFLAGS = -Wall -O3 -std=c++0x -march=native
+
+# comment the following flags if you do not want to SSE instructions
+DFLAG += -DUSESSE
+
+# comment the following flags if you do not want to use OpenMP
+DFLAG += -DUSEOMP
+CXXFLAGS += -fopenmp
+
+all: ffm-train ffm-predict
+
+ffm-train: ffm-train.cpp ffm.o timer.o
+	$(CXX) $(CXXFLAGS) $(DFLAG) -o $@ $^
+
+ffm-predict: ffm-predict.cpp ffm.o timer.o
+	$(CXX) $(CXXFLAGS) $(DFLAG) -o $@ $^
+
+ffm.o: ffm.cpp ffm.h timer.o
+	$(CXX) $(CXXFLAGS) $(DFLAG) -c -o $@ $<
+
+timer.o: timer.cpp timer.h
+	$(CXX) $(CXXFLAGS) $(DFLAG) -c -o $@ $<
+
+clean:
+	rm -f ffm-train ffm-predict ffm.o timer.o

data/vendor/libffm/Makefile.win

@@ -0,0 +1,26 @@
+CXX = cl.exe
+CFLAGS = /nologo /O2 /EHsc /D "_CRT_SECURE_NO_DEPRECATE" /D "USEOMP" /D "USESSE" /openmp
+
+TARGET = windows
+
+all: $(TARGET) $(TARGET)\ffm-train.exe $(TARGET)\ffm-predict.exe
+
+$(TARGET)\ffm-predict.exe: ffm.h ffm-predict.cpp ffm.obj timer.obj
+	$(CXX) $(CFLAGS) ffm-predict.cpp ffm.obj timer.obj -Fe$(TARGET)\ffm-predict.exe
+
+$(TARGET)\ffm-train.exe: ffm.h ffm-train.cpp ffm.obj timer.obj
+	$(CXX) $(CFLAGS) ffm-train.cpp ffm.obj timer.obj -Fe$(TARGET)\ffm-train.exe
+
+ffm.obj: ffm.cpp ffm.h
+	$(CXX) $(CFLAGS) -c ffm.cpp
+
+timer.obj: timer.cpp timer.h
+	$(CXX) $(CFLAGS) -c timer.cpp
+
+.PHONY: $(TARGET)
+$(TARGET):
+	-mkdir $(TARGET)
+
+clean:
+	-erase /Q *.obj *.exe $(TARGET)\. 
+	-rd $(TARGET)

data/vendor/libffm/README

@@ -0,0 +1,294 @@
+Table of Contents
+=================
+
+- What is LIBFFM
+- Overfitting and Early Stopping
+- Installation
+- Data Format
+- Command Line Usage
+- Examples
+- OpenMP and SSE
+- Building Windows Binaries
+- FAQ
+
+
+What is LIBFFM
+==============
+
+LIBFFM is a library for field-aware factorization machine (FFM). 
+
+Field-aware factorization machine is a effective model for CTR prediction. It has been used to win the top-3 positions
+of following competitions:
+
+    * Criteo: https://www.kaggle.com/c/criteo-display-ad-challenge
+
+    * Avazu: https://www.kaggle.com/c/avazu-ctr-prediction
+
+    * Outbrain: https://www.kaggle.com/c/outbrain-click-prediction
+
+    * RecSys 2015: http://dl.acm.org/citation.cfm?id=2813511&dl=ACM&coll=DL&CFID=941880276&CFTOKEN=60022934
+
+You can find more information about FFM in the following paper / slides:
+
+    * http://www.csie.ntu.edu.tw/~r01922136/slides/ffm.pdf
+
+    * http://www.csie.ntu.edu.tw/~cjlin/papers/ffm.pdf
+
+    * https://arxiv.org/abs/1701.04099
+
+
+Overfitting and Early Stopping
+==============================
+
+FFM is prone to overfitting, and the solution we have so far is early stopping. See how FFM behaves on a certain data
+set:
+
+    > ffm-train -p va.ffm -l 0.00002 tr.ffm
+    iter   tr_logloss   va_logloss
+       1      0.49738      0.48776
+       2      0.47383      0.47995
+       3      0.46366      0.47480
+       4      0.45561      0.47231
+       5      0.44810      0.47034
+       6      0.44037      0.47003
+       7      0.43239      0.46952
+       8      0.42362      0.46999
+       9      0.41394      0.47088
+      10      0.40326      0.47228
+      11      0.39156      0.47435
+      12      0.37886      0.47683
+      13      0.36522      0.47975
+      14      0.35079      0.48321
+      15      0.33578      0.48703
+
+
+We see the best validation loss is achieved at 7th iteration. If we keep training, then overfitting begins. It is worth
+noting that increasing regularization parameter do not help:
+
+    > ffm-train -p va.ffm -l 0.0002 -t 50 -s 12 tr.ffm
+    iter   tr_logloss   va_logloss
+       1      0.50532      0.49905
+       2      0.48782      0.49242
+       3      0.48136      0.48748
+                 ...
+      29      0.42183      0.47014
+                 ...
+      48      0.37071      0.47333
+      49      0.36767      0.47374
+      50      0.36472      0.47404
+
+
+To avoid overfitting, we recommend always provide a validation set with option `-p.' You can use option `--auto-stop' to
+stop at the iteration that reaches the best validation loss:
+
+    > ffm-train -p va.ffm -l 0.00002 --auto-stop tr.ffm
+    iter   tr_logloss   va_logloss
+       1      0.49738      0.48776
+       2      0.47383      0.47995
+       3      0.46366      0.47480
+       4      0.45561      0.47231
+       5      0.44810      0.47034
+       6      0.44037      0.47003
+       7      0.43239      0.46952
+       8      0.42362      0.46999
+    Auto-stop. Use model at 7th iteration.
+
+
+Installation
+============
+
+Requirement: It requires a C++11 compatible compiler. We also use OpenMP to provide multi-threading. If OpenMP is not
+available on your platform, please refer to section `OpenMP and SSE.'
+
+- Unix-like systems:
+  Typeype `make' in the command line.
+
+- Windows:
+  See `Building Windows Binaries' to compile.
+
+
+
+Data Format
+===========
+
+The data format of LIBFFM is:
+
+<label> <field1>:<feature1>:<value1> <field2>:<feature2>:<value2> ...
+.
+.
+.
+
+`field' and `feature' should be non-negative integers. See an example `bigdata.tr.txt.'
+
+It is important to understand the difference between `field' and `feature'. For example, if we have a raw data like this:
+
+Click  Advertiser  Publisher
+=====  ==========  =========
+    0        Nike        CNN
+    1        ESPN        BBC
+
+Here, we have 
+
+    * 2 fields: Advertiser and Publisher
+
+    * 4 features: Advertiser-Nike, Advertiser-ESPN, Publisher-CNN, Publisher-BBC
+
+Usually you will need to build two dictionares, one for field and one for features, like this:
+    
+    DictField[Advertiser] -> 0
+    DictField[Publisher]  -> 1
+    
+    DictFeature[Advertiser-Nike] -> 0
+    DictFeature[Publisher-CNN]   -> 1
+    DictFeature[Advertiser-ESPN] -> 2
+    DictFeature[Publisher-BBC]   -> 3
+
+Then, you can generate FFM format data:
+
+    0 0:0:1 1:1:1
+    1 0:2:1 1:3:1
+
+Note that because these features are categorical, the values here are all ones.
+
+
+Command Line Usage
+==================
+
+-   `ffm-train'
+
+    usage: ffm-train [options] training_set_file [model_file]
+
+    options:
+    -l <lambda>: set regularization parameter (default 0.00002)
+    -k <factor>: set number of latent factors (default 4)
+    -t <iteration>: set number of iterations (default 15)
+    -r <eta>: set learning rate (default 0.2)
+    -s <nr_threads>: set number of threads (default 1)
+    -p <path>: set path to the validation set
+    --quiet: quiet model (no output)
+    --no-norm: disable instance-wise normalization
+    --auto-stop: stop at the iteration that achieves the best validation loss (must be used with -p)
+
+    By default we do instance-wise normalization. That is, we normalize the 2-norm of each instance to 1. You can use
+    `--no-norm' to disable this function.
+    
+    A binary file `training_set_file.bin' will be generated to store the data in binary format.
+
+    Because FFM usually need early stopping for better test performance, we provide an option `--auto-stop' to stop at
+    the iteration that achieves the best validation loss. Note that you need to provide a validation set with `-p' when
+    you use this option.
+
+
+-   `ffm-predict'
+
+    usage: ffm-predict test_file model_file output_file
+
+
+
+Examples
+========
+
+Download a toy data from:
+
+    zip: https://drive.google.com/open?id=1HZX7zSQJy26hY4_PxSlOWz4x7O-tbQjt
+
+    tar.gz: https://drive.google.com/open?id=12-EczjiYGyJRQLH5ARy1MXRFbCvkgfPx
+
+This dataset is subsampled 1% from Criteo's challenge.
+
+> tar -xzf libffm_toy.tar.gz
+
+or 
+
+> unzip libffm_toy.zip
+
+
+> ./ffm-train -p libffm_toy/criteo.va.r100.gbdt0.ffm libffm_toy/criteo.tr.r100.gbdt0.ffm model
+
+train a model using the default parameters
+
+
+> ./ffm-predict libffm_toy/criteo.va.r100.gbdt0.ffm model output
+
+do prediction
+
+
+> ./ffm-train -l 0.0001 -k 15 -t 30 -r 0.05 -s 4 --auto-stop -p libffm_toy/criteo.va.r100.gbdt0.ffm libffm_toy/criteo.tr.r100.gbdt0.ffm model
+
+train a model using the following parameters:
+
+    regularization cost = 0.0001
+    latent factors = 15
+    iterations = 30
+    learning rate = 0.3
+    threads = 4
+    let it auto-stop
+
+
+OpenMP and SSE
+==============
+
+We use OpenMP to do parallelization. If OpenMP is not available on your
+platform, then please comment out the following lines in Makefile.
+
+    DFLAG += -DUSEOMP
+    CXXFLAGS += -fopenmp
+
+Note: Please run `make clean all' if these flags are changed.
+
+We use SSE instructions to perform fast computation. If you do not want to use it, comment out the following line:
+
+    DFLAG += -DUSESSE
+
+Then, run `make clean all'
+
+
+
+Building Windows Binaries
+=========================
+
+The Windows part is maintained by different maintainer, so it may not always support the latest version.
+
+The latest version it supports is: v1.21
+
+To build them via command-line tools of Visual C++, use the following steps:
+
+1. Open a DOS command box (or Developer Command Prompt for Visual Studio) and go to LIBFFM directory. If environment
+variables of VC++ have not been set, type
+
+"C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\amd64\vcvars64.bat"
+
+You may have to modify the above command according which version of VC++ or
+where it is installed.
+
+2. Type
+
+nmake -f Makefile.win clean all
+
+
+FAQ
+===
+
+Q: Why I have the same model size when k = 1 and k = 4?
+
+A: This is because we use SSE instructions. In order to use SSE, the memory need to be aligned. So even you assign k =
+   1, we still fill some dummy zeros from k = 2 to 4.
+
+
+Q: Why the logloss is slightly different on the same data when I run the program two or more times when I use multi-threading
+
+A: When there are more then one thread, the program becomes non-deterministic. To make it determinisitc you can only use one thread.
+
+
+Contributors
+============
+
+Yuchin Juan, Wei-Sheng Chin, and Yong Zhuang
+
+For questions, comments, feature requests, or bug report, please send your email to:
+
+    Yuchin Juan (juan.yuchin@gmail.com)
+
+For Windows related questions, please send your email to:
+
+    Wei-Sheng Chin (image.chin@gmail.com)