標籤: 網站設計公司

決策樹(上)-ID3、C4.5、CART

admin

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

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  ?

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

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

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

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

Unity中用Mesh畫一個圓環(二)

admin

中目標-生成完整面

在之前的內容中我們已經成功生成了一個面，接下來我們要生成剩下的面就很容易了。

我們把之前生成的面當作頂面，接着我們來生成底面。

還記得前面說過\(\color{#1E90FF}{Depth}\)這個參數用來控制深度，也就是頂面和地面之間的距離，放到坐標系中就是控制Z的位置。

底面和頂面的頂點生成方法是一樣的，唯一不同的地方就是Z軸的不同。 我們只要用生成頂面的方法改下Z坐標，就可以得到底面了。

//下
        for (int i = 0; i <= NumberOfSides; i++)
        {
            float angle = 180 - i * incrementAngle;
            float innerX = (Radius - Thickness) * Mathf.Cos(angle * Mathf.Deg2Rad);
            float innerY = (Radius - Thickness) * Mathf.Sin(angle * Mathf.Deg2Rad);
            vertexList.Add(new Vector3(innerX, innerY, -1 * Depth / 2));
            float outsideX = Radius * Mathf.Cos(angle * Mathf.Deg2Rad);
            float outsideY = Radius * Mathf.Sin(angle * Mathf.Deg2Rad);
            vertexList.Add(new Vector3(outsideX, outsideY, - 1 * Depth / 2));
        }

三角形索引的生成和之前也是一樣的，不同的是一開始的方向，因為頂面的法線是向上的，而底面的法線是向下的：

  direction = 1;
        startIndex += (NumberOfSides + 1) * 2;
        for (int i = 0; i < NumberOfSides * 2; i++)
        {
            int[] triangleIndexs = getTriangleIndexs(i, direction, startIndex);
            direction *= -1;
            for (int j = 0; j < triangleIndexs.Length; j++)
            {
                triangleList.Add(triangleIndexs[j]);
            }
        }

至於UV索引則設置和頂面的一樣即可。

其實生成頂面和底面之後，大部分的工作已經完成了，這時候我們已經生成了我們需要的所有頂點。前後左右也只是用現有的這些頂點進行生成。

我們前面生成的圓柱體是基於圓生成的，如果我們改成基於貝塞爾生成的那也是可以的。

修改方法很簡單，就是改下生成頂點時的過程就好了，其他的不需要動。

具體過程直接看代碼吧，包看包懂。

當然下面的代碼是為了方面理解所以寫得冗餘，如果用到項目中建議優化下，不然會被主程打的。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

//[RequireComponent(typeof(MeshFilter))]
//[RequireComponent(typeof(MeshRenderer))]
[ExecuteInEditMode]
public class DrawArch : MonoBehaviour
{
    public float Radius = 20.0f;                //外圈的半徑
    public float Thickness = 10.0f;             //厚度，外圈半徑減去內圈半徑
    public float Depth = 1.0f;                  //厚度
    public int NumberOfSides = 30;         //由多少個面組成
    public float DrawArchDegrees = 90.0f;       //要繪畫多長
    public Vector2[] bezierPoints = new Vector2[4];
    public Material archMaterial = null;

    private int VertexCountOneSide = 0;         //生成一面所需的頂點數
    private Mesh mesh = null;

    private float incrementAngle = 0;
    private List<Vector3> vertexList = new List<Vector3>();
    private List<int> triangleList = new List<int>();
    private List<Vector2> uvList = new List<Vector2>();

    // Start is called before the first frame update
    void Start()
    {
        mesh = new Mesh();
    }

    void GenerateMesh()
    {
        VertexCountOneSide = (NumberOfSides + 1) * 2;
        incrementAngle = DrawArchDegrees / NumberOfSides;

        GenerateVertex();
        GenerateTriangleIndex();
        GenerateUV();

        mesh.vertices = vertexList.ToArray();
        mesh.uv = uvList.ToArray();
        mesh.triangles = triangleList.ToArray();

        mesh.RecalculateNormals();
        gameObject.GetComponent<MeshFilter>().mesh = mesh;
        gameObject.GetComponent<MeshRenderer>().material = archMaterial;
    }

    //生成頂點坐標
    void GenerateVertex()
    {
        //上
        vertexList.Clear();
        for (int i = 0; i <= NumberOfSides; i++)
        {
            //float[] points = GetCirclePoint(Radius - Thickness,  i);
            //vertexList.Add(new Vector3(points[0], points[1], Depth / 2));
            //points = GetCirclePoint(Radius, i);
            //vertexList.Add(new Vector3(points[0], points[1], Depth / 2));
            float[] points = GetBezierPoint(i);
            vertexList.Add(new Vector3(points[0], points[1], Depth / 2));
            points = GetBezierPoint(i);
            vertexList.Add(new Vector3(points[0] - 1, points[1], Depth / 2));
        }

        //下
        for (int i = 0; i <= NumberOfSides; i++)
        {
            //float[] points = GetCirclePoint(Radius - Thickness,  i);
            //vertexList.Add(new Vector3(points[0], points[1], -1 * Depth / 2));
            //points = GetCirclePoint(Radius, i);
            //vertexList.Add(new Vector3(points[0], points[1], -1 * Depth / 2));
            float[] points = GetBezierPoint(i);
            vertexList.Add(new Vector3(points[0], points[1], -1 * Depth / 2));
            points = GetBezierPoint(i);
            vertexList.Add(new Vector3(points[0] - 1, points[1], -1 * Depth / 2));
        }

        //前
        for (int i = 0; i <= NumberOfSides * 2 ; i += 2)
        {
            vertexList.Add(vertexList[i]);
            vertexList.Add(vertexList[i + VertexCountOneSide]);
        }
        //后
        for (int i = 0; i <= NumberOfSides * 2; i += 2)
        {
            vertexList.Add(vertexList[i + 1]);
            vertexList.Add(vertexList[i + VertexCountOneSide + 1]);
        }
        //左
        vertexList.Add(vertexList[0]);
        vertexList.Add(vertexList[1]);
        vertexList.Add(vertexList[VertexCountOneSide + 0]);
        vertexList.Add(vertexList[VertexCountOneSide + 1]);
        //右
        vertexList.Add(vertexList[VertexCountOneSide -2]);
        vertexList.Add(vertexList[VertexCountOneSide - 1]);
        vertexList.Add(vertexList[VertexCountOneSide * 2 - 2]);
        vertexList.Add(vertexList[VertexCountOneSide * 2 - 1]);
    }

    void GenerateTriangleIndex()
    {
        //三角形索引
        triangleList.Clear();
        //上
        int direction = -1;
        int startIndex = 0;
        for (int i = 0; i < NumberOfSides * 2; i++)
        {
            int[] triangleIndexs = getTriangleIndexs(i, direction);
            direction *= -1;
            for (int j = 0; j < triangleIndexs.Length; j++)
            {
                triangleList.Add(triangleIndexs[j]);
            }
        }

        //下
        direction = 1;
        startIndex += (NumberOfSides + 1) * 2;
        for (int i = 0; i < NumberOfSides * 2; i++)
        {
            int[] triangleIndexs = getTriangleIndexs(i, direction, startIndex);
            direction *= -1;
            for (int j = 0; j < triangleIndexs.Length; j++)
            {
                triangleList.Add(triangleIndexs[j]);
            }
        }

        //前
        direction = 1;
        startIndex += VertexCountOneSide;
        for (int i = 0; i < NumberOfSides * 2; i++)
        {
            int[] triangleIndexs = getTriangleIndexs(i, direction, startIndex);
            direction *= -1;
            for (int j = 0; j < triangleIndexs.Length; j++)
            {
                triangleList.Add(triangleIndexs[j]);
            }
        }

        //后
        direction = -1;
        startIndex += VertexCountOneSide;
        for (int i = 0; i < NumberOfSides * 2; i++)
        {
            int[] triangleIndexs = getTriangleIndexs(i, direction, startIndex);
            direction *= -1;
            for (int j = 0; j < triangleIndexs.Length; j++)
            {
                triangleList.Add(triangleIndexs[j]);
            }
        }
        startIndex += VertexCountOneSide;
        //左
        triangleList.Add(startIndex + 0);
        triangleList.Add(startIndex + 1);
        triangleList.Add(startIndex + 2);
        triangleList.Add(startIndex + 3);
        triangleList.Add(startIndex + 2);
        triangleList.Add(startIndex + 1);
        //右
        triangleList.Add(startIndex + 4 + 2);
        triangleList.Add(startIndex + 4 + 1);
        triangleList.Add(startIndex + 4 + 0);
        triangleList.Add(startIndex + 4 + 1);
        triangleList.Add(startIndex + 4 + 2);
        triangleList.Add(startIndex + 4 + 3);
    }

    //UV索引
    void GenerateUV()
    {
        uvList.Clear();
        //上
        for (int i = 0; i <= NumberOfSides; i++)
        {
            float angle = 180 - i * incrementAngle;
            float littleX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(littleX, 0));
            float bigX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(bigX, 1));
        }

        //下
        for (int i = 0; i <= NumberOfSides; i++)
        {
            float angle = 180 - i * incrementAngle;
            float littleX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(littleX, 0));
            float bigX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(bigX, 1));
        }

        //前
        for (int i = 0; i <= NumberOfSides; i++)
        {
            float angle = 180 - i * incrementAngle;
            float littleX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(littleX, 0));
            float bigX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(bigX, 1));
        }

        //后
        for (int i = 0; i <= NumberOfSides; i++)
        {
            float angle = 180 - i * incrementAngle;
            float littleX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(littleX, 0));
            float bigX = (1.0f / NumberOfSides) * i;
            uvList.Add(new Vector2(bigX, 1));
        }
        //左
        uvList.Add(new Vector2(1.0f, 1.0f));
        uvList.Add(new Vector2(0.0f, 1.0f));
        uvList.Add(new Vector2(0.0f, 0.0f));
        uvList.Add(new Vector2(1.0f, 0.0f));
        //右
        uvList.Add(new Vector2(1.0f, 1.0f));
        uvList.Add(new Vector2(0.0f, 1.0f));
        uvList.Add(new Vector2(0.0f, 0.0f));
        uvList.Add(new Vector2(1.0f, 0.0f));
    }

    int[] getTriangleIndexs(int index, int direction, int startIndex = 0)
    {
        int[] triangleIndexs = new int[3] { 0+ startIndex, 1 + startIndex, 2 + startIndex };
        for (int i = 0; i < triangleIndexs.Length; i++)
        {
            triangleIndexs[i] += index;
        }
        if (direction == -1)
        {
            int temp = triangleIndexs[0];
            triangleIndexs[0] = triangleIndexs[2];
            triangleIndexs[2] = temp;
        }
        return triangleIndexs;
    }

    private void Update()
    {
        GenerateMesh();
    }

    float[] GetCirclePoint(float radius, int index)
    {
        float angle = 180 - index * incrementAngle;
        float[] points = new float[2];
        float x = radius * Mathf.Cos(angle * Mathf.Deg2Rad);
        float y = radius * Mathf.Sin(angle * Mathf.Deg2Rad);
        points[0] = x;
        points[1] = y;
        return points;
    }

    float[] GetBezierPoint(int index)
    {
        float t = 1.0f / (NumberOfSides + 1) * index;
        float[] points = new float[2];
        var vec = Bezier(bezierPoints[0], bezierPoints[1], bezierPoints[2], bezierPoints[3], t);
        points[0] = vec.x;
        points[1] = vec.y;
        return points;
    }

    Vector2 Bezier(Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3, float t)
    {
        Vector2 result;
        Vector2 p0p1 = (1 - t) * p0 + t * p1;
        Vector2 p1p2 = (1 - t) * p1 + t * p2;
        Vector2 p2p3 = (1 - t) * p2 + t * p3;
        Vector2 p0p1p2 = (1 - t) * p0p1 + t * p1p2;
        Vector2 p1p2p3 = (1 - t) * p1p2 + t * p2p3;
        result = (1 - t) * p0p1p2 + t * p1p2p3;
        return result;
    }
}

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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

