這個月的8號、9號，個人很榮幸參加了China.NET Conf 2019 , 中國.NET開發者峰會，同時分享了技術專題《.NET技術架構下的混沌工程實踐》，給廣大的.NET開發小夥伴介紹混沌工程和高可用性改造實踐。會後大傢伙聚餐的時候，陳計節老師建議大家將各自的議題分享到社區，分享給大家。因此，今天和大家分享我的技術專題《.NET技術架構下的混沌工程實踐》。

先放幾張大會照片：

整個專題主要分為四個部分：

1. .NET分佈式、微服務架構下的高可用性挑戰
2. 混沌工程簡介
3. .NET混沌工程的實踐和成果分享
4. 展望和規劃

一、.NET分佈式、微服務架構下的高可用性挑戰

目前，我們特來電的技術架構是分佈式、微服務化的，線上超過1000台Server，高可用保障壓力很大：

• 系統7*24小時運行，不允許宕機，一旦宕機出問題，直接影響全國人民出行；
• 系統SLA要求99.95% ，全年可宕機時間只有4.38小時；
• 服務調用鏈路越來越長，依賴越來越複雜，某個環節出問題，都有肯能導致服務雪崩、大規模宕機；
• 線上遭遇：網絡抖動、內存泄露、線程阻塞、CPU被打爆、 數據庫被打爆、中間件宕機等棘手問題；
• 每天上百次發布更新，系統高可用性保障壓力非常大；

一張全鏈路監控圖可以反映我們系統的複雜：

 

例如主機CPU被打爆的問題，線上經常會遇到：

經歷了線上各種高可用性問題后，我們做了很多反思和總結：

系統在實現了分佈式、微服務化之後，我們到底有多少把握來保證系統的正常運行？  

如果出現問題，整個分佈式系統會變得非常“混亂”，甚至會引發系統的大規模宕機。

因此，我們有必要在線上事故出現之前，提前識別出系統有哪些弱點和問題，統一管控系統的固有混沌。

這套管控系統固有混沌的方法和體系，就是我們今天要介紹的主角：混沌工程。

二、混沌工程簡介

1. 什麼是混沌工程？

通過受控的實驗，掌握系統運行行為的過程，稱為混沌工程。

    混沌工程的典型實踐：Chaos Monkey
     一隻搗亂的猴子，在你的系統裏面上蹦下竄，不停搗亂，直到搞掛你的系統。

    

2. 為什麼需要混沌工程？

   混沌工程可以提升整個系統的彈性。
   通過混沌實驗，可以發現系統脆弱的一面，主動發現這些問題，並解決這些問題。

3. 混沌工程怎麼做？

   混沌工程的一般實施步驟：

1 選擇系統正常運行狀態下的可度量指標，作為基準的“穩定狀態” 2 混沌實驗分為實驗組和對照組，都能保持系統的“穩定狀態” 3 對實驗組注入混沌事件，如服務不可用、中間件宕機等混沌事件 4 比較實驗組和對照組“穩定狀態”的差異

   如果混沌實驗前後系統的“穩定狀態”一致，則可以認為系統應對這種混沌事件是彈性的、高可用的。
   相反的，如果打破了系統的穩定狀態，我們就找到了一個系統弱點，然後盡可能地解決它，提升系統的高可用性。

4. 實施混沌工程的推薦原則

• 明確系統穩定運行的狀態（指標）
• 混沌事件必須是現實世界可能發生的（合理的）
• 在生產環境進行混沌實驗 ：生產環境可以真實地反映系統的穩定性
• 持續集成：線上應用每天都在更新，通過持續集成的方式可以不斷髮現問題、解決問題。
• 最小化影響範圍：線上進行混沌實驗，必須可控，必須確定混沌實驗的最小化影響範圍。

   這裏大家會問：在生產環境上搞混沌實驗，能行嗎？

5. 現實中的混沌工程

  生產環境必須以穩定為前提，因此推薦O2O模式的混沌實驗：即線下演練、線上驗證
  在系統未經過大規模高可用性改造之前，建議首先進行全面的線下演練：

   

   那麼, .NET技術架構下的混沌工程怎麼做？

三、.NET混沌工程的實踐和成果分享

  我們線上系統主要用到了以下.NET技術棧和開源技術：

• ASP.NET MVC
• 基於ASP.NET Core的Web運行框架-WRF
• 基於ASP.NET Web API的分佈式服務網關-SG
• 基於.NET RPC通訊技術的分佈式微服務平台-HSF
• 基於RabbitMQ和Kafka的消息應用中心-MAC
• iBatis.NET & Entity Framework
• RabbitMQ & RabbitMQ Client for .NET
• Kafka & Confluent.Kafka
• Redis
• Nginx
• …

    在上述.NET 技術架構下，我們梳理了大量的混沌工程事件：

    

    

    

     通過大量的混沌實驗，我們逐步建立了提升系統高可用性的方法論和體系：

     

     .NET技術架構下的高可用性改進-依賴治理、容錯降級     

      業務場景：
      隨着業務複雜度的上升，服務調用鏈路越來越長，鏈路上存在大量不可控的因素：      

• • 網絡抖動，導致服務異常
  • Redis、MQ、DB等中間件不可用，導致服務超時、異常
  • 依賴的服務不可用，直接影響服務調用方  

          

     如何應對：識彆強弱依賴，對弱依賴進行降級，對強依賴有限降級     

• • “用戶有感知” 是強依賴
  • “用戶無感知” 是弱依賴
  • 故障發生時，核心業務有損失的是強依賴，無損失的是弱依賴

           

      .NET技術架構下的高可用性改進-解耦/隔離       

      業務場景：
      核心業務的調用鏈路很長，整個鏈路上包含主流程和輔流程
      輔流程的重要性低，不能因為輔流程的不可用，影響了主流程。

      

       如何應對：

       

       .NET技術架構下的高可用性改進-超時治理        

       業務場景：
       對於服務超時，長時間等待會影響用戶體驗，併發大時還可能造成線程池被打爆。
       同時可能產生服務級聯反應，導致大範圍服務雪崩。

              

        應對方案：
        超時時間設置：服務剛上線時，可以根據壓測情況預估一個值；
        服務上線后再根據實際監控進行修改，比如設置99%的請求響應時間為超時時間。
        超時后的處理策略：
        如果不是核心服務，可直接超時返回失敗。
        如果是核心服務，可以設置相應的重試次數.         

        示例：
        配置服務超時時間
        設置Http請求超時時間
        設置數據庫連接超時、SQL執行超時
        代碼控制超時時間（例如：Polly的Timeout策略）

      .NET技術架構下的高可用性改進-重試補償         

        業務場景：
        實際線上應用中，假如遇到網絡抖動、發布重啟、數據庫阻塞超時等情況，都有可能引起服務調用失敗。         

        應對方案：
        通過失敗重試、異常后的補償，盡可能地保證業務可用。
        重試情況下：業務要保證冪等性、保證最終一致性。        

        示例：
        服務失敗重試策略
        消息發送、消費失敗重試、補償
        代碼層面失敗重試補償（例如：Polly的Retry策略）

      高可用改進還有很多技巧，這裏不一一詳細給大家贅述了。

      通過對系統進行全面的高可用性改進，提升了我們對線上系統的信心！

