Word Sense Disambiguation using Diffusion Kernel PCA

TL;DR

This paper introduces Diffusion Kernel PCA, a supervised method for word sense disambiguation that leverages semantic diffusion kernels to improve accuracy, especially with limited labeled data.

Contribution

The paper presents a novel supervised WSD algorithm combining Kernel PCA and semantic diffusion kernels, demonstrating improved performance with scarce labeled data.

Findings

DKPCA outperforms SVM and KPCA on SensEval data.

Effective with limited labeled data.

Encouraging results for semi-supervised WSD development.

Abstract

One of the major problems in natural language processing (NLP) is the word sense disambiguation (WSD) problem. It is the task of computationally identifying the right sense of a polysemous word based on its context. Resolving the WSD problem boosts the accuracy of many NLP focused algorithms such as text classification and machine translation. In this paper, we introduce a new supervised algorithm for WSD, that is based on Kernel PCA and Semantic Diffusion Kernel, which is called Diffusion Kernel PCA (DKPCA). DKPCA grasps the semantic similarities within terms, and it is based on PCA. These properties enable us to perform feature extraction and dimension reduction guided by semantic similarities and within the algorithm. Our empirical results on SensEval data demonstrate that DKPCA achieves higher or very close accuracy results compared to SVM and KPCA with various well-known kernels when the labeled data ratio is meager. Considering the scarcity of labeled data, whereas large quantities of unlabeled textual data are easily accessible, these are highly encouraging first results to develop DKPCA further.

Tables

Table 1. Table 1: Senses and Frequencies in Hard Dataset

No	Sense	Frequency
1	not easy (difficult)	3455
2	not soft (metaphoric)	502
3	not soft (physical)	376

Table 2. Table 2: Senses and Frequencies in Line Dataset

No	Sense	Frequency
1	Stand in line	349
2	A nylon line	502
3	A line between good and evil	374
4	A line from Shakespeare	404
5	The line went dead	429
6	A new line of workstations	2217

Table 3. Table 3: Senses and Frequencies in Serve Dataset

No	Sense	Frequency
1	Function as something	853
2	Provide a service	439
3	Supply with food	1814
4	Hold an office	1272

Table 4. Table 4: Senses and Frequencies in Interest Dataset

No	Sense	Frequency
1	Readiness to give attention	361
2	Quality of causing attention to be given	11
3	Activity, etc. That one gives attention to	66
4	Advantage, advancement or favor	177
5	A share in a company or business	500
6	Money paid for the use of money	1252

Table 5. Table 5: Accuracy scores on the Datasets: If the difference between two competitive scores is less than 1 % percent 1 1\% then we emphasized both scores.

Dataset	Size %	SVM Lin	SVM RBF	SVM Dif.	PCA	KPCA Pol.	KPCA RBF	DKPCA
Interest	5%	57,36	53,00	63,86	64,17	64,37	64,32	72,94
	10%	65,06	53,15	65,39	67,41	66,77	67,65	77,53
	30%	79,48	53,59	79,04	73,08	72,99	72,80	81,68
Line	5%	53,74	53,46	58	60,45	62,76	62	67,92
	10%	56,06	53,45	61,26	63,88	66,48	65,57	71,27
	30%	73,27	53,46	75,51	69,21	70,58	71,71	75,75
Serve	5%	65,27	41,44	68,71	63,53	64,04	62,06	71,73
	10%	72,26	41,45	70,69	66,56	66,94	67,05	74,48
	30%	81,71	41,48	78,51	69,81	70,88	70,47	77,23
Hard	5%	79,80	79,76	81,81	80,19	79,76	79,80	81,15
	10%	80,12	79,76	82,54	80,41	79,86	79,79	82,31
	30%	81,79	79,85	84,07	80,86	80,08	80	83,86

Table 6. Table 6: DKPCA Scores Without Dimension Reduction for Interest Dataset