※南投搬家前需注意的眉眉角角，別等搬了再說!

特斯拉盼於德國設廠 因環保問題遭抗議

admin

摘錄自2020年01月19日中央通訊社德國報導

美國電動車大廠特斯拉（Tesla）計畫在柏林郊區設立超級工廠，大約250名德國民眾今天（19日）到設廠地點抗議，宣稱這樣的建設將會危害區域內的水源供應和野生生物。

特斯拉去年11月宣布，計畫在德國東部布蘭登堡邦（Brandenburg）市鎮格林海德（Grünheide）設立他們在歐洲的第一座工廠。政界、工會、產業團體都對特斯拉表示歡迎，宣稱那會為地區帶來工作機會，但因為對環境保護的憂慮，讓數百名當地人在今天走上街頭。

在此之前，布蘭登堡邦水利當局16日警告，預定興建的特斯拉工廠，將使得「飲水供應以及工廠廢水排放，出現廣泛及嚴重的問題。」

同時，民眾也為附近道路和村落之間的交通憂心不已，他們預期交通未來會有「巨幅」成長，他們為此表達抗議。

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

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

泰國曼谷空品差 民眾抱怨政府無作為

admin

摘錄自2020年1月21日公視報導

泰國曼谷近年來每到冬天，空氣品質就拉警報。曼谷的天空再度為霧霾籠罩，機車騎士紛紛戴上口罩，家庭主婦出門也不例外。