四、 展望和規劃

    2019年，我們啟動了混沌工程實踐，逐步建立了混沌工程的自有方法論和體系，通過近一年的混沌工程實踐，混沌工程文化逐漸被開發團隊所認可。目前，混沌工程已經逐步過渡到線上生產環境進行（這來自於足夠的信心和把握）。但這隻是一個起步，未來：

• 正式的混沌工程團隊：通過多團隊配合、保障資源的持續投入
• 覆蓋所有的關鍵核心應用：讓混沌工程深入到每個產品
• 堅持O2O混沌工程實踐：線下演練、線上驗證，更可控
• 混沌事件注入工具：ChaosBlade for .NET，工具讓混沌工程更高效
• 持續的混沌實驗：持續進行、持續改進

    目標：通過混沌工程揭示問題、解決問題、形成閉環，不斷提升系統高可用性。

以上是本次China.NET Conf 2019的技術專題，分享給大家。

 

周國慶

2019/11/15

 

 

 本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

Magicodes.Pay，打造開箱即用的統一支付庫，已提供ABP模塊封裝

簡介

Magicodes.Pay，是心萊科技團隊提供的統一支付庫，相關庫均使用.NET標準庫編寫，支持.NET Framework以及.NET Core。目前已提供Abp模塊的封裝，支持開箱即用。

Nuget

新的包

 

 

已棄用的包，不再更新

 

 

主要功能

Magicodes.Pay，是心萊科技團隊提供的統一支付庫，相關庫均使用.NET標準庫編寫，支持.NET Framework以及.NET Core。目前已提供Abp模塊的封裝，支持開箱即用。目前支持以下支付方式和功能：

• 支付寶支付

• APP支付

• Wap支付

• 支付寶國際支付

• 支持分賬

• 微信支付

• 小程序支付

• APP支付

• 訂單查詢

• 企業付款（提現）

• 退款申請

• 普通紅包

• 通聯支付

• 小程序支付

• 統一支付回調處理

• 支持日誌函數注入（不依賴支付庫）

• 支持支付配置函數注入，以便於支持自定義配置獲取邏輯，以應用於不同的場景（比如從配置文件、用戶設置獲取配置，或者多租戶支持）

• 針對ABP提供模塊封裝，添加模塊依賴即可立即使用。主要包括：

• 支付渠道註冊（IPaymentRegister）

• 支付回調邏輯處理（IPaymentCallbackAction）

• 統一支付服務實現（IToPayService）

• 統一支付服務封裝（見IPayAppService）

• 支付管理器封裝（IPaymentManager），包含：

• 交易日誌封裝，自動記錄客戶端信息以及自動異常處理和記錄

• 僅需編寫一次回調邏輯，即可支持多個支付渠道

• 業務參數支持更大長度（500）

開始使用

如果使用Abp相關模塊，則使用起來比較簡單，具體您可以參考相關單元測試的編寫。主要有以下步驟：

1. 引用對應的Abp支付的Nuget包 如果僅需某個支付，僅需引用該支付的包。下面以通聯支付為例，我們需要在工程中引用此包：

2. 添加模塊依賴 在對應工程的Abp的模塊（AbpModule）中，添加對“AbpAllinpayModule”的依賴，如：

 [DependsOn(typeof(AbpAllinpayModule))]

1. 在DbContext中添加名為“TransactionLogs”的DbSet 整個支付過程中（無論是支付成功還是出現異常），均會記錄交易日誌。交易日誌會記錄交易過程中的一些信息，比如客戶端信息、交易參數、自定義參數以及異常信息。因此我們需要針對EF添加對TransactionLog的支持。需要在DbContext中添加的完整代碼如下所示：

public DbSet<TransactionLog> TransactionLogs { get; set; }

1. 註冊回調邏輯 我們需要實現“IPaymentCallbackAction”接口來編寫自定義的回調邏輯。如以下示例所示：

public class TestPaymentCallbackAction : IPaymentCallbackAction
    {
        /// <summary>
        /// 業務Key
        /// </summary>
        public string Key { get; set; } = "繳費支付";

        /// <summary>
        /// 執行回調
        /// </summary>
        /// <returns></returns>
        public async Task Process(IUnitOfWorkManager unitOfWork, TransactionLog transactionLog)
        {
            var data = transactionLog.CustomData.FromJsonString<JObject>();
            //業務處理

            await Task.FromResult(0);
        }
    }

注意Key不要重複。

1. 向容器中註冊回調邏輯

我們可以將回調邏輯寫在一個公共的程序集，然後使用以下代碼進行註冊：

 IocManager.IocContainer.Register(
                //註冊自定義支付回調邏輯
                Classes.FromAssembly(typeof(ApplicationCoreModule).GetAssembly())
                    .BasedOn<IPaymentCallbackAction>()
                    .LifestyleTransient()
                    .Configure(component => component.Named(component.Implementation.FullName))
                    .WithServiceFromInterface()
            );

除了上面的方式，我們還可以通過注入IPaymentManager對象，通過其RegisterCallbackAction方法來註冊自定義的回調邏輯。

1. 發起支付

通過容器獲得IPayAppService，然後調用Pay方法即可。也可以自行封裝：

public async Task<object> Payment(PaymentInput input)
        {
            return await _payAppService.Pay(new PayInputBase()
            {
                Body = $"{input.Name} {input.ChargeProjectName}",
                CustomData = input.ToJsonString(),
                Key = "繳費支付",
                OpenId = input.OpenId,
                Subject = input.ChargeProjectName,
                TotalAmount = input.Amount,
                PayChannel = input.PayChannel
            });
        }

