/
eda.html
5091 lines (4772 loc) · 218 KB
/
eda.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
<meta name="generator" content="pdoc 0.10.0" />
<title>ktrain.text.eda API documentation</title>
<meta name="description" content="" />
<link rel="preload stylesheet" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/11.0.1/sanitize.min.css" integrity="sha256-PK9q560IAAa6WVRRh76LtCaI8pjTJ2z11v0miyNNjrs=" crossorigin>
<link rel="preload stylesheet" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/11.0.1/typography.min.css" integrity="sha256-7l/o7C8jubJiy74VsKTidCy1yBkRtiUGbVkYBylBqUg=" crossorigin>
<link rel="stylesheet preload" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/styles/github.min.css" crossorigin>
<style>:root{--highlight-color:#fe9}.flex{display:flex !important}body{line-height:1.5em}#content{padding:20px}#sidebar{padding:30px;overflow:hidden}#sidebar > *:last-child{margin-bottom:2cm}.http-server-breadcrumbs{font-size:130%;margin:0 0 15px 0}#footer{font-size:.75em;padding:5px 30px;border-top:1px solid #ddd;text-align:right}#footer p{margin:0 0 0 1em;display:inline-block}#footer p:last-child{margin-right:30px}h1,h2,h3,h4,h5{font-weight:300}h1{font-size:2.5em;line-height:1.1em}h2{font-size:1.75em;margin:1em 0 .50em 0}h3{font-size:1.4em;margin:25px 0 10px 0}h4{margin:0;font-size:105%}h1:target,h2:target,h3:target,h4:target,h5:target,h6:target{background:var(--highlight-color);padding:.2em 0}a{color:#058;text-decoration:none;transition:color .3s ease-in-out}a:hover{color:#e82}.title code{font-weight:bold}h2[id^="header-"]{margin-top:2em}.ident{color:#900}pre code{background:#f8f8f8;font-size:.8em;line-height:1.4em}code{background:#f2f2f1;padding:1px 4px;overflow-wrap:break-word}h1 code{background:transparent}pre{background:#f8f8f8;border:0;border-top:1px solid #ccc;border-bottom:1px solid #ccc;margin:1em 0;padding:1ex}#http-server-module-list{display:flex;flex-flow:column}#http-server-module-list div{display:flex}#http-server-module-list dt{min-width:10%}#http-server-module-list p{margin-top:0}.toc ul,#index{list-style-type:none;margin:0;padding:0}#index code{background:transparent}#index h3{border-bottom:1px solid #ddd}#index ul{padding:0}#index h4{margin-top:.6em;font-weight:bold}@media (min-width:200ex){#index .two-column{column-count:2}}@media (min-width:300ex){#index .two-column{column-count:3}}dl{margin-bottom:2em}dl dl:last-child{margin-bottom:4em}dd{margin:0 0 1em 3em}#header-classes + dl > dd{margin-bottom:3em}dd dd{margin-left:2em}dd p{margin:10px 0}.name{background:#eee;font-weight:bold;font-size:.85em;padding:5px 10px;display:inline-block;min-width:40%}.name:hover{background:#e0e0e0}dt:target .name{background:var(--highlight-color)}.name > span:first-child{white-space:nowrap}.name.class > span:nth-child(2){margin-left:.4em}.inherited{color:#999;border-left:5px solid #eee;padding-left:1em}.inheritance em{font-style:normal;font-weight:bold}.desc h2{font-weight:400;font-size:1.25em}.desc h3{font-size:1em}.desc dt code{background:inherit}.source summary,.git-link-div{color:#666;text-align:right;font-weight:400;font-size:.8em;text-transform:uppercase}.source summary > *{white-space:nowrap;cursor:pointer}.git-link{color:inherit;margin-left:1em}.source pre{max-height:500px;overflow:auto;margin:0}.source pre code{font-size:12px;overflow:visible}.hlist{list-style:none}.hlist li{display:inline}.hlist li:after{content:',\2002'}.hlist li:last-child:after{content:none}.hlist .hlist{display:inline;padding-left:1em}img{max-width:100%}td{padding:0 .5em}.admonition{padding:.1em .5em;margin-bottom:1em}.admonition-title{font-weight:bold}.admonition.note,.admonition.info,.admonition.important{background:#aef}.admonition.todo,.admonition.versionadded,.admonition.tip,.admonition.hint{background:#dfd}.admonition.warning,.admonition.versionchanged,.admonition.deprecated{background:#fd4}.admonition.error,.admonition.danger,.admonition.caution{background:lightpink}</style>
<style media="screen and (min-width: 700px)">@media screen and (min-width:700px){#sidebar{width:30%;height:100vh;overflow:auto;position:sticky;top:0}#content{width:70%;max-width:100ch;padding:3em 4em;border-left:1px solid #ddd}pre code{font-size:1em}.item .name{font-size:1em}main{display:flex;flex-direction:row-reverse;justify-content:flex-end}.toc ul ul,#index ul{padding-left:1.5em}.toc > ul > li{margin-top:.5em}}</style>
<style media="print">@media print{#sidebar h1{page-break-before:always}.source{display:none}}@media print{*{background:transparent !important;color:#000 !important;box-shadow:none !important;text-shadow:none !important}a[href]:after{content:" (" attr(href) ")";font-size:90%}a[href][title]:after{content:none}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100% !important}@page{margin:0.5cm}p,h2,h3{orphans:3;widows:3}h1,h2,h3,h4,h5,h6{page-break-after:avoid}}</style>
<script defer src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/highlight.min.js" integrity="sha256-Uv3H6lx7dJmRfRvH8TH6kJD1TSK1aFcwgx+mdg3epi8=" crossorigin></script>
<script>window.addEventListener('DOMContentLoaded', () => hljs.initHighlighting())</script>
</head>
<body>
<main>
<article id="content">
<header>
<h1 class="title">Module <code>ktrain.text.eda</code></h1>
</header>
<section id="section-intro">
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">import time
from .. import utils as U
from ..imports import *
from . import preprocessor as pp
from . import textutils as TU
class TopicModel:
def __init__(
self,
texts=None,
n_topics=None,
n_features=10000,
min_df=5,
max_df=0.5,
stop_words="english",
model_type="lda",
max_iter=5,
lda_max_iter=None,
lda_mode="online",
token_pattern=None,
verbose=1,
hyperparam_kwargs=None,
):
"""
Fits a topic model to documents in <texts>.
Example:
tm = ktrain.text.get_topic_model(docs, n_topics=20,
n_features=1000, min_df=2, max_df=0.95)
Args:
texts (list of str): list of texts
n_topics (int): number of topics.
If None, n_topics = min{400, sqrt[# documents/2]})
n_features (int): maximum words to consider
max_df (float): words in more than max_df proportion of docs discarded
stop_words (str or list): either 'english' for built-in stop words or
a list of stop words to ignore
model_type(str): type of topic model to fit. One of {'lda', 'nmf'}. Default:'lda'
max_iter (int): maximum iterations. 5 is default if using lda_mode='online' or nmf.
If lda_mode='batch', this should be increased (e.g., 1500).
lda_max_iter (int): alias for max_iter for backwards compatilibity
lda_mode (str): one of {'online', 'batch'}. Ignored if model_type !='lda'
token_pattern(str): regex pattern to use to tokenize documents.
verbose(bool): verbosity
hyperparam_kwargs(dict): hyperparameters for LDA/NMF
Keys in this dict can be any of the following:
alpha: alpha for LDA default: 5./n_topics
beta: beta for LDA. default:0.01
nmf_alpha: alias for alpha for backwars compatilibity
l1_ratio: l1_ratio for NMF. default: 0
ngram_range: whether to consider bigrams, trigrams. default: (1,1)
"""
self.verbose = verbose
# estimate n_topics
if n_topics is None:
if texts is None:
raise ValueError("If n_topics is None, texts must be supplied")
estimated = max(1, int(math.floor(math.sqrt(len(texts) / 2))))
n_topics = min(400, estimated)
print("n_topics automatically set to %s" % (n_topics))
# train model
if texts is not None:
(model, vectorizer) = self.train(
texts,
model_type=model_type,
n_topics=n_topics,
n_features=n_features,
min_df=min_df,
max_df=max_df,
stop_words=stop_words,
max_iter=max_iter,
lda_max_iter=lda_max_iter,
lda_mode=lda_mode,
token_pattern=token_pattern,
hyperparam_kwargs=hyperparam_kwargs,
)
else:
vectorizer = None
model = None
# save model and vectorizer and hyperparameter settings
self.vectorizer = vectorizer
self.model = model
self.n_topics = n_topics
self.n_features = n_features
if verbose:
print("done.")
# these variables are set by self.build():
self.topic_dict = None
self.doc_topics = None
self.bool_array = None
self.scorer = None # set by self.train_scorer()
self.recommender = None # set by self.train_recommender()
return
def train(
self,
texts,
model_type="lda",
n_topics=None,
n_features=10000,
min_df=5,
max_df=0.5,
stop_words="english",
max_iter=5,
lda_max_iter=None,
lda_mode="online",
token_pattern=None,
hyperparam_kwargs=None,
):
"""
Fits a topic model to documents in <texts>.
Example:
tm = ktrain.text.get_topic_model(docs, n_topics=20,
n_features=1000, min_df=2, max_df=0.95)
Args:
texts (list of str): list of texts
n_topics (int): number of topics.
If None, n_topics = min{400, sqrt[# documents/2]})
n_features (int): maximum words to consider
max_df (float): words in more than max_df proportion of docs discarded
stop_words (str or list): either 'english' for built-in stop words or
a list of stop words to ignore
max_iter (int): maximum iterations for 'lda'. 5 is default if using lda_mode='online'.
lda_max_iter (int): alias for max_iter for backwards compatibility
If lda_mode='batch', this should be increased (e.g., 1500).
Ignored if model_type != 'lda'
lda_mode (str): one of {'online', 'batch'}. Ignored of model_type !='lda'
token_pattern(str): regex pattern to use to tokenize documents.
If None, a default tokenizer will be used
hyperparam_kwargs(dict): hyperparameters for LDA/NMF
Keys in this dict can be any of the following:
alpha: alpha for LDA default: 5./n_topics
beta: beta for LDA. default:0.01
nmf_alpha: alias for alpha for backwars compatilibity
l1_ratio: l1_ratio for NMF. default: 0
ngram_range: whether to consider bigrams, trigrams. default: (1,1)
Returns:
tuple: (model, vectorizer)
"""
max_iter = lda_max_iter if lda_max_iter is not None else max_iter
if hyperparam_kwargs is None:
hyperparam_kwargs = {}
alpha = hyperparam_kwargs.get("alpha", 5.0 / n_topics)
nmf_alpha = hyperparam_kwargs.get("nmf_alpha", None)
alpha = nmf_alpha if nmf_alpha is not None else alpha
beta = hyperparam_kwargs.get("beta", 0.01)
l1_ratio = hyperparam_kwargs.get("l1_ratio", 0)
ngram_range = hyperparam_kwargs.get("ngram_range", (1, 1))
# adjust defaults based on language detected
if texts is not None:
lang = TU.detect_lang(texts)
if lang != "en":
stopwords = None if stop_words == "english" else stop_words
token_pattern = (
r"(?u)\b\w+\b" if token_pattern is None else token_pattern
)
if pp.is_nospace_lang(lang):
text_list = []
for t in texts:
text_list.append(" ".join(jieba.cut(t, HMM=False)))
texts = text_list
if self.verbose:
print("lang: %s" % (lang))
# preprocess texts
if self.verbose:
print("preprocessing texts...")
if token_pattern is None:
token_pattern = TU.DEFAULT_TOKEN_PATTERN
# if token_pattern is None: token_pattern = r'(?u)\b\w\w+\b'
vectorizer = CountVectorizer(
max_df=max_df,
min_df=min_df,
max_features=n_features,
stop_words=stop_words,
token_pattern=token_pattern,
ngram_range=ngram_range,
)
x_train = vectorizer.fit_transform(texts)
# fit model
if self.verbose:
print("fitting model...")
if model_type == "lda":
model = LatentDirichletAllocation(
n_components=n_topics,
max_iter=max_iter,
learning_method=lda_mode,
learning_offset=50.0,
doc_topic_prior=alpha,
topic_word_prior=beta,
verbose=self.verbose,
random_state=0,
)
elif model_type == "nmf":
model = NMF(
n_components=n_topics,
max_iter=max_iter,
verbose=self.verbose,
alpha=alpha,
l1_ratio=l1_ratio,
random_state=0,
)
else:
raise ValueError("unknown model type:", str(model_type))
model.fit(x_train)
# save model and vectorizer and hyperparameter settings
return (model, vectorizer)
@property
def topics(self):
"""
convenience method/property
"""
return self.get_topics()
def get_document_topic_distribution(self):
"""
Gets the document-topic distribution.
Each row is a document and each column is a topic
The output of this method is equivalent to invoking get_doctopics with no arguments.
"""
self._check_build()
return self.doc_topics
def get_sorted_docs(self, topic_id):
"""
Returns all docs sorted by relevance to <topic_id>.
Unlike get_docs, this ranks documents by the supplied topic_id rather
than the topic_id to which document is most relevant.
"""
docs = self.get_docs()
d = {}
for doc in docs:
d[doc["doc_id"]] = doc
m = self.get_document_topic_distribution()
doc_ids = (-m[:, topic_id]).argsort()
return [d[doc_id] for doc_id in doc_ids]
def get_word_weights(self, topic_id, n_words=100):
"""
Returns a list tuples of the form: (word, weight) for given topic_id.
The weight can be interpreted as the number of times word was assigned to topic with given topic_id.
REFERENCE: https://stackoverflow.com/a/48890889/13550699
Args:
topic_id(int): topic ID
n_words=int): number of top words
"""
self._check_model()
if topic_id + 1 > len(self.model.components_):
raise ValueError(
"topic_id must be less than %s" % (len(self.model.components_))
)
feature_names = self.vectorizer.get_feature_names()
word_probs = self.model.components_[topic_id]
word_ids = [i for i in word_probs.argsort()[: -n_words - 1 : -1]]
words = [feature_names[i] for i in word_ids]
probs = [word_probs[i] for i in word_ids]
return list(zip(words, probs))
def get_topics(self, n_words=10, as_string=True, show_counts=False):
"""
Returns a list of discovered topics
Args:
n_words(int): number of words to use in topic summary
as_string(bool): If True, each summary is a space-delimited string instead of list of words
show_counts(bool): If True, returns list of tuples of form (id, topic summary, count).
Otherwise, a list of topic summaries.
Returns:
List of topic summaries if show_count is False
Dictionary where key is topic ID and value is a tuple of form (topic summary, count) if show_count is True
"""
self._check_model()
feature_names = self.vectorizer.get_feature_names()
topic_summaries = []
for topic_idx, topic in enumerate(self.model.components_):
summary = [feature_names[i] for i in topic.argsort()[: -n_words - 1 : -1]]
if as_string:
summary = " ".join(summary)
topic_summaries.append(summary)
if show_counts:
self._check_build()
topic_counts = sorted(
[(k, topic_summaries[k], len(v)) for k, v in self.topic_dict.items()],
key=lambda kv: kv[-1],
reverse=True,
)
return dict((t[0], t[1:]) for t in topic_counts)
return topic_summaries
def print_topics(self, n_words=10, show_counts=False):
"""
print topics
n_words(int): number of words to describe each topic
show_counts(bool): If True, print topics with document counts, where
the count is the number of documents with that topic as primary.
"""
topics = self.get_topics(n_words=n_words, as_string=True)
if show_counts:
self._check_build()
topic_counts = sorted(
[(k, topics[k], len(v)) for k, v in self.topic_dict.items()],
key=lambda kv: kv[-1],
reverse=True,
)
for (idx, topic, count) in topic_counts:
print("topic:%s | count:%s | %s" % (idx, count, topic))
else:
for i, t in enumerate(topics):
print("topic %s | %s" % (i, t))
return
def build(self, texts, threshold=None):
"""
Builds the document-topic distribution showing the topic probability distirbution
for each document in <texts> with respect to the learned topic space.
Args:
texts (list of str): list of text documents
threshold (float): If not None, documents with whose highest topic probability
is less than threshold are filtered out.
"""
if threshold is not None:
doc_topics, bool_array = self.predict(texts, threshold=threshold)
else:
doc_topics = self.predict(texts)
bool_array = np.array([True] * len(texts))
self.doc_topics = doc_topics
self.bool_array = bool_array
texts = [text for i, text in enumerate(texts) if bool_array[i]]
self.topic_dict = self._rank_documents(texts, doc_topics=doc_topics)
return
def filter(self, obj):
"""
The build method may prune documents based on threshold.
This method prunes other lists based on how build pruned documents.
This is useful to filter lists containing metadata associated with documents
for use with visualize_documents.
Args:
obj(list|np.ndarray|pandas.DataFrame):a list, numpy array, or DataFrame of data
Returns:
filtered obj
"""
length = (
obj.shape[0] if isinstance(obj, (pd.DataFrame, np.ndarray)) else len(obj)
)
if length != self.bool_array.shape[0]:
raise ValueError(
"Length of obj is not consistent with the number of documents "
+ "supplied to get_topic_model"
)
obj = np.array(obj) if isinstance(obj, list) else obj
return obj[self.bool_array]
def get_docs(self, topic_ids=[], doc_ids=[], rank=False):
"""
Returns document entries for supplied topic_ids.
Documents returned are those whose primary topic is topic with given topic_id
Args:
topic_ids(list of ints): list of topid IDs where each id is in the range
of range(self.n_topics).
doc_ids (list of ints): list of document IDs where each id is an index
into self.doctopics
rank(bool): If True, the list is sorted first by topic_id (ascending)
and then ty topic probability (descending).
Otherwise, list is sorted by doc_id (i.e., the order
of texts supplied to self.build (which is the order of self.doc_topics).
Returns:
list of dicts: list of dicts with keys:
'text': text of document
'doc_id': ID of document
'topic_proba': topic probability (or score)
'topic_id': ID of topic
"""
self._check_build()
if not topic_ids:
topic_ids = list(range(self.n_topics))
result_texts = []
for topic_id in topic_ids:
if topic_id not in self.topic_dict:
continue
texts = [
{
"text": tup[0],
"doc_id": tup[1],
"topic_proba": tup[2],
"topic_id": topic_id,
}
for tup in self.topic_dict[topic_id]
if not doc_ids or tup[1] in doc_ids
]
result_texts.extend(texts)
if not rank:
result_texts = sorted(result_texts, key=lambda x: x["doc_id"])
return result_texts
def get_doctopics(self, topic_ids=[], doc_ids=[]):
"""
Returns a topic probability distribution for documents
with primary topic that is one of <topic_ids> and with doc_id in <doc_ids>.
If no topic_ids or doc_ids are provided, then topic distributions for all documents
are returned (which equivalent to the output of get_document_topic_distribution).
Args:
topic_ids(list of ints): list of topid IDs where each id is in the range
of range(self.n_topics).
doc_ids (list of ints): list of document IDs where each id is an index
into self.doctopics
Returns:
np.ndarray: Each row is the topic probability distribution of a document.
Array is sorted in the order returned by self.get_docs.
"""
docs = self.get_docs(topic_ids=topic_ids, doc_ids=doc_ids)
return np.array([self.doc_topics[idx] for idx in [x["doc_id"] for x in docs]])
def get_texts(self, topic_ids=[]):
"""
Returns texts for documents
with primary topic that is one of <topic_ids>
Args:
topic_ids(list of ints): list of topic IDs
Returns:
list of str
"""
if not topic_ids:
topic_ids = list(range(self.n_topics))
docs = self.get_docs(topic_ids)
return [x[0] for x in docs]
def predict(self, texts, threshold=None, harden=False):
"""
Args:
texts (list of str): list of texts
threshold (float): If not None, documents with maximum topic scores
less than <threshold> are filtered out
harden(bool): If True, each document is assigned to a single topic for which
it has the highest score
Returns:
if threshold is None:
np.ndarray: topic distribution for each text document
else:
(np.ndarray, np.ndarray): topic distribution and boolean array
"""
self._check_model()
transformed_texts = self.vectorizer.transform(texts)
X_topics = self.model.transform(transformed_texts)
# if self.model_type == 'nmf':
# scores = np.matrix(X_topics)
# scores_normalized= scores/scores.sum(axis=1)
# X_topics = scores_normalized
_idx = np.array([True] * len(texts))
if threshold is not None:
_idx = (
np.amax(X_topics, axis=1) > threshold
) # idx of doc that above the threshold
_idx = np.array(_idx)
X_topics = X_topics[_idx]
if harden:
X_topics = self._harden_topics(X_topics)
if threshold is not None:
return (X_topics, _idx)
else:
return X_topics
def visualize_documents(
self,
texts=None,
doc_topics=None,
width=700,
height=700,
point_size=5,
title="Document Visualization",
extra_info={},
colors=None,
filepath=None,
):
"""
Generates a visualization of a set of documents based on model.
If <texts> is supplied, raw documents will be first transformed into document-topic
matrix. If <doc_topics> is supplied, then this will be used for visualization instead.
Args:
texts(list of str): list of document texts. Mutually-exclusive with <doc_topics>
doc_topics(ndarray): pre-computed topic distribution for each document in texts.
Mutually-exclusive with <texts>.
width(int): width of image
height(int): height of image
point_size(int): size of circles in plot
title(str): title of visualization
extra_info(dict of lists): A user-supplied information for each datapoint (attributes of the datapoint).
The keys are field names. The values are lists - each of which must
be the same number of elements as <texts> or <doc_topics>. These fields are displayed
when hovering over datapoints in the visualization.
colors(list of str): list of Hex color codes for each datapoint.
Length of list must match either len(texts) or doc_topics.shape[0]
filepath(str): Optional filepath to save the interactive visualization
"""
# error-checking
if texts is not None:
length = len(texts)
else:
length = doc_topics.shape[0]
if colors is not None and len(colors) != length:
raise ValueError(
"length of colors is not consistent with length of texts or doctopics"
)
if texts is not None and doc_topics is not None:
raise ValueError("texts is mutually-exclusive with doc_topics")
if texts is None and doc_topics is None:
raise ValueError("One of texts or doc_topics is required.")
if extra_info:
invalid_keys = ["x", "y", "topic", "fill_color"]
for k in extra_info.keys():
if k in invalid_keys:
raise ValueError('cannot use "%s" as key in extra_info' % (k))
lst = extra_info[k]
if len(lst) != length:
raise ValueError("texts and extra_info lists must be same size")
# check fo bokeh
try:
import bokeh.plotting as bp
from bokeh.io import output_notebook
from bokeh.models import HoverTool
from bokeh.plotting import save
except:
warnings.warn(
"visualize_documents method requires bokeh package: pip install bokeh"
)
return
# prepare data
if doc_topics is not None:
X_topics = doc_topics
else:
if self.verbose:
print("transforming texts...", end="")
X_topics = self.predict(texts, harden=False)
if self.verbose:
print("done.")
# reduce to 2-D
if self.verbose:
print("reducing to 2 dimensions...", end="")
tsne_model = TSNE(
n_components=2, verbose=self.verbose, random_state=0, angle=0.99, init="pca"
)
tsne_lda = tsne_model.fit_transform(X_topics)
print("done.")
# get random colormap
colormap = U.get_random_colors(self.n_topics)
# generate inline visualization in Jupyter notebook
lda_keys = self._harden_topics(X_topics)
if colors is None:
colors = colormap[lda_keys]
topic_summaries = self.get_topics(n_words=5)
os.environ["BOKEH_RESOURCES"] = "inline"
output_notebook()
dct = {
"x": tsne_lda[:, 0],
"y": tsne_lda[:, 1],
"topic": [topic_summaries[tid] for tid in lda_keys],
"fill_color": colors,
}
tool_tups = [("index", "$index"), ("(x,y)", "($x,$y)"), ("topic", "@topic")]
for k in extra_info.keys():
dct[k] = extra_info[k]
tool_tups.append((k, "@" + k))
source = bp.ColumnDataSource(data=dct)
hover = HoverTool(tooltips=tool_tups)
p = bp.figure(
plot_width=width,
plot_height=height,
tools=[hover, "save", "pan", "wheel_zoom", "box_zoom", "reset"],
# tools="pan,wheel_zoom,box_zoom,reset,hover,previewsave",
title=title,
)
# plot_lda = bp.figure(plot_width=1400, plot_height=1100,
# title=title,
# tools="pan,wheel_zoom,box_zoom,reset,hover,previewsave",
# x_axis_type=None, y_axis_type=None, min_border=1)
p.circle("x", "y", size=point_size, source=source, fill_color="fill_color")
bp.show(p)
if filepath is not None:
bp.output_file(filepath)
bp.save(p)
return
def train_recommender(self, n_neighbors=20, metric="minkowski", p=2):
"""
Trains a recommender that, given a single document, will return
documents in the corpus that are semantically similar to it.
Args:
n_neighbors (int):
Returns:
None
"""
from sklearn.neighbors import NearestNeighbors
rec = NearestNeighbors(n_neighbors=n_neighbors, metric=metric, p=p)
probs = self.get_doctopics()
rec.fit(probs)
self.recommender = rec
return
def recommend(self, text=None, doc_topic=None, n=5, n_neighbors=100):
"""
Given an example document, recommends documents similar to it
from the set of documents supplied to build().
Args:
texts(list of str): list of document texts. Mutually-exclusive with <doc_topics>
doc_topics(ndarray): pre-computed topic distribution for each document in texts.
Mutually-exclusive with <texts>.
n (int): number of recommendations to return
Returns:
list of tuples: each tuple is of the form:
(text, doc_id, topic_probability, topic_id)
"""
# error-checks
if text is not None and doc_topic is not None:
raise ValueError("text is mutually-exclusive with doc_topic")
if text is None and doc_topic is None:
raise ValueError("One of text or doc_topic is required.")
if text is not None and type(text) not in [str]:
raise ValueError("text must be a str ")
if doc_topic is not None and type(doc_topic) not in [np.ndarray]:
raise ValueError("doc_topic must be a np.ndarray")
if n > n_neighbors:
n_neighbors = n
x_test = [doc_topic]
if text:
x_test = self.predict([text])
docs = self.get_docs()
indices = self.recommender.kneighbors(
x_test, return_distance=False, n_neighbors=n_neighbors
)
results = [doc for i, doc in enumerate(docs) if i in indices]
return results[:n]
def train_scorer(self, topic_ids=[], doc_ids=[], n_neighbors=20):
"""
Trains a scorer that can score documents based on similarity to a
seed set of documents represented by topic_ids and doc_ids.
NOTE: The score method currently employs the use of LocalOutLierFactor, which
means you should not try to score documents that were used in training. Only
new, unseen documents should be scored for similarity.
REFERENCE:
https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.LocalOutlierFactor.html#sklearn.neighbors.LocalOutlierFactor
Args:
topic_ids(list of ints): list of topid IDs where each id is in the range
of range(self.n_topics). Documents associated
with these topic_ids will be used as seed set.
doc_ids (list of ints): list of document IDs where each id is an index
into self.doctopics. Documents associated
with these doc_ids will be used as seed set.
Returns:
None
"""
from sklearn.neighbors import LocalOutlierFactor
clf = LocalOutlierFactor(
n_neighbors=n_neighbors, novelty=True, contamination=0.1
)
probs = self.get_doctopics(topic_ids=topic_ids, doc_ids=doc_ids)
clf.fit(probs)
self.scorer = clf
return
def score(self, texts=None, doc_topics=None):
"""
Given a new set of documents (supplied as texts or doc_topics), the score method
uses a One-Class classifier to score documents based on similarity to a
seed set of documents (where seed set is computed by train_scorer() method).
Higher scores indicate a higher degree of similarity.
Positive values represent a binary decision of similar.
Negative values represent a binary decision of dissimlar.
In practice, negative scores closer to zer will also be simlar as One-Class
classifiers are more strict than traditional binary classifiers.
Documents with negative scores closer to zero are good candidates for
inclusion in a training set for binary classification (e.g., active labeling).
NOTE: The score method currently employs the use of LocalOutLierFactor, which
means you should not try to score documents that were used in training. Only
new, unseen documents should be scored for similarity.
Args:
texts(list of str): list of document texts. Mutually-exclusive with <doc_topics>
doc_topics(ndarray): pre-computed topic distribution for each document in texts.
Mutually-exclusive with <texts>.
Returns:
list of floats: larger values indicate higher degree of similarity
positive values indicate a binary decision of similar
negative values indicate binary decision of dissimilar
In practice, negative scores closer to zero will also
be similar as One-class classifiers are more strict
than traditional binary classifiers.
"""
# error-checks
if texts is not None and doc_topics is not None:
raise ValueError("texts is mutually-exclusive with doc_topics")
if texts is None and doc_topics is None:
raise ValueError("One of texts or doc_topics is required.")
if texts is not None and type(texts) not in [list, np.ndarray]:
raise ValueError("texts must be either a list or numpy ndarray")
if doc_topics is not None and type(doc_topics) not in [np.ndarray]:
raise ValueError("doc_topics must be a np.ndarray")
x_test = doc_topics
if texts:
x_test = self.predict(texts)
return self.scorer.decision_function(x_test)
def search(self, query, topic_ids=[], doc_ids=[], case_sensitive=False):
"""
search documents for query string.
Args:
query(str): the word or phrase to search
topic_ids(list of ints): list of topid IDs where each id is in the range
of range(self.n_topics).
doc_ids (list of ints): list of document IDs where each id is an index
into self.doctopics
case_sensitive(bool): If True, case sensitive search
"""
# setup pattern
if not case_sensitive:
query = query.lower()
pattern = re.compile(r"\b%s\b" % query)
# retrive docs
docs = self.get_docs(topic_ids=topic_ids, doc_ids=doc_ids)
# search
mb = master_bar(range(1))
results = []
for i in mb:
for doc in progress_bar(docs, parent=mb):
text = doc["text"]
if not case_sensitive:
text = text.lower()
matches = pattern.findall(text)
if matches:
results.append(doc)
if self.verbose:
mb.write("done.")
return results
def _rank_documents(self, texts, doc_topics=None):
"""
Rank documents by topic score.
If topic_index is supplied, rank documents based on relevance to supplied topic.
Otherwise, rank all texts by their highest topic score (for any topic).
Args:
texts(list of str): list of document texts.
doc_topics(ndarray): pre-computed topic distribution for each document
If None, re-computed from texts.
Returns:
dict of lists: each element in list is a tuple of (doc_index, topic_index, score)
... where doc_index is an index into either texts
"""
if doc_topics is not None:
X_topics = doc_topics
else:
if self.verbose:
print("transforming texts to topic space...")
X_topics = self.predict(texts)
topics = np.argmax(X_topics, axis=1)
scores = np.amax(X_topics, axis=1)
doc_ids = np.array([i for i, x in enumerate(texts)])
result = list(zip(texts, doc_ids, topics, scores))
if self.verbose:
print("done.")
result = sorted(result, key=lambda x: x[-1], reverse=True)
result_dict = {}
for r in result:
text = r[0]
doc_id = r[1]
topic_id = r[2]
score = r[3]
lst = result_dict.get(topic_id, [])
lst.append((text, doc_id, score))
result_dict[topic_id] = lst
return result_dict
def _harden_topics(self, X_topics):
"""
Transforms soft-clustering to hard-clustering
"""
max_topics = []
for i in range(X_topics.shape[0]):
max_topics.append(X_topics[i].argmax())
X_topics = np.array(max_topics)
return X_topics
def _check_build(self):
self._check_model()
if self.topic_dict is None:
raise Exception("Must call build() method.")
def _check_scorer(self):
if self.scorer is None:
raise Exception("Must call train_scorer()")
def _check_recommender(self):
if self.recommender is None:
raise Exception("Must call train_recommender()")
def _check_model(self):
if self.model is None or self.vectorizer is None:
raise Exception("Must call train()")
def save(self, fname):
"""
save TopicModel object
"""
with open(fname + ".tm_vect", "wb") as f:
pickle.dump(self.vectorizer, f)
with open(fname + ".tm_model", "wb") as f:
pickle.dump(self.model, f)
params = {
"n_topics": self.n_topics,
"n_features": self.n_features,
"verbose": self.verbose,
}
with open(fname + ".tm_params", "wb") as f:
pickle.dump(params, f)
return
get_topic_model = TopicModel</code></pre>
</details>
</section>
<section>
</section>
<section>
</section>
<section>
</section>
<section>
<h2 class="section-title" id="header-classes">Classes</h2>
<dl>
<dt id="ktrain.text.eda.TopicModel"><code class="flex name class">
<span>class <span class="ident">TopicModel</span></span>
<span>(</span><span>texts=None, n_topics=None, n_features=10000, min_df=5, max_df=0.5, stop_words='english', model_type='lda', max_iter=5, lda_max_iter=None, lda_mode='online', token_pattern=None, verbose=1, hyperparam_kwargs=None)</span>
</code></dt>
<dd>
<div class="desc"><p>Fits a topic model to documents in <texts>.</p>
<h2 id="example">Example</h2>
<p>tm = ktrain.text.get_topic_model(docs, n_topics=20,
n_features=1000, min_df=2, max_df=0.95)</p>
<h2 id="args">Args</h2>
<dl>
<dt><strong><code>texts</code></strong> : <code>list</code> of <code>str</code></dt>
<dd>list of texts</dd>
<dt><strong><code>n_topics</code></strong> : <code>int</code></dt>
<dd>number of topics.
If None, n_topics = min{400, sqrt[# documents/2]})</dd>
<dt><strong><code>n_features</code></strong> : <code>int</code></dt>
<dd>maximum words to consider</dd>
<dt><strong><code>max_df</code></strong> : <code>float</code></dt>
<dd>words in more than max_df proportion of docs discarded</dd>
<dt><strong><code>stop_words</code></strong> : <code>str</code> or <code>list</code></dt>
<dd>either 'english' for built-in stop words or
a list of stop words to ignore</dd>
<dt>model_type(str): type of topic model to fit. One of {'lda', 'nmf'}.
Default:'lda'</dt>
<dt><strong><code>max_iter</code></strong> : <code>int</code></dt>
<dd>maximum iterations.
5 is default if using lda_mode='online' or nmf.
If lda_mode='batch', this should be increased (e.g., 1500).</dd>
<dt><strong><code>lda_max_iter</code></strong> : <code>int</code></dt>
<dd>alias for max_iter for backwards compatilibity</dd>
<dt><strong><code>lda_mode</code></strong> : <code>str</code></dt>
<dd>one of {'online', 'batch'}. Ignored if model_type !='lda'</dd>
</dl>
<p>token_pattern(str): regex pattern to use to tokenize documents.
verbose(bool): verbosity
hyperparam_kwargs(dict): hyperparameters for LDA/NMF
Keys in this dict can be any of the following:
alpha: alpha for LDA
default: 5./n_topics
beta: beta for LDA.
default:0.01
nmf_alpha: alias for alpha for backwars compatilibity
l1_ratio: l1_ratio for NMF. default: 0
ngram_range:
whether to consider bigrams, trigrams. default: (1,1)</p></div>
<details class="source">
<summary>
<span>Expand source code</span>
</summary>
<pre><code class="python">class TopicModel:
def __init__(
self,
texts=None,
n_topics=None,
n_features=10000,
min_df=5,
max_df=0.5,
stop_words="english",
model_type="lda",
max_iter=5,
lda_max_iter=None,
lda_mode="online",
token_pattern=None,
verbose=1,
hyperparam_kwargs=None,
):
"""
Fits a topic model to documents in <texts>.
Example:
tm = ktrain.text.get_topic_model(docs, n_topics=20,
n_features=1000, min_df=2, max_df=0.95)
Args:
texts (list of str): list of texts
n_topics (int): number of topics.
If None, n_topics = min{400, sqrt[# documents/2]})
n_features (int): maximum words to consider
max_df (float): words in more than max_df proportion of docs discarded
stop_words (str or list): either 'english' for built-in stop words or
a list of stop words to ignore
model_type(str): type of topic model to fit. One of {'lda', 'nmf'}. Default:'lda'
max_iter (int): maximum iterations. 5 is default if using lda_mode='online' or nmf.
If lda_mode='batch', this should be increased (e.g., 1500).
lda_max_iter (int): alias for max_iter for backwards compatilibity
lda_mode (str): one of {'online', 'batch'}. Ignored if model_type !='lda'
token_pattern(str): regex pattern to use to tokenize documents.
verbose(bool): verbosity
hyperparam_kwargs(dict): hyperparameters for LDA/NMF
Keys in this dict can be any of the following:
alpha: alpha for LDA default: 5./n_topics
beta: beta for LDA. default:0.01
nmf_alpha: alias for alpha for backwars compatilibity
l1_ratio: l1_ratio for NMF. default: 0
ngram_range: whether to consider bigrams, trigrams. default: (1,1)