Lattice API 網格

<span style="font-size:24px;">public class Lattice
Aisee是一個圖形可視化工具。具體情況請看：http://www.AbsInt.com

提供了識別的lattices 結果（results）。Lattice是從Result類所創建，創建的lattice可以是局部的也可以完整的。
Lattices describe all theories considered by the Recognizer that have not been pruned out。Lattice描述的是被識別器所考慮的所有未被剪枝的理論。
Lattice是一個包含節點和邊所組成的有向圖。一個節點代表了特定時間內所說的一個字。一條邊對應於一個字跟隨另一個字的得分。通常的result結果腳本是貫通lattice的有着最高得分路徑的節點的序列。Lattice是一個非常有用的工具用來分析“alternate results”即可選擇的結果。
一個lattice網格對象從一個有這全標記數的result結果對象產生。目前，僅有WordPruningBreadthFirstSearchManager類有一個AlternativeHypothesisManager。此外，構造lattice的代碼僅在語言學家中起作用，在字搜索狀態在iswordstart方法中返回爲false處，在字的狀態出現在語言學家字的結束處。所有lattice應該是來自與lextreelinguist和WordPruningBreadthFirstSearchManager的結果所創建。
Lattice網格也能夠被一個收縮狀態的標記token樹和它的 AlternativeHypothesisManager所創建。一般，在兩個字token標記之間是一系列的其它類型狀態的token，例如：單元狀態，hmm狀態。使用’w’表示字token標記，u爲單元標記，h爲hmm標記，則一個標記鏈如下：
W - U - H - H - H - H - U - H - H - H - H - W
一般hmm標記包含聲學得分，字標記包含語言得分。如果我們想知道在任何兩個字之間的聲學和語言得分，則保留單元和hmm標記是有必要的。因此對於使用它們的聲學得分和語言得分被collapsed“收縮成”一個token標記。如此看上去爲如下所示：
W - P - W
其中p爲一標記表示在兩個字之間的路徑，p包含在兩字之間的聲學和語言得分。這是一個lattice類所期待的典型的collapsed token tree即收縮標記樹。一般收縮標記樹的任務是由WordPruningBreadthFirstSearchManager類或對象所完成的。一棵收縮的標記樹看上去如下所示：
                              "cat" - P - </s>
                            /
                           P
                          /
 <s> - P - "a" - P - "big"
                          \
                           P
                            \
                             "dog" - P - </s>
 
當一個lattice對象被一個result對象所創建，以上的用可選擇的假設all代替a的收縮的標記樹，將會轉化爲看上去如下的lattice：
   "a"           "cat"
     /     \        /     \
 <s>          "big"         - </s>
     \     /        \     /
      "all"          "dog"

開始或首先，一個lattice網格對象可以有冗餘的節點，也就是有表示相同字來源於相同前續節點的節點。這些節點被collapsed 收縮通過使用latticeoptimizer，即網格優化器。
本類的屬性：
protected Node initialNode;初始節點
protected Node terminalNode;終止節點
protected Set<Edge> edges;邊集
protected Map<String, Node> nodes;節點map
protected double logBase;log基
protected LogMath logMath;
private Set<Token> visitedWordTokens;已經訪問過的標記集
private AlternateHypothesisManager loserManager;可選擇假設選擇管理。
本類的構造方法：
protected Lattice()；創建一個空的lattice網格。
public Lattice(LogMath logMath)；創建一個空的lattice。
public Lattice(Result result)；從result對象創建一個lattice對象。Lattice網格從result所引用的token樹所所創建。然後lattice被優化即被collapsed 化。
本類的方法：
private Node getNode(Token token)；返回與給定字標記相關的節點爲字節點。輸入參數：token爲我們想要的節點的標記。
private String getNodeID(Token token)；返回的是與給定標記token相關的節點的id。返回的是此節點的id。本方法分爲兩種情況，一是：與token相關的節點存在與nodes中的情況，存在則返回此節點，2是token相關的節點不存在於nodes中的情況，則新建與token相關的節點，並加入nodes中，返回新建的節點。
protected void addNode(Node n)；把給定的輸入節點添加入lattice的節點集中即nodes屬性中。此nodes不存在着輸入節點時加入，否則不加入。
protected boolean hasNode(String ID)；參數：id爲查找節點的id。即lattice即nodes屬性中存在着與輸入id相關的節點返回爲true。否則爲false。檢測lattice是否已經包含與一個給定token相關的一個節點。
  boolean hasNode(Node node)；檢測lattice是否包含給定的節點，即nodes屬性中是否存在此輸入節點，存在則返回爲true。