Size	$F_1$-macro	$F_1$-micro	Accuracy
5%	36,38	65,51	65,51
10%	41,96	74,74	68,46
30%	50,68	74,74	74,74

Table 7. Table 7: Micro F 1 subscript 𝐹 1 F_{1} -scores on the Datasets: If the difference among two competitive scores is less than 1 % percent 1 1\% then we emphasized both scores.

Dataset	Size %	SVM Lin	SVM RBF	SVM Dif.	PCA	KPCA Pol.	KPCA RBF	DKPCA
Interest	5%	57,36	53,00	63,86	64,17	64,37	64,32	72,94
	10%	65,06	53,15	65,39	67,41	66,77	67,65	77,53
	30%	79,48	53,59	79,04	73,08	72,99	72,80	81,68
Line	5%	53,74	53,46	58	60,45	62,76	62	67,92
	10%	56,06	53,45	61,26	63,88	66,48	65,57	71,27
	30%	73,27	53,46	75,51	69,21	70,58	71,71	75,75
Serve	5%	65,27	41,44	68,71	63,53	64,04	62,06	71,73
	10%	72,26	41,45	70,69	66,56	66,94	67,05	74,48
	30%	81,71	41,48	78,51	69,81	70,88	70,47	77,23
Hard	5%	79,80	79,76	81,81	80,19	79,76	79,80	81,15
	10%	80,12	79,76	82,54	80,41	79,86	79,79	82,31
	30%	81,79	79,85	84,07	80,86	80,08	80	83,86

Table 8. Table 8: Macro F 1 subscript 𝐹 1 F_{1} -scores on the Datasets: If the difference among two competitive scores is less than 1 % percent 1 1\% then we emphasized both scores.

Dataset	Size %	SVM Lin	SVM RBF	SVM Dif.	PCA	KPCA Pol.	KPCA RBF	DKPCA
Interest	5%	17,92	11,76	29,18	32,19	32,77	32,01	45,26
	10%	26,03	12,32	34,49	39,31	38,21	39,97	52,56
	30%	51,69	13,40	54,87	47,92	48,19	47,60	57,62
Line	5%	12,55	11,61	21,97	31,63	41,76	40,31	49,08
	10%	19,59	11,61	28,58	38,88	47,78	46,73	54,78
	30%	60,24	11,61	61,21	48,68	53,48	54,64	61,76
Serve	5%	42,59	14,65	53,43	47,65	49,66	46,81	62,94
	10%	56,79	14,68	55,76	51,37	53,00	53,10	67,02
	30%	75,18	14,73	70,97	57,77	59,73	58,80	70,38
Hard	5%	30,05	29,74	43,60	35,52	30,30	30,64	48,30
	10%	32,63	29,94	47,19	36,31	30,79	30,72	53,77
	30%	43,75	43,75	54,79	38,17	32,37	32.32	58,40

Table 9. Table 9: DKPCA Scores Without Dimension Reduction for Line, Hard and Serve Datasets

Dataset	Size	Accuracy	$F_1$-micro	$F_1$-macro
Line	5%	65,17	65,17	42,95
	10%	68,68	68,68	48,92
	30%	72,77	72,77	55,79
Serve	5%	67,02	67,02	53,73
	10%	69,56	69,56	57,93
	30%	72,21	72,21	62,23
Hard	5%	80,10	80,10	34,33
	10%	80,44	80,44	36,21
	30%	81,36	81,36	34,33

Equations

$$\phi :\mathcal{D}$$

$$d_i$$

$$D=\bordermatrix{&t_{1}&\dots&t_{N}\cr d_{1}&tf(t_{1},d_{1})&\dots&tf(t_{N},d_{1})\cr\vdots&\vdots&\ddots&\vdots\cr d_{m}&tf(t_{1},d_{m})&\dots&tf(t_{N},d_{m})\cr}$$

$$K=D{D}^T$$

$$K:X\times X$$

$$(x_i,x_j)$$

$$\text{GaussianKernel}$$

