基因演算法(Genetic Algorithms)

         基因演算法，其哲學理論就是達爾文那套優勝劣汰適者生存的進化理論的思想。一個種群，通過長時間的繁衍，種群的基因會向著更適應環境的趨勢進化，適應性強的個體基因被保留，後代越來越多，適應能力低個體的基因被淘汰，後代越來越少。經過幾代的繁衍進化，留下來的少數個體，就是相對能力最強的個體了。

        目前用數學來導出進化模式,用亂數先産生一组亞當與夏娃初始基因排序值,再利用優生理論選出最優基, 本文選擇方法是用機率分佈的所謂輪盤法（Roulette Wheel Selection）來選擇。後續善用自然生態演變的兩種模式 ,突變及交配産出最優的基因?原則上引用多組基因透過亂數來仿真突變及交配産出最優的基因? 但在虚擬環境中畢竟少了真實環境的因子，也造成基因演算法的區域性搜尋能力較差，導致單純的遺傳演算法比較費時，在進化後期搜尋效率較低。在實際應用中，遺傳演算法容易產生過早收斂的問題。

本文的函式如下:

流程圖如下:

Genetic Algorithms with python code 

import numpy as np

import math

import ga

import matplotlib.pyplot as plt

chromosome_length = 33

population_size = 500

best_outputs = []

num_generations = 20

best_score_progress = [] # Tracks progress

next_population=[]

reference = ga.create_reference_solution(chromosome_length)

