albert's blog

2018/09/01

[閱讀筆記] Thinking, Fast and Slow (6/9)

透過上述兩個條件可以得知，為什麼選股專家的正確率會這麼低，因為選股專家的失敗，反映出他們試著去預測本質上是無法被預測的股票市場
去指責任何人在無法預測的世界進行精準的預測是錯誤的，但是，去指責那些過度自信的、自以為可以成功預測的專家，則是另當別論
記住，直覺所獲得的結論，在沒有『穩定、規律地出現重複事件』的環境條件下，是無法被信任的
你在某個特定的任務能獲得多少的 expertise ，需要看你花多少時間來練習。累積 expertise 的速度，端視於你是否有機會學習？以及多快得到清楚的回饋?
「規劃謬誤」（planning fallacy）常出現許多地方，如公司的軟體專案、政府的公共建設工程等，人們常對於計畫或專案完成所需的時間與預算一貫抱持不切實際的樂觀態度。任何做過專案的人都知道，所有的工作都會比你預期的時間拖更久，即使你早已知道規劃謬誤是無法避免的。你應該避免不切實際的過度樂觀，且你應該去看看有無類似的案例，看看類似的案例花了多少預算與時程，然後再來推估你手上的案例所需的預算與時程 (這也是針對 planning fallacy 的唯一解藥)
Reference class forecasting (參考類別預測) 是解決 planning fallacy 的方法，此預測方法可以避免你忽略了 base rate：

【步驟一】找出適合的 reference class (參考類別)，如類似的廚房裝修工程、大型的鐵路建造案等等 (尋找 outside view)
【步驟二】取得所選定的 reference class (參考類別) 相關的統計數字 (如鐵道建設的每一英里的成本或者是超過預算的百分比等)，用此產生 baseline prediction
【步驟三】使用所取得的相關資訊來對照自己手上的專案，進行 baseline prediction 的調整

管理者在預測時，常常會高估效益、低估成本，導致很難如期、如預算的交付、甚至很難完成交付。
為什麼人們很容易成為 planning fallacy 的受害者？因為人們習慣做 best-case scenario 的假設，但是會有很多不同的風險都會造成計畫失敗，而且你無法預知所有可能的風險
因為不願意承認失敗，而投入更多的人力、時間、金錢等，這就犯下了 sunk-cost fallacy (沉沒成本謬誤)。人們在決定是否去做一件事情時，不僅會看這件事會為自己帶來的好處，也會沉溺在過去已投入且不能回收的成本中，而做出不理性的選擇
創業者常會有幻覺，根據統計，美國的小公司可以存活五年以上的機率只有 35%，但是創業者覺得這樣的統計數字無法套用在他們身上，他們認為他們成功的機率超過 60%。又如同汽車駕駛人，90% 的人認為它們的技術比一般人都還要好。這就是所謂的 above average effect，人們常會高估自己的優點、低估自己的缺點
被媒體或報章雜誌歌功頌德的 CEOs，接下來無論是在股價或是公司營運績效等，表現都會變差。因為變成名人的 CEOs，他花了較多的時間在與公司營運無關的事務上 (如寫書、上節目等)，卻忽略了本業
為什麼創業者行有過度樂觀的問題，認知偏誤是主要的原因，這也是 System 1 的特性 WYSIATI：

只聚焦於目標、計畫，卻忽略了 base rates，導致 planning fallacy
只聚焦於想做的與能做的，卻忽略完成此計畫所需的其他技能
觀察過去與預測未來時，只聚焦於技能（skills）所扮演的角色，卻忽略了機運（luck）所占有的重要性，這常會造成控制假象（Illusion of Control），決策者常高估自我能力，對管理活動過度自信（overconfident），產生近乎誇大的判斷
只聚焦於所知道的事情，卻忽略不知道的事情，這常會造成創業者過度自信