通過IPayAppService統一支付有如下好處：

• 統一支付（無論支付寶還是微信各種端的支付，均可統一）

• 自動記錄交易日誌以及進行相關邏輯處理

• 自定義數據依賴交易日誌進行存儲，而不依賴支付渠道，因此支持無業務參數的支付渠道，也支持存儲更多自定義數據

非ABP集成

請參考Abp相關模塊的封裝或者歷史代碼。

官方訂閱號

關注“麥扣聊技術”訂閱號免費獲取：

• 最新文章、教程、文檔

• 視頻教程

• 基礎版免費授權

• 模板

• 解決方案

• 編程心得和理念

官方博客/文檔站

其他開源庫地址

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

參考資料(要是對於本文的理解不夠透徹，必須將以下博客認知閱讀，方可全面了解決策樹)：

1.

2.

3.

決策樹是一個非常常見並且優秀的機器學習算法，它易於理解、可解釋性強，其可作為分類算法，也可用於回歸模型。本文將分三篇介紹決策樹，第一篇介紹基本樹（包括 ID3、C4.5、CART），第二篇介紹 Random Forest、Adaboost、GBDT，第三篇介紹 Xgboost 和 LightGBM。

在進入正題之前，先讓我們了解一些有關信息論的知識！

信息論

1.信息熵

在決策樹算法中，熵是一個非常非常重要的概念。一件事發生的概率越小，我們說它所蘊含的信息量越大。比如：我們聽女人能懷孕不奇怪，如果某天聽到哪個男人懷孕了，我們就會覺得emmm…信息量很大了。

所以我們這樣衡量信息量：

 

 其中，P(y)是事件發生的概率。信息熵就是所有可能發生的事件的信息量的期望：

表達了Y事件發生的不確定度。

決策樹屬性劃分算法

眾所周知，決策樹學習的關鍵在於如何選擇最優劃分屬性，一般而言，隨着劃分過程不斷進行，我們希望決策樹的分支結點所包含的樣本盡可能屬於同一類別，即結點的“純度”越來越高。

1.ID3

(1)思想

從信息論的知識中我們知道：信息熵越大，從而樣本純度越低，。ID3 算法的核心思想就是以信息增益來度量特徵選擇，選擇信息增益最大的特徵進行分裂。算法採用自頂向下的貪婪搜索遍歷可能的決策樹空間（C4.5 也是貪婪搜索）。

(2)劃分標準(詳細過程以及公式推導見西瓜書即可)

ID3算法使用信息增益為準則來選擇劃分屬性，“信息熵”(information entropy)是度量樣本結合純度的常用指標，假定當前樣本集合D中第k類樣本所佔比例為pk，則樣本集合D的信息熵定義為：

假定通過屬性劃分樣本集D，產生了V個分支節點，v表示其中第v個分支節點，易知：分支節點包含的樣本數越多，表示該分支節點的影響力越大。故可以計算出劃分后相比原始數據集D獲得的“信息增益”（information gain）。

信息增益越大，表示使用該屬性劃分樣本集D的效果越好，因此ID3算法在遞歸過程中，每次選擇最大信息增益的屬性作為當前的劃分屬性。

(3)缺點

• ID3 沒有剪枝策略，容易過擬合；
• 信息增益準則對可取值數目較多的特徵有所偏好，類似“編號”的特徵其信息增益接近於 1；
• 只能用於處理離散分佈的特徵；
• 沒有考慮缺失值。

 

2. C4.5

2.1 思想

C4.5 算法最大的特點是克服了 ID3 對特徵數目的偏重這一缺點，引入信息增益率來作為分類標準。

C4.5 相對於 ID3 的缺點對應有以下改進方式：

• 引入悲觀剪枝策略進行后剪枝；
• 引入信息增益率作為劃分標準；
• 可以處理連續值：將連續特徵離散化，假設 n 個樣本的連續特徵 A 有 m 個取值，C4.5 將其排序並取相鄰兩樣本值的平均數共 m-1 個劃分點，分別計算以該劃分點作為二元分類點時的信息增益，並選擇信息增益最大的點作為該連續特徵的二元離散分類點；
• 可以處理缺失值：對於缺失值的處理可以分為兩個子問題：
• 問題一：在特徵值缺失的情況下進行劃分特徵的選擇？（即如何計算特徵的信息增益率）
• 問題二：選定該劃分特徵，對於缺失該特徵值的樣本如何處理？（即到底把這個樣本劃分到哪個結點里）
• 針對問題一，C4.5 的做法是：對於具有缺失值特徵，用沒有缺失的樣本子集所佔比重來折算；
• 針對問題二，C4.5 的做法是：將樣本同時劃分到所有子節點，不過要調整樣本的權重值，其實也就是以不同概率劃分到不同節點中。

2.2 劃分標準

利用信息增益率可以克服信息增益的缺點，其公式為：

 

注意：信息增益率對可取值較少的特徵有所偏好（分母越小，整體越大），因此 C4.5 並不是直接用增益率最大的特徵進行劃分，而是使用一個啟髮式方法：先從候選劃分特徵中找到信息增益高於平均值的特徵，再從中選擇增益率最高的。

2.3 剪枝策略(預剪枝+后剪枝)

決策樹解決過擬合的主要方法：剪枝、隨機森林

2.3.1 預剪枝

(1) 在決策樹生成過程中，對每個結點在劃分前先進行估計，若當前結點的劃分不能帶來決策樹泛化性能提升，則停止劃分並將當前結點標記為恭弘=叶 恭弘結點。在構造的過程中先評估，再考慮是否分支。衡量決策樹泛化性能提升的方法：

• 節點內數據樣本低於某一閾值；
• 所有節點特徵都已分裂；
• 節點劃分前準確率比劃分后準確率高。

(2)優缺點

• 降低過擬合風險、顯著減少決策樹的訓練時間開銷和測試時間開銷。
• 預剪枝基於“貪心”策略，有可能會帶來欠擬合風險。

2.3.2 后剪枝(C4.5採用的是基於后剪枝的悲觀剪枝方法)

(1) 后剪枝是先從訓練集生成一棵完整的決策樹，然後自底向上地對非恭弘=叶 恭弘子結點進行考察，若將該結點對應的子樹替換為恭弘=叶 恭弘結點能帶來決策樹泛化性能提升，則將該子樹替換為恭弘=叶 恭弘結點。