for generation in range(num_generations):

    print("Generation : ", generation)

    # Measuring the fitness of each chromosome in the population.

    

    #fitness = ga.cal_pop_fitness(equation_inputs, testnew_population)

    fitness = ga.cal_pop_fitness(xnew_population,ynew_population)

    print("fitness")

    print(fitness)

    f_population=np.concatenate((v_population, fitness), axis=1)

    print("f_population")

    print(f_population)

    #best_outputs.append(numpy.max(numpy.sum(testnew_population*equation_inputs, axis=1)))

    best_outputs.append(np.max(fitness))

    # The best result in the current iteration.

    #print("Best result : ", numpy.max(numpy.sum(testnew_population*equation_inputs, axis=1)))

    print("Best result : ", np.max(fitness))

    # 

    # Selecting the best parents in the population for mating.

    total_fitness=np.sum(fitness)

    print("total_fitness")

    print(total_fitness)

    

    #to caculation orbaally of fitness

    prob_select=fitness/total_fitness

    print("prob_select")

    print(prob_select)

    

    prob_list=ga.get_probability_list(fitness)

    prob_list=np.array(prob_list)

    print("prob_list")

    print(prob_list)

    

    #print("relative_fitness")

    #print(ga.get_probability_list)

    

    parents=ga.roulette_wheel_pop(v_population,prob_list,10)

    parents=np.array(parents)

    print("Parents")

    print(parents)

    #parents = ga.select_mating_pool(v_population, fitness, num_parents_mating)

    # print("Parents")

    #print(parents)

    

    #parents=list[parents]

    parent1=ga.random_pop(parents,10)

    print("Parent1")

    print(parent1)

    parent1=np.array(parent1)

    #parent1=parent1[1][0]

    #print("Parent1")

    #print(parent1)

    

    parents = parents.view([('', parents.dtype)] * parents.shape[1])

    parent1 = parent1.view([('', parent1.dtype)] * parent1.shape[1])

    

    parent=np.setdiff1d(parents,parent1).view(parents.dtype).reshape(-1, parents.shape[1])

    print("Parent")

    print(parent)

    parent2=ga.random_pop(parent,10)

    print("Parent1")

    print(parent1)

    print("Parent2")

    print(parent2)

    parent1=np.array(parent1)

    parent2=np.array(parent2)

    # to binary code

    parent1_bin=ga.trans_binary(parent1)

    parent2_bin=ga.trans_binary(parent2)

    print("Parent1_bin")

    print(parent1_bin)

    print("Parent2_bin")

    print(parent2_bin)

    """

    child=(ga.breed_by_crossover(parent1_bin, parent2_bin))

    chide1=child[0]

    chide2=child[1]

    print("chide1")

    print(chide1)

    print("chide2")

    print(chide2)

    """

    new_population=[0]

    child_1, child_2 = ga.breed_by_crossover(parent1_bin, parent2_bin)

    #x1=' '.join(format(child_1, 'b') for x in bytearray(child_1))

    x1=child_1[0]

    x1=' '.join(format(x, 'b') for x in bytearray(x1))

    x3=child_1[1]

    x3=' '.join(format(x, 'b') for x in bytearray(x3))

    

    x2=child_2[0]

    x2=' '.join(format(x, 'b') for x in bytearray(x2))

    x4=child_2[1]

    x4=' '.join(format(x, 'b') for x in bytearray(x4))

    

    #for i in xrange(k):

    #    print(x1[i])

    child_1=ga.rebinary(x1,x3)

    #child_1.append(ga.rebinary(x3))

    child_2=ga.rebinary(x2,x4)

    #child_2.append(ga.rebinary(x4))

     

    

    #xx1=np.array(xx1)

    #xx3=np.array(xx3)

    #child_1=np.array(child_1)

    #child_2=np.array(child_2)

    print("child_1")

    print(child_1)                                                                   

    print("child_2")

    print(child_2)

    #child_1=np.concatenate(xx1,xx3)

    #child_1 = child_1.view([('', child_1.dtype)] * child_1.shape[1])

    #child_2 = child_2.view([('', child_2.dtype)] * child_2.shape[1])

    #print("child_1")

    #                                                                                                  print(child_1)

    chile_1,chile_2 = ga.breed_by_mutation(child_1,child_2)

    new_population=child_1

    new_population.append(child_2)

    print("new_population")

    print(new_population)

    # Replace the old population with the new one

    New_x1= ga.binaryToDecimal(child_1[:17])

    New_x2= ga.binaryToDecimal(child_1[18:])

    New_y1= ga.binaryToDecimal(child_2[:17])

    New_y2= ga.binaryToDecimal(child_2[18:])

    #New_x1= int(child_1[:18])

    #New_x2= int(child_1[18:])

    #New_y1= int(child_2[:18])

    #New_y2= int(child_2[18:])

    print("New+x1")

    print(New_x1)  

    print("New+x2")

    print(New_x2)  

    print("New_y1")

    print(New_y1) 

    print("New_y2")

    print(New_y2)                                                      

    child_x1=-3.0+New_x1*(12.1-(-3.0))/(2**17)-1

    child_x2=4.1+New_x2*(5.8-4.1)/(2**15)-1

    child_y1=-3.0+New_y1*(12.1-(-3.0))/(2**17)-1

    child_y2=4.1+New_y2*(5.8-4.1)/(2**15)-1

    print("child_x1")

    print(child_x1)  

    print("child_x2")

    print(child_x2)  

    print("child_y1")

    print(child_y1)  

    print("child_y2")

    print(child_y2)  

    child=np.random.ranf(size=(2,2))

   

    child[0,0]=child_x1

    child[0,1]=child_x2

    child[1,0]=child_y1

    child[1,1]=child_y2

       

    print("child")

    print(child)  

   # print("child_2")

   # print(child_2)  

    print("parent")

    print(parent1[0,0])

    parentn=np.random.ranf(size=(2,2))

    x=parent1[0,0]

    parentn[0,0]=x[0]

    parentn[0,1]=x[1]

    x=parent2[0,0]

    parentn[1,0]=x[0]

    parentn[1,1]=x[1]

    

   # parents.append(parent2)

    print("parent")

    print(parentn)

     

   

    new_population=np.array(new_population)

    #next_poulation=ga.randomly_mutate_population(new_population,0.1)

    #print("Next_population")

    #print(next_population)

      

    #new_population[parents.shape[0]:, :] = offspring_mutation

    # Creating the new population based on the parents and offspring.

    print("old_poulation")

    print(v_population)

    random_point = int(np.random.uniform(1, 7, 1))

    v_population[random_point,0] = parentn[0,0]

    v_population[random_point,1] = parentn[0,1]

    v_population[random_point+1,0] = parentn[1,0]

    v_population[random_point+1,1] = parentn[1,1]

    v_population[random_point+2,0] = child[0,0]

    v_population[random_point+2,1] = child[0,1]

    v_population[random_point+3,0] = child[1,0]

    v_population[random_point+3,1] = child[1,1]

    print("new_poulation")

    print(v_population)

   # v_population[parents.shape[0]:, :] = child

    #xnew_population=np.hsplit(v_population, 2, axis=0)

    #ynew_population=np.hsplit(v_population, 2, axis=1)

    num_repat=10

    for i in np.arange(num_repat): 

        xnew_population[i]=v_population[i][0]

        ynew_population[i]=v_population[i][1]

      