華頓商學院（Wharton School）與科羅拉多大學（University of Colorado）研究發現，若能預先設想往後可能發生的情況，可以讓正確預測未來結果的能力提高30％。其運用這個原則，設計出一套「事前驗屍」（premortem）的方法，幫助計畫執行團隊從一開始就鎖定風險因子。事前驗屍和事後驗屍正好相反。醫學上的事後驗屍，讓醫生及家屬了解病患的死因是什麼，這對每個人都有幫助，只是對已死的病患沒有任何幫助。企業界的事前驗屍（premortem）則是在計畫開始時進行，而非在結束後進行，目的是為了改進計畫，而不是等計畫失敗了再來追究原因。一般的事後檢討都是問計畫成員，可能發生了什麼差錯；事前驗屍（premortem）則不同，是假設「病患」已經死亡，並追究真正的死因。換句話說，專案小組必須找出計畫失敗的種種可能原因。
「事前驗屍」（premortem）的方法並不是萬靈丹，它無法提供完整的保護，無法完全避免預料之外的結果，但是它能將降低發生預料之外的風險發生時所造成的衝擊，並可減少 WYSIATI 的偏誤與過度自信、樂觀。所以我們應該好好地執行「事前驗屍」（premortem），在計畫執行前找出我們所忽略的風險或威脅
當決策者出現控制假象（Illusion of Control）時，他們通常都是嚴重低估未來會遇到的障礙與風險
過度自信（overconfidient）的表徵是，他們相信他們所知道的，比他們實際知道的還多
韋伯－費勒（Weber-Fechner）定律是營銷學中研究購買者價格差異感受的一條定律。韋伯－費勒（Weber-Fechner）定律反映的就是消費者對價格變化的感受更多取決於變化的百分比。所謂價格差異感是指當購買者在面對價格的調整、變化或者不同價格時的心理認知程度。如果消費者能夠對價格的差異作出理性的判斷，那麼當絕對的價差—樣時，就應該產生相同的行為。但是實踐和實驗的結果都表明，購買者對同樣的價差的反應並不相同。如加薪2000元與加薪20%，20%比較能引起注意
以下是兩個不同假設條件的實驗，在哪種情況下你會改變到其他商店去購買：

實驗A:假設你所光顧的文具店計算器的價格是20元，而有人告訴你其他商店的價格是15元。
實驗B: 假設你所光顧的文具店計算器的價格是120元，而有人告訴你其他商店的價格是115元。
實驗的結果是，在A實驗中大約68％的人會換一家商店去購買，B實驗中大約29%人會願意換一家商店去購買。只要我們仔細分析一下兩組實驗中的價差，就會發現兩組實驗的差價其實是一樣的（都是5元），所以實驗結果的不同尋常之處就在於，如果購物者都是理性經濟人的話，為什麼在相同的經濟損益面前，其行為卻有如此的不同呢？進一步分析，我們會發現，雖然兩種實驗中購物者實際節省的都是5元，但是在A中，5元相對於價格總額是一個不小的數字；而在B中，5元相對於價格微不足道。這就是營銷學中著名的韋伯－費勒（Weber-Fechner）定律：購買者對價格的感受與基礎價格的水平有關，購買者對價格的感受更多地取決於相對價值，而非絕對價值。

