The document describes the design of a semantic role labeling system. It includes UML descriptions of the DepTree, DepTreeNode, and Corpus_type classes that make up the system. The DepTree class represents a dependency parse tree, DepTreeNode represents nodes in the tree, and Corpus_type represents a corpus of training and testing data. The design generates subtrees from sentences for semantic relation labeling and uses a tree distance algorithm to find similar subtrees in a training corpus for labeling.
Name a naming mechanism for delay disruption tolerant networkIJCNCJournal
This paper presents the design and implementation of the naming mechanism (NAME), a resource
discovery and service location approach for Delay/Disruption-Tolerant Network (DTN). First discuss the
architecture of NAME mainly including Name Knowledge Base, Name Dissemination, Name Resolution
and Name-based Routing. In the design and implementation of NAME, we introduce the simple namespecifiers
to describe name, the name-tree for name storage and the efficient predicate-based routing
algorithm. Future work is finally discussed for completing NAME and providing APIs for abundant
applications.
Transformer Models have taken over most of the Natural language Inference tasks. In recent
times they have proved to beat several benchmarks. Chunking means splitting the sentences into
tokens and then grouping them in a meaningful way. Chunking is a task that has gradually
moved from POS tag-based statistical models to neural nets using Language models such as
LSTM, Bidirectional LSTMs, attention models, etc. Deep neural net Models are deployed
indirectly for classifying tokens as different tags defined under Named Recognition Tasks. Later
these tags are used in conjunction with pointer frameworks for the final chunking task. In our
paper, we propose an Ensemble Model using a fine-tuned Transformer Model and a recurrent
neural network model together to predict tags and chunk substructures of a sentence. We
analyzed the shortcomings of the transformer models in predicting different tags and then
trained the BILSTM+CNN accordingly to compensate for the same.
Collaborative Cuisine's 1 Hour JNDI CookbookKen Lin
For programmers who are already familiar with JNDI and LDAP basics, but wonder how to mix all those ingredients together into collaborative directory-enabled JEE solutions.
http://kenlin.com
Name a naming mechanism for delay disruption tolerant networkIJCNCJournal
This paper presents the design and implementation of the naming mechanism (NAME), a resource
discovery and service location approach for Delay/Disruption-Tolerant Network (DTN). First discuss the
architecture of NAME mainly including Name Knowledge Base, Name Dissemination, Name Resolution
and Name-based Routing. In the design and implementation of NAME, we introduce the simple namespecifiers
to describe name, the name-tree for name storage and the efficient predicate-based routing
algorithm. Future work is finally discussed for completing NAME and providing APIs for abundant
applications.
Transformer Models have taken over most of the Natural language Inference tasks. In recent
times they have proved to beat several benchmarks. Chunking means splitting the sentences into
tokens and then grouping them in a meaningful way. Chunking is a task that has gradually
moved from POS tag-based statistical models to neural nets using Language models such as
LSTM, Bidirectional LSTMs, attention models, etc. Deep neural net Models are deployed
indirectly for classifying tokens as different tags defined under Named Recognition Tasks. Later
these tags are used in conjunction with pointer frameworks for the final chunking task. In our
paper, we propose an Ensemble Model using a fine-tuned Transformer Model and a recurrent
neural network model together to predict tags and chunk substructures of a sentence. We
analyzed the shortcomings of the transformer models in predicting different tags and then
trained the BILSTM+CNN accordingly to compensate for the same.
Collaborative Cuisine's 1 Hour JNDI CookbookKen Lin
For programmers who are already familiar with JNDI and LDAP basics, but wonder how to mix all those ingredients together into collaborative directory-enabled JEE solutions.
http://kenlin.com
This Edureka Recurrent Neural Networks tutorial will help you in understanding why we need Recurrent Neural Networks (RNN) and what exactly it is. It also explains few issues with training a Recurrent Neural Network and how to overcome those challenges using LSTMs. The last section includes a use-case of LSTM to predict the next word using a sample short story
Below are the topics covered in this tutorial:
1. Why Not Feedforward Networks?
2. What Are Recurrent Neural Networks?
3. Training A Recurrent Neural Network
4. Issues With Recurrent Neural Networks - Vanishing And Exploding Gradient
5. Long Short-Term Memory Networks (LSTMs)
6. LSTM Use-Case
Machine-learning scoring functions for molecular dockingPedro Ballester
Docking tools to predict whether and how a small molecule binds to a macromolecular target can be applied if a structural model of such target is available. The reliability of docking depends, however, on the accuracy of the adopted scoring function (SF). Despite intense research over the years, improving the accuracy of SFs for structure‐based binding affinity prediction or virtual screening has proven to be a challenging task for any class of method. New SFs based on modern machine‐learning regression models, which do not impose a predetermined functional form and thus are able to exploit effectively much larger amounts of experimental data, have recently been the object of much interest. These machine‐learning SFs have been shown to outperform a wide range of classical SFs at both binding affinity prediction and virtual screening. The emerging picture from these studies is that the classical approach of using linear regression with a small number of expert‐selected structural features can be strongly improved by a machine‐learning approach based on nonlinear regression allied with comprehensive data‐driven feature selection. As the performance of classical SFs does not grow with larger training datasets, this performance gap is expected to widen as more training data becomes available in the future.
Mathieu Letourneau, Andrei Saygo, Eoin Ward, Microsoft
This talk will present our research project on .Net file clustering based on their respective basic blocks and the parallel that can be made with DNA sequence variation analysis. We implemented a system that extracts the basic blocks on each file and creates clusters based on them. We also developed an IDA plugin to make use of that data and speed up our analysis of .Net files.
Andrei Saygo, Eoin Ward and Mathieu Letourneau all work as Anti-Malware Security Engineers in the AM Scan team of Microsoft’s Product Release & Security Services group in Dublin, Ireland.
This Edureka Recurrent Neural Networks tutorial will help you in understanding why we need Recurrent Neural Networks (RNN) and what exactly it is. It also explains few issues with training a Recurrent Neural Network and how to overcome those challenges using LSTMs. The last section includes a use-case of LSTM to predict the next word using a sample short story
Below are the topics covered in this tutorial:
1. Why Not Feedforward Networks?
2. What Are Recurrent Neural Networks?
3. Training A Recurrent Neural Network
4. Issues With Recurrent Neural Networks - Vanishing And Exploding Gradient
5. Long Short-Term Memory Networks (LSTMs)
6. LSTM Use-Case
Machine-learning scoring functions for molecular dockingPedro Ballester
Docking tools to predict whether and how a small molecule binds to a macromolecular target can be applied if a structural model of such target is available. The reliability of docking depends, however, on the accuracy of the adopted scoring function (SF). Despite intense research over the years, improving the accuracy of SFs for structure‐based binding affinity prediction or virtual screening has proven to be a challenging task for any class of method. New SFs based on modern machine‐learning regression models, which do not impose a predetermined functional form and thus are able to exploit effectively much larger amounts of experimental data, have recently been the object of much interest. These machine‐learning SFs have been shown to outperform a wide range of classical SFs at both binding affinity prediction and virtual screening. The emerging picture from these studies is that the classical approach of using linear regression with a small number of expert‐selected structural features can be strongly improved by a machine‐learning approach based on nonlinear regression allied with comprehensive data‐driven feature selection. As the performance of classical SFs does not grow with larger training datasets, this performance gap is expected to widen as more training data becomes available in the future.
Mathieu Letourneau, Andrei Saygo, Eoin Ward, Microsoft
This talk will present our research project on .Net file clustering based on their respective basic blocks and the parallel that can be made with DNA sequence variation analysis. We implemented a system that extracts the basic blocks on each file and creates clusters based on them. We also developed an IDA plugin to make use of that data and speed up our analysis of .Net files.
Andrei Saygo, Eoin Ward and Mathieu Letourneau all work as Anti-Malware Security Engineers in the AM Scan team of Microsoft’s Product Release & Security Services group in Dublin, Ireland.
These 16 dreams came to King Pasenadi on night during his sleep. But these dreams were strange dreams and it has troubled him because he does not know whether if those were sign of bad omen that would bring misfortune to him and his kingdom. However, when he approached the Buddha for an explanation, the Exalted Ones revealed one by one what those dream were meant to be. It would be good for us to know how those dreams, which happened about 2,600 years ago can relates to events that are happening around us today.
BERT: Bidirectional Encoder Representation from Transformer.
BERT is a Pretrained Model by Google for State of the art NLP tasks.
BERT has the ability to take into account Syntaxtic and Semantic meaning of Text.
Don't be fooled by the thumbnail - the first couple of slides are a silly joke I forgot to remove before uploading.
Presentation derived from the "What's new in Python 2.4" document on http://www.python.org/ including much reformatting for presenting and presenter notes.
Please download the Keynote original - that way the presentation notes aren't burned into the slides.
Write a program in Java to implement the ADT Binary Tree part of who.docxrochellwa9f
Write a program in Java to implement the ADT Binary Tree part of whose definition is given below. You are also to write a driver program that demonstrates the correctness of your implementation by way of taking a series of commands from a text file and carrying them out. In each binary tree that you will deal with, the values are distinct (i.e. there are no duplicates).
Note: Code for binary tree that I discussed in class is available on Isidore. Feel free to use it but you will assume responsibility for the correctness.
The ADT Binary Tree
The only (private) data member you can use is root, as given below. However, feel free to use as many private member functions as you need.
/* Class BinaryTree */
public class BinaryTree> {
/* Class BinaryNode */
static private class BinaryNode> {
T
BinaryNode
BinaryNode
element; // data part
left; // left child
right; // right child
// Add appropriate constructors for BinaryNode
} // end of BinaryNode
private BinaryNode root; // root of the tree
private final int LCHILD = 1; // constant for left child
private final int RCHILD = 2; // constant for right child
// constructor for BinaryTree
public BinaryTree() {
root = null; // construct an empty tree
}
// Below are the methods that you must implement
//
// Create a tree with the given item as the root with its
// subtrees being empty.
// Post: Previous value of the tree is lost.
//
public void insertRoot (T item)
// If node containing parent exists, and if the specified // child is absent, create the specified child of parent // with item as data element and return true; otherwise
// return false.
//
// Pre: data items in the tree are distinct, i.e., no
duplicates.
// item, if it can be successfully inserted, is
different from
// each value in the tree.
// Post: if insertion were successful, item is the specified
child of
// parent.
// Parameters:
// item: data item to be inserted
// parent: data item of the potential parent // child == 1 => item is to be inserted as left
child of parent
// child == 2 => item is to be inserted as right
child of parent
// Return Value:
// true, if insertion succeeded, and false
otherwise.
public boolean insertItem (T item, T parent, int child)
// Print the tree contents in inorder to the stream
// associated with the printwriter output
public void printTree(PrintWriter output)
// Returns true if val1 exists, val2 exists, and they are
// siblings; otherwise, returns false
public boolean siblings (T val1, T val2)
// print to the given printwriter the frontier of the tree, // i.e., all the leaves in a "right to left reading of the // leaves” order; consecutive items are separated by a space public void printFrontier (PrintWriter output)
// delete subtree rooted at item, if item is present;
// otherwise, tree remains unchanged
public void deleteSubtree (T item)
// Post: if item is present, returns refer.
DataStax | Building a Spark Streaming App with DSE File System (Rocco Varela)...DataStax
In this talk, we review a real-world use case that tested the Cassandra+Spark stack on Datastax Enterprise (DSE). We also cover implementation details around application high availability and fault tolerance using the new DSE File System (DSEFS). From a field and testing perspective, we discuss the strategies we can leverage to meet our requirements. Such requirements include (but not limited to) functional coverage, system integration, usability, and performance. We will discuss best practices and lessons we learned covering everything from application development to DSE setup and tuning.
About the Speaker
Rocco Varela Software Engineer in Test, DataStax
After earning his PhD in bioinformatics from UCSF, Rocco Varela took his passion for technology to DataStax. At DataStax he works on several aspects of performance and test automation around DataStax Enterprise (DSE) integrated offerings such as Apache Spark, Hadoop, Solr, and more recently DSE Graph.
Students, digital devices and success - Andreas Schleicher - 27 May 2024..pptxEduSkills OECD
Andreas Schleicher presents at the OECD webinar ‘Digital devices in schools: detrimental distraction or secret to success?’ on 27 May 2024. The presentation was based on findings from PISA 2022 results and the webinar helped launch the PISA in Focus ‘Managing screen time: How to protect and equip students against distraction’ https://www.oecd-ilibrary.org/education/managing-screen-time_7c225af4-en and the OECD Education Policy Perspective ‘Students, digital devices and success’ can be found here - https://oe.cd/il/5yV
2024.06.01 Introducing a competency framework for languag learning materials ...Sandy Millin
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdfTechSoup
In this webinar you will learn how your organization can access TechSoup's wide variety of product discount and donation programs. From hardware to software, we'll give you a tour of the tools available to help your nonprofit with productivity, collaboration, financial management, donor tracking, security, and more.
This is a presentation by Dada Robert in a Your Skill Boost masterclass organised by the Excellence Foundation for South Sudan (EFSS) on Saturday, the 25th and Sunday, the 26th of May 2024.
He discussed the concept of quality improvement, emphasizing its applicability to various aspects of life, including personal, project, and program improvements. He defined quality as doing the right thing at the right time in the right way to achieve the best possible results and discussed the concept of the "gap" between what we know and what we do, and how this gap represents the areas we need to improve. He explained the scientific approach to quality improvement, which involves systematic performance analysis, testing and learning, and implementing change ideas. He also highlighted the importance of client focus and a team approach to quality improvement.
Synthetic Fiber Construction in lab .pptxPavel ( NSTU)
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
Palestine last event orientationfvgnh .pptxRaedMohamed3
An EFL lesson about the current events in Palestine. It is intended to be for intermediate students who wish to increase their listening skills through a short lesson in power point.
How to Create Map Views in the Odoo 17 ERPCeline George
The map views are useful for providing a geographical representation of data. They allow users to visualize and analyze the data in a more intuitive manner.
How to Make a Field invisible in Odoo 17Celine George
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
1. Current design
21-may-09
SRL System 1.0.
Code extended by Hector Franco
UML description
2. DepTree Name of class
+ vector<string> stanza;
+ vector<unsigned int> pred; atributes
+ vector<vector<pair<unsigned int, string> > > apreds;
+ vector<DepTreeNode *> all_nodes;
+ vector<unsigned int> pos_order_vector
+ DepTree(void);
+ DepTree(vector<string> input); methods
+ bool build_tree(void);
+ void export_tree(ofstream &f);
+ bool is_pred(unsigned int index);
+ bool get_sem_dep(unsigned int dep_index, unsigned int head_index, string &rel);
+ bool set_sem_dep(unsigned int dep_index, unsigned int head_index, string &rel);
+ bool get_syn_dep(unsigned int dep_index, unsigned int head_index, string &rel);
+ DepTreeNode *get_lub(DepTreeNode *dt1, DepTreeNode *dt2, vector<DepTreeNode *>&
lpath, vector<DepTreeNode *>& rpath);
+ bool make_subset_for_pred(unsigned int p_index, vector<DepTreeNode *>& nodes);
+ bool make_fresh_tree_for_pred(unsigned int p_index, DepTree& sub_tree);
+ bool export_a_sub_tree(unsigned int p_index, ofstream& sub_tree_f);
+ bool set_post_order_index()
+ boid set_pointers()
+ unsigned int post_order_2_dep_order(unsigned int val);
+ unsigned int sub_tree_order_2_sentence_order(unsigned int val);
// debug:
+ void dot_show(void);
+ void dot_show(ofstream &f);
+ void show_stanza(void);
+ void show_words(void);
+ test1();
3. DepTreeNode
+vector<DepTreeNode *> dtrs; // this node's dependents
+ DepTreeNode *parent; // points to this node's 'head‘
+ unsigned int index; // which node is it
+ unsigned int post_order_index;
+ DepTreeNode * me;
+ string form;
+ string lemma;
+ string pos;
+ string dep_rel; // what rel. between head and this node
+ string pred;
+ DepTree *cntr; // container via this can back up to whole tree if necessary
+ DepTreeNode(void);
+ set_post_order_index(unsigned int & counter, vector<unsigned int & post_order_vector>)
+ DepTreeNode(DepTree *dt, unsigned int i);
+ void show();
4. Tree // it is a struct
Postorder_list *postorder_list; NO changes in Tree Distance implementation.
int *keyroots
none
Postorder_list // it is a struct
Int type;
Enum wildtype wild
Float weight
Int father
Int sons
Int leftmostleaf
none
AlignRecord // it is a struct alignOutcome// it is a struct
Start_of_match N // node index
End_of_match Enum matchtype match_type
Align_src_trg;
none
Align_trg_src
none
5. Description:
+ void re_label(Corpus_type training_data);
• Generate sub_dep_trees in traing and testing.
• For each sub_dep_tree:
Get a ordered list of the most near sub dependences
trees on training data with out alignment, and
generat the alignment only if is need it.
For each semantic relation take the K first and select the
most frequent label (or other KNN voting method).
Using the pointer on info copy back the selected
semantic relation and update stanza.
6. 1 2
4
Time ->
3 sub
Tree
predicate
Deep sub
Tree Tree
sentence
Deep predicate
Hard disk: Tree sub
Corpus 1
Training data sentence
Tree
predicate
Testing data
Deep sub
Corpus 2 Tree Tree
1 training and Deep
sentence predicate
testing data Tree
are at the file sentence
system 2 data is read
it, and 3 each corpus 4 each
created a contains sentence is
corpus. sentences in a discomposed
dependency in sub-
tree structure trees, one for
each
7. 5 6 7
Time ->
sub
t1
Tree q1
predicate
t2
sub
Tree t3
predicate
sub
Tree
predicate
sub
Tree q1
predicate
5-6 each sub-tree is translated 6-7 for each sub-tree from the training data, is
into a tree structure, for tree- found the K nearest (knn),
distance algorithm And save the possible alignments.
If found just one of the most nears trees, who
contain the wanted semantic relation beween
the wanted 2 nodes.
8. 8 11 12
-
Time ->
10
q1 sentence Corpus 2
Output file
Deep
Tree
sentence
8-10 using maping nodes 10-11 for each relation it’s selected the
dep-tree to tree-distance most voted label, and save the results in
the sentences,
11-12, all corpus is write back into the file
system in the same format with new the
labels, ready for the scoring script.
10. DepTree Name of class
+ vector<string> stanza;
+ vector<unsigned int> pred; atributes
+ vector<vector<pair<unsigned int, string> > > apreds; Current design
+ vector<DepTreeNode *> all_nodes;
+ DepTree(void);
methods
+ DepTree(vector<string> input);
+ bool build_tree(void);
+ void export_tree(ifstream &f); // not yet implemented
+ bool is_pred(unsigned int index);
+ bool get_sem_dep(unsigned int dep_index, unsigned int head_index, string &rel);
+ bool get_syn_dep(unsigned int dep_index, unsigned int head_index, string &rel);
+ DepTreeNode *get_lub(DepTreeNode *dt1, DepTreeNode *dt2, vector<DepTreeNode
*>& lpath, vector<DepTreeNode *>& rpath);
+ bool make_subset_for_pred(unsigned int p_index, vector<DepTreeNode *>& nodes);
+ bool make_fresh_tree_for_pred(unsigned int p_index, DepTree& sub_tree);
+ bool export_a_sub_tree(unsigned int p_index, ofstream& sub_tree_f);
// debug:
+ void dot_show(void);
+ void dot_show(ofstream &f);
+ void show_stanza(void);
+ void show_words(void);
11. Current design
DepTreeNode
+vector<DepTreeNode *> dtrs; // this node's dependents
+ DepTreeNode *parent; // points to this node's 'head‘
+ unsigned int index; // which node is it
+ string form;
+ string lemma;
+ string pos;
+ string dep_rel; // what rel. between head and this node
+ string pred;
+ DepTree *cntr; // container via this can back up to whole tree if necessary
+ DepTreeNode(void);
+ DepTreeNode(DepTree *dt, unsigned int i);
+ void show();
12. Tree // it is a struct
Postorder_list *postorder_list; Current design
int *keyroots
none No objects in tree distance implementation
Postorder_list // it is a struct
Int type;
Enum wildtype wild
Float weight
Int father
Int sons
Int leftmostleaf
none
AlignRecord // it is a struct alignOutcome// it is a struct
Start_of_match N // node index
End_of_match Enum matchtype match_type
Align_src_trg;
none
Align_trg_src
none
15. new design
DepTreeNode
- vector<DepTreeNode *> dtrs; // this node's dependents
- DepTreeNode *parent; // points to this node's 'head‘
- int Info; // it works as a pointer in the symbol table.
- DepTree *cntr; // container via this can back up to whole tree if necessary
+ DepTreeNode(string);
+ void update_string(string);
- DepTreeNode(void);
- DepTreeNode(DepTree *dt, unsigned int i);
//Debug:
+ void show();
17. Description:
+ void re_label(Corpus_type training_data);
• Generate sub_dep_trees in traing and testing.
• For each sub_dep_tree:
Get a ordered list of the most near sub
dependences trees on training data with
alignment,
For each semantic relation take the K first and select
the most frequent label (or other KNN voting
method).
Using the pointer on info copy back the selected
semantic relation and update stanza.
18. new design
Info_data //struct type.
unsigned int index; // which node is it
string form;
string lemma;
string pos;
string dep_rel; // what rel. between head and this node
string pred;
string * p_cad // to update the string that generates it-selve.
DepTreeNode * p_depTreeNode; // back to the
none
19. new design
Symbol_table_type
- vector<Info_data *> data; // this node's dependents
+ Symbol_table_type()
+ int encode(Info_data* d)
+ Info_data * decode(int code);
+ double distance(int codeA, int codB);
20. 1 2
4
Time ->
3 sub
Tree
predicate
Deep sub
Tree Tree
sentence
Deep predicate
Hard disk: Tree sub
Corpus 1
Training data sentence
Tree
predicate
Testing data
Deep sub
Corpus 2 Tree Tree
1 training and Deep
sentence predicate
testing data Tree
are at the file sentence
system 2 data is read
it, and 3 each corpus 4 each
created a contains sentence is
corpus. sentences in a discomposed
dependency in sub-trees,
tree structure one for each
predicate
21. 5 6 7
Time ->
sub
t1
Tree q1
predicate
t2
sub
Tree t3
predicate
sub
Tree
predicate
sub
Tree q1
predicate
5-6 each sub-tree is translated 6-7 for each sub-tree from the
into a tree structure, for tree- training data, is found the K
distance algorithm nearest (knn),
And save the possible
alignments.
22. 8 11 12
9
Time ->
10
q1 sentence Corpus 2
Info
node Output file
Deep
Tree
sentence
8-10 each node can access to this 10-11 for each relation it’s selected the
information on the symbol table, and from most voted label, and save the results in
that information, access to the original the sentences,
tree, node to node.
11-12, all corpus is write back into the file
system in the same format with new the
labels, ready for the scoring script.
25. Design II
DepTreeNode
+vector<DepTreeNode *> dtrs; // this node's dependents
+ DepTreeNode *parent; // points to this node's 'head‘
+ unsigned int index; // which node is it
+ string form;
+ string lemma;
+ string pos;
+ string dep_rel; // what rel. between head and this node
+ string pred;
+ DepTree *cntr; // container via this can back up to whole tree if necessary
+ DepTreeNode(void);
+ DepTreeNode(DepTree *dt, unsigned int i);
+ void show();
27. Description:
+ void re_label(Corpus_type training_data);
• Generate sub_dep_trees in traing and testing.
• For each sub_dep_tree:
Get a ordered list of the most near sub dependences
trees on training data with out alignment, and
generat the alignment only if is need it.
For each semantic relation take the K first and select the
most frequent label (or other KNN voting method).
Using the pointer on info copy back the selected
semantic relation and update stanza.
28. 1 2
4
Time ->
3 sub
Tree
predicate
Deep sub
Tree Tree
sentence
Deep predicate
Hard disk: Tree sub
Corpus 1
Training data sentence
Tree
predicate
Testing data
Deep sub
Corpus 2 Tree Tree
1 training and Deep
sentence predicate
testing data Tree
are at the file sentence
system 2 data is read
it, and 3 each corpus 4 each
created a contains sentence is
corpus. sentences in a discomposed
dependency in sub-
tree structure trees, one for
each
29. 5 6 7
Time ->
sub
t1
Tree q1
predicate
t2
sub
Tree t3
predicate
sub
Tree
predicate
sub
Tree q1
predicate
5-6 each sub-tree is translated 6-7 for each sub-tree from the
into a tree structure, for tree- training data, is found the K
distance algorithm nearest (knn),
And save the possible
alignments.
30. 8 11 12
-
Time ->
10
q1 sentence Corpus 2
Output file
Deep
Tree
sentence
8-10 using maping nodes 10-11 for each relation it’s selected the
dep-tree to tree-distance most voted label, and save the results in
the sentences,
11-12, all corpus is write back into the file
system in the same format with new the
labels, ready for the scoring script.
31. Description:
+ getMap(Corpus_type training_data);
• New functions:
• On depTree:
+ getMap_tdep_tdis(AlignRecord &)
// gives a post order alignment.
Corpus_type
+ void re_label(Corpus_type training_data);