# Getting the best solution after iterating finishing all generations.

#At first, the fitness is calculated for each solution in the final generation.

    

    fitness = ga.cal_pop_fitness(xnew_population,ynew_population)

# Then return the index of that solution corresponding to the best fitness.

    best_match_idx = np.where(fitness == np.max(fitness))

    f_population=np.concatenate((v_population, fitness), axis=1)

    best_score=fitness[best_match_idx]

    print("1st generation f_population")

    print(f_population)

    print("Best solution : ", v_population[best_match_idx, :])

    print("Best solution fitness : ", fitness[best_match_idx])

    best_score_progress.append(best_score)

plt.plot(best_score_progress)

plt.xlabel('Generation')

plt.ylabel('Best score (% target)')

plt.show()

如何建構一個好程式

                                                                                               如何建構一個好程式

如何結構一個靈活，健壯和清晰（易於理解和使用）軟件設計是軟體工程師追求的夢。

也許你的同事和你的老闆告訴你幾乎不可能在第一次就做對了。 即使你想這樣做，因需求隨時會發生變化，新的需求會隨之出現，因此隨著時間柚推移，您需要擴展和修改代碼。 因此，每當您發現以您希望的方式更改代碼時很難或很難，在此筆者有幾項方式來建構靈活，健壯和清晰。

建構一個完整的程式代碼，類同創造故事一樣，有引言，大綱，內文及結論。

1)     建構它為開放架構。設計模式和架構技巧來建立系統，從模型建構，類似MVC (Model–View–Controller)或Model control interface來建構程式架構。

2)     建立限制條件。系統中確實存在很多不合理的地方，例如法规限制，程式自我测試條件及硬體條件等。故有不少的這種程式碼，恰恰是為了解決一些特定場景下的問題的。也就是說，所有的規範以及程式設計的原則需打破惯性思維。

3)     程式生命週期。所有讀本及代碼有其生命期，因應需求或相容改變需要改進或重構。重構其意義是，在程式設計的過程中熟悉一些程式碼調整和優化的技巧，簡言之，基礎打牢固，多看點優秀的程式碼，在此推薦一本讀物是”重構模式”。

好的程式設計很少開箱即適用，需通過應用程序生命週期內的一系列轉換和改進而出現的。當然，擁有的經驗越多，就越容易看到死胡同。

從風災及豬舍太陽能板火警來看再生能源宿命

為邁向2025非核家園目標 推動新能源政策，於2016通過的能源政策。民進黨政府其為確保供電短期增加火力機組造成全台空污嚴重。在20%再生能源不切實際政策下，從2019起，全民發現全台灣島內所有可使用土地全部種光電也達不成20%的能源政策。何况現在己找不到大面積土地可以種光電的穷境清况下，必須依懶其它的能源。

20%再生能源其意義是不關光伏或風電，簡言之回到人勝不了天的兒時記憶了。過去看天吃飯，沒有風就沒有風力，離岸風電也須看風場。在國際1KW的太陽能建置費用己跌入500美金之下。大量衝擊國內太陽光伏相關産業。不過台灣現階段建置1KW成本尚需5萬到7萬的建置費用。這中間被通路或整合商上下剝削了很多層。再來台灣颱風季來臨時，風災後總時多少有災情。又不像歐洲大陸少有怪風來破壞光伏設備。

以台灣的天災頻繁來看。應從都市结構來建置分散型電廠， 善用外牆結構體來建置光伏， 應該很適合北部建築密集城市發展暨鼓勵緑建築需貢獻多少比例的自行再生能源發電， 以降低輸配電的缐損來提高能源使用的效率。

能源政策不可能一篇文章就能講清楚， 需幾篇連載才能講清楚說明白。另外現行的太陽光面板其使用年限為20年， 後續如何回收分解再利用是一個新商機。