(2) 后剪枝決策樹的欠擬合風險很小，泛化性能往往優於預剪枝決策樹。但同時其訓練時間會大的多。

2.4 缺點

• 剪枝策略可以再優化；
• C4.5 用的是多叉樹，用二叉樹效率更高；
• C4.5 只能用於分類；
• C4.5 使用的熵模型擁有大量耗時的對數運算，連續值還有排序運算；
• C4.5 在構造樹的過程中，對數值屬性值需要按照其大小進行排序，從中選擇一個分割點，所以只適合於能夠駐留於內存的數據集，當訓練集大得無法在內存容納時，程序無法運行。

 

3. CRAT

ID3 和 C4.5 雖然在對訓練樣本集的學習中可以盡可能多地挖掘信息，但是其生成的決策樹分支、規模都比較大，CART 算法的二分法可以簡化決策樹的規模，提高生成決策樹的效率。

Cart算法的兩個主要步驟為：(1)將樣本遞歸劃分進行建樹過程 ; (2)用驗證數據進行剪枝.

3.1 思想

CART 在 C4.5 的基礎上進行了很多提升。

• C4.5 為多叉樹，運算速度慢，CART 為二叉樹，運算速度快；
• C4.5 只能分類，CART 既可以分類也可以回歸；
• CART 使用 Gini 係數作為變量的不純度量，減少了大量的對數運算；
• CART 採用代理測試來估計缺失值，而 C4.5 以不同概率劃分到不同節點中；
• CART 採用“基於代價複雜度剪枝”方法進行剪枝，而 C4.5 採用悲觀剪枝方法。

3.2 劃分標準(Cart分類樹、Cart回歸樹)

首先我們來看看Cart分類樹！

CART決策樹(分類樹)使用“基尼指數”（Gini index）來選擇劃分屬性，基尼指數反映的是從樣本集D中隨機抽取兩個樣本，其類別標記不一致的概率，因此Gini(D)越小越好，這和信息增益（率）正好相反，基尼指數定義如下：

進而，使用屬性α劃分后的基尼指數為：

 

接下來讓我們通過一個實例，從實例中去了解如何創建一棵Cart分類樹。 如下圖所示

在上述圖中，共10條數據，屬性有3個，分別是有房情況(離散屬性且2種取值)，婚姻狀況(離散屬性且有3種取值)和年收入(連續屬性)，拖欠貸款者屬於分類的結果。

對於離散屬性(2種取值與多種取值)和連續屬性我們該如何進行Gini係數的計算以及劃分呢？

1.首先來看有房情況這個屬性，因為該屬性只有“是”“否”兩種取值，所以其Gini係數比較容易計算，那麼按照它劃分后的Gini指數計算如下：

 

 2.接下來對婚姻狀況進行計算，我們發現婚姻狀況一共有三種取值：單身、已婚、離異，又因為Cart分類樹只能是二叉樹，所以我們只能對多種取值的屬性進行組合：

 

 3.最後對年收入屬性進行計算。年收入屬性為連續值，Cart分類樹又是如何對連續值屬性進行處理的呢？(Cart分類樹對於連續值的處理其實和C4.5算法對於連續值的處理類似，只不過Cart使用Gini指數，C4.5使用信息增益率)

將連續特徵離散化，假設 n 個樣本的連續特徵 A 有 m 個取值，C4.5/Cart 將其排序並取相鄰兩樣本值的平均數共 m-1 個劃分點，分別計算以該劃分點作為二元分類點時的信息增益/Gini係數，並選擇信息增益最大/Gini係數最小的點作為該連續特徵的二元離散分類點；

通過計算我們可以發現，(單身或離異，已婚) 和 (<=97,>97)這種劃分其Gini係數最小(假設我們選擇年收入)。所以根節點分裂為兩個子節點，其中一個為恭弘=叶 恭弘子結點。對於另外一個結點我們繼續使用上述方法在婚姻狀況、有房情況中選擇最佳特徵以及最佳切分點，反覆循環直到滿足條件為止。

 接下來讓我們看看Cart回歸樹(最小二乘回歸樹)

眾所周知，決策樹學習的關鍵在於如何選擇最優劃分屬性，然而對於Cart回歸樹而言，還有一個重要的問題就是：如何決定樹中恭弘=叶 恭弘節點的輸出值？

回歸樹的模型可以表示如下：

上式中，  為對應恭弘=叶 恭弘子節點的輸出值，  為指示函數，當x屬於  時，值為1，否則為0。

回歸樹的建立過程，優化策略或損失函數為最小化平方誤差，即最小化下式：

 

（1）問題1：怎樣對輸入空間進行劃分？即如何選擇劃分點？

CART回歸樹的建樹過程是二分裂節點，並且保證分裂的結果符合最小化平方誤差，這裏採用了比較暴力的遍曆法，即遍歷所有特徵j和每個特徵的多個閾值s，以平方誤差最小的組合作為分裂依據，數學描述如下：

 
上式中，R為以s為分割點分割的左右子樹樣本合集，c為該集合的均值。

確定了j，s后，就可以就行分裂了，將樹分裂為左右兩個區域：

（2）問題2：如何決定樹中恭弘=叶 恭弘節點的輸出值？

分裂完畢以後，要確定每個恭弘=叶 恭弘子結點的輸出值，使用類別均值：

接下來讓我們通過一個實例，從實例中去了解如何創建一棵Cart回歸樹。 如下圖所示

3.3 剪枝策略(簡略版本，具體推導見李航 統計學習方法)

採用一種“基於代價複雜度的剪枝”方法進行后剪枝，這種方法會生成一系列樹，每個樹都是通過將前面的樹的某個或某些子樹替換成一個恭弘=叶 恭弘節點而得到的，這一系列樹中的最後一棵樹僅含一個用來預測類別的恭弘=叶 恭弘節點。然後用一種成本複雜度的度量準則來判斷哪棵子樹應該被一個預測類別值的恭弘=叶 恭弘節點所代替。這種方法需要使用一個單獨的測試數據集來評估所有的樹，根據它們在測試數據集熵的分類性能選出最佳的樹。

3.4類別不平衡

CART 的一大優勢在於：無論訓練數據集有多失衡，它都可以將其消除不需要建模人員採取其他操作。