$$\text{PolynomialKernel}$$

$$\text{LinearKernel}$$

$$(D^{T})_{ij}=\left\{\begin{array}[]{rl}1&\,\,\text{if}\,\,t_{j}\in d_{i},\\ 0&\,\,\text{if}\,\,otherwise.\end{array}\right.$$

$$K_{new}(x_i,x_j)=x_{i}S{S}^T{x}_j$$

$$S$$

$$K_{sd}=DS(DS{)}^T=DS{S}^T{D}^T$$

$$\hat{K}_{sd}=JK_{sd}J^{T}\,\,\text{where}\,\,J_{ij}=\left\{\begin{array}[]{rl}1&\,\,\text{if}\,\,i=j\\ \frac{-1}{m}&\,\,\,\,otherwise.\end{array}\right.$$

$${\hat{K}}_{sd}{w}_i={\lambda }_i{w}_i$$

$${\hat{K}}_{sd}W=\Lambda W.$$

$$||w_i||={\lambda }^{-1/2}⟺{\hat{W}}_d={\Lambda }_d^{-1/2}{W}_d.$$

$$Y$$

Full text

1 Introduction

Nearly $\%40$ words in the English language have estimated to have ambiguous meanings, i.e., their meanings depend on their contexts. There are two documented reasons for such an ambiguity; Homonymy which means that an ambiguous word can have the same spelling or pronunciation with a word that has a different sense or polysemy which means that the ambiguous word can have more than one sense [22]. For example, the word interest can have six different meanings (see Table 4). If it is used as in interest in this business, then the meaning is to give attention (see sense 3 in Table 4), and the usage ten percent interest in this business has another meaning which means a share in a company (see Sense 5 in Table 4). There is a clear semantic link between these two sentences whereas the homonymous words are semantically unrelated such as the usage of the word bank as in the savings bank and the usage as in a river bank [19]. Hence the main problem is to predict the exact sense of the word, i.e., choosing the right class defined by the dictionary based on its context. The generalized name for resolving such problems is Word Sense Disambiguation (WSD) which is to computationally identify the exact sense of an ambiguous word from its context [21]. Compared to polysemy, the homonymy is more natural to resolve since the context of the words are in general very different. Polysemy, on the other hand, can be seen in very similar contexts as in the example, and it may become a very subtle problem. Native speakers tend to understand these subtle changes in the meaning subconsciously, and catching the exact meaning seems effortless to them. On the other hand, for computers as well as language learners, solving the problem is a nontrivial task [29].

WSD is handled extensively as a part of text classification studies since it potentially has significant effects on choosing the right class of a given document. Moreover, it is used as a part of machine translation algorithms [3]. There are two kinds of methods that are used in attacking a WSD problem, one of them is called knowledge-based, and the other one is called the corpus-based method [21]. Knowledge-based methods take advantage of the knowledge resources such as dictionaries whereas corpus-based methods use manually sense annotated datasets to train a model. For machine learning, the general approach is to use corpus-based methods since the performance of supervised methods are higher than the unsupervised ones [18]. Another approach for resolving the WSD problem is to use Kernel methods [4, 20, 26]. The basic idea of Kernel methods is to get the non-linear similarities of the data without explicitly computing the feature maps via kernel trick [24]. The problem of choosing the right kernel for the right task is called model selection [8]. General usage favors Support Vector Machines (SVM) as the classifier [4, 20, 26, 32, 33, 32]. On the other hand, there are kernel studies that make use of Principal Component Analysis (PCA), which is called Kernel Principal Component Analysis (KPCA) [25, 28, 34]. For further reading on kernel methods, we refer to [10], and for further knowledge of the usage of kernels for WSD, we refer to [18].

In this study, we introduce a corpus-based kernel method, which is called ’Diffusion Kernel Principal Component Analysis’ (DKPCA). Following the footprints of [13, 32, 34], we merge the semantic diffusion kernel and non-linear PCA in order to construct DKPCA. In section 2.1, we explain Bag of Words (BoW) representation and its shortcomings for grasping intrinsic semantic relations of terms. Such drawbacks of this representation lead to the demand for semantic similarity kernels, and we show the construction of such kernel, i.e., semantic diffusion kernel. We wrap up the mathematics and give an algorithm to compute semantic diffusion kernel. In section 3, we give a linear algebra based approach to the well known KPCA algorithm [30]. By using the results from section 3, we introduce DKPCA.

We test our algorithm with SensEval data and compare it with SVM and KPCA algorithms with several kernels. For evaluating our algorithm, we use mainly $F_{1}$ scores, since the label distribution of our datasets is imbalanced. Our $F_{1}$ macro-averaged results indicate that DKPCA outperforms all the competitive algorithms for $5\%$ and $10\%$ labeled data in SenSeval task (interest, serve, line, and hard) and get similar results for $\%30$ labeled data. For $F_{1}$ micro averaged scores, we get close results with SVM with semantic diffusion kernel for hard data set and DKPCA still outperforms the other algorithms $5\%$ and $10\%$ labeled data for interest, serve and line datasets. These results are highly encouraging concerning the scarcity of the labeled data.

2 Semantic Diffusion Kernel for WSD

2.1 Problem Set up for WSD

Let $\{t_{0},t_{1},\dots,t_{N}\}$ denote the terms (words) in our dictionary which is the set of terms appear in the corpus (the set of documents or contexts) and let $\{d_{1},...,d_{m}\}$ denote the set of documents. Let $t_{0}$ be disambiguated which is seen in the document $d.$ We remove $t_{0}$ from the document $d$ and define the following map

[TABLE]

where $tf(t_{j},d_{i})$ represents the frequency of the term $t_{j}$ in document $d_{i}.$ Then the $document\times term$ data matrix $D$ is given as follows.

[TABLE]

This representation of the data is called the Bag of Words (BoW) representation. The matrix

[TABLE]

is the Gram matrix that represents the following inner product

[TABLE]

where $D^{T}$ is a $term\times document$ matrix [26], and $K$ is a $document\times document$ matrix. Note that we use the same symbol $K$ for the Gram matrix and the inner product map since they are equivalent. The Kernel Map (2.1) and the matrix Kernel (2) defined above both indicate the most basic kernel, namely the linear kernel, that satisfies the Mercer Conditions. These conditions force the given matrix to be positive semi-definite and symmetric in order to be a valid Kernel function. More sophisticated functions can be chosen as a kernel candidate as long as the representation matrix satisfies the Mercer conditions. Some popular kernels are as follows.

[TABLE]

2.2 Semantic Diffusion Kernel

We can represent a data matrix by employing an undirected graph where each vertex indexes each term and each edge keeps the information of the co-occurrences between terms in the documents. Let us explain what we mean by ’co-occurrences between terms’ with an example. Let us consider three sentences: Today is very cold and dark is the first one, Dark rooms have generally have mold is the second one and Mold can cause sickness is the third one. We call them as $d_{1},d_{2},$ and $d_{3}$ respectively. We focus on the terms cold, dark, mold and sickness, which we name $t_{1},t_{2},t_{3},$ and $t_{4}$ respectively. The terms $t_{1}$ and $t_{2}$ have a first order co-occurrence since they are both in $d_{1}.$ Similarly, terms $t_{2}$ and $t_{3}$ with terms $t_{3}$ and $t_{4}$ have first order co-occurrence. This way, we can construct the representation matrix $D^{T}$ as given in [32, 33].

[TABLE]

Wang et al. [32, 33] show that Matrix $G=D^{T}D$ captures the first order correlations since it gives out the first order co-occurrence paths between terms. However, the first order co-occurrences indicate a substantial similarity between the terms, the representations that depend on them like BoW representation and the graph representation, are both sparse and only carries limited information. For example, there is a semantic similarity between cold and mold, which is maybe crucial in classifying $d_{1}$ and $d_{2}$, but $G$ fails to represent this phenomenon.

Hence, careful observation will reveal that the similarity information of semantically close yet distinct words is lost in these representations. A common approach to solve this problem is to enrich BoW representation with the usage of semantic kernels. A semantic kernel $S$ is a $term\times term$ matrix which carries the global similarity scores among terms. It is used to diffuse this information to the kernel in use without harming the Mercer conditions (positive definiteness and the symmetry). In Equation (8) we diffuse a semantic kernel $S$ to the linear (BoW) kernel $K_{lin}.$

[TABLE]

There are different ways to create a semantic kernel [1, 5, 7] but how can we construct a semantic kernel $S$ that can be used as a vessel to carry this semantic information? Before answering this question, let us go back to our example. If there is a first order co-occurrence between two terms, then they are said to have first order correlation, e.g., cold and dark have a first order correlation. The similarity between the term mold and the term cold is called the second order correlation through the term dark. Moreover, there is a third order correlation between cold and sickness through cold and mold. Such correlations among terms are called higher order correlations and can be captured by $G^{p}$ where $p$ is the order. The answer to our question is the semantic diffusion kernel in Equation (2.2)[13], which is a matrix that is designed to carry out the high order semantic correlations.

[TABLE]

Intuitively, as the order of the correlation increases the similarity score should decrease. That is why we use $\lambda$ as the decaying factor in Equation 2.2, which is the Taylor expansion of $e^{\lambda G/2}.$ As the sum goes to infinity, this kernel approaches the Gaussian kernel. In essence, the diffusion kernel is the discretized Gaussian kernel, which is the solution of the time-dependent (continuous) diffusion equation [15]. In practice, the semantic problem does not need a continuous construction at all. Our experiments show that even after the second or third step of the Taylor expansion, the similarity scores among terms fade away. Now let us check whether Mercer conditions hold. The matrix $S$ is a $term\times term$ symmetric, positive semi-definite matrix. It encodes the semantic relations among terms (features). This semantic kernel has to be diffused to the linear Kernel (2) as follows.

[TABLE]

Matrix $K_{sd}$ is a symmetric and positive semi-definite. Let us sum up the discussion above in the following algorithm.

3 Kernel Principal Component Analysis

Principal Component Analysis (PCA) is a technique that captures the information from data by a linear transformation to a coordinate system which is mathematically designed to maximize the variance among data points [23, 9]. If the data does not fit in a linear subspace of the space that data lies then PCA fails to perform this task. A general method to deal with such non-linearity is Kernel PCA (KPCA) [25]. A Kernel function or a Kernel matrix is calculated directly from the data and represents a dot product in a feature space. It enables us to get the non-linear similarities of the data without explicitly computing the feature maps via kernel trick [10]. Mathematically, KPCA is a method to compute the non-linear principal components, which correspond to the eigenvector of the Kernel matrix [30]. If we focus on the Kernel methods what we observe that the basic idea of such methods is to map the data points from the input space to some feature space where the separation of the data becomes computationally more manageable, this simplicity stems from the so-called ’Kernel Trick.’ Kernel trick enables us to skip the cumbersome mathematics of computing the images of $D$ in a feature space and projecting back the result of the inner product in that space. Instead, we can construct an inner product with specific criteria, and we have all the similarities of the data in feature space.

As discussed above, KPCA projects the data a non -linear coordinate system which describes the intrinsic relations among data points better than a linear coordinate system. The first step to achieve this goal is to construct the right kernel matrix. In this work, to capture the semantic similarities, best possible kernel among custom kernels is the semantic diffusion kernel.

For the problem setup, we follow the notation of [30] and we refer this excellent source for detailed information on the topic. We construct the semantic diffusion kernel $K_{sd}$ by following Algorithm (1). To get a meaningful variance, we center the kernel matrix $K_{sd}$ as

[TABLE]

Matrix $J$ in Equation (11) is called the centering matrix, and it is an $M\times M$ matrix which has $1$ on the diagonal and $\frac{-1}{m}$ on the other positions. After centering we compute the eigenvalues and the corresponding eigenvectors of $\hat{K}_{sd}.$

[TABLE]

The eigenvalues are $\lambda_{i},$ and $w_{i}$ are the corresponding eigenvectors. We let $\Lambda$ denote the diagonal matrix that contains the eigenvalues and $W$ denote the matrix of eigenvectors. Then Equation (12) becomes

[TABLE]

However, our main purpose is to find the right transformation which enables us to separate the data as accurate as possible, before the projection step we can also apply the dimension reduction as in traditional PCA in order to clear the noise. This step is crucial when the number of features is very high. Let us choose the dimension $d$ and take the first $d$ eigenvalues $\Lambda_{d}$ and corresponding eigenvectors $W_{d}.$ For choosing this number either grid search on the ratios of the eigenvalues or by using a graph can be applied.

After ordering the eigenvalues in descending order, we pick the first $d$ eigenvalues and the corresponding eigenvectors. Then we normalize the eigenvectors so that for every $i\in\{1,...,d\}$ we have

[TABLE]

Then the low dimensional non-linear principal components for the entire data set can be calculated as follows.

[TABLE]

Equation 14 implies that the low dimensional coordinates can be computed by using the eigenvalues and eigenvectors of the kernel matrix $K_{sd}.$

3.1 Approach-Diffusion Kernel PCA Algorithm

The main goal of this work is to create a methodology which learns the semantic similarities efficiently and transforms the data while applying dimension reduction guided by these similarities and classify this processed data. In the previous sections, we have established the basic theoretical tools necessary to construct such an algorithm. Now we combine these tools to create our algorithm the Diffusion Kernel Principal Component Analysis.

We start by preprocessing the data by cleaning punctuation and stop words with NLTK111https://www.nltk.org/ and continue to get the BoW representation of it as given in Section 2.1. Then we compute the Diffusion Kernel $K_{sd}$ as explained in Section 2.2. This kernel is a $document\times document$ matrix. We use this matrix as we use the covariance matrix in plain PCA, i.e., we centralize $K_{sd}$ as in Equation (11) and compute the eigenvalues (12) and eigenvectors as in (13).

At this point, we decide whether a dimension reduction should be applied. The main idea is the find the values that explain the most significant portion of the variance. First, we order the eigenvalues in descending order, and we did grid search in one fold of the ten folds train-test splits (this part is explained in detail in Section 4) to find the most appropriate dimension and avoid data leakage. Our search process checks the ratios of the eigenvalues. As well checking the ratios of eigenvalues, suitable dimension can be estimated by checking the ratio of each eigenvalue to the sum of the eigenvalues and getting rid of the smallest values. When all features are crucial for the model, this step can be skipped, but we believe for long texts with a large vocabulary, this step is a vital ingredient to get the right dimension reduction that is guided by the semantic similarities. Then by applying Equality (14) we get the non-linear transformation of the data.

These steps were done in an unsupervised manner except for the search for the right dimension. We need a classifier to convert the algorithm to a supervised algorithm. We choose the k-nearest neighbors algorithm because of three main reasons.

We want to compare our results with [34] which introduces the usage of (polynomial kernel) KPCA with KNN for WSD and [32] which presents the usage of Diffusion Kernel with SVM

• 2)

As a result of Reason (1), SVM as a classifier is not an option

• 3)