數位時代的領導力

                                                   數位時代的領導力!!!

麻省理工學院最近進行調查，訪談全球一千多位執行長，結果發現，90％的高階主管認為自家企業正遭受數位商業模式的破壞，但70％認為自己沒有可因應的營運架構。「數位領導力」成為現代執行長迫切需要的能力，而領導人究竟需具備哪些數位能力呢？

所謂數位時代的領導力是為善用數位科技進行公司自理。數位科技使用數位身份，即線上的員工，客戶及關係人即數位化以利企業獲利。數位科技深入人心透過對人性深層心靈層次的理解及副交感神經來提高同仁工作熱情，工作表現，工作品質，工作滿足感及客戶滿意度。

                                        photo from website

筆者建議先從即有的資料Label 化及標準化以利身份數位化。所謂身份數位化即能力，專業分級以利未來數位轉型。透過數位身份辨識串流成未來去中心化和扁平化的數位轉型組織。因應未來也沒有所謂專家獨大而是各自專業分工透過資料滙流以利判斷作決策。領導是3份靠天份其它靠學習，重點要身體力行的同理心管理，Otherwise, 就是豬頭管理。

依據MIT長期追蹤400家企業、最慘的事實是沒有數位化、又缺乏領導力的企業『豬頭企業』，與所謂數位化與領導兼強的『數位菁英』企業相比，前者獲利落後對手24％，幾乎可以確認，這群『豬頭企業』將是最快被市場淘汰的一群。面對未來數位科技的商業模式,必須用三維空間來學習全方位思維。

註1:  豬頭企業就是管理者把公司視為豬場經營的一種異術 。

穩私權

           

                                           小人物的穩私權

近來手機拍照太方便了, 一個閃失你的手機就侵犯別人穩私權。如何保障你的肖像權應該仿歐美先進國家立法禁止數位相機及手機拍照是消音。必須強制其音效以警惕使用者避免隨時侵犯個人隱私。

                                         photo from   https://www.walkingphotographer.net/street-photography-milanowebsite

    /應強制音效/

        // In fact, in many places (most of Europe, Japan, parts of US, etc.) it's illegal to disable the shutter sound

        /*

        try {

            CameraFeatures.canDisableShutterSound = ci.canDisableShutterSound;

        }catch(NoSuchFieldError ex) {

            CameraFeatures.canDisableShutterSound = false;

        }

        */

        

個人隱私定義:

凡是關於個人的任何相關資料，自己能掌握並且不受到侵犯的權利，即為隱私權。

人權宣言第12條:任何人的私生活、家庭、住宅和通信不得任意干涉，他的榮譽和名譽不得加以攻擊。人人有權享受法律保護，以免受這種干涉或攻擊。

隱私權的內容

●為商業利益使用他人的姓名或肖像

●侵犯私人的財產，土地，干擾私人生活的寧靜

●公佈私人隱私資料使人困窘

●發佈某人的錯誤信息，把當事人以錯誤的形象呈現在大眾面前

發財術

    豬年發財術

在多年企導生涯過程中常被年輕學子問到，如何快速累積財富於半百來臨前退休。

如果想要快速累積財富，唯一的就是從商， 三百六十五行業，行行出狀元膽看你的膽識及企圖心。新創事業成功率為仟分之五遠大於中樂透的機率。

photo  from  website 

從商者要有夢想，從夢想發啟，富有想像不等同天馬行空，在明確的目標下儘情發揮想像力 ，筆者就成功的從商者特質整理如下 :

1: 做常人之不敢做的事，如Tesla 的Elon Musk。

2: 有勇氣走出第一步，這一步不關失敗或成功己是從商的分水嶺。

3: 比週邊人要拼，愛拼才知行不行。

4: 不冒險就是最大的冒險。

5: 害怕失敗，就等于拒绝成功。

6: 要想知道成功的味道，就要親口動手做,切忌纸上用兵。

後記: 筆者年少靠專利確實賺了第一桶金 ，後來創業因本人自知不善於經營故藉價格好是出脫所有股份。
後來有一段投入資本市場。在房市頗有收獲。重點就是入手價格要合乎投資報酬率。