boolean hasEdge(Edge edge)；檢測lattice是否包含給定的邊，即edges屬性是否包含輸入的邊，存在則返回爲true。否則爲false。
protected Node addNode(Token token, int beginTime, int endTime)；根據來自於result標記樹中與節點相關的標記，以及開始和結束時間來添加節點入lattice的節點集中。一般一個標記應該引用一個是字搜索狀態的搜索狀態，儘管其他的標記也許是用來調試的。
public Node addNode(Word word, int beginTime, int endTime) ；添加一個給定字表示，加入時間和結束時間的節點入lattice的nodes屬性中。
  protected Node addNode(String id, Word word, int beginTime, int endTime)；此方法用於從.LAT文件中裝載lattice時使用，添加給定節點的id，字，開始和結束時間的節點入lattice的nodes屬性中。
public Node addNode(String id, String word, int beginTime, int endTime)；此方法用於從.LAT文件中裝載lattice時使用，添加給定節點的id，字的字符串表示，開始和結束時間的節點入lattice的nodes屬性中。
public Edge addEdge(Node fromNode, Node toNode,double acousticScore, double lmScore)；添加一給定起始節點，目標節點，及其聲學和語言得分的邊到lattice的邊集中即Edges中，並返回此邊。起始節點和目標節點都添加了此邊。
public Lattice(String fileName)；從一個LAT文件創建一個lattice網格。LAT文件是由Lattice.dump()方法所創建的。對lattice的相關屬性進行了設置。此方法一般先創建一個空的lattice，在根據此方法來對空的lattice進行設置。以便使之成爲非空的。
private void collapseWordPath(Node parentWordNode, Token token,float acousticScore, float languageScore)；輸入參數：parentWordNode爲返回邊的目標節點。Token的節點爲邊的開始節點，此token的前續token被parentWordNode所表示。acousticScore爲直到幷包括token的祖先（parent）前續的聲學得分。languageScore爲爲直到幷包括token的祖先（parent）前續的語言得分。：如果此標記是表示一個字，則創建一個節點爲此標記，然後創建一條從創建的節點指向parentWordNode節點的邊。收縮到此標記結束的token標記序列。我們已經到達了句的開始標記。如果是一個非字標記，則僅僅添加聲學和語言得分到當前的得分（和得分）上，然後移動到此標記的前續標記。快速移動通過那些不感興趣的狀態來節省棧空間。對所有的丟失的token也進行相同的處理。
private void collapseWordToken(Token token)；collapse收縮給定的字結束標記。這意味着收縮此標記所表示的字相關的所有單元和hmm標記入一條lattice的弧中。即字的所有單元及hmm標記用一條弧表示。
protected void removeNode(Node n)；從lattice的nodes中移除給定節點。
protected Node getNode(String id)；獲得與輸入id相關的節點，是通過nodes來獲得的。
protected Collection<Node> getCopyOfNodes()；獲得lattice中的nodes屬性的一份拷貝。返回的是節點的Collection。此方法被LatticeOptimizer類對象所使用來防止併發的修改節點列表。即防止同時修改。（在多線程使用。）
public Collection<Node> getNodes()；返回的是所有節點的Collection，即nodes.values()。
protected void removeEdge(Edge e)；從lattice的Edges屬性中移除給定輸入的邊，即移除給定的邊。
public Collection<Edge> getEdges()；得到所有的邊的集合即edges屬性。
public void dumpAISee(String fileName, String title)；以Aisee理解的方式打印此lattice到指定的文件中。Aisee是一個圖形可視化工具。具體情況請看：http://www.AbsInt.com
public void dumpDot(String fileName, String title)；以 Graphviz理解的方式打印此lattice到指定的文件中。Graphviz的具體情況請看： http://graphviz.org/
protected void dump(PrintWriter out)；以LAT文件的形式打印lattice。
public void dump(String file) ；以LAT文件的形式打印lattice。爲了測試和實現用於把lattice存儲在ASCII文件中即當做ASCII文件存儲。
protected void removeNodeAndEdges(Node n)；移除從lattice中一個通過輸入給定節點以及與此節點相連的所有的邊。移除後檢測了一致性。僅是從lattice的邊集合節點集中移除相應的項。
protected void removeNodeAndCrossConnectEdges(Node n)；從lattice中移除通過輸入給定節點及相連的邊，用邊連接連接要移除的節點的所有節點。給予如下例子：
Nodes A, B, X, M, N Edges A-->X, B-->X, X-->M, X-->N
 Removing and cross connecting X would result in
 Nodes A, B, M, N Edges A-->M, A-->N, B-->M, B-->N