CART 使用了一種先驗機制，其作用相當於對類別進行加權。這種先驗機制嵌入於 CART 算法判斷分裂優劣的運算里，在 CART 默認的分類模式中，總是要計算每個節點關於根節點的類別頻率的比值，這就相當於對數據自動重加權，對類別進行均衡。

4.總結

最後通過總結的方式對比下 ID3、C4.5 和 CART 三者之間的差異。

除了之前列出來的劃分標準、剪枝策略、連續值確實值處理方式等之外，我再介紹一些其他差異：

• 劃分標準的差異：ID3 使用信息增益偏向特徵值多的特徵，C4.5 使用信息增益率克服信息增益的缺點，偏向於特徵值小的特徵，CART 使用基尼指數克服 C4.5 需要求 log 的巨大計算量，偏向於特徵值較多的特徵。
• 使用場景的差異：ID3 和 C4.5 都只能用於分類問題，CART 可以用於分類和回歸問題；ID3 和 C4.5 是多叉樹，速度較慢，CART 是二叉樹，計算速度很快；
• 樣本數據的差異：ID3 只能處理離散數據且缺失值敏感，C4.5 和 CART 可以處理連續性數據且有多種方式處理缺失值；從樣本量考慮的話，小樣本建議 C4.5、大樣本建議 CART。C4.5 處理過程中需對數據集進行多次掃描排序，處理成本耗時較高，而 CART 本身是一種大樣本的統計方法，小樣本處理下泛化誤差較大 ；
• 樣本特徵的差異：ID3 和 C4.5 層級之間只使用一次特徵，CART 可多次重複使用特徵；
• 剪枝策略的差異：ID3 沒有剪枝策略，C4.5 是通過悲觀剪枝策略來修正樹的準確性，而 CART 是通過代價複雜度剪枝

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

如果Pandas只是能把一些數據變成 dataframe 這樣優美的格式，那麼Pandas絕不會成為叱吒風雲的數據分析中心組件。因為在數據分析過程中，描述數據是通過一些列的統計指標實現的，分析結果也需要由具體的分組行為，對各組橫向縱向對比。

GroupBy 就是這樣的一個有力武器。事實上，SQL語言在Pandas出現的幾十年前就成為了高級數據分析人員的標準工具，很大一部分原因正是因為它有標準的SELECT xx FROM xx WHERE condition GROUP BY xx HAVING condition 範式。

感謝 Wes Mckinney及其團隊，除了SQL之外，我們多了一個更靈活、適應性更強的工具，而非困在SQL Shell或Python里步履沉重。

【示例】將一段SQL語句用Pandas表達

SQL

SELECT Column1, Column2, mean(Column3), sum(Column4)
FROM SomeTable
WHERE Condition 1
GROUP BY Column1, Column2
HAVING Condition2

Pandas

df [Condition1].groupby([Column1, Column2], as_index=False).agg({Column3: “mean”, Column4: “sum”}).filter(Condition2)

Group By: split – apply – combine

GroupBy可以分解為三個步驟：

• Splitting: 把數據按主鍵劃分為很多個小組
• Applying: 對每個小組獨立地使用函數
• Combining: 把所得到的結果組合

那麼，這一套行雲流水的動作是如何完成的呢？

• Splitting 由 groupby 實現
• Applying 由 agg、apply、transform、filter實現具體的操作
• Combining 由 concat 等實現

其中，在apply這一步，通常由以下四類操作：

• Aggregation:做一些統計性的計算
• Apply：做一些數據轉換
• Transformation:做一些數據處理方面的變換
• Filtration:做一些組級別的過濾

注意，這裏討論的apply,agg,transform,filter方法都是限制在 pandas.core.groupby.DataFrameGroupBy裏面，不能跟 pandas.core.groupby.DataFrame混淆。

先導入需要用到的模塊

import numpy as np
import pandas as pd
import sys, traceback
from itertools import chain

Part 1: Groupby 詳解

df_0 = pd.DataFrame({'A': list(chain(*[['foo', 'bar']*4])),
                     'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                     'C': np.random.randn(8),
                     'D': np.random.randn(8)})

df_0

	A	B	C	D
0	foo	one	1.145852	0.210586
1	bar	one	-1.343518	-2.064735
2	foo	two	0.544624	1.125505
3	bar	three	1.090288	-0.296160
4	foo	two	-1.854274	1.348597
5	bar	two	-0.246072	-0.598949
6	foo	one	0.348484	0.429300
7	bar	three	1.477379	0.917027

Talk 1：創建一個Groupby對象時應注意的問題

Good Practice

df_01 = df_0.copy()
df_01.groupby(["A", "B"], as_index=False, sort=False).agg({"C": "sum", "D": "mean"})

	A	B	C	D
0	foo	one	1.494336	0.319943
1	bar	one	-1.343518	-2.064735
2	foo	two	-1.309649	1.237051
3	bar	three	2.567667	0.310433
4	bar	two	-0.246072	-0.598949

Poor Practice

df_02 = df_0.copy()
df_02.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"}).reset_index()

	A	B	C	D
0	bar	one	-1.343518	-2.064735
1	bar	three	2.567667	0.310433
2	bar	two	-0.246072	-0.598949
3	foo	one	1.494336	0.319943
4	foo	two	-1.309649	1.237051

• 直接使用 as_index=False 參數是一個好的習慣，因為如果dataframe非常巨大（比如達到GB以上規模）時，先生成一個Groupby對象，然後再調用reset_index()會有額外的時間消耗。
• 在任何涉及數據的操作中，排序都是非常”奢侈的”。如果只是單純的分組，不關心順序，在創建Groupby對象的時候應當關閉排序功能，因為這個功能默認是開啟的。尤其當你在較大的大數據集上作業時更當注意這個問題。
• 值得注意的是：groupby會按照數據在原始數據框內的順序安排它們在每個新組內的順序。這與是否指定排序無關。

如果要得到一個多層索引的數據框，使用默認的as_index=True即可，例如下面的例子：

df_03 = df_0.copy()
df_03.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"})

		C	D
A	B
bar	one	-1.343518	-2.064735
	three	2.567667	0.310433
	two	-0.246072	-0.598949
foo	one	1.494336	0.319943
	two	-1.309649	1.237051

注意，as_index僅當做aggregation操作時有效，如果是其他操作，例如transform，指定這個參數是無效的

df_04 = df_0.copy()
df_04.groupby(["A", "B"], as_index=True).transform(lambda x: x * x)

	C	D
