Thursday, November 24, 2011

Analytics: Hadoop V.S. DBMS

最近兩周,我開始參加 GTUG 的活動,在活動間,有人問起,為什麼我公司選用DBMS(MySQL)來做資料分析,而不用 Hadoop。在這邊,我把跟公司的DB怪才同事的討論結果,稍為簡單敘述一下。

首先,要先理解到的一點是,在 MapReduce 及 Hadoop 出現之前,Data Mining的工具及技術,已經在DBMS上建構了有30年了,相關的技術也發產的很成熟且有許多專書論述。

ETL(Extract, Transform, Load)是這個領域的關鍵字,用 ETL 去找下去,會找到許多的書籍講怎麼做資料分析
  • Extract: 如何在雜亂的原始資料中,找出有用的訊號,並把這些訊號歸檔
    例如:把 Apache 的 access.log 轉換成一對對的 (timestamp, session)
  • Transform: 如何把整理好的訊號,轉換成更好用的中介查詢表格
    例如:把前面的 (timestamp, session) 轉換成以小時為單位的存取次數 (time-slice, count)
  • Load: 把整理好的資料,存到資料庫中。
透過這個轉換過的Fact Table,我們可以把很昂貴的『每日訪問總數查尋』從
# pseudo code 應該是錯的,不過你知道我在表達什麼就好了 :P

SELECT COUNT(UNIQUE session) FROM http_access
  GROUP BY DATE_FORMAT(timestamp,'%Y %m %d')
變成
SELECT SUM(count) FROM access_counts
  GROUP BY DATE_FORMAT(time_slice,'%Y %m %d')

假設,你的原始資料有一整年這麼多,總共有四千萬筆(40M),那麼,前者就是把四千萬筆的資料讀出來,然後過濾加總,而後者,由於資料匯入時已先處理過了,所以要處理的只有24 * 365筆資料;而這兩者間所花費的時間差易,會隨著查尋次數而產生重大差異。 

試問,若是每次你老闆跟你要資料時,你要跟他說,要等半小時才可以,還是說等我五分鐘? 至於前面的半小時是怎麼算出來的呢?

由於DB運算,瓶頸多是卡在硬碟存取上,在前面的例子中,40M筆資料,假設一筆是1K bytes,那麼,總資料量是 40GB ,從硬碟循序讀取 40GB 出來,所花的時間是 40GB / 40MB/s(硬碟速度) = 17分鐘

MapReduce & DBMS


MapReduce是把資料分拆運算,然後再加總的技術;但是,MapReduce的概念對 RDBMS 並不是什麼新奇的事,在這份IBM的文件中,便清楚的敘述到,DBMS會對 SQL 指令做編譯,DBMS內部就會依資料型態、INDEX檔、CPU Core的數量等,去做最佳化,這些,是Hadoop不會幫你做的。

既然DBMS那麼好那麼,為什麼會有 MapReduce 等技術的出現呢,那是因為,DBMS可以幫你scale up,但是最終,還是會碰上硬體的極限,那麼,這時只有 scale out ,才能解決這問題。 但是 scale out 的程式難度,總是比 scale up 困難,而且,一個不好的分析模式,並不會因為跑的快10倍,就變得比較好;因此, ETL 的概念,在使用 MapReduce 時仍是可以應用的,


講到這邊,什麼時候該用 Hadoop ,什麼時候該選用 DBMS ,應該很清楚了
  1. 首先,就是要先看你要找的分析訊號是什麼,定好分析的步驟及查詢表格
  2. 再來,看你的資料量會有多大,做些簡單的計算,看看是不是能在合理的時間內跑完
  3. 最後,看你這些報表倒底是有多常被取用,若是,這是內部的報表,只要一個月能出一次就好,那麼,Hadoop可能就大才小用;若是,你是要做產品,像Google Analytics做到即時大量分析,那麼你可能就需要用到Hadoop

    過去我在 Medio 服務時,公司有幫美國幾大電信商分析 App 的購買行為,由於,這些是每個月才需產生一次的報表,而且,資料的訊號有待我們的 data expert 去尋找,因此,我們的資料專家是把資料倒到 MicroStrategy 再去下指令分析的,並沒有用到 Hadoop