public Node getInitialNode()；獲得此lattice的初始節點，一般爲<s>符號。
public void setInitialNode(Node p_initialNode)；爲此lattice設置初始節點，一般爲<s>符號。
public Node getTerminalNode()；獲得此lattice的終止節點。一般爲</s>符號.
public void setTerminalNode(Node p_terminalNode);爲此lattice設置終止節點，一般爲</s>符號。
  public double getLogBase()；獲得logmath所使用的基。
public LogMath getLogMath()；獲得在lattice中使用的logmath。
public void setLogMath(LogMath logMath)；設置使用的logmath。
  protected List<String> allPathsFrom(String path, Node n)；符號的是節點列表的一個列表。用於產生從給定的輸入節點開始的內部路徑包括從此節點開始的所有路徑。直接和間接節點所組成的直到每一條路的終止節點爲止。
public List<String> allPaths()；產生從開始節點開始的所有路徑，產生的是通過此lattice的所有路徑列表。在此方法中調用了allPathsFrom("", initialNode)方法。
public void dumpAllPaths()；打印出通過此lattice的所有路徑。用於調試。
boolean checkConsistency()；一致性檢查，即lattice中的nodes中的節點與edges中的邊是否完整的對應。必須完整對應返回爲true，否則拋出錯誤。
protected void sortHelper(Node n, List<Node> sorted, Set<Node> visited)；對此節點及所有的後續（直接和間接）節點進行sort，即放入輸入的sorted中，已經訪問過的所有節點放入輸入的visited中。從右到左的形式
public List<Node> sortNodes()；拓撲分類（sort）在lattice中的所有節點。返回的拓撲sort後的所有節點的列表。以lattice圖的從左到右的形式。
boolean isFillerNode(Node node)；此節點是否表示填充節點即節點字的拼寫是否等於<sil>。
public void removeFillers()；移除在lattice中所有填充字的節點，並用邊連接移除節點的前續和後續節點。檢測了一致性。
  private boolean checkNodesEquivalent(Node n1, Node n2)；輸入參數：n1爲第一個lattice的開始節點。n2爲第二個lattice的開始節點。如果這兩個lattice相等則返回爲true。本方法會迭代的檢查兩個lattice的所有子節點，直到兩lattice的節點不存在子節點爲止。它們的所有節點和邊都相等纔會返回true。