當我們給予兩位應徵者相同薪水時，這兩位並不會感受到相同的滿足，因為彼此的參考點 (reference points) 是不一樣的，原本擁有較高薪水的應徵者，滿足程度一定較低
John 三年前獲得 20000 元的獎金時非常快樂，但是之後他的薪水調薪了20%，若要達到相同的效用 (utility)，必要又得到更高的獎金才會得到三年前那時相同的快樂，這是因為參考點 (reference points) 改變了
當男女雙方要離婚、分配贍養費時 (假設是男生要付贍養費給女生)，女生會偏向雙方談好就好，男方會傾向上法院。男女會有不同的傾向其實並不意外，因為在此狀況，獲利者會傾向風險規避 (risk averse)，然而另外一方因為所面臨的都是不好的選擇，所以寧願冒風險 (risk seeking)
在財務的滿足來說，參考點 (reference points) 可能是現況，也有可能是你預期的，也有可能是與其他人相較之下的結果。當結果超過參考點 (reference points) 你會感覺滿足，若低於參考點 (reference points) 則會感受到不滿足
財富改變的評估，會有敏感度高低的差別 (diminishing sensitivity)。如在昏暗的房間打開一盞微弱光線的燈會有巨大的反應，但是在燈光明亮的房間則不容易被察覺。相同的， $900 與 $1000 差距的主觀差異，會比 $100 與 $200 之間的差異小的多
人類很厭惡損失 (loss aversion)，人們對損失和獲得的敏感程度是不同的，損失的痛苦要遠遠大於獲得的快樂 (loses loom larger than gains)。這也是為什麼很多人在股市賺一點錢就賣掉股票，賠錢的股票卻一直留著不放手。
在博弈中，若輸贏兩者機率相同時，人們會傾向風險規避，會選擇比較保守的選項。但是若眼前只有不好的選擇，在確定會輸錢與有可能會輸更多的選項中，由於 diminishing sensitivity 的關係，會傾向冒險選擇後者。人們在面臨獲得時，往往小心翼翼，不願冒風險；而在面對損失時，人人都變成了冒險家

2018/08/31

[Travel] 201808 貓空 (Maokong)

2018/08/15

[Neo4j] Neo4j offline backup and import database

Scenario

Screenshot for 1.1 and 1.2

Screenshot for 1.3

Screenshot for 2.1, 2.2, and 2.3

Screenshot for 2.4

Reference
[1] https://neo4j.com/docs/operations-manual/current/tools/dump-load/

2018/08/14

[Neo4j] Import data using Neo4j-shell-tools

假設我想要在 neo4j 建立起下圖的關係

由關係圖可以看出會有七個節點，包含

哆啦A夢
大雄
靜香
小夫
胖虎
小叮鈴
玉子 (大雄的媽媽)
伸助 (大雄的爸爸)

這七個人 (nodes) 之間的有九個關係：

大雄的寵物是哆啦A夢
大雄的配偶是靜香
大雄的朋友是小夫
大雄的朋友是胖虎
小夫的朋友是胖虎
哆啦A夢的妹妹是小叮鈴
大雄的爸爸是伸助
大雄的媽媽是玉子
伸助的配偶是玉子

分析與執行步驟如下：

步驟如下：
(1) Download neo4j-shell-tools_3.0.1.zip from https://github.com/jexp/neo4j-shell-tools

(2) Unzip neo4j-shell-tools_3.0.1.zip and copy jar files into neo4j-community-3.3.3\lib

(3) Prepare nodes csv files with UTF-8 encoding in neo4j-community-3.3.3\import directory

(4) Prepare relationship csv files with UTF-8 encoding in neo4j-community-3.3.3\import directory

(5) Execute import-cypher command via neo4j-shell to create nodes