0	1.312976	0.044347
1	1.805040	4.263130
2	0.296616	1.266761
3	1.188727	0.087711
4	3.438331	1.818714
5	0.060552	0.358740
6	0.121441	0.184298
7	2.182650	0.840938

可以看到，我們得到了一個和df_0一樣長度的新dataframe，同時我們還希望A,B能成為索引，但這並沒有生效。

Talk 2：使用 pd.Grouper

pd.Grouper 比 groupby更強大、更靈活，它不僅支持普通的分組，還支持按照時間進行升採樣或降採樣分組

df_1 = pd.read_excel("dataset\sample-salesv3.xlsx")
df_1["date"] = pd.to_datetime(df_1["date"])

df_1.head()

	account number	name	sku	quantity	unit price	ext price	date
0	740150	Barton LLC	B1-20000	39	86.69	3380.91	2014-01-01 07:21:51
1	714466	Trantow-Barrows	S2-77896	-1	63.16	-63.16	2014-01-01 10:00:47
2	218895	Kulas Inc	B1-69924	23	90.70	2086.10	2014-01-01 13:24:58
3	307599	Kassulke, Ondricka and Metz	S1-65481	41	21.05	863.05	2014-01-01 15:05:22
4	412290	Jerde-Hilpert	S2-34077	6	83.21	499.26	2014-01-01 23:26:55

【例子】計算每個月的ext price總和

df_1.set_index("date").resample("M")["ext price"].sum()

date
2014-01-31    185361.66
2014-02-28    146211.62
2014-03-31    203921.38
2014-04-30    174574.11
2014-05-31    165418.55
2014-06-30    174089.33
2014-07-31    191662.11
2014-08-31    153778.59
2014-09-30    168443.17
2014-10-31    171495.32
2014-11-30    119961.22
2014-12-31    163867.26
Freq: M, Name: ext price, dtype: float64

df_1.groupby(pd.Grouper(key="date", freq="M"))["ext price"].sum()

date
2014-01-31    185361.66
2014-02-28    146211.62
2014-03-31    203921.38
2014-04-30    174574.11
2014-05-31    165418.55
2014-06-30    174089.33
2014-07-31    191662.11
2014-08-31    153778.59
2014-09-30    168443.17
2014-10-31    171495.32
2014-11-30    119961.22
2014-12-31    163867.26
Freq: M, Name: ext price, dtype: float64

兩種寫法都得到了相同的結果，並且看上去第二種寫法似乎有點兒難以理解。再看一個例子

【例子】計算每個客戶每個月的ext price總和

df_1.set_index("date").groupby("name")["ext price"].resample("M").sum().head(20)

name                             date      
Barton LLC                       2014-01-31     6177.57
                                 2014-02-28    12218.03
                                 2014-03-31     3513.53
                                 2014-04-30    11474.20
                                 2014-05-31    10220.17
                                 2014-06-30    10463.73
                                 2014-07-31     6750.48
                                 2014-08-31    17541.46
                                 2014-09-30    14053.61
                                 2014-10-31     9351.68
                                 2014-11-30     4901.14
                                 2014-12-31     2772.90
Cronin, Oberbrunner and Spencer  2014-01-31     1141.75
                                 2014-02-28    13976.26
                                 2014-03-31    11691.62
                                 2014-04-30     3685.44
                                 2014-05-31     6760.11
                                 2014-06-30     5379.67
                                 2014-07-31     6020.30
                                 2014-08-31     5399.58
Name: ext price, dtype: float64

df_1.groupby(["name", pd.Grouper(key="date",freq="M")])["ext price"].sum().head(20)

name                             date      
Barton LLC                       2014-01-31     6177.57
                                 2014-02-28    12218.03
                                 2014-03-31     3513.53
                                 2014-04-30    11474.20
                                 2014-05-31    10220.17
                                 2014-06-30    10463.73
                                 2014-07-31     6750.48
                                 2014-08-31    17541.46
                                 2014-09-30    14053.61
                                 2014-10-31     9351.68
                                 2014-11-30     4901.14
                                 2014-12-31     2772.90
Cronin, Oberbrunner and Spencer  2014-01-31     1141.75
                                 2014-02-28    13976.26
                                 2014-03-31    11691.62
                                 2014-04-30     3685.44
                                 2014-05-31     6760.11
                                 2014-06-30     5379.67
                                 2014-07-31     6020.30
                                 2014-08-31     5399.58
Name: ext price, dtype: float64

這次，第二種寫法遠比第一種寫法清爽、便於理解。這種按照特定字段和時間採樣的混合分組，請優先考慮用pd.Grouper

Talk 3: 如何訪問組

如果只是做完拆分動作，沒有做後續的apply，得到的是一個groupby對象。這裏討論下如何訪問拆分出來的組
主要方法為：

• groups
• get_group
• 迭代遍歷

df_2 = pd.DataFrame({'X': ['A', 'B', 'A', 'B'], 'Y': [1, 4, 3, 2]})
df_2

	X	Y
0	A	1
1	B	4
2	A	3
3	B	2

1. 使用 groups方法可以看到所有的組

df_2.groupby("X").groups

{'A': Int64Index([0, 2], dtype='int64'),
 'B': Int64Index([1, 3], dtype='int64')}

1. 使用get_group方法可以訪問到指定的組

df_2.groupby("X", as_index=True).get_group(name="A")

	X	Y
0	A	1
2	A	3

注意，get_group方法中，name參數只能傳遞單個str，不可以傳入list，儘管Pandas中的其他地方常常能看到這類傳參。如果是多列做主鍵的拆分，可以傳入tuple。

1. 迭代遍歷

for name, group in df_2.groupby("X"):
    print(name)
    print(group,"\n")

A
   X  Y
0  A  1
2  A  3 

B
   X  Y
1  B  4
3  B  2 

​

這裏介紹一個小技巧，如果你得到一個<pandas.core.groupby.groupby.DataFrameGroupBy object對象，想要將它還原成其原本的 dataframe ，有一個非常簡便的方法值得一提:

gropbyed_object.apply(lambda x: x)

囿於篇幅，就不對API逐個解釋了，這裏僅指出最容易忽視也最容易出錯的三個參數

參數	注意事項
level	僅作用於層次化索引的數據框時有效
as_index	僅對數據框做 agg 操作時有效，
group_keys	僅在調用 apply 時有效

Part 2: Apply 階段詳解

拆分完成后，可以對各個組做一些的操作，總體說來可以分為以下四類：