Tuesday, November 22, 2011

Source code of my Scala on Android Project.

把前面幾回講的用Scala寫的Android程式,放上 bitbucket 了,有興趣的可以自己去下載來看。

https://bitbucket.org/bluetang/android-taipei-disaster

Wednesday, November 16, 2011

My experience with Scala on Android

用Scala開發Android,是個滿有趣的經驗,大致上來因為我切入的時間點較晚,所以大部份的問題已經被前人所解決,就用 https://github.com/jberkel/android-plugin 把專案用 sbt 開好後,就可以開始寫 android.

我用的 IDE 是 intellij 11 EAP,用 sbt-idea 把 idea project 設好後,把預設的 asset pa th 從 .idea_module 改成 src/main ,就可以開始開發了。


在開發上,除了前一回碰上的proguard問題外,我還碰上另一個比較嚴重的問題-不能在Scala裡寫 AsyncTask

這問題跟SI-3622 SI-3494有關,看來是在 Scala 2.8解掉的問題,2.9又跑回來了,我這邊看到的狀況是

override protected def doInBackground(params: Params*): Result

會被Scala compiler專換成
public Result doInBackground(Seq params)
    public Result doInBackground(Params[] params)


而底下的code,則是scala compiler會吐出 overides nothing.
override protected def doInBackground(params: Array[Params]): Result

不管怎樣,都跟Android要求的protected Result doInBackground(Params[] params)不同,所以在runtime時會跑出NoSuchMethodError.

解決方法是在 java 裡寫個 bridge interface ,幫 scala compiler 搞不定的東西,在這個 interface 裡定意好

public abstract class SAsyncTask<Params, Progress, Result> extends AsyncTask<Params, Progress, Result> {

    protected abstract Result doInBackground(Seq<Params> params);

    @Override
    protected Result doInBackground(Params... paramses) {
        return doInBackground(JavaConversions.asScalaBuffer(Arrays.asList(paramses)));
    }
}

Tuesday, November 15, 2011

Data Modeling With Jackson Json and Scala - Proguard

關於Proguard,官方的網頁是這麼自述的:
ProGuard is a free Java class file shrinker, optimizer, obfuscator, and preverifier. It detects and removes unused classes, fields, methods, and attributes. It optimizes bytecode and removes unused instructions. It renames the remaining classes, fields, and methods using short meaningless names. Finally, it preverifies the processed code for Java 6 or for Java Micro Edition.

在Mobile App開發的時候,多會用proguard把沒有用到的程式碼濾除,並把變數名稱跟函式名稱用更精簡的字串來取代,這樣編出來的程式會更小,以我用Scala開發的Android程式,使用的的函式庫大小超過10MB,但是用proguard編出來的class.min.jar只有1.7MB,8.xMB的scala-runtime.jar一大票沒用到的功能都被移掉了。

這麼好的功具當然也有他的問題存在,proguard是使用靜態分析的方式,去追縱看有那些程式碼會被執行到,有那些程式碼是不會被碰到的可以被移除的;但由於Jackson是使用Reflection的方式去取得物件的屬性及是用reflection的方式去生成物件,因此,這些行為並不會被proguard偵測到,反而是被認為是dead code而被移除掉。

另外proguard會把變數名稱改寫,這也是跟jackson不相容的地方,當getXxxx被改寫成gY,jackson自然無法知道這是Xxxx的getter,因此若是要在proguard的環境下使用jackson,obfuscator是要被關掉的。

底下這邊,是我在台北積水地圖內,用的proguard設定檔