KNN is an algorithm with high variance and low bias. Choosing KNN disables the classifier to infuse its own bias to our model and enables us to test the performance of DKPCA better.

Let us wrap up the mathematical computation and our discussion with the following algorithm. As explained above for the last step, any standard classification algorithm can be used.

4 Experiments, Evaluations and Results

In order to evaluate the performance of DKPCA for the WSD task, we use the most commonly used datasets of the SensEval.222http://senseval.org/ We implemented SVM and non-linear PCA based kernel methods with linear, polynomial, Gaussian and semantic diffusion kernels.

4.1 Datasets

Hard Data

consists of 4333 instances with three senses taken from WordNet, which is given in Table 1. The instances are taken from the San Jose Mercury News Corpus (SJMN) [17]. As seen in Table 1 the data is not equally distributed, nearly three fourth of the data is labeled with sense 1, which is why we included $F_{1}$ micro and macro scores.

Line Data

is due to [16]. It consists of 4147 instances which are gathered from 1987-1989 Wall Street Journal(WSJ) corpus and the American Printing House for the Blind (APHB) with six different senses annotated from WordNet. Similar to hard data, the distribution of the instances are not homogenous.

Serve Data

is due to [17] like hard data and like line data, the data is gathered from 1987-1989 Wall Street Journal (WSJ) corpus and the American Printing House for the Blind (APHB). It is labeled with four distinct senses from WordNet.

