def cosine_similarity(segmented_topics,
accumulator,
topics,
measure='nlr',
gamma=1,
with_std=False,
with_support=False):
r"""
This function calculates the indirect cosine measure.
Given context vectors u = V(W') and w = V(W*) for the
word sets of a pair S_i = (W', W*) indirect cosine measure
is computed as the cosine similarity between u and w.
The formula used is
m_{sim}_{(m, \gamma)}(W', W*) =
s_{sim}(\vec{V}^{\,}_{m,\gamma}(W'), \vec{V}^{\,}_{m,\gamma}(W*))
where each vector
\vec{V}^{\,}_{m,\gamma}(W') =
\Bigg \{{\sum_{w_{i} \in W'}^{ } m(w_{i}, w_{j})^{\gamma}}\Bigg \}_{j = 1,...,|W|}
Args:
segmented_topics: Output from the segmentation module of the
segmented topics. Is a list of list of tuples.
accumulator: Output from the probability_estimation module. Is an
accumulator of word occurrences (see text_analysis module).
topics: Topics obtained from the trained topic model.
measure (str): Direct confirmation measure to be used. Supported
values are "nlr" (normalized log ratio).
gamma: Gamma value for computing W', W* vectors; default is 1.
with_std (bool): True to also include standard deviation across topic
segment sets in addition to the mean coherence for each topic;
default is False.
with_support (bool): True to also include support across topic segments.
The support is defined as the number of pairwise similarity
comparisons were used to compute the overall topic coherence.
Returns:
list: of indirect cosine similarity measure for each topic.
"""
context_vectors = ContextVectorComputer(measure, topics, accumulator,
gamma)
topic_coherences = []
for topic_words, topic_segments in zip(topics, segmented_topics):
topic_words = tuple(topic_words) # because tuples are hashable
segment_sims = np.zeros(len(topic_segments))
for i, (w_prime, w_star) in enumerate(topic_segments):
w_prime_cv = context_vectors[w_prime, topic_words]
w_star_cv = context_vectors[w_star, topic_words]
segment_sims[i] = _cossim(w_prime_cv, w_star_cv)
topic_coherences.append(
aggregate_segment_sims(segment_sims, with_std, with_support))
return topic_coherences
def cosine_similarity(
segmented_topics, accumulator, topics, measure='nlr', gamma=1,
with_std=False, with_support=False):
r"""
This function calculates the indirect cosine measure.
Given context vectors u = V(W') and w = V(W*) for the
word sets of a pair S_i = (W', W*) indirect cosine measure
is computed as the cosine similarity between u and w.
The formula used is
m_{sim}_{(m, \gamma)}(W', W*) =
s_{sim}(\vec{V}^{\,}_{m,\gamma}(W'), \vec{V}^{\,}_{m,\gamma}(W*))
where each vector
\vec{V}^{\,}_{m,\gamma}(W') =
\Bigg \{{\sum_{w_{i} \in W'}^{ } m(w_{i}, w_{j})^{\gamma}}\Bigg \}_{j = 1,...,|W|}
Args:
segmented_topics: Output from the segmentation module of the
segmented topics. Is a list of list of tuples.
accumulator: Output from the probability_estimation module. Is an
accumulator of word occurrences (see text_analysis module).
topics: Topics obtained from the trained topic model.
measure (str): Direct confirmation measure to be used. Supported
values are "nlr" (normalized log ratio).
gamma: Gamma value for computing W', W* vectors; default is 1.
with_std (bool): True to also include standard deviation across topic
segment sets in addition to the mean coherence for each topic;
default is False.
with_support (bool): True to also include support across topic segments.
The support is defined as the number of pairwise similarity
comparisons were used to compute the overall topic coherence.
Returns:
list: of indirect cosine similarity measure for each topic.
"""
context_vectors = ContextVectorComputer(measure, topics, accumulator, gamma)
topic_coherences = []
for topic_words, topic_segments in zip(topics, segmented_topics):
topic_words = tuple(topic_words) # because tuples are hashable
segment_sims = np.zeros(len(topic_segments))
for i, (w_prime, w_star) in enumerate(topic_segments):
w_prime_cv = context_vectors[w_prime, topic_words]
w_star_cv = context_vectors[w_star, topic_words]
segment_sims[i] = _cossim(w_prime_cv, w_star_cv)
topic_coherences.append(aggregate_segment_sims(segment_sims, with_std, with_support))
return topic_coherences
def word2vec_similarity(segmented_topics,
accumulator,
with_std=False,
with_support=False):
"""For each topic segmentation, compute average cosine similarity using a
WordVectorsAccumulator.
Args:
Args:
segmented_topics (list): Output from the segmentation module of the segmented
topics. Is a list of list of tuples.
accumulator: word occurrence accumulator from probability_estimation.
with_std (bool): True to also include standard deviation across topic segment
sets in addition to the mean coherence for each topic; default is False.
with_support (bool): True to also include support across topic segments. The
support is defined as the number of pairwise similarity comparisons were
used to compute the overall topic coherence.
Returns:
list : of word2vec cosine similarities per topic.
"""
topic_coherences = []
total_oov = 0
for topic_index, topic_segments in enumerate(segmented_topics):
segment_sims = []
num_oov = 0
for w_prime, w_star in topic_segments:
if not hasattr(w_prime, '__iter__'):
w_prime = [w_prime]
if not hasattr(w_star, '__iter__'):
w_star = [w_star]
try:
segment_sims.append(accumulator.ids_similarity(
w_prime, w_star))
except ZeroDivisionError:
num_oov += 1
if num_oov > 0:
total_oov += 1
logger.warning(
"%d terms for topic %d are not in word2vec model vocabulary",
num_oov, topic_index)
topic_coherences.append(
aggregate_segment_sims(segment_sims, with_std, with_support))
if total_oov > 0:
logger.warning("%d terms for are not in word2vec model vocabulary",
total_oov)
return topic_coherences
def word2vec_similarity(segmented_topics, accumulator, with_std=False, with_support=False):
"""For each topic segmentation, compute average cosine similarity using a
WordVectorsAccumulator.
Args:
segmented_topics (list): Output from the segmentation module of the segmented
topics. Is a list of list of tuples.
accumulator: word occurrence accumulator from probability_estimation.
with_std (bool): True to also include standard deviation across topic segment
sets in addition to the mean coherence for each topic; default is False.
with_support (bool): True to also include support across topic segments. The
support is defined as the number of pairwise similarity comparisons were
used to compute the overall topic coherence.
Returns:
list : of word2vec cosine similarities per topic.
"""
topic_coherences = []
total_oov = 0
for topic_index, topic_segments in enumerate(segmented_topics):
segment_sims = []
num_oov = 0
for w_prime, w_star in topic_segments:
if not hasattr(w_prime, '__iter__'):
w_prime = [w_prime]
if not hasattr(w_star, '__iter__'):
w_star = [w_star]
try:
segment_sims.append(accumulator.ids_similarity(w_prime, w_star))
except ZeroDivisionError:
num_oov += 1
if num_oov > 0:
total_oov += 1
logger.warning(
"%d terms for topic %d are not in word2vec model vocabulary",
num_oov, topic_index)
topic_coherences.append(aggregate_segment_sims(segment_sims, with_std, with_support))
if total_oov > 0:
logger.warning("%d terms for are not in word2vec model vocabulary", total_oov)
return topic_coherences
def word2vec_similarity(segmented_topics,
accumulator,
with_std=False,
with_support=False):
"""For each topic segmentation, compute average cosine similarity using a
:class:`~gensim.topic_coherence.text_analysis.WordVectorsAccumulator`.
Parameters
----------
segmented_topics : list of lists of (int, `numpy.ndarray`)
Output from the :func:`~gensim.topic_coherence.segmentation.s_one_set`.
accumulator : :class:`~gensim.topic_coherence.text_analysis.WordVectorsAccumulator` or
:class:`~gensim.topic_coherence.text_analysis.InvertedIndexAccumulator`
Word occurrence accumulator.
with_std : bool, optional
True to also include standard deviation across topic segment sets
in addition to the mean coherence for each topic.
with_support : bool, optional
True to also include support across topic segments. The support is defined as
the number of pairwise similarity comparisons were used to compute the overall topic coherence.
Returns
-------
list of (float[, float[, int]])
Сosine word2vec similarities per topic (with std/support if `with_std`, `with_support`).
Examples
--------
.. sourcecode:: pycon
>>> import numpy as np
>>> from gensim.corpora.dictionary import Dictionary
>>> from gensim.topic_coherence import indirect_confirmation_measure
>>> from gensim.topic_coherence import text_analysis
>>>
>>> # create segmentation
>>> segmentation = [[(1, np.array([1, 2])), (2, np.array([1, 2]))]]
>>>
>>> # create accumulator
>>> dictionary = Dictionary()
>>> dictionary.id2token = {1: 'fake', 2: 'tokens'}
>>> accumulator = text_analysis.WordVectorsAccumulator({1, 2}, dictionary)
>>> _ = accumulator.accumulate([['fake', 'tokens'], ['tokens', 'fake']], 5)
>>>
>>> # should be (0.726752426218 0.00695475919227)
>>> mean, std = indirect_confirmation_measure.word2vec_similarity(segmentation, accumulator, with_std=True)[0]
"""
topic_coherences = []
total_oov = 0
for topic_index, topic_segments in enumerate(segmented_topics):
segment_sims = []
num_oov = 0
for w_prime, w_star in topic_segments:
if not hasattr(w_prime, '__iter__'):
w_prime = [w_prime]
if not hasattr(w_star, '__iter__'):
w_star = [w_star]
try:
segment_sims.append(accumulator.ids_similarity(
w_prime, w_star))
except ZeroDivisionError:
num_oov += 1
if num_oov > 0:
total_oov += 1
logger.warning(
"%d terms for topic %d are not in word2vec model vocabulary",
num_oov, topic_index)
topic_coherences.append(
aggregate_segment_sims(segment_sims, with_std, with_support))
if total_oov > 0:
logger.warning("%d terms for are not in word2vec model vocabulary",
total_oov)
return topic_coherences
def cosine_similarity(segmented_topics,
accumulator,
topics,
measure='nlr',
gamma=1,
with_std=False,
with_support=False):
"""Calculate the indirect cosine measure.
Parameters
----------
segmented_topics: list of lists of (int, `numpy.ndarray`)
Output from the segmentation module of the segmented topics.
accumulator: :class:`~gensim.topic_coherence.text_analysis.InvertedIndexAccumulator`
Output from the probability_estimation module. Is an topics: Topics obtained from the trained topic model.
measure : str, optional
Direct confirmation measure to be used. Supported values are "nlr" (normalized log ratio).
gamma: float, optional
Gamma value for computing :math:`W'` and :math:`W^{*}` vectors.
with_std : bool
True to also include standard deviation across topic segment sets in addition to the mean coherence
for each topic; default is False.
with_support : bool
True to also include support across topic segments. The support is defined as the number of pairwise similarity
comparisons were used to compute the overall topic coherence.
Returns
-------
list
List of indirect cosine similarity measure for each topic.
Examples
--------
.. sourcecode:: pycon
>>> from gensim.corpora.dictionary import Dictionary
>>> from gensim.topic_coherence import indirect_confirmation_measure, text_analysis
>>> import numpy as np
>>>
>>> # create accumulator
>>> dictionary = Dictionary()
>>> dictionary.id2token = {1: 'fake', 2: 'tokens'}
>>> accumulator = text_analysis.InvertedIndexAccumulator({1, 2}, dictionary)
>>> accumulator._inverted_index = {0: {2, 3, 4}, 1: {3, 5}}
>>> accumulator._num_docs = 5
>>>
>>> # create topics
>>> topics = [np.array([1, 2])]
>>>
>>> # create segmentation
>>> segmentation = [[(1, np.array([1, 2])), (2, np.array([1, 2]))]]
>>> obtained = indirect_confirmation_measure.cosine_similarity(segmentation, accumulator, topics, 'nlr', 1)
>>> print(obtained[0])
0.623018926945
"""
context_vectors = ContextVectorComputer(measure, topics, accumulator,
gamma)
topic_coherences = []
for topic_words, topic_segments in zip(topics, segmented_topics):
topic_words = tuple(topic_words) # because tuples are hashable
segment_sims = np.zeros(len(topic_segments))
for i, (w_prime, w_star) in enumerate(topic_segments):
w_prime_cv = context_vectors[w_prime, topic_words]
w_star_cv = context_vectors[w_star, topic_words]
segment_sims[i] = _cossim(w_prime_cv, w_star_cv)
topic_coherences.append(
aggregate_segment_sims(segment_sims, with_std, with_support))
return topic_coherences
def word2vec_similarity(segmented_topics, accumulator, with_std=False, with_support=False):
"""For each topic segmentation, compute average cosine similarity using a
:class:`~gensim.topic_coherence.text_analysis.WordVectorsAccumulator`.
Parameters
----------
segmented_topics : list of lists of (int, `numpy.ndarray`)
Output from the :func:`~gensim.topic_coherence.segmentation.s_one_set`.
accumulator : :class:`~gensim.topic_coherence.text_analysis.WordVectorsAccumulator` or
:class:`~gensim.topic_coherence.text_analysis.InvertedIndexAccumulator`
Word occurrence accumulator.
with_std : bool, optional
True to also include standard deviation across topic segment sets
in addition to the mean coherence for each topic.
with_support : bool, optional
True to also include support across topic segments. The support is defined as
the number of pairwise similarity comparisons were used to compute the overall topic coherence.
Returns
-------
list of (float[, float[, int]])
Сosine word2vec similarities per topic (with std/support if `with_std`, `with_support`).
Examples
--------
.. sourcecode:: pycon
>>> import numpy as np
>>> from gensim.corpora.dictionary import Dictionary
>>> from gensim.topic_coherence import indirect_confirmation_measure
>>> from gensim.topic_coherence import text_analysis
>>>
>>> # create segmentation
>>> segmentation = [[(1, np.array([1, 2])), (2, np.array([1, 2]))]]
>>>
>>> # create accumulator
>>> dictionary = Dictionary()
>>> dictionary.id2token = {1: 'fake', 2: 'tokens'}
>>> accumulator = text_analysis.WordVectorsAccumulator({1, 2}, dictionary)
>>> _ = accumulator.accumulate([['fake', 'tokens'], ['tokens', 'fake']], 5)
>>>
>>> # should be (0.726752426218 0.00695475919227)
>>> mean, std = indirect_confirmation_measure.word2vec_similarity(segmentation, accumulator, with_std=True)[0]
"""
topic_coherences = []
total_oov = 0
for topic_index, topic_segments in enumerate(segmented_topics):
segment_sims = []
num_oov = 0
for w_prime, w_star in topic_segments:
if not hasattr(w_prime, '__iter__'):
w_prime = [w_prime]
if not hasattr(w_star, '__iter__'):
w_star = [w_star]
try:
segment_sims.append(accumulator.ids_similarity(w_prime, w_star))
except ZeroDivisionError:
num_oov += 1
if num_oov > 0:
total_oov += 1
logger.warning(
"%d terms for topic %d are not in word2vec model vocabulary",
num_oov, topic_index)
topic_coherences.append(aggregate_segment_sims(segment_sims, with_std, with_support))
if total_oov > 0:
logger.warning("%d terms for are not in word2vec model vocabulary", total_oov)
return topic_coherences
def cosine_similarity(segmented_topics, accumulator, topics, measure='nlr',
gamma=1, with_std=False, with_support=False):
"""Calculate the indirect cosine measure.
Parameters
----------
segmented_topics: list of lists of (int, `numpy.ndarray`)
Output from the segmentation module of the segmented topics.
accumulator: :class:`~gensim.topic_coherence.text_analysis.InvertedIndexAccumulator`
Output from the probability_estimation module. Is an topics: Topics obtained from the trained topic model.
measure : str, optional
Direct confirmation measure to be used. Supported values are "nlr" (normalized log ratio).
gamma: float, optional
Gamma value for computing :math:`W'` and :math:`W^{*}` vectors.
with_std : bool
True to also include standard deviation across topic segment sets in addition to the mean coherence
for each topic; default is False.
with_support : bool
True to also include support across topic segments. The support is defined as the number of pairwise similarity
comparisons were used to compute the overall topic coherence.
Returns
-------
list
List of indirect cosine similarity measure for each topic.
Examples
--------
.. sourcecode:: pycon
>>> from gensim.corpora.dictionary import Dictionary
>>> from gensim.topic_coherence import indirect_confirmation_measure, text_analysis
>>> import numpy as np
>>>
>>> # create accumulator
>>> dictionary = Dictionary()
>>> dictionary.id2token = {1: 'fake', 2: 'tokens'}
>>> accumulator = text_analysis.InvertedIndexAccumulator({1, 2}, dictionary)
>>> accumulator._inverted_index = {0: {2, 3, 4}, 1: {3, 5}}
>>> accumulator._num_docs = 5
>>>
>>> # create topics
>>> topics = [np.array([1, 2])]
>>>
>>> # create segmentation
>>> segmentation = [[(1, np.array([1, 2])), (2, np.array([1, 2]))]]
>>> obtained = indirect_confirmation_measure.cosine_similarity(segmentation, accumulator, topics, 'nlr', 1)
>>> print(obtained[0])
0.623018926945
"""
context_vectors = ContextVectorComputer(measure, topics, accumulator, gamma)
topic_coherences = []
for topic_words, topic_segments in zip(topics, segmented_topics):
topic_words = tuple(topic_words) # because tuples are hashable
segment_sims = np.zeros(len(topic_segments))
for i, (w_prime, w_star) in enumerate(topic_segments):
w_prime_cv = context_vectors[w_prime, topic_words]
w_star_cv = context_vectors[w_star, topic_words]
segment_sims[i] = _cossim(w_prime_cv, w_star_cv)
topic_coherences.append(aggregate_segment_sims(segment_sims, with_std, with_support))
return topic_coherences