proguardOption in Android :=
      ("-dontoptimize -dontpreverify -dontobfuscate"  // shrinking only
          :: "-dontskipnonpubliclibraryclassmembers"  // keep Jackson's internal classes
          :: "-dontskipnonpubliclibraryclasses"       // keep Jackson's internal classes
          :: "-keepattributes *Annotation*."          // keep Jackson Json Annotations.
          :: "-keep class org.codehaus.jackson.**"
          :: "-keep class com.bluetangstudio.android.model.**"
          :: "-keep class com.bluetangstudio.searchcloud.client.**"
          :: """-keep class com.bluetangstudio.searchcloud.client.** {
                 (...);
                 public static ** valueOf(...);
             }"""
          :: """-keep class com.bluetangstudio.** {
                 void set*(***);
                 void set*(int, ***);

                 boolean is*();
                 boolean is*(int);

                 *** get*();
                 *** get*(int);
             }"""
          :: """-keep class * implements android.os.Parcelable {
                 public static final android.os.Parcelable$Creator *;
             }"""
          :: """-keepclassmembers class * {
                 ** MODULE$;
             }"""
          :: "-keep public class org.xml.sax.EntityResolver"
          :: "-keep public class scala.Either"
          :: "-keep public class scala.Function1"
          :: "-keep public class scala.Function2"
          :: "-keep public class scala.Tuple2"
          :: "-keep public class scala.collection.Iterable"
          :: "-keep public class scala.PartialFunction"
          :: "-keep public class scala.collection.Seq"
          :: "-keep public class scala.collection.TraversableOnce"
          :: "-keep public class scala.collection.generic.CanBuildFrom"
          :: "-keep public class scala.collection.immutable.Map"
          :: "-keep public class scala.collection.immutable.List"
          :: "-keep public class scala.collection.mutable.StringBuilder"
          :: "-keep public class scala.Predef$$less$colon$less"
          :: "-keep public class scala.math.Numeric"
          :: "-keep public class scala.math.Ordering"
          :: "-keep public class scala.reflect.ClassManifest"
          :: "-keep public class scala.runtime.IntRef"
          :: "-keep public class scala.runtime.BooleanRef"
          :: "-keep public class scala.runtime.AbstractFunction1"
          :: "-keep public class * extends android.app.Activity"
          :: "-keep public class * extends android.app.Application"
          :: "-keep public class * extends android.app.Service"
          :: "-keep public class * extends android.appwidget.AppWidgetProvider"
          :: "-keep public class * extends android.content.BroadcastReceiver"
          :: "-keep public class * extends android.content.BroadcastReceiver"
          :: "-keep public class * extends android.app.backup.BackupAgentHelper"
          :: "-keep public class * extends android.content.ContentProvider"
          :: "-keep public class * extends android.view.View"
          :: "-keep public class * extends android.preference.Preference"
          :: Nil
      ) mkString " "

Data Modeling With Jackson Json and Scala - lazy val

Scala中有個好用的功能是 lazy val - lazy initialized variable ,然而,Scala在實作這功能時,是會加入一個
public volatile int bitmap$0;

若是這欄位沒有被從生成的 json 中替除的話,那麼,讀回來的 scala object 中,所有的lazy val,都會仍是 null ,不會被初始化。

這個問題,只有做好unit-testing可以避免,因為這個欄位是 public 的,所以不需要setter or constructor, Jackson 就可以直接把值設定進去,只用unit-test仔細檢查生成的,確定沒有預料之外的欄位被寫入到 json 中,才可以免去後來在 runtime 發生不可預料的問題。

至於怎麼去除這欄位呢,只要在class上標上@JsonIgnoreProperties({"bitmap$0"})即可

Data Modeling With Jackson Json and Scala - Polymorphic Types

關於 Jackson Json 對多型的支援,原開發者已經有一篇 blog 很清楚的解釋該怎麼做,因此,我只寫下在 scala 上面要注意的眉角。