Interest Data

is created with 2368 instances from part of speech tagged subset of the Penn Treebank Wall Street Journal Corpus (ACL/DCI version) which are annotated by using the Longman Dictionary of Contemporary English [2].

4.2 Experimental Setup

In this study, we compare the performances of six different algorithms. Three of them are SVM based: SVM with linear, Gaussian, or radial basis function (RBF) and semantic diffusion kernel. The rest is PCA based: PCA, Kernel PCA with Gaussian (RBF), Polynomial, and Diffusion Kernel PCA (DKPCA). All proposed algorithms are implemented with Python333https:// www.python.org/downloads/ using Python Data Analysis Library (pandas v0.22.0), NLTK, Machine Learning Libraries (scikit learn 0.19.1 and sklearn). For the kernels (RBF, Lin and Pol) and algorithms (PCA, KPCA and SVM) we used the embedded algorithms in scikitlearn. We implemented Diffusion kernel and Diffusion Kernel PCA by following Algorithms (1) and (2). Our implementation can be reached in GitHub444Github.com/dkpca/wsd-project. All the tests are performed on a computer with CPU: INTEL(R) CORE(TM)I7-8700CPU@3.20GHZ and 16 GB RAM.

For preprocessing, the stop words with non-alphabetical words are removed and we compute the vector representation of the data by using tf (term frequency) as in Section 2.1. We split the datasets into three different training set sizes with label percentage: $\%5,\%10$ and $\%30.$ We run the algorithms for ten times with these train-test splits. After testing for each fold we take the arithmetic mean of these results as the final evaluation result in Tables 5-8.