根據曼谷官方監測的數據，曼谷部分地區中午時段PM2.5濃度，飆升到每立方公尺 95微克，幾乎是安全標準的兩倍。官員表示這主要是受到逆溫現象的影響，也就是暖空氣將冷空氣困在地面附近，導致汽機車廢氣滯留且散不出去。泰國政府雖然已經開始管控汽車廢氣，必要時還派出無人機灑水，但霧鎖曼谷的情況依然每年上演。最新民調顯示，曼谷有八成一的民眾，認為政府改善空污沒有效率。

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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

※南投搬家前需注意的眉眉角角，別等搬了再說!

氣候變遷是真的 高調擁煤的澳洲總理認了

admin

摘錄自2020年1月16日中央社報導

曾高調支持煤炭政策、不願將野火與氣候變遷做連結的澳洲總理莫里森（Scott Morrison），今天（15日）終於承認氣候變遷是真的。

三年前，時任財政部長的澳洲總理莫里森在國會殿堂上揮舞一塊煤炭，將其作為執政的保守派聯盟計劃維持電力供應與低電價的象徵。

如今，澳洲正經歷空前嚴重的野火季節，加上莫里森因為自己的擁煤政策面臨外界批評，他今天承認氣候變遷是真的，也談到澳洲對環境的「適應力」與「復原力」。