首先,我先寫下理想中,Jackson在Scala上該怎麼使用,在來談,為什麼不能這麼用
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes(Array(
     new JsonSubTypes.Type(name = "flood", value = classOf[Flood]),
     new JsonSubTypes.Type(name = "mountainslide", value = classOf[MountainSlide])
)) 
trait Disaster {}

case class Flood @JsonCreator()(
    @BeanProperty @JsonProperty("event") event: String,
    @BeanProperty @JsonProperty("address") address: String
) extends Disaster

case class MountainSlide @JsonCreator()(
    @BeanProperty @JsonProperty("event") event: String,
    @BeanProperty @JsonProperty("landmark") landmark: String
) extends Disaster


在 scala 2.8.0 上面,我碰上的問題是不能在annotation內使用 java enum 如: use = JsonTypeInfo.Id.NAME

在 scala 2.9.1 上,上面的問題消失了,不過碰上另一個問題,當一個 annotation 上面有兩個 java enum,scala compiler 及 java compiler 都不會吐出錯誤,但是annotations從bytecode中消失了,SI-5165中紀錄了這問題。

不管怎樣,在現在這時間,若是你想用Jackson + Scala來處理多型,那麼,最頂層類別,一定要用Java來寫,才不會碰上上述兩個問題。

Data Modeling With Jackson Json and Scala

我用Scala有一年半左右,第一次看brianhsu介紹 case class ,就對 Scala 的簡潔著迷,當然,經過了一年半後,許多的面紗揭開後,Scala在與Java函式庫整合的小問題就跑出來了,接下來,我會寫寫怎麼用Jackson Json及Scala來設計一個Json WebService API的Model Objects.

case class


Scala的case class在經過Scala compiler轉換後,就會生成一個POJO,例如這樣一個簡單的case class
case class Disaster(event: String)

會被轉換成如下的Java Code
public class Disaster
    implements ScalaObject, Product, Serializable
{
    public String event()
    {
        return event;
    }
    public int hashCode()
    {
        return ScalaRunTime$.MODULE$._hashCode(this);
    }
    public String toString()
    {
        return ScalaRunTime$.MODULE$._toString(this);
    }
    public boolean equals(Object obj)
    {
        //removed
    }
    public Disaster(String event)
    {
        this.event = event;
        super();
        scala.Product.class.$init$(this);
    }
    private final String event;
}

這個POJO跟一般POJO的不同處在於
  1. immutable object,沒有辦法去更改這物件的屬性
  2. getter的命名不是Java通用的 getXxxx() 而是 xxxx()

這在一般使用上,不是問題,反而是優點,然而,當於 Java binding framework 如 Jackson Json 或 JAXB 要做整合時,就變成問題了,原因在於,多數的 java binding frameworks 在將資料轉回Java Object時,多是呼叫沒代參數的default constructor,然後再呼叫setter(s)把物件的屬性傳進去。

另一個問題則是,多數的java binding frameworks在偵側那些屬性是serializable時,要麻是用java annotation一個個屬性去標,要不然就是用 refection 去找 getXxxx()

而好死不死的plain scala case class沒有辦法滿足上面兩個條件,因此,我們要想辦法繞過這兩個問題。第二個問題比較好解,只要在屬性上標上 @scala.reflect.BeanProperty ,Scala compiler就會自動幫你把你的屬性加上 getXxxx() 及 setXxxx(...)。

case class Disaster(@BeanProperty event: String)

第一的問題,在Jackson Json的解法是用 @JsonCreator 去指定不代變數default constructor的替代品,然而,在這邊我們須要把每一個屬性的名稱,用 @JsonProperty("xxx") 標在 constructor 的參數上,這是因為,Java compiler在編譯時,會把 parameter 的名稱擦去,如 public Disaster(String event) 在經過編譯後的 bytecode 中只剩下 public Disaster(String p1),因此我們須要用java annotation來強制幫參數取個名稱,這樣,當Jackson在把 Json String 轉成Object時,才知道該把那個json object的屬性對到java object的那個屬性之上。