In order to avoid data leakage, we optimize parameters only in one fold of these train-test splits. For the linear kernel, the only optimization is done for parameter $C.$ After grid search for the values $\{0.01,0.05,0.1,0.5,1,10\}$ we find out that the values $1,0.01,0.05,10$ cause slight increases in the accuracy results depending on the data set. For the RBF kernel, we do not optimize the parameter $\gamma$ since our previous attempts show that the default value in sklearn gives the best accuracy values. The choice of the decaying factor $\lambda$ is done by grid search as well and is fixed as $\{0.0039\}.$ We are surprised to observe that choice of the Taylor step should be done either 2 or 3 steps. This makes sense once we consider the effect of the semantic similarity, which is expected to be getting smaller as the correlation is of higher order [6]. For the polynomial kernel, we use the default degree, which is 3. We perform dimension reduction on the interest dataset by checking the ratios of the eigenvalues. Estimating the right dimension can be done by calculating the ratios of each eigenvalue to the sum of eigenvalues as well. Interest dataset has 2367 documents (contexts) and 6929 terms (features). We reduced the dimension from 6929 to 1710 as seen in Fig 1. In Table 6, we present the test results without the dimension reduction and compare the performance in Section 4.3. Our main algorithm is based on KPCA and in order to use the unsupervised KPCA as a supervised algorithm, we need to use a classifier other than SVM. We choose KNN as we explain in detail in Section 3.1. Choice of the number of neighbors for KNN is done by employing cross validation on the values $\{1,..10\}$ and tests indicate that it should be 6.