路透社報導，莫里森今天在首都坎培拉（Canberra）告訴記者：「我想我們都希望擁有高度信心，作為一個國家，我們正在提升自身復原力，和對我們所生存現實環境的適應力。」

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

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

日本風災損害輻射檢查設備 營養午餐難保食安

admin

文：宋瑞文（媽媽監督核電廠聯盟特約撰述）

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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

※南投搬家前需注意的眉眉角角，別等搬了再說!

Pandas進階筆記 （一） Groupby 重難點總結

admin

如果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  ?

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

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

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

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

vue學習筆記(五)條件渲染和列表渲染

admin

前言

在眾多的編程語言中，我們的基礎語法總是少不了一些專業語法，比如像定義變量，條件語句，for循環，數組，函數等等，vue.js這個優秀的前端框架中也有同樣的語法，我們換一個名詞，將條件語句改成專業詞彙叫做條件渲染，循環語句改成專業詞彙叫做列表渲染，這樣比較舒服一點。

本章目標

  • 學會條件渲染的使用

  • 學會可復用的key的使用

  • 學會列表渲染的使用

條件渲染

1.v-if的使用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<div id="app01">
    <span v-if="type==='A'">成績為A</span>
</div>
<script src="../js/vue.js"></script>
<script>
    let vm=new Vue({
        el:'#app01',
        data:{
            type:'A'
        },
        methods:{
            
        },
        watch:{
            
        },
        computed:{
            
        }
    })
</script>
</body>
</html>

結果：成績為A

v-if判斷條件是否相等，就像if一樣，如果相等，那麼值就會true,與之對應的還有v-else,v-else-if

2.v-else的使用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<div id="app01">
    <span v-if="type==='A'">成績為A</span>
    <span v-else>成績為B</span>
</div>
<script src="../js/vue.js"></script>
<script>
    let vm=new Vue({
        el:'#app01',    
        data:{
            type:'B'
        },
        methods:{
            
        },
        watch:{
            
        },
        computed:{
            
        }
    })
</script>
</body>
</html>

結果:成績為B

小練習