import-cypher -d , -i ./import/nodes.csv -o ./import/nodes_output.txt create(p#{node}:Person {id:{node}, name:{name}, gender:{gender}})

(6) Execute import-cypher command via neo4j-shell to create relationships

import-cypher -d , -i ./import/relationships.csv -o ./import/relationships_output.txt match (from:Person), (to:Person) where from.id={From} and to.id={To} create (from)-[:#{Relation Type}]->(to)

產生的關係圖如下：

2018/08/13

[JSON] How to ignore Inheritance properties with Jackson

How-To
AbstractCommonEntity Superclass:

  package com.xxx.entity;
  
  
  import java.io.Serializable;
  import java.util.Date;
  
  import javax.persistence.Column;
  import javax.persistence.MappedSuperclass;
  
  import org.codehaus.jackson.annotate.JsonIgnoreProperties;
  import org.hibernate.annotations.GenerationTime;
  import org.hibernate.annotations.GeneratorType;
  import org.springframework.data.annotation.LastModifiedDate;
  
  import com.xxx.LoggedUserGenerator;
  
  import lombok.Data;
  
  @Data
  @MappedSuperclass
  public abstract class AbstractCommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
  
      @GeneratorType(type = LoggedUserGenerator.class, when = GenerationTime.ALWAYS)
      @Column(name = "LAST_MODIFIED_BY")
      private String lastModifiedBy;
  
      @LastModifiedDate
      @Column(name = "LAST_MODIFIED_DATETIME")
      private Date lastModifiedDatetime;
  
  }

Action subclass:

  package com.xxx.entity;
  
  import java.io.Serializable;
  
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.EntityListeners;
  import javax.persistence.GeneratedValue;
  import javax.persistence.GenerationType;
  import javax.persistence.Id;
  import javax.persistence.SequenceGenerator;
  import javax.persistence.Table;
  
  import org.springframework.data.jpa.domain.support.AuditingEntityListener;
  
  import lombok.Data;
  import lombok.EqualsAndHashCode;
  
  @Entity
  @Table(name = "ACTION")
  @Data
  @EntityListeners(AuditingEntityListener.class)
  @EqualsAndHashCode(of = "id", callSuper = false)
  public class Action extends AbstractCommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
      
      @Id
      @SequenceGenerator(name = "ACTION_ID_SEQ", sequenceName = "ACTION_ID_SEQ", allocationSize = 1)
      @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ACTION_ID_SEQ")
      @Column(name = "ID")
      private Integer id;
      
      @Column(name = "NAME")
      private String name;
      
      @Column(name = "DEPEND_SLOTS")
      private String dependSlots;
  
      @Column(name = "PROJECT_ID")
      private Integer projectId;
  
  }

If I would like to genenrate JSON from Action subclass and ignore properties from its superclass, how to do it?

How-To
Simply add @JsonIgnoreProperties in superclass:

  package com.xxx.entity;
  
  
  import java.io.Serializable;
  import java.util.Date;
  
  import javax.persistence.Column;
  import javax.persistence.MappedSuperclass;
  
  import org.codehaus.jackson.annotate.JsonIgnoreProperties;
  import org.hibernate.annotations.GenerationTime;
  import org.hibernate.annotations.GeneratorType;
  import org.springframework.data.annotation.LastModifiedDate;
  
  import com.xxx.LoggedUserGenerator;
  
  import lombok.Data;
  
  @Data
  @MappedSuperclass
  @JsonIgnoreProperties({ "lastModifiedBy", "lastModifiedDatetime" })
  public abstract class AbstractCommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
  
      @GeneratorType(type = LoggedUserGenerator.class, when = GenerationTime.ALWAYS)
      @Column(name = "LAST_MODIFIED_BY")
      private String lastModifiedBy;
  
      @LastModifiedDate
      @Column(name = "LAST_MODIFIED_DATETIME")
      private Date lastModifiedDatetime;
  
  }

2018/08/12

[PostgreSQL] How to retrieve a value which separated by comma

Problem
I retrieve 3 records via the following SQL statement:

  select id,  domain_projects 
  from project
  where domain_classifier = true

The value in domain_projects column is separated by comma, if I would like to pick up the value which contains 26, how to do it?

How-To
Here has SQL statement:

  select id,  domain_projects 
  from project
  where domain_classifier = true 
        and '26' = any(string_to_array(domain_projects, ','))

Reference
[1] https://www.postgresql.org/docs/9.1/static/functions-array.html
[2] https://www.postgresql.org/docs/9.1/static/functions-comparisons.html

2018/08/11

[JPA] Entity Inheritance in JPA

Problem
I have three tables which has two identical column (i.e. LAST_MODIFIED_BY and LAST_MODIFIED_DATETIME).

How do define entities via entity inheritance in JPA?