public boolean isEquivalent(Lattice other)；把此lattice與給定的輸入lattice對象比較，看它們是否相等，相等返回true。
private double computeEdgeScore(Edge edge, float languageModelWeightAdjustment,boolean useAcousticScoresOnly)；計算給定邊的得分。它乘以一個調整因子，因爲語言模型得分被在語言學家中的語言模型權重所scored（比例化）。參數： edge爲要計算得分的邊。languageModelWeightAdjustment爲用於已經被語言模型權重比例化scale的語言得分的權重乘數。useAcousticScoresOnly爲是否只使用聲學得分。返回edge.getAcousticScore() + edge.getLMScore() * languageModelWeightAdjustment
或edge.getAcousticScore();
  public List<Node> getViterbiPath()；獲得此lattice的MAP 路徑，僅在computeNodePosteriors方法調用時纔會起作用。返回的是表示MAP 路徑的節點列表。
public void computeNodePosteriors(float languageModelWeightAdjustment,boolean useAcousticScoresOnly)；爲在lattice中的每一個節點計算utterance（句）層次上的後驗概率。也就是此節點發生在通過lattice的所有路徑上的概率。使用用了一個前向-後向算法來確定非循環的從左到右的lattice結構的特性。對於節點層次的節點後驗概率通過節點對象的getPosterior()方法獲得。languageModelWeightAdjustment爲用於已經被語言模型權重比例化scale的語言得分的權重乘數。useAcousticScoresOnly爲是否僅使用聲學得分來計算後驗概率而忽視語言模型權重和得分。此方法分爲3本方，前向，後向，inner三部分。
public void computeNodePosteriors(float languageModelWeightAdjustment) {
        computeNodePosteriors(languageModelWeightAdjustment, false);
    }計算utterance層次的節點的後驗概率。





public void computeNodePosteriors(float languageModelWeightAdjustment,
                                      boolean useAcousticScoresOnly) {
        if (initialNode == null)
                return;
        //forward
        initialNode.setForwardScore(LogMath.getLogOne());
        initialNode.setViterbiScore(LogMath.getLogOne());
        List<Node> sortedNodes = sortNodes();
        assert sortedNodes.get(0) == initialNode;
        for (Node currentNode : sortedNodes) {
            for (Edge edge : currentNode.getLeavingEdges()) {
                double forwardProb = edge.getFromNode().getForwardScore();
                double edgeScore = computeEdgeScore
                        (edge, languageModelWeightAdjustment, useAcousticScoresOnly);
                forwardProb += edgeScore;
                edge.getToNode().setForwardScore
                        (logMath.addAsLinear
                                ((float) forwardProb,
                                        (float) edge.getToNode().getForwardScore()));
                double vs = edge.getFromNode().getViterbiScore() +
                        edgeScore;
                if (edge.getToNode().getBestPredecessor() == null ||
                        vs > edge.getToNode().getViterbiScore()) {
                    edge.getToNode().setBestPredecessor(currentNode);
                    edge.getToNode().setViterbiScore(vs);
                }
            }
        }

        //backward
        terminalNode.setBackwardScore(LogMath.getLogOne());
        assert sortedNodes.get(sortedNodes.size() - 1) == terminalNode;
        ListIterator<Node> n = sortedNodes.listIterator(sortedNodes.size() - 1);
        while (n.hasPrevious()) {
            Node currentNode = n.previous();
            Collection<Edge> currentEdges = currentNode.getLeavingEdges();
            for (Edge edge : currentEdges) {
                double backwardProb = edge.getToNode().getBackwardScore();
                backwardProb += computeEdgeScore
                        (edge, languageModelWeightAdjustment, useAcousticScoresOnly);
                edge.getFromNode().setBackwardScore
                        (logMath.addAsLinear((float) backwardProb,
                                (float) edge.getFromNode().getBackwardScore()));
            }
        }

        //inner
        double normalizationFactor = terminalNode.getForwardScore();
        for (Node node : nodes.values()) {
            node.setPosterior((node.getForwardScore() +
                node.getBackwardScore()) - normalizationFactor);
        }
    }</span>