我們做一個小練習，鞏固一下v-if和v-else的使用，需求如下：點擊一個按鈕時,按鈕上的文字變為显示，再次點擊時按鈕上的文字變為隱藏，當按鈕上的文字显示隱藏時，显示紅色，按鈕上的文字變為显示時显示藍色

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
            .box{
                width: 100px;
                height: 100px;
            }
            .red{
                background: red;
            }
            .blue{
                background: blue;
            }
        </style>
    </head>
    <body>
        <div id="app">
            <button @click="handleClick">{{text}}</button>
            <div v-if="show" class="box red"></div>
            <div v-else class="blue box"></div>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    show:true,
                    text:'隱藏'
                },
                methods:{
                    handleClick(){
                        this.show=!this.show;
                        this.text=this.show?'隱藏':'显示'
                    }
                }
            })
            
        </script>
    </body>
</html>

結果

 

3.v-else-if的使用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<div id="app01">
    <input type="text" v-model="type"/>
    <div v-if="type==='A'">成績為A</div>
    <div v-else-if="type==='B'">成績為B</div>
    <div v-else-if="type==='C'">成績為C</div>
    <div v-else>不及格</div>
</div>
<script src="../js/vue.js"></script>
<script>
    let vm=new Vue({
        el:'#app01',    
        data:{
            type:''
        },
        methods:{
            
        },
        watch:{
            
        },
        computed:{
            
        }
    })
</script>
</body>
</html>

結果:

4.v-show