4.3 Evaluation

The average test results after ten train-test splits are summarized in Tables 5-8. The abbreviations on the tables are Lin. indicates linear kernel. RBF corresponds to Gaussian kernel. Dif. is the SVM with Diffusion kernel and Pol. is the polynomial kernel. The datasets we use have skewed label distribution as given in Tables 1-4. As a result, we employ $F_{1}$ micro and macro scores as our primary evaluation metric.

Tables 5-8 show the results after the dimension reduction and Tables 6 and 9 show the test performance of DKPCA without dimension reduction.

According to Tables 6 and 5, dimension reduction improves the accuracy and $F_{1}$ scores substantially, yet even without the dimension reduction DKPCA performs better than the other algorithms for $5\%$ and $10\%$ for interest and line datasets and similar for hard and serve data sets. On the other hand, dimension reduction improves the efficiency of KNN, since KNN performs poorly for datasets with high dimensions (dimensionality curse).

For hard (12055 terms), serve(17475 terms ) and line(17002 terms) datasets, we just set the dimension to be 1710 randomly, to see how random choice affects the algorithm. In Table 9 we present the scores DKPCA get when applied on these datasets without the dimension reduction. Moreover, the skewness of the distribution of the classes are significant and this skewness causes the micro averaged scores to be larger than macro averaged scores as seen in Tables 8 and 7.