• aggregation
• apply
• transform
• filter

先總括地對比下這四類操作

1. 任何能將一個Series壓縮成一個標量值的都是agg操作，例如求和、求均值、求極值等統計計算
2. 對數據框或者groupby對象做變換，得到子集或一個新的數據框的操作是apply或transform
3. 對聚合結果按標準過濾的操作是filter

apply 和 transform有那麼一點相似，下文會重點剖析二者

Talk 4：agg VS apply

agg和apply都可以對特定列的數據傳入函數，並且依照函數進行計算。但是區別在於，agg更加靈活高效，可以一次完成操作。而apply需要輾轉多次才能完成相同操作。

df_3 = pd.DataFrame({"name":["Foo", "Bar", "Foo", "Bar"], "score":[80,80,95,70]})
df_3

	name	score
0	Foo	80
1	Bar	80
2	Foo	95
3	Bar	70

我們需要計算出每個人的總分、最高分、最低分

（1）使用apply方法

df_3.groupby("name", sort=False).score.apply(lambda x: x.sum())

name
Foo    175
Bar    150
Name: score, dtype: int64

df_3.groupby("name", sort=False).score.apply(lambda x: x.max())

name
Foo    95
Bar    80
Name: score, dtype: int64

df_3.groupby("name", sort=False).score.apply(lambda x: x.min())

name
Foo    80
Bar    70
Name: score, dtype: int64

顯然，我們輾轉操作了3次，並且還需要額外一次操作（將所得到的三個值粘合起來）

（2）使用agg方法

df_3.groupby("name", sort=False).agg({"score": [np.sum, np.max, np.min]})

	score
	sum	amax	amin
name
Foo	175	95	80
Bar	150	80	70

小結 agg一次可以對多個列獨立地調用不同的函數，而apply一次只能對多個列調用相同的一個函數。

Talk 5：transform VS agg

transform作用於數據框自身，並且返回變換后的值。返回的對象和原對象擁有相同數目的行，但可以擴展列。注意返回的對象不是就地修改了原對象，而是創建了一個新對象。也就是說原對象沒變。

df_4 = pd.DataFrame({'A': range(3), 'B': range(1, 4)})
df_4

	A	B
0	0	1
1	1	2
2	2	3

df_4.transform(lambda x: x + 1)

	A	B
0	1	2
1	2	3
2	3	4

可以對數據框先分組，然後對各組賦予一個變換，例如元素自增1。下面這個例子意義不大，可以直接做變換。

df_2.groupby("X").transform(lambda x: x + 1)

	Y
0	2
1	5
2	4
3	3

下面舉一個更實際的例子

df_5 = pd.read_csv(r"dataset\tips.csv")
df_5.head()

	total_bill	tip	sex	smoker	day	time	size
0	16.99	1.01	Female	No	Sun	Dinner	2
1	10.34	1.66	Male	No	Sun	Dinner	3
2	21.01	3.50	Male	No	Sun	Dinner	3
3	23.68	3.31	Male	No	Sun	Dinner	2
4	24.59	3.61	Female	No	Sun	Dinner	4

現在我們想知道每天，各數值列的均值
對比以下 agg 和 transform 兩種操作

df_5.groupby("day").aggregate("mean")

	total_bill	tip	size
day
Fri	17.151579	2.734737	2.105263
Sat	20.441379	2.993103	2.517241
Sun	21.410000	3.255132	2.842105
Thur	17.682742	2.771452	2.451613

df_5.groupby('day').transform(lambda x : x.mean()).total_bill.unique()

array([21.41      , 20.44137931, 17.68274194, 17.15157895])

觀察得知，兩種操作是相同的，都是對各個小組求均值。所不同的是，agg方法僅返回4行（即壓縮后的統計值），而transform返回一個和原數據框同樣長度的新數據框。

Talk 6：transform VS apply

transform 和 apply 的不同主要體現在兩方面：

1. apply 對於每個組，都是同時在所有列上面調用函數；而 transform 是對每個組，依次在每一列上調用函數
2. 由上面的工作方法決定了：apply 可以返回標量、Series、dataframe——取決於你在什麼上面調用了apply 方法；而 transform 只能返回一個類似於數組的序列，例如一維的 Series、array、list，並且最重要的是，要和原始組有同樣的長度，否則會引發錯誤。

【例子】通過打印對象的類型來對比兩種方法的工作對象

df_6 = pd.DataFrame({'State':['Texas', 'Texas', 'Florida', 'Florida'], 
                   'a':[4,5,1,3], 'b':[6,10,3,11]})
df_6

	State	a	b
0	Texas	4	6
1	Texas	5	10
2	Florida	1	3
3	Florida	3	11

def inspect(x):
    print(type(x))
    print(x)

df_6.groupby("State").apply(inspect)

<class 'pandas.core.frame.DataFrame'>
     State  a   b
2  Florida  1   3
3  Florida  3  11
<class 'pandas.core.frame.DataFrame'>
     State  a   b
2  Florida  1   3
3  Florida  3  11
<class 'pandas.core.frame.DataFrame'>
   State  a   b
0  Texas  4   6
1  Texas  5  10

從打印結果我們清晰地看到兩點：apply 每次作用的對象是一個 dataframe，其次第一個組被計算了兩次，這是因為pandas會通過這種機制來對比是否有更快的方式完成後面剩下組的計算。

df_6.groupby("State").transform(inspect)

<class 'pandas.core.series.Series'>
2    1
3    3
Name: a, dtype: int64
<class 'pandas.core.series.Series'>
2     3
3    11
Name: b, dtype: int64
<class 'pandas.core.frame.DataFrame'>
   a   b
2  1   3
3  3  11
<class 'pandas.core.series.Series'>
0    4
1    5
Name: a, dtype: int64
<class 'pandas.core.series.Series'>
0     6
1    10
Name: b, dtype: int64

從打印結果我們也清晰地看到兩點：transform每次只計算一列；會出現計算了一個組整體的情況，這有點令人費解，待研究。

從上面的對比，我們直接得到了一個有用的警示：不要傳一個同時涉及到多列的函數給transform方法，因為那麼做只會得到錯誤。例如下面的代碼所示：

def subtract(x):
    return x["a"] - x["b"]

try:
    df_6.groupby("State").transform(subtract)
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[-1])

KeyError: ('a', 'occurred at index a')