How-To
There are two steps to implement entity inheritance:
[Step 1] Extract the two columns into an abstract class with @MappedSuperclass

  package test.entity;
  
  import java.io.Serializable;
  import java.util.Date;
  
  import javax.persistence.Column;
  import javax.persistence.MappedSuperclass;
  
  import org.springframework.data.annotation.LastModifiedBy;
  import org.springframework.data.annotation.LastModifiedDate;
  
  import lombok.Data;
  
  @Data
  @MappedSuperclass
  public abstract class CommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
  
      @LastModifiedBy
      @Column(name = "LAST_MODIFIED_BY")
      private String lastModifiedBy;
  
      @LastModifiedDate
      @Column(name = "LAST_MODIFIED_DATETIME")
      private Date lastModifiedDatetime;
  
  }

[Step 2] Extend the abstract class from the three entities:

  package test.entity;
  
  import java.io.Serializable;
  
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.EntityListeners;
  import javax.persistence.GeneratedValue;
  import javax.persistence.GenerationType;
  import javax.persistence.Id;
  import javax.persistence.SequenceGenerator;
  import javax.persistence.Table;
  
  import org.springframework.data.jpa.domain.support.AuditingEntityListener;
  
  import lombok.Data;
  import lombok.EqualsAndHashCode;
  
  @Entity
  @Table(name = "PROJECT")
  @Data
  @EqualsAndHashCode(of = "id", callSuper = false)
  public class Project extends CommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
      
      @Id
      @SequenceGenerator(name = "PROJECT_ID_SEQ", sequenceName = "PROJECT_ID_SEQ", allocationSize = 1)
      @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "PROJECT_ID_SEQ")
      @Column(name = "ID")
      private Integer id;
      
      @Column(name = "IDENTIFIER")
      private String identifier;
      
      @Column(name = "NAME")
      private String name;
      
      @Column(name = "STATUS")
      private String status;
  }

  package test.entity;
  
  import java.io.Serializable;
  
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.EntityListeners;
  import javax.persistence.Id;
  import javax.persistence.Lob;
  import javax.persistence.Table;
  
  import org.springframework.data.jpa.domain.support.AuditingEntityListener;
  
  import lombok.Data;
  import lombok.EqualsAndHashCode;
  
  @Entity
  @Table(name = "MODEL")
  @Data
  @EqualsAndHashCode(of = "id", callSuper = false)
  public class Model extends CommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
      
      @Id
      @Column(name = "ID")
      private String id;
      
      @Column(name = "PROJECT_ID")
      private Integer projectId;
      
      @Lob
      @Column(name = "STATISTICS_JSON")
      private String statisticsJson;
      
  }

  package com.cht.ai.bot.entity;
  
  import java.io.Serializable;
  
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.EntityListeners;
  import javax.persistence.GeneratedValue;
  import javax.persistence.GenerationType;
  import javax.persistence.Id;
  import javax.persistence.SequenceGenerator;
  import javax.persistence.Table;
  
  import org.springframework.data.jpa.domain.support.AuditingEntityListener;
  
  import lombok.Data;
  import lombok.EqualsAndHashCode;
  
  @Entity
  @Table(name = "SLOT")
  @Data
  @EqualsAndHashCode(of = "id", callSuper = false)
  public class Slot extends CommonEntity implements Serializable {
  
      private static final long serialVersionUID = 1L;
      
      @Id
      @SequenceGenerator(name = "SLOT_ID_SEQ", sequenceName = "SLOT_ID_SEQ", allocationSize = 1)
      @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SLOT_ID_SEQ")
      @Column(name = "ID")
      private Integer id;
      
      @Column(name = "NAME")
      private String name;
      
      @Column(name = "TYPE")
      private String type;
      
  }

2018/08/10

[Win10] 如何取消定期強制更改密碼？

How-To

Snapshot for Step 1

Snapshot for Step 3

Total Pageviews