說起這個v-show，其實和v-if有與曲同工的妙處，但是又有不同的地方，我們來看下示例你就秒懂了

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
            .box{
                width: 100px;
                height: 100px;
            }
            .red{
                background: red;
            }
            .blue{
                background: blue;
            }
        </style>
    </head>
    <body>
        <div id="app">
            <div v-show="show" class="box red"></div>
            <button @click="handleClick()">{{text}}</button>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    show:true,
                    text:'隱藏',
                },
                methods:{
                    handleClick(){
                        this.show=!this.show;
                        this.text=this.show?'隱藏':'显示'
                    }
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

當按鈕變為显示的時候，背景顏色消失，這裏就不截圖了，有興趣的小夥伴可以自己去嘗試，既然v-if可以幫我們實現元素的显示和隱藏，那我們還需要v-show干什麼呢？不妨看下接下來的實例。

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
            .box{
                width: 100px;
                height: 100px;
            }
            .red{
                background: red;
            }
            .blue{
                background: blue;
            }
        </style>
    </head>
    <body>
        <div id="app">
            <div v-show="show" class="box red"></div>
            <div class="box blue" v-if="show"></div>
            <button @click="handleClick()">{{text}}</button>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    show:true,
                    text:'隱藏',
                },
                methods:{
                    handleClick(){
                        this.show=!this.show;
                        this.text=this.show?'隱藏':'显示'
                    }
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

 當我們點擊按鈕的時候

 

現在結果已經出來了，使用v-show的dom元素，dom元素只是簡單的切換display屬性，而v-if會將dom元素移除，當我們再次點擊時，v-if又會重新渲染元素，可想而知如果頻繁的切換的話，那麼有多麼的耗費性能，因此我總結了如下幾點

  • 頻繁的切換显示/隱藏要使用v-show

  • 只判斷一次時，使用v-if

5.減少dom的生成

我們都知道js操作dom元素是非常消耗性能的，但是我們需要盡量的避免這個問題，vue中為我們提供了一個template標籤，這個標籤叫做模板(至於什麼叫做模板，後期的博客會講到)，我們先看一個示例

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
            .box{
                width: 100px;
                height: 100px;
            }
            .red{
                background: red;
            }
            .blue{
                background: blue;
            }
        </style>
    </head>
    <body>
        <div id="app">
            <div v-if="show">
                <div class="box red"></div>
                <div class="box blue"></div>
            </div>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    show:true,
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

 我們想讓圖上的那個div消失，不想為了管理同一組元素而多生成一個節點，這樣是非常消耗性能的，我們將div標籤變成template標籤

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
            .box{
                width: 100px;
                height: 100px;
            }
            .red{
                background: red;
            }
            .blue{
                background: blue;
            }
        </style>
    </head>
    <body>
        <div id="app">
            <div v-if="show">
                <div class="box red"></div>
                <div class="box blue"></div>
            </div>
            <template v-if="show">
                <div class="box red"></div>
                <div class="box blue"></div>
            </template>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    show:true,
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

View Code

 現在我有心中萌生了一個想法，v-if可以使用template,那麼v-show是否可以使用呢？

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style type="text/css">
            .box{
                width: 100px;
                height: 100px;
            }
            .red{
                background: red;
            }
            .blue{
                background: blue;
            }
        </style>
    </head>
    <body>
        <div id="app">
            <template v-if="show">
                <div class="box red"></div>
                <div class="box blue"></div>
            </template>
            <template v-show="show">
                <div class="box red"></div>
                <div class="box blue"></div>
            </template>
            <button @click="handleClick()">{{text}}</button>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    show:true,
                    text:'隱藏',
                },
                methods:{
                    handleClick(){
                        this.show=!this.show;
                        this.text=this.show?'隱藏':'显示'
                    }
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

View Code

 

 答案是v-if可以使用template，而v-show不能使用template

vue中用key管理可復用的元素

Vue 會盡可能高效地渲染元素，通常會復用已有元素而不是從頭開始渲染。這麼做除了使 Vue 變得非常快之外，還有其它一些好處。例如，如果你允許用戶在不同的登錄方式之間切換。

示例一：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<div id="app01">
    <template v-if="type==='username'">
        <label>用戶名</label>
        <input type="text" placeholder="請輸入您的賬號" />
    </template>
    <template v-else>
        <label>郵箱</label>
        <input type="text" placeholder="請輸入您的郵箱" />
    </template>
    <p>
        <a href=""@click.prevent="type='username'">用戶名登錄</a>|
        <a href=""@click.prevent="type='email'">郵箱登錄</a>
    </p>
</div>
<script src="../js/vue.js"></script>
<script>
    let vm=new Vue({
        el:'#app01',    
        data:{
            isShow:true,
            type:'username'
        },
        methods:{
            
        },
        watch:{
            
        },
        computed:{
            
        }
    })
</script>
</body>
</html>

結果：

 

 

當我們在用戶名登錄和郵箱切換的時候，我們發現我們輸入的內容始終保持，為什麼呢?總的來說，因為兩個模板使用了相同的元素，input不會被替換掉——僅僅是替換了它的 placeholder屬性，這樣也不總是符合實際需求，所以 Vue 為你提供了一種方式來表達這兩個元素是完全獨立的,不要復用它們,只需添加一個具有唯一值的key屬性即可。

示例二:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
<div id="app01">
    <template v-if="type==='username'">
        <label>用戶名:</label>
        <input type="text" placeholder="請輸入您的用戶名"  key='usename'/>
    </template>
    <template v-else>
        <label>郵箱:</label>
        <input type="text" placeholder="請輸入您的郵箱"  key='email'/>
    </template>
    <p>
        <a href=""@click.prevent="type='username'">用戶名登錄</a>|
        <a href=""@click.prevent="type='email'">郵箱登錄</a>
    </p>
</div>
<script src="../js/vue.js"></script>
<script>
    let vm=new Vue({
        el:'#app01',    
        data:{
            isShow:true,
            type:'username'
        },
        methods:{
            
        },
        watch:{
            
        },
        computed:{
            
        }
    })
</script>
</body>
</html>

結果：

 

現在我們點擊切換的時候，輸入框都會重新渲染，當然我們的<label>標籤依舊的高效的復用，因為它沒有添加key。

列表渲染

我們用v-for指令根據一組數組的選項列表進行渲染，v-for指令需要以item in items的形式的特殊語法，items是原數據數組並且item是元素迭代的別名

1.v-for的基本使用

語法：(item,index) in|of items

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>v-for的基本使用</title>
    </head>
    <body>
        <div id="app">
            <ul>
                <li v-for="(item) in arr">{{item}}</li>
            </ul>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    arr:['apple','banana','pear']
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

結果：

當然v-for中也可以帶第二個參數index

2.v-for中帶索引

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>v-for的基本使用</title>
    </head>
    <body>
        <div id="app">
            <ul>
                <li v-for="(item,index) in arr">{{item}}--{{index}}</li>
            </ul>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    arr:['apple','banana','pear']
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

View Code

3.v-for迭代字符串

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>v-for的基本使用</title>
    </head>
    <body>
        <div id="app">
            <ul>
                <li v-for="(item,index) in arr">{{item}}--{{index}}</li>
            </ul>
            <ul>
                <li v-for="item in 'helloworld'">{{item}}</li>
            </ul>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    arr:['apple','banana','pear']
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

View Code

4.v-for迭代對象

語法：(value,key,index) of | in items

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>v-for迭代對象</title>
    </head>
    <body>
        <div id="app">
            <ul>
                <li v-for="(value,key,index) of obj">{{value}}-{{key}}-{{index}}</li>
            </ul>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    obj:{
                        name:'kk',
                        age:18,
                        sex:'male'
                    }
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

結果:

5.v-for迭代整數

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>v-for迭代對象</title>
    </head>
    <body>
        <div id="app">
            <ul>
                <li v-for="(value,key,index) of obj">{{value}}-{{key}}-{{index}}</li>
            </ul>
            <ul>
                <li v-for="item in 10">{{item}}</li>
            </ul>
        </div>
        <script src="../js/vue.js" type="text/javascript" charset="utf-8"></script>
        <script type="text/javascript">
            let vm=new Vue({
                el:'#app',
                data:{
                    obj:{
                        name:'kk',
                        age:18,
                        sex:'male'
                    }
                },
                methods:{
                    
                },
                computed:{
                    
                }
            })
        </script>
    </body>
</html>

結果：

注意：但我們迭代整數的時候，item從1開始而不是從0開始

總結

在本章內容中，我們一共學習了三個知識點，分別是條件渲染的使用(v-if,v-else,v-else-if),管理可復用的key,列表渲染(v-for的基本使用等等)，本章的內容也多但是在實際應用上非常廣泛，畢竟這些是非常基礎的語法，基礎不牢，地動山搖，學習任何東西都需要自己一步一個腳印走出來。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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

※南投搬家前需注意的眉眉角角，別等搬了再說!

美生物學家夫婦深入拉美記錄野生動物

admin

摘錄自2020年1月25日公視報導

氣候變遷讓全世界許多珍貴的物種面臨可能消失的危機，有一對美國的生物學家夫婦在哥斯大黎加執行拍攝動物的計畫，希望能將這些影像分享給世人。

八年前，來自美國賓州的生物學家洛沙索以及太太琳熙，搬到哥斯大黎加西北部的瓜拿卡斯特省，去年底，他們成立瓜拿卡斯特監控計畫，在當地超過40個森林裡架設隱藏式攝影機，收錄超過100個不同的野生動物物種、約1萬個錄影的片段。這些鏡頭防水防震，還有動態捕捉以及夜間攝影功能。他們希望將這些拍攝到的珍貴畫面，分享給在地的孩子。

根據世界自然基金會的報告，哥斯大黎加面積不到全世界的1%，但其生物多樣性卻佔全球的5%，而這其中有超過25%，是國家指定為特別保護的森林及保育區。

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

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

【自然語言處理】利用LDA對希拉里郵件進行主題分析

admin

首先是讀取數據集，並將csv中ExtractedBodyText為空的給去除掉

import pandas as pd
import re
import os

dir_path=os.path.dirname(os.path.abspath(__file__))
data_path=dir_path+"/Database/HillaryEmails.csv"
df=pd.read_csv(data_path)
df=df[['Id','ExtractedBodyText']].dropna()

對於這些郵件信息，並不是所有的詞都是有意義的，也就是先要去除掉一些噪聲數據：

def clean_email_text(text):
    text = text.replace('\n'," ") #新行，我們是不需要的
    text = re.sub(r"-", " ", text) #把 "-" 的兩個單詞，分開。（比如：july-edu ==> july edu）
    text = re.sub(r"\d+/\d+/\d+", "", text) #日期，對主體模型沒什麼意義
    text = re.sub(r"[0-2]?[0-9]:[0-6][0-9]", "", text) #時間，沒意義
    text = re.sub(r"[\w]+@[\.\w]+", "", text) #郵件地址，沒意義
    text = re.sub(r"/[a-zA-Z]*[:\//\]*[A-Za-z0-9\-_]+\.+[A-Za-z0-9\.\/%&=\?\-_]+/i", "", text) #網址，沒意義
    pure_text = ''
    # 以防還有其他特殊字符（数字）等等，我們直接把他們loop一遍，過濾掉
    for letter in text:
        # 只留下字母和空格
        if letter.isalpha() or letter==' ':
            pure_text += letter
    # 再把那些去除特殊字符后落單的單詞，直接排除。
    # 我們就只剩下有意義的單詞了。
    text = ' '.join(word for word in pure_text.split() if len(word)>1)
    return text

然後取出ExtractedBodyText的那一列，對每一行email進行噪聲過濾，並返回一個對象：

docs = df['ExtractedBodyText']
docs = docs.apply(lambda s: clean_email_text(s))

然後我們呢把裏面的email提取出來：

doclist=docs.values

接下來，我們使用gensim庫來進行LDA模型的構建，gensim可用指令pip install -U gensim安裝。但是，要注意輸入到模型中的數據的格式。例如：將[[一條郵件字符串]，[另一條郵件字符串], ...]轉換成[[一，條，郵件，在，這裏],[第，二，條，郵件，在，這裏],[今天，天氣，腫么，樣],...]。對於英文的分詞，只需要對空白處分割即可。同時，有些詞語（不同於噪聲）是沒有意義的，我們要過濾掉那些沒有意義的詞語，這裏簡單的寫一個停止詞列表：

stoplist = ['very', 'ourselves', 'am', 'doesn', 'through', 'me', 'against', 'up', 'just', 'her', 'ours',
            'couldn', 'because', 'is', 'isn', 'it', 'only', 'in', 'such', 'too', 'mustn', 'under', 'their',
            'if', 'to', 'my', 'himself', 'after', 'why', 'while', 'can', 'each', 'itself', 'his', 'all', 'once',
            'herself', 'more', 'our', 'they', 'hasn', 'on', 'ma', 'them', 'its', 'where', 'did', 'll', 'you',
            'didn', 'nor', 'as', 'now', 'before', 'those', 'yours', 'from', 'who', 'was', 'm', 'been', 'will',
            'into', 'same', 'how', 'some', 'of', 'out', 'with', 's', 'being', 't', 'mightn', 'she', 'again', 'be',
            'by', 'shan', 'have', 'yourselves', 'needn', 'and', 'are', 'o', 'these', 'further', 'most', 'yourself',
            'having', 'aren', 'here', 'he', 'were', 'but', 'this', 'myself', 'own', 'we', 'so', 'i', 'does', 'both',
            'when', 'between', 'd', 'had', 'the', 'y', 'has', 'down', 'off', 'than', 'haven', 'whom', 'wouldn',
            'should', 've', 'over', 'themselves', 'few', 'then', 'hadn', 'what', 'until', 'won', 'no', 'about',
            'any', 'that', 'for', 'shouldn', 'don', 'do', 'there', 'doing', 'an', 'or', 'ain', 'hers', 'wasn',
            'weren', 'above', 'a', 'at', 'your', 'theirs', 'below', 'other', 'not', 're', 'him', 'during', 'which']

然後我們將輸入轉換成gensim所需的格式，並過濾掉停用詞：

texts = [[word for word in doc.lower().split() if word not in stoplist] for doc in doclist]

再將這所有的單詞放入到一個詞袋中，把每個單詞用一個数字index指代：

from gensim import corpora, models, similarities
import gensim
dictionary = corpora.Dictionary(texts)

再分別統計每一篇email中每個詞語在這個詞袋中出現的次數，並返回一個列表：

corpus = [dictionary.doc2bow(text) for text in texts]

 這個列表告訴我們，第14（從0開始是第一）個郵件中，一共6個有意義的單詞（經過我們的文本預處理，並去除了停止詞后）其中，51號單詞出現1次，505號單詞出現1次，以此類推。。。

最後，就可以開始構建我們的模型了：

lda = gensim.models.ldamodel.LdaModel(corpus=corpus, id2word=dictionary, num_topics=20)
print(lda.print_topic(10, topn=5))

 可以看到，第11個主題最常用的單詞，接下來，我們看下所有的主題：

for i in lda.print_topics(num_topics=20, num_words=5):
    print(i)

 我們再看下第一篇email屬於哪一個主題：

print(lda.get_document_topics(corpus[0]))

 屬於第四個主題的概率是0.95

相關代碼和數據：鏈接: https://pan.baidu.com/s/1sl1I5IeQFDHjVwf2a0C89g 提取碼: xqqf 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

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

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

※南投搬家前需注意的眉眉角角，別等搬了再說!