另一個警示則是：在使用 transform 方法的時候，不要去試圖修改返回結果的長度，那樣不僅會引發錯誤，而且traceback的信息非常隱晦，很可能你需要花很長時間才能真正意識到錯誤所在。

def return_more(x):
    return  np.arange(3)

try:
    df_6.groupby("State").transform(return_more)
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[-1])

ValueError: Length mismatch: Expected axis has 6 elements, new values have 4 elements

這個報錯信息有點彆扭，期待返回6個元素，但是返回的結果只有4個元素；其實，應該說預期的返回為4個元素，但是現在卻返回6個元素，這樣比較容易理解錯誤所在。

最後，讓我們以一條有用的經驗結束這個talk：如果你確信自己想要的操作時同時作用於多列，並且速度最好還很快，請不要用transform方法，Talk9有一個這方面的好例子。

Talk 7：agg 用法總結

（1）一次對所有列調用多個函數

df_0.groupby("A").agg([np.sum, np.mean, np.min])

	C			D
	sum	mean	amin	sum	mean	amin
A
bar	0.978077	0.244519	-1.343518	-2.042817	-0.510704	-2.064735
foo	0.184686	0.046172	-1.854274	3.113988	0.778497	0.210586

（2）一次對特定列調用多個函數

df_0.groupby("A")["C"].agg([np.sum, np.mean, np.min])

	sum	mean	amin
A
bar	0.978077	0.244519	-1.343518
foo	0.184686	0.046172	-1.854274

（3）對不同列調用不同函數

df_0.groupby("A").agg({"C": [np.sum, np.mean], "D": [np.max, np.min]})

	C		D
	sum	mean	amax	amin
A
bar	0.978077	0.244519	0.917027	-2.064735
foo	0.184686	0.046172	1.348597	0.210586

df_0.groupby("A").agg({"C": "sum", "D": "min"})

	C	D
A
bar	0.978077	-2.064735
foo	0.184686	0.210586

（4）對同一列調用不同函數，並且直接重命名

df_0.groupby("A")["C"].agg([("Largest", "max"), ("Smallest", "min")])

	Largest	Smallest
A
bar	1.477379	-1.343518
foo	1.145852	-1.854274

（5）對多個列調用同一個函數

agg_keys = {}.fromkeys(["C", "D"], "sum")
df_0.groupby("A").agg(agg_keys)

	C	D
A
bar	0.978077	-2.042817
foo	0.184686	3.113988

（6）注意agg會忽略缺失值，這在計數時需要加以注意

df_7 = pd.DataFrame({"ID":["A","A","A","B","B"], "Num": [1,np.nan, 1,1,1]})
df_7

	ID	Num
0	A	1.0
1	A	NaN
2	A	1.0
3	B	1.0
4	B	1.0

df_7.groupby("ID").agg({"Num":"count"})

	Num
ID
A	2
B	2

注意：Pandas 中的 count,sum,mean,median,std,var,min,max等函數都用C語言優化過。所以，還是那句話，如果你在大數據集上使用agg，最好使用這些函數而非從numpy那裡借用np.sum等方法，一個緩慢的程序是由每一步的緩慢積累而成的。

Talk 8：Filtration 易錯點剖析

通常，在對一個 dataframe 分組並且完成既定的操作之後，可以直接返回結果，也可以視需求對結果作一層過濾。這個過濾一般都是指 filter 操作，但是務必要理解清楚自己到底需要對組作過濾還是對組內的每一行作過濾。這個Talk就來討論過濾這個話題。

【例子】找出每門課程考試分數低於這門課程平均分的學生

df_8 = pd.DataFrame({"Subject": list(chain(*[["Math"]*3,["Computer"]*3])),
                    "Student": list(chain(*[["Chan", "Ida", "Ada"]*2])),
                    "Score": [80,90,85,90,85,95]})

df_8

	Subject	Student	Score
0	Math	Chan	80
1	Math	Ida	90
2	Math	Ada	85
3	Computer	Chan	90
4	Computer	Ida	85
5	Computer	Ada	95

這樣一個需求是否適合用 filter 來處理呢？我們試試看：

try:
    df_8.groupby("Subject").filter(lambda x: x["Score"] < x["Score"].mean())
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[-1])

TypeError: filter function returned a Series, but expected a scalar bool

顯然不行，因為 filter 實際上做的事情是要麼留下這個組，要麼過濾掉這個組。我們在這裏弄混淆的東西，和我們初學 SQL時弄混 WHERE 和 HAVING 是一回事。就像需要記住 HAVING 是一個組內語法一樣，請記住 filter 是一個組內方法。

我們先解決這個例子，正確的做法如下:

df_8.groupby("Subject").apply(lambda g: g[g.Score < g.Score.mean()])

		Subject	Student	Score
Subject
Computer	4	Computer	Ida	85
Math	0	Math	Chan	80

而關於 filter，我們援引官方文檔上的例子作為對比

df_9 = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
                          'foo', 'bar'],
                    'B' : [1, 2, 3, 4, 5, 6],
                    'C' : [2.0, 5., 8., 1., 2., 9.]})
df_9

	A	B	C
0	foo	1	2.0
1	bar	2	5.0
2	foo	3	8.0
3	bar	4	1.0
4	foo	5	2.0
5	bar	6	9.0

df_9.groupby('A').filter(lambda x: x['B'].mean() > 3.)

	A	B	C
1	bar	2	5.0
3	bar	4	1.0
5	bar	6	9.0

Part 3：groupby 應用舉例

Talk 9：組內缺失值填充

df_10 = pd.DataFrame({"ID":["A","A","A","B","B","B"], "Num": [100,np.nan,300,np.nan,500,600]})
df_10

	ID	Num
0	A	100.0
1	A	NaN
2	A	300.0
3	B	NaN
4	B	500.0
5	B	600.0

df_10.groupby("ID", as_index=False).Num.transform(lambda x: x.fillna(method="ffill")).transform(lambda x: x.fillna(method="bfill"))

	Num
0	100.0
1	100.0
2	300.0
3	500.0
4	500.0
5	600.0

如果dataframe比較大（超過1GB）,transform + lambda方法會比較慢，可以用下面這個方法，速度約比上面的組合快100倍。

df_10.groupby("ID",as_index=False).ffill().groupby("ID",as_index=False).bfill()

	ID	Num
0	A	100.0
1	A	100.0
2	A	300.0
3	B	500.0
4	B	500.0
5	B	600.0

參考資料：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益