Table 5 shows that for $5\%$ and $10\%$ labeling the accuracy scores of DKPCA are significantly larger than all the other algorithms for the datasets line, serve and interest. This is an important result, concerning the scarcity of the labelled data. This result also indicates that this algorithm can be converted to semi-supervised algorithm as done in [28]. Moreover, carefully done dimension reduction on interest dataset creates a larger positive difference, circa $10\%,$ for DKPCA. Even random or no reduction on the other sets creates a lesser difference, circa $2\%.$ For the hard dataset the difference between the closest Algorithm, i.e., Diffusion Kernel SVM are statistically the same since the difference is not statistically significant. Hence, careful parameter optimization for hard data might change the difference. However, for $30\%$ labeled dataset, DKPCA has a competitive performance compared to SVM Dif. and SVM Lin., for serve dataset, SVM Lin. gives very high performance. Micro-averaged $F_{1}$ scores, as seen in Table 7, are very similar to accuracy scores. On the other hand, macro-averaged $F_{1}$ scores are very low compared to the other metrics in use. Despite this fact, DKPCA outperforms all the other algorithms for $5\%$ and $10\%$ percent labeled data and get statistically similar results for $30\%$ labeling except for the serve dataset.

5 Conclusion and Further Study

Experimental results show that DKPCA outperforms all kernel based SVM algorithms including the semantic diffusion kernel based SVM for $\%5$ and $\%10$ percent train-test splits for all datasets except for hard dataset. Considering the scarcity of the labeled data, our proposed algorithm (Diffusion Kernel Principal Component Analysis) DKPCA gives promising results. As stated in [28] there are some disadvantages of using KPCA based algorithms for datasets that contain targets with dissimilar contexts. In the same paper, this issue is resolved by converting the supervised method to semi-supervised method by including unlabeled data for creating the kernel. As future work, we want to apply this semi-supervised technique with DKPCA and compare our results.

Instead of employing DKPCA only for WSD problems, it can be applied to other research areas in machine learning, i.e., DKPCA can be quite versatile. For example, DKPCA can be used for feature extraction and dimension reduction based on higher order correlation of the data, and this approach may lead to hybrid DKPCA models with other machine learning algorithms or neural networks. We believe that it is a good starting point for merging DKPCA with other deep learning methods. We expect that DKPCA boots the other algorithms performance when there are higher order similarities among data [6].