case class Disaster @JsonCreator()(
    @BeanProperty @JsonProperty("event") event: String
)




當我們的Scala case class已經是Jackson Json Serializable後,我們要怎麼樣把scala case class object轉成json string再轉回來呢,請看底下的例子。

val disaster = new Disaster("88 typhoon")
val mapper = new org.codehaus.jackson.map.ObjectMapper()

val json = mapper.writeValueAsString(disaster)
assert(json === """{"event": "88typhon"}"""}
  
val copy = mapper.readValue[Disaster](json, classOf[[Disaster])
assert(copy === disaster)

這邊我們會碰上Scala較Java語法上比較沒有那麼漂亮的地方,在Java裡,若是函式支援generic 且又有個Class的參數,那麼,我們不用把傳兩次進去這個函式,如

Disaster copy = mapper.readValue(json, Disaster.class)

因此在Scala的這邊,我會寫個JsonSerializer來把 scala 這邊的語法弄漂亮些

object JsonSerializer {
  private val mapper = new ObjectMapper

  def fromJson[T <: AnyRef](jsonString: String)(implicit m: Manifest[T]): T = {
    mapper.readValue(jsonString, m.erasure).asInstanceOf[T];
  }
}
// readValue the scala way.
val disaster = JsonSerializer.fromJson[Disaster](json)

最後,@JsonCreator不一定是要標在constructor上面,他也可以標在static method上面,這樣一來,可以讓你做到scala constructor無法做到的一些處理

case class Disaster(
    @BeanProperty event: String, 
    location: Option[GeoPoint]) {
  
  /** helper method for jackson json */
  def getLocation = location.getOrElse(null)
}

object Disaster {

  @JsonCreator
  def newInstance(
    @Property("event") event: String,
    @Property("location") location: GeoPoint): Disaster = {
    
    val locationOption = if (location == null) {
       None
    } else {
       Some(location)
    } 
    return new Disaster(event, locationOption)
  }
}
下一回,我們會看,如何讓Jackson Json能夠對多型的物件做處理

台北市政府公開資料(三)- 台北積水地圖

花了三個禮拜,學習怎麼開發Android程式,在沒買開發機的狀況下,在模擬器上完成了我的第一個Android App - 台北積水地圖







資料來源一樣是從台北市政府所來,原始資料檔可從『臺北市歷年積水紀錄圖』下載。我把資料檔的座標系轉換(TW67 -> WSG84)後,就塞到跟前一回一樣的後端去做處理,剩下的就都是前端的工作了。

在前端UI開發上,依以前開發的習慣,先把wireframe(假UI)畫好才動工,找了找一些畫UI的工具,最後買了keynotopia出的工具,這傢伙也是個奇人,開start-up不到三小時就開始獲利;在畫假UI時就發現,傳統上我們用點來代表一個物件,在畫地圖(羞~)時,並不能合理的表現許多地理圖型。

然而,若是我們要把地理圖型直接畫在地圖上讓使用者直接點開,那麼,我們又要處理重疊的狀況,這在淹水地圖上就特別麻煩,因為常淹水的區塊會互相重疊多次,或像納利颱風,一次淹掉了一大塊的區塊,在處理點選時,我們要怎麼知道使用者點選的是那一層的資料?

而在顯示上,要怎麼處理重疊的區塊,讓使用者知道,某個地點曾淹水多次?一個選項是用顏色來做,重疊的部份用加深的顏色來顯式;最後,我們還是回歸傳統的點座標的方式,來表示淹水的區域,等使用者點開後,才用色塊畫出實際淹水的地區。等下次改版時,等我對Android 2D再熟一些時,或許會嘗試用顏色的方式來做呈現。


接下來,我會在有空的時候,再開發一個程式,把台北市的土地分區(住一、住二、商用...)資料,跟土地的地號資料,做成個台北都更地圖,若各位有類似的需求,請與我聯絡