Repository navigation
Expand file tree
/
Copy pathmain.cpp
More file actions
3334 lines (3062 loc) · 165 KB
/
Copy pathmain.cpp
File metadata and controls
3334 lines (3062 loc) · 165 KB
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
#include <map>
#include <set>
#include <omp.h>
#include <cmath>
#include <tuple>
#include <queue>
#include <string>
#include <chrono>
#include <vector>
#include <cstring>
#include <fstream>
#include <iostream>
#include <unistd.h>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include "rapidjson/document.h"
#include "rapidjson/istreamwrapper.h"
using namespace rapidjson;
class entity;
class expscore;
class patternentity;
class pattern;
class triple;
class graph;
std::chrono::system_clock::time_point start_read, end_read, start_detect, end_detect;
std::chrono::system_clock::time_point start, end;
std::map<std::string, std::map<std::string, double> > ProcessTime;
std::vector<std::string> QueryVector;
double time_div = 1000.0;
double weight = 1; //無接続の隣接要素のカウント数の重み
int WildCardNum = 0; //ワイルドカードとなる値
int EntityNum, LabelNum, LinkNum;
std::string NowQuery;
std::map<std::string, std::vector<int> > SearchedPatternNum;
std::map<std::string, std::vector<int> > ExistMatchPatternNum;
//現在時刻を表示
void PrintNow(){
std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
std::time_t now_c = std::chrono::system_clock::to_time_t(now);
std::cout << "Now = " << std::ctime(&now_c);
}
//前回呼び出し時からの経過時間を計測
//queryには実行中のクエリ,process_nameには直前に行なっていた計測対象の処理名を入力
//process_no=""の場合は前回呼出時刻更新のみ行う(プログラム開始時または入力処理の場合)
void TimeTime(std::string process_name){
if (process_name != ""){ //経過時間を計測
end = std::chrono::system_clock::now();
double msec = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
if (ProcessTime.find(NowQuery)==ProcessTime.end()) QueryVector.push_back(NowQuery);
if (ProcessTime[NowQuery].find(process_name)==ProcessTime[NowQuery].end()) ProcessTime[NowQuery][process_name] = 0.0;
ProcessTime[NowQuery][process_name] += msec / time_div;
}
start = std::chrono::system_clock::now();
}
//処理時間を表示
void PrintProcessTime(){
double SumTime = 0.0;
std::string SearchQuery;
std::map<std::string, double>::iterator iter_sd, end_sd;
std::cout << "Process Time:" << std::endl << std::endl;
for (int i=0, size_i=QueryVector.size(); i<size_i; ++i){
SearchQuery = QueryVector[i];
std::cout << "<" << SearchQuery << ">" << std::endl;
for (iter_sd=ProcessTime[SearchQuery].begin(), end_sd=ProcessTime[SearchQuery].end(); iter_sd!=end_sd; ++iter_sd){
std::cout << "\t" << iter_sd->first << ": " << iter_sd->second << std::endl;
SumTime += iter_sd->second;
}
std::cout << "\tSumTime: " << SumTime << std::endl << std::endl;
SumTime = 0.0;
}
}
//探索したパターン数を表示
void PrintSearchedPatternNum(){
std::string SearchQuery;
std::cout << "Searched Pattern Num:" << std::endl << std::endl;
for (int i=1, size_i=QueryVector.size(); i<size_i; ++i){
SearchQuery = QueryVector[i];
std::cout << "<" << SearchQuery << ">" << std::endl;
for (int i=0, size_i=SearchedPatternNum[SearchQuery].size(); i<size_i; ++i) std::cout << "\t" << i << ": " << SearchedPatternNum[SearchQuery][i] << std::endl;
}
std::cout << std::endl;
}
////マッチするエンティティが存在するパターン数を表示
void PrintExistMatchPatternNum(){
std::string SearchQuery;
std::map<std::string, std::vector<int> >::iterator iter, end;
std::cout << "Pattern which has matched entities Num:" << std::endl << std::endl;
for (int i=1, size_i=QueryVector.size(); i<size_i; ++i){
SearchQuery = QueryVector[i];
std::cout << "<" << SearchQuery << ">" << std::endl;
for (int i=0, size_i=ExistMatchPatternNum[SearchQuery].size(); i<size_i; ++i) std::cout << "\t" << i << ": " << ExistMatchPatternNum[SearchQuery][i] << std::endl;
}
std::cout << std::endl;
}
//ラベルIDをリンク名に変換
std::string LabelEncoder(int label_id, std::vector<std::string>& LabelList){
if (label_id>-1 and label_id<LabelList.size()) return LabelList[label_id];
else return "*";
}
//リンクIDをリンク名に変換
std::string LinkEncoder(int link_id, std::vector<std::string>& LinkList){
if (link_id>0 and link_id<LinkList.size()) return LinkList[link_id] + "->";
else if (link_id<0 and link_id>-LinkList.size()) return LinkList[-link_id] + "<-";
else if (link_id==0) return "_NoLink_";
else return "*";
}
//指定なしのエンティティかどうか
bool IsWildCardEntity(int entity_id, bool IsLabel){
return (entity_id>LabelNum or entity_id< -LabelNum) and IsLabel or (entity_id>EntityNum or entity_id< -EntityNum) and !IsLabel;
}
//指定なしのリンクかどうか
bool IsWildCardLink(int link_id){
return link_id > LinkNum or link_id< -LinkNum;
}
//taskの処理コストを基にGreedy法で割り当て
std::vector<std::vector<int> > GreedyAlloc(std::vector<int>& task, int ThreadNum){
int min_thread, min_sumtime;
std::vector<std::vector<int> > thread_alloc(ThreadNum); //返すvector(行でスレッド,列でタスク番号を指定)
std::vector<int> thread_sumtime(ThreadNum); //各スレッドの処理合計時間
std::map<int, std::vector<int> > task_map; //taskを処理時間でソートしたもの(key:処理時間,value=タスク番号集合)
std::map<int, std::vector<int> >::reverse_iterator riter_ivi, rend_ivi;
//初期化
for (int i=0; i<ThreadNum; ++i) thread_sumtime[i] = 0;
for (int i=0, size_i=task.size(); i<size_i; ++i) task_map[task[i]].push_back(i);
//処理時間の多いタスクから,一番処理合計時間が少ないスレッドに割り当て
for (riter_ivi=task_map.rbegin(), rend_ivi=task_map.rend(); riter_ivi!=rend_ivi; ++riter_ivi){
for (int i=0, size_i=riter_ivi->second.size(); i<size_i; ++i){
min_thread = 0; //処理合計時間最小のスレッド(合計時間同じの場合は最小のスレッド番号)
min_sumtime = thread_sumtime[0]; //最小の処理合計時間
for (int i=1; i<ThreadNum; ++i){
if (thread_sumtime[i] < min_sumtime){
min_thread = i;
min_sumtime = thread_sumtime[i];
}
}
thread_alloc[min_thread].push_back(riter_ivi->second[i]); //min_threadのスレッドに走査中のタスクを追加
thread_sumtime[min_thread] += riter_ivi->first; //min_threadのスレッドの処理時間を加算
}
}
return thread_alloc;
}
//ファイル名に関するパラメータを読み込み
std::map<std::string, std::string> FilePath(std::string filename, std::string queries_json_name, std::string dataset){
std::string EntityFileName, LinkFileName, org_dataset, datasize, querydir, indexdir;
std::map<std::string, std::string> filepath;
Document doc;
std::map<std::string, std::string>::iterator iter, end;
//JSONファイル読み込み
std::ifstream ifs(filename);
IStreamWrapper isw(ifs);
doc.ParseStream(isw);
ifs.close();
if (dataset.find(".")==dataset.npos){
org_dataset = dataset;
datasize = "";
}
else{
org_dataset = dataset.substr(0, dataset.find("_"));
datasize = dataset.substr(dataset.find("_")+1) + "/";
}
//データセットファイル
filepath["DatasetEntity"] = doc["DatasetDir"].GetString() + org_dataset + "/" + datasize + org_dataset + "_entity.json";
filepath["DatasetLabel"] = doc["DatasetDir"].GetString() + org_dataset + "/" + datasize + org_dataset + "_label.json";
filepath["DatasetLink"] = doc["DatasetDir"].GetString() + org_dataset + "/" + datasize + org_dataset + "_link.json";
//クエリファイル
filepath["QueryDir"] = doc["QueryDir"].GetString() + org_dataset + "/";
filepath["QueriesFile"] = filepath["QueryDir"] + queries_json_name + ".json";
filepath["TargetFileName"] = doc["TargetFile"].GetString();
filepath["ContextFileName"] = doc["ContextFile"].GetString();
//一覧ファイル
filepath["EnumerateDir"] = doc["EnumerateDir"].GetString() + org_dataset + "/";
filepath["EntityEnumerate"] = filepath["EnumerateDir"] + datasize + doc["EntityEnumerateFile"].GetString();
filepath["LinkEnumerate"] = filepath["EnumerateDir"] + datasize + doc["LinkEnumerateFile"].GetString();
filepath["CombinationEnumerate"] = filepath["EnumerateDir"] + datasize + doc["CombinationEnumerateFile"].GetString();
//インデックスファイル
filepath["IndexDir"] = doc["IndexDir"].GetString() + org_dataset + "/" + datasize;
filepath["IndexFileName"] = filepath["IndexDir"] + doc["IndexFile"].GetString();
//for (iter=filepath.begin(), end=filepath.end(); iter!=end; ++iter) std::cout << iter->first << ": " << iter->second << std::endl;
return filepath;
}
class entity{
private:
int ID; //エンティティID
std::string Name; //エンティティ名
std::unordered_set<int> Label; //エンティティラベルのID
std::unordered_map<int, std::vector<int> > Relation; //リンク情報
public:
int GetId(){return ID;}; //IDを返す
std::string& GetName(){return Name;} //Nameを返す
std::unordered_set<int>& GetLabel(){return Label;}; //Labelを返す
std::unordered_map<int, std::vector<int> >& GetRelation(){return Relation;}; //Relationを返す
bool empty(); //空かどうか
void ModifyEntity(int, std::string, std::unordered_set<int>); //entityを変更
void AddLink(int, int); //リンクを追加
void PrintEntity(std::ostream&, bool, bool, std::vector<entity>&, std::vector<std::string>&, std::vector<std::string>&); //エンティティを表示
entity(){ID = 0;};
~entity(){Name.clear(); Label.clear(); Relation.clear();};
};
//空かどうか
bool entity::empty(){
return ID == 0;
}
//entityを変更
void entity::ModifyEntity(int id, std::string name, std::unordered_set<int> label){
ID = id;
Name = name;
Label = label;
}
//リンクを追加
void entity::AddLink(int link_id, int ee_id){
Relation[link_id].push_back(ee_id);
}
//エンティティを表示(PrintLink:隣接エンティティを表示するかどうか)
void entity::PrintEntity(std::ostream& os, bool PrintLink, bool PrintName, std::vector<entity>& EntityList, std::vector<std::string>& LabelList, std::vector<std::string>& LinkList){
std::unordered_set<int>::iterator iter_l, end_l;
std::unordered_map<int, std::vector<int> >::iterator iter_rlt, end_rlt;
if (!empty()){
if (ID>-1 and ID<EntityList.size()) os << ID << ". " << Name << "("; //IDとエンティティ名
else os << "*" << "("; //IDとエンティティ名
if (PrintName) for (iter_l=Label.begin(), end_l=Label.end(); iter_l!=end_l; ++iter_l) os << LabelEncoder(*iter_l, LabelList) << " "; //ラベル
else for (iter_l=Label.begin(), end_l=Label.end(); iter_l!=end_l; ++iter_l) os << *iter_l << " ";
}
os << ")" << std::endl;
if (PrintLink and !Relation.empty()){
for (iter_rlt=Relation.begin(), end_rlt=Relation.end(); iter_rlt!=end_rlt; ++iter_rlt) { //各リンク
if (PrintName) os << "\t" << LinkEncoder(iter_rlt->first, LinkList) << ":";
else os << "\t" << iter_rlt->first << ":";
for (int j=0, size_j=iter_rlt->second.size(); j<size_j; ++j) os << iter_rlt->second[j] << ", ";
os << std::endl;
}
}
}
//エンティティIDをリンク名に変換
std::string EntityEncoder(int entity_id, std::vector<entity>& EntityList){
if (entity_id>-1 and entity_id<EntityList.size()) return EntityList[entity_id].GetName();
else return "*";
}
//トリプルクラス(Exprankingのkeyとして使用)
class triple{
public:
int ID_se; //始点エンティティID
int ID_link; //リンクラベルID
int ID_ee; //終点エンティティID
void SetTriple(int se_id, int link_id, int ee_id){ID_se=se_id; ID_link=link_id; ID_ee=ee_id;};
bool operator<(const triple& t) const{return ID_se<t.ID_se or ID_se==t.ID_se and (ID_link<t.ID_link or ID_link==t.ID_link and ID_ee<t.ID_ee);}
triple(){};
triple(int se_id, int link_id, int ee_id){ID_se=se_id; ID_link=link_id; ID_ee=ee_id;};
~triple(){};
};
//パターン中のエンティティクラス
class patternentity{
private:
int ID; //ID(エンティティID,ラベルIDどちらも可)
bool IsLabel; //そのエンティティがラベルかどうか
int ID_pe; //PatternList中のインデックス値
std::unordered_map<int, std::vector<int> > Relation; //リンク情報
std::unordered_set<int> MatchEntity; //該当エンティティ
std::unordered_map<int, std::unordered_set<int> > LinkClassifiedME; //隣接リンクごとに分類したマッチエンティティ
std::unordered_map<int, std::unordered_map<int, int> > CombineLabelEntity; //結合するエンティティラベル(key:リンクラベルID,value:結合しているエンティティラベル集合)
std::unordered_map<int, std::unordered_map<int, int> > CombineUniqueEntity; //結合するエンティティ(key:リンクラベルID,value:結合しているエンティティ集合)
std::unordered_map<int, std::unordered_map<int, int> > CombineLink; //結合するリンク(key:終点エンティティラベル,value:結合しているリンク)
std::vector<bool> Prunable; //枝刈り可能かどうか(順に,エンティティラベル,固有エンティティ,リンク,patternentityの枝刈り可能性)
double UpperBoundScore; //patternentityの上界スコア(PatternUnitListでのみ使用)
public:
//メンバ返し・等号
int GetId(){return ID;}; //IDを返す
bool GetIsLabel(){return IsLabel;}; //IsLabelを返す
int GetId_pe(){return ID_pe;}; //ID_peを返す
std::unordered_map<int, std::vector<int> >& GetRelation(){return Relation;}; //Relationを返す
std::unordered_set<int>& GetMatchEntity(){return MatchEntity;}; //MatchEntityを返す
std::unordered_map<int, std::unordered_set<int> >& GetLinkClassifiedME(){return LinkClassifiedME;}; //LinkClassifiedMEを返す
std::unordered_map<int, std::unordered_map<int, int> >& GetCombineLabelEntity(){return CombineLabelEntity;}; //CombineLabelEntityを返す
std::unordered_map<int, std::unordered_map<int, int> >& GetCombineUniqueEntity(){return CombineUniqueEntity;}; //CombineUniqueEntityを返す
std::unordered_map<int, std::unordered_map<int, int> >& GetCombineLink(){return CombineLink;}; //CombineLinkを返す
std::vector<bool>& GetPrunable(){return Prunable;}; //Prunableを返す
bool SamePatternentity(patternentity&); //同じpatternentityかどうか
void CopyPrunable(patternentity&); //枝刈り状況をコピー
patternentity& operator=(patternentity&); //等号演算
//メンバ変更
void ModifyEntity(int, int, bool); //パターン構造中のエンティティを変更
void ModifyLink(int, int, int); //リンクラベルを変更
void AddLink(int, int); //リンクを追加
void ClearEntity(); //エンティティ情報をクリア(ワイルドカードにする)
void ClearLink(int, int, bool); //リンク情報をクリア(ワイルドカードにする)
void ModifyMatchEntity(std::unordered_set<int>&); //MatchEntityを変更
void AddMatchEntity(int); //エンティティをMatchEntityに追加
void AddLinkClassifiedME(int, int); //エンティティをLinkClassifiedMEに追加
void ModifyCombineElement(std::unordered_map<int, std::unordered_map<int, int> >& combine, int Kind); //CombineXXをセット
void AddCombineEntity(int, int, std::unordered_set<int>&); //結合しているエンティティとして追加
void AddCombineLink(int, int); //結合しているリンクとして追加
void ClearCombineElement(int); //CombineXXをクリア
void SetUpperBoundScore(double); //UpperBoundScoreを変更
//枝刈り関係
double GetUpperBoundScore_kind_r_dist(std::map<double, int>&, double); //rでの例外の種類レベルでの上界スコアを計算(分布の偏りベース)
double GetUpperBoundScore_kind_r_freq(std::map<double, int>&, double); //rでの例外の種類レベルでの上界スコアを計算(頻度ベース)
double GetUpperBoundScore_kind(int, std::string&); //例外の種類レベルでの上界スコアを計算(kindは0から順に,エンティティラベル,固有エンティティ,リンク)
double GetUpperBoundScore(std::string&); //UpperBoundScoreを返す
void Pruning_kind(int, std::string&, double); //例外の種類レベルでの枝刈りが可能なら実行(kindは0から順に,エンティティラベル,固有エンティティ,リンク)
void Pruning(std::string&, double); //パターンエンティティレベルでの枝刈りが可能なら実行
//表示
void PrintPatternentity(std::ostream&, bool, bool, bool, bool, bool, bool, std::vector<entity>&, std::vector<std::string>&, std::vector<std::string>&); //patternentityを表示
void PrintPrunable(std::ostream&); //枝刈り状況を表示
//その他
patternentity(){Prunable.resize(4); for (int i=0; i<4; ++i) Prunable[i] = false; UpperBoundScore=0;};
~patternentity(){Relation.clear(); MatchEntity.clear(); CombineLabelEntity.clear(); CombineUniqueEntity.clear(); CombineLink.clear(); Prunable.clear(); UpperBoundScore=0;};
};
//同じpatternentityかどうか
bool patternentity::SamePatternentity(patternentity& pe){
return ID==pe.GetId() && (IsLabel && pe.GetIsLabel() || !IsLabel && !pe.GetIsLabel());
}
//枝刈り状況をコピー
void patternentity::CopyPrunable(patternentity& pe){
Prunable = pe.GetPrunable();
}
//等号演算
patternentity& patternentity::operator=(patternentity& pe){
ID_pe = pe.GetId_pe();
ID = pe.GetId();
IsLabel = pe.GetIsLabel();
Relation = pe.GetRelation();
return *this;
}
//エンティティを変更
void patternentity::ModifyEntity(int id_pe, int id, bool islabel){
ID_pe = id_pe;
ID = id;
IsLabel = islabel;
}
//リンクラベルを変更
void patternentity::ModifyLink(int link_id, int epe_idx, int new_link_id){
int idx;
if (Relation[link_id].size()==1) Relation.erase(link_id); //Relation[link_id]が一つしかない場合,タプルを削除
else{ //複数ある場合
for (int i=0, size_i=Relation[link_id].size(); i<size_i; ++i){
if (Relation[link_id][i]==epe_idx){
idx = i;
break;
}
}
for (int i=idx, size_i=Relation[link_id].size()-1; i<size_i; ++i) Relation[link_id][i] = Relation[link_id][i+1];
Relation[link_id].resize(Relation[link_id].size()-1);
}
Relation[new_link_id].push_back(epe_idx);
}
//リンクを追加
void patternentity::AddLink(int link_id, int pe_idx){
Relation[link_id].push_back(pe_idx);
}
//エンティティ情報をクリア(ワイルドカードにする)
void patternentity::ClearEntity(){
ModifyEntity(ID_pe, WildCardNum, true);
}
//リンク情報をクリア(ワイルドカードにする)
void patternentity::ClearLink(int link_id, int epe_idx, bool WildCardIsPosNum){
if (WildCardIsPosNum) ModifyLink(link_id, epe_idx, WildCardNum);
else ModifyLink(link_id, epe_idx, -WildCardNum);
}
//MatchEntityを変更
void patternentity::ModifyMatchEntity(std::unordered_set<int>& ME){
MatchEntity = ME;
}
//エンティティをMatchEntityに追加
void patternentity::AddMatchEntity(int id){
MatchEntity.insert(id);
}
//エンティティをLinkClassifiedMEに追加
void patternentity::AddLinkClassifiedME(int link_id, int entity_id){
LinkClassifiedME[link_id].insert(entity_id);
}
//CombineXXを変更
void patternentity::ModifyCombineElement(std::unordered_map<int, std::unordered_map<int, int> >& combine, int Kind){
if (Kind==0) CombineLabelEntity = combine;
else if (Kind==1) CombineUniqueEntity = combine;
else CombineLink = combine;
}
//結合しているエンティティとして追加
void patternentity::AddCombineEntity(int link_id, int ee_id, std::unordered_set<int>& label){
std::unordered_set<int>::iterator iter, end;
CombineUniqueEntity[link_id][ee_id]++;
for (iter=label.begin(), end=label.end(); iter!=end; ++iter) CombineLabelEntity[link_id][*iter]++;
}
//結合しているリンクとして追加
void patternentity::AddCombineLink(int link_id, int label){
CombineLink[label][link_id]++;
}
//CombineXXをクリア
void patternentity::ClearCombineElement(int kind){
if (kind==0 or kind==3) CombineLabelEntity.clear();
if (kind==1 or kind==3) CombineUniqueEntity.clear();
if (kind==2 or kind==3) CombineLink.clear();
}
//UpperBoundScoreを変更
void patternentity::SetUpperBoundScore(double score){
UpperBoundScore = score;
}
//rでの例外の種類レベルでの上界スコアを計算(分布の偏りベース)
double patternentity::GetUpperBoundScore_kind_r_dist(std::map<double, int>& CountAll, double score_old){
double mincnt, sumsq, num, score_bef, score_aft;
bool decrease = false;
std::map<double, int>::reverse_iterator riter_di, rend_di;
mincnt = (double)CountAll.begin()->first; //最小カウント数
sumsq = 1.0; //二乗和
num = 1.0; //二乗和を割る数
score_bef = 1.0;
for (riter_di=CountAll.rbegin(), rend_di=CountAll.rend(); riter_di!=rend_di; ++riter_di){ //カウント数の大きなものから順に走査
for (int i=1, size=riter_di->second; i<=size; ++i){
if (riter_di->first!=mincnt or i!=riter_di->second){ //最後の要素でない場合
sumsq += std::pow(riter_di->first, 2);
num++;
score_aft = sumsq / num;
if (score_bef >= score_aft){ //上界スコアが下がった場合,走査を終了
decrease = true;
break;
}
else score_bef = score_aft; //そうでない場合,score_befを更新
}
}
if (decrease) break;
}
return std::max(score_bef, score_old); //古い方と新しい方の大きい方を返す
}
//rでの例外の種類レベルでの上界スコアを計算(頻度ベース)
double patternentity::GetUpperBoundScore_kind_r_freq(std::map<double, int>& CountAll, double score_old){
double mincnt, sum;
std::map<double, int>::reverse_iterator riter_di, rend_di;
mincnt = (double)CountAll.begin()->first; //最小カウント数
sum = 0.0; //1つの最小カウント数以外の和
for (riter_di=CountAll.rbegin(), rend_di=CountAll.rend(); riter_di!=rend_di; ++riter_di){ //カウント数の大きなものから順に走査
for (int i=1, size=riter_di->second; i<=size; ++i){
if (riter_di->first!=mincnt or i!=riter_di->second) sum += riter_di->first; //最後の要素でない場合
else sum += 1; //最後の要素の場合
}
}
return 1 - 1/sum; //古い方と新しい方の大きい方を返す
}
//例外の種類レベルでの上界スコアを計算(kindは0から順に,エンティティラベル,固有エンティティ,リンク)
double patternentity::GetUpperBoundScore_kind(int exp_kind, std::string& score_kind){
double count;
double score = 0;
std::map<double, int> CountAll; //隣接要素のカウント(key:カウント数,value:そのカウント数の数)
std::unordered_map<int, std::unordered_map<int, int> >::iterator iter_i_ii, end_i_ii;
std::unordered_map<int, int>::iterator iter_ii, end_ii;
//カウント数を格納し,rでの例外の種類レベルでの上界スコアを計算
if (exp_kind==0){ //エンティティラベルのとき
for (iter_i_ii=CombineLabelEntity.begin(), end_i_ii=CombineLabelEntity.end(); iter_i_ii!=end_i_ii; ++iter_i_ii){
for (iter_ii=iter_i_ii->second.begin(), end_ii=iter_i_ii->second.end(); iter_ii!=end_ii; ++iter_ii){
if (iter_ii->first!=0) count = (double)iter_ii->second;
else count = weight * (double)iter_ii->second;
if (CountAll.find(count)==CountAll.end()) CountAll[count] = 1; //初めてのカウント数のとき
else CountAll[count]++; //既出のとき
}
if (score_kind=="dist") score = GetUpperBoundScore_kind_r_dist(CountAll, score); //rでの上界スコアを計算
else if (score_kind=="freq") score = GetUpperBoundScore_kind_r_freq(CountAll, score);
CountAll.clear();
}
}
else if (exp_kind==1){ //固有エンティティのとき
for (iter_i_ii=CombineUniqueEntity.begin(), end_i_ii=CombineUniqueEntity.end(); iter_i_ii!=end_i_ii; ++iter_i_ii){
for (iter_ii=iter_i_ii->second.begin(), end_ii=iter_i_ii->second.end(); iter_ii!=end_ii; ++iter_ii){
count = (double)iter_ii->second;
if (CountAll.find(count)==CountAll.end()) CountAll[count] = 1; //初めてのカウント数のとき
else CountAll[count]++; //既出のとき
}
if (score_kind=="dist") score = GetUpperBoundScore_kind_r_dist(CountAll, score); //rでの上界スコアを計算
else if (score_kind=="freq") score = GetUpperBoundScore_kind_r_freq(CountAll, score);
CountAll.clear();
}
}
else{ //リンクのとき
for (iter_i_ii=CombineLink.begin(), end_i_ii=CombineLink.end(); iter_i_ii!=end_i_ii; ++iter_i_ii){
for (iter_ii=iter_i_ii->second.begin(), end_ii=iter_i_ii->second.end(); iter_ii!=end_ii; ++iter_ii){
if (iter_ii->first!=0) count = (double)iter_ii->second;
else count = weight * (double)iter_ii->second;
if (CountAll.find(count)==CountAll.end()) CountAll[count] = 1; //初めてのカウント数のとき
else CountAll[count]++; //既出のとき
}
if (score_kind=="dist") score = GetUpperBoundScore_kind_r_dist(CountAll, score); //rでの上界スコアを計算
else if (score_kind=="freq") score = GetUpperBoundScore_kind_r_freq(CountAll, score); //rでの上界スコアを計算
CountAll.clear();
}
}
return score;
}
//パターンエンティティレベルでの上界スコアを計算
double patternentity::GetUpperBoundScore(std::string& score_kind){
if (IsLabel==false) return 0; //エンティティのときは0を返す
else if (UpperBoundScore!=0) return UpperBoundScore; //上界スコア保存済みのときはそのスコアを返す
else{ //初めての上界スコア計算のときは計算も行う
double tmpscore, score;
score = 0.0;
for (int kind=0; kind<3; ++kind){
tmpscore = GetUpperBoundScore_kind(kind, score_kind);
if (tmpscore > score) score = tmpscore;
}
return score;
}
}
//例外の種類レベルでの枝刈りが可能なら実行(kindは0から順に,エンティティラベル,固有エンティティ,リンク)
void patternentity::Pruning_kind(int exp_kind, std::string& score_kind, double minscore){
if (minscore==-1){ //例外スコアランキングが空の場合はfalseを格納
Prunable[exp_kind] = false;
return;
}
if (!Prunable[exp_kind]){ //枝刈りが不可能であれば
if (GetUpperBoundScore_kind(exp_kind, score_kind)<minscore) Prunable[exp_kind] = true; //上界スコアがk番目より低い場合,枝刈り
}
}
//パターンエンティティレベルでの枝刈りが可能なら実行
void patternentity::Pruning(std::string& score_kind, double minscore){
if (Prunable[3]) return; //既に枝刈り可能なら実行せずに終了
if (minscore==-1){ //例外スコアランキングが空の場合はfalseを格納
Prunable[3] = false;
return;
}
for (int kind=0; kind<3; ++kind) Pruning_kind(kind, score_kind, minscore); //例外の種類レベルでの枝刈りを実行
Prunable[3] = Prunable[0] and Prunable[1] and Prunable[2]; //それらの論理積を格納
}
//patternentityを表示
void patternentity::PrintPatternentity(std::ostream& os, bool PrintName, bool PrintRelation, bool PrintMatchEntity, bool PrintLinkClassifiedME, bool PrintCombineElement, bool PrintExpScore, std::vector<entity>& EntityList, std::vector<std::string>& LabelList, std::vector<std::string>& LinkList){
std::unordered_map<int, std::vector<int> >::iterator iter_r, end_r;
std::unordered_map<int, std::unordered_map<int, int> >::iterator iter_cmb, end_cmb;
std::unordered_set<int>::iterator iter_mt, end_mt;
std::unordered_map<int, std::unordered_set<int> >::iterator iter_lcme, end_lcme;
std::unordered_map<int, int>::iterator iter_ii, end_ii;
std::map<triple, expscore>::iterator iter_es, end_es;
std::unordered_set<int>::iterator iter_sei, end_sei;
//patternentityの基本情報の表示
if (PrintName){
if (IsLabel) os << ID_pe << ":" << LabelEncoder(ID, LabelList) << "(";
else os << ID_pe << ":" << EntityEncoder(ID, EntityList) << "(";
}
else os << ID_pe << ":" << ID << "(";
if (IsLabel) os << "Label)" << std::endl;
else os << "Entity)" << std::endl;
//Relationの表示
if (PrintRelation and !Relation.empty()){
os << "[Relation]" << std::endl;
for (iter_r=Relation.begin(), end_r=Relation.end(); iter_r!=end_r; ++iter_r) {
if (PrintName) os << "\t" << LinkEncoder(iter_r->first, LinkList) << ":";
else os << "\t" << iter_r->first << ":";
for (int i=0, size=iter_r->second.size(); i<size; ++i) os << iter_r->second[i] << ", ";
os << std::endl;
}
}
//MatchEntityの表示
if (PrintMatchEntity){
os << "[MatchEntity]" << std::endl << "\t";
if (PrintName){
for (iter_sei=MatchEntity.begin(), end_sei=MatchEntity.end(); iter_sei!=end_sei; ++iter_sei) os << EntityEncoder(*iter_sei, EntityList) << ", ";
}
else{
for (iter_sei=MatchEntity.begin(), end_sei=MatchEntity.end(); iter_sei!=end_sei; ++iter_sei) os << *iter_sei << ", ";
}
os << std::endl;
}
//LinkClassifiedMEの表示
if (PrintLinkClassifiedME){
os << "[LinkClassifiedME]" << std::endl;
if (PrintName){
for (iter_lcme=LinkClassifiedME.begin(), end_lcme=LinkClassifiedME.end(); iter_lcme!=end_lcme; ++iter_lcme){
os << "\t" << LinkEncoder(iter_lcme->first, LinkList) << std::endl << "\t\t";
for (iter_sei=iter_lcme->second.begin(), end_sei=iter_lcme->second.end(); iter_sei!=end_sei; ++iter_sei) os << EntityEncoder(*iter_sei, EntityList) << ", ";
std::cout << std::endl;
}
}
else {
for (iter_lcme=LinkClassifiedME.begin(), end_lcme=LinkClassifiedME.end(); iter_lcme!=end_lcme; ++iter_lcme){
os << "\t" << iter_lcme->first << std::endl << "\t\t";
for (iter_sei=iter_lcme->second.begin(), end_sei=iter_lcme->second.end(); iter_sei!=end_sei; ++iter_sei) os << *iter_sei << ", ";
std::cout << std::endl;
}
}
}
if (PrintCombineElement){
//CombineLabelEntityの表示
os << "[CombineLabelEntity]" << std::endl;
for (iter_cmb=CombineLabelEntity.begin(), end_cmb=CombineLabelEntity.end(); iter_cmb!=end_cmb; ++iter_cmb) {
if (PrintName) os << "\t" << LinkEncoder(iter_cmb->first, LinkList) << std::endl;
else os << "\t" << iter_cmb->first << std::endl;
for (iter_ii=iter_cmb->second.begin(), end_ii=iter_cmb->second.end(); iter_ii!=end_ii; ++iter_ii){
if (PrintName){
//if (iter_ii->first==0) os << "\t\t_NoEntity_:" << iter_ii->second << std::endl; else
os << "\t\t" << LabelEncoder(iter_ii->first, LabelList) << ":" << iter_ii->second << std::endl;
}
else os << "\t\t" << iter_ii->first << ":" << iter_ii->second << std::endl;
}
}
//CombineUniqueEntityの表示
os << "[CombineUniqueEntity]" << std::endl;
for (iter_cmb=CombineUniqueEntity.begin(), end_cmb=CombineUniqueEntity.end(); iter_cmb!=end_cmb; ++iter_cmb) {
if (PrintName) os << "\t" << LinkEncoder(iter_cmb->first, LinkList) << std::endl;
else os << "\t" << iter_cmb->first << std::endl;
for (iter_ii=iter_cmb->second.begin(), end_ii=iter_cmb->second.end(); iter_ii!=end_ii; ++iter_ii){
if (PrintName){
//if (iter_ii->first==0) os << "\t\t_NoEntity_:" << iter_ii->second << std::endl; else
os << "\t\t" << EntityEncoder(iter_ii->first, EntityList) << ":" << iter_ii->second << std::endl;
}
else os << "\t\t" << iter_ii->first << ":" << iter_ii->second << std::endl;
}
}
//CombineLabelEntityの表示
os << "[CombineLink]" << std::endl;
for (iter_cmb=CombineLink.begin(), end_cmb=CombineLink.end(); iter_cmb!=end_cmb; ++iter_cmb) {
if (PrintName) os << "\t" << LabelEncoder(iter_cmb->first, LabelList) << std::endl;
else os << "\t" << iter_cmb->first << std::endl;
for (iter_ii=iter_cmb->second.begin(), end_ii=iter_cmb->second.end(); iter_ii!=end_ii; ++iter_ii){
if (PrintName){
os << "\t\t" << LinkEncoder(iter_ii->first, LinkList) << ":" << iter_ii->second << std::endl;
}
else os << "\t\t" << iter_ii->first << ":" << iter_ii->second << std::endl;
}
}
}
}
//枝刈り状況を表示
void patternentity::PrintPrunable(std::ostream& os){
if (Prunable[3]) os << "T(";
else os << "F(";
for (int kind=0; kind<3; ++kind){
if (Prunable[kind]) os << "T";
else os << "F";
if (kind!=2) os << ",";
else os << ")" << std::endl;
}
}
//パターンクラス
class pattern{
private:
std::vector<patternentity> PatternentityList; //パターン中のエンティティのリスト
std::unordered_set<int> Children; //子パターンのリスト(子パターンの第2インデックス値の集合)
bool Prunable; //パターン構造レベルでの枝刈りが可能かどうか
int WildCardNum; //ワイルドカードの数
bool MatchingObjective; //マッチング対象のパターンであればtrue
bool Searched; //すでに探索済みであれば(もう探索する必要がなければ)true
public:
//メンバ返し・コピー
std::vector<patternentity>& GetPatternentityList(){return PatternentityList;}; //PatternentityListを返す
std::unordered_set<int>& GetChildren(){return Children;}; //Childrenを返す
bool GetPrunable(){return Prunable;}; //Prunableを返す
int GetWildCardNum(){return WildCardNum;}; //WildCardNumを返す
bool GetMatchingObjective(){return MatchingObjective;}; //MatchingObjectiveを返す
bool GetSearched(){return Searched;}; //Searchedを返す
int GetDeg(int); //ワイルドカードを除いた次数を返す
void CopyMatchEntity(pattern&); //マッチするエンティティをコピー
void CopyPrunable(pattern&); //枝刈り状況をコピー
pattern& operator=(pattern&); //等号演算
//各種要素の変更
void AddChild(int); //子パターンを追加
void DeleteChild(int); //子パターンを削除
void SetWildCardNum(int num); //WildCardNumをセット
void ChangeMatchingObjective(); //MatchingObjectiveをtrueに切り替え
void ChangeSearched(); //Searchedをtrueに切り替え
//patternentity構造の変更
void ModifyEntity(int, int, bool); //patternentityを修正
void ModifyLink(int, int, int, int); //リンクラベルを修正
void AddEntity(int, bool); //パターンエンティティを追加
void AddLink(int, int, int); //リンクを追加
void ClearEntity(int); //エンティティ情報をクリア(ワイルドカードにする)
void ClearLink(int, int, int); //リンク情報をクリア(ワイルドカードにする)
void ModifyWildCardInTriple(int, int, int, patternentity&, int, patternentity&, bool, bool, bool); //トリプル中のワイルドカードを変更
void AddTriple(int, int, patternentity&); //トリプルを追加
void ChangeStructure(pattern&); //パターン構造を変更
//patternentityのメンバの変更
void ModifyMatchEntity(int pe_idx, std::unordered_set<int>& ME); //MatchEntityリストを変更
void AddMatchEntity(int, int); //パターン構造に合致するエンティティを追加
void AddLinkClassifiedME(int, int, int); //エンティティをLinkClassifiedMEに追加
void ModifyCombineElement(int, std::unordered_map<int, std::unordered_map<int, int> >&, int); //CombineXXを変更
void AddCombineEntity(int, int, int, std::unordered_set<int>&); //結合しているエンティティとして追加
void AddCombineLink(int, int, int); //結合しているリンクとして追加
void ClearCombineElement(int, int); //CombineXXをクリア
//パターン構造に関する値
bool ExistSameEntity(); //同じpatternentityが存在するかどうか
std::unordered_map<int, int> GetCorrespondingIndex(pattern&); //入力パターンに対応するインデックス値を返す(map[i]でthisのi番目が入力パターンで何番目かを示す)
std::string GetPatternID(); //パターン識別子を返す
//枝刈り関係
double GetUpperBoundScore(std::string&); //上界スコアを返す
int GetAddedPatternUnit(pattern&); //追加されているパターンユニットのインデックスを返す
void Pruning(std::string&, double); //パターン構造レベルでの枝刈りが可能なら実行
//表示
void PrintPattern(std::ostream&, int, int, bool, bool, bool, bool, bool, bool, bool, bool, std::vector<entity>&, std::vector<std::string>&, std::vector<std::string>&); //パターンを表示
void PrintPrunable(std::ostream&); //枝刈り状態を表示
//その他
void ClearPattern(bool); //パターンをクリア
pattern(){Prunable = false; MatchingObjective = false; Searched = false; WildCardNum=0;};
~pattern(){ClearPattern(false);};
};
//ワイルドカードを除いた次数を返す
int pattern::GetDeg(int pe_idx){
std::unordered_map<int, std::vector<int> >& relate = PatternentityList[pe_idx].GetRelation();
std::unordered_map<int, std::vector<int> >::iterator iter_ivi, end_ivi;
int deg = 0; //次数を0で初期化
for (iter_ivi=relate.begin(), end_ivi=relate.end(); iter_ivi!=end_ivi; ++iter_ivi){ //各リンク
if (IsWildCardLink(iter_ivi->first)) continue; //ワイルドカードでないリンクのみ探索
for (int i=0, size_i=iter_ivi->second.size(); i<size_i; ++i){ //そのリンクによって接続する各エンティティ
if (!IsWildCardEntity(PatternentityList[iter_ivi->second[i]].GetId(), PatternentityList[iter_ivi->second[i]].GetIsLabel())) deg++; //ワイルドカードでなければ次数を1追加
}
}
return deg;
}
//マッチするエンティティをコピー
void pattern::CopyMatchEntity(pattern& p){
std::vector<patternentity>& pel = p.GetPatternentityList();
std::unordered_map<int, int> CorresIndex = GetCorrespondingIndex(p);
std::unordered_map<int, int>::iterator iter_ii, end_ii;
for (iter_ii=CorresIndex.begin(), end_ii=CorresIndex.end(); iter_ii!=end_ii; ++iter_ii){
ModifyMatchEntity(iter_ii->first, pel[CorresIndex[iter_ii->second]].GetMatchEntity());
}
}
//枝刈り状況をコピー
void pattern::CopyPrunable(pattern& p){
std::vector<patternentity>& pel = p.GetPatternentityList();
std::unordered_map<int, int> CorresIndex = GetCorrespondingIndex(p);
std::unordered_map<int, int>::iterator iter_ii, end_ii;
Prunable = p.GetPrunable();
for (iter_ii=CorresIndex.begin(), end_ii=CorresIndex.end(); iter_ii!=end_ii; ++iter_ii){
PatternentityList[iter_ii->first].CopyPrunable(pel[CorresIndex[iter_ii->second]]);
}
}
//等号演算
pattern& pattern::operator=(pattern& p){
PatternentityList.resize(p.GetPatternentityList().size());
for (int i=0, size=PatternentityList.size(); i<size; ++i) PatternentityList[i] = p.GetPatternentityList()[i];
WildCardNum = p.GetWildCardNum();
return *this;
}
//子パターンを追加
void pattern::AddChild(int p_idx){
Children.insert(p_idx);
}
void pattern::DeleteChild(int p_idx){
Children.erase(p_idx);
}
//WildCardNumをセット
void pattern::SetWildCardNum(int num){
WildCardNum = num;
}
//MatchingObjectiveをtrueに切り替え
void pattern::ChangeMatchingObjective(){
MatchingObjective = true;
}
//Searchedをtrueに切り替え
void pattern::ChangeSearched(){
Searched = true;
}
//patternentityを変更
void pattern::ModifyEntity(int id_pe, int id, bool islabel){
PatternentityList[id_pe].ModifyEntity(id_pe, id, islabel);
}
//リンクラベルを変更
void pattern::ModifyLink(int spe_idx, int link_id, int epe_idx, int new_link_id){
PatternentityList[spe_idx].ModifyLink(link_id, epe_idx, new_link_id);
PatternentityList[epe_idx].ModifyLink(-link_id, spe_idx, -new_link_id);
}
//パターンエンティティを追加
void pattern::AddEntity(int id, bool islabel){
patternentity new_pe;
new_pe.ModifyEntity(PatternentityList.size(), id, islabel);
PatternentityList.push_back(new_pe);
}
//リンクを追加
void pattern::AddLink(int spe_idx, int link_id, int epe_idx){
PatternentityList[spe_idx].AddLink(link_id, epe_idx);
PatternentityList[epe_idx].AddLink(-link_id, spe_idx);
}
//エンティティ情報をクリア(ワイルドカードにする)
void pattern::ClearEntity(int pe_idx){
std::unordered_map<int, std::vector<int> > relate = PatternentityList[pe_idx].GetRelation();
std::unordered_map<int, std::vector<int> >::iterator iter_ivi, end_ivi;
for (iter_ivi=relate.begin(), end_ivi=relate.end(); iter_ivi!=end_ivi; ++iter_ivi){ //各トリプルを走査
for (int i=0, size_i=iter_ivi->second.size(); i<size_i; ++i){
ClearLink(pe_idx, iter_ivi->first, iter_ivi->second[i]); //pe_idxのパターンエンティティに隣接するリンクをクリア
}
}
if (!IsWildCardEntity(PatternentityList[pe_idx].GetId(), PatternentityList[pe_idx].GetIsLabel())){ //元々ワイルドカードでなければ
PatternentityList[pe_idx].ClearEntity(); //エンティティのクリア処理を施し
WildCardNum++; //WildCardNumをインクリメントする
}
}
//リンク情報をクリア(ワイルドカードにする)
void pattern::ClearLink(int spe_idx, int link_id, int epe_idx){
if (!IsWildCardLink(link_id)){ //元々ワイルドカードでなければ
PatternentityList[spe_idx].ClearLink(link_id, epe_idx, true); //リンクのクリア処理を施し
PatternentityList[epe_idx].ClearLink(-link_id, spe_idx, false);
WildCardNum++; //WildCardNumをインクリメントする
}
}
//patternを修正
void pattern::ModifyWildCardInTriple(int spe_idx, int link_id, int epe_idx, patternentity& new_spe, int new_link, patternentity& new_epe, bool HeadIsWildCard, bool LinkIsWildCard, bool TailIsWildCard){
if (HeadIsWildCard){
PatternentityList[spe_idx].ModifyEntity(spe_idx, new_spe.GetId(), new_spe.GetIsLabel());
WildCardNum--;
}
if (TailIsWildCard){
PatternentityList[epe_idx].ModifyEntity(epe_idx, new_epe.GetId(), new_epe.GetIsLabel());
WildCardNum--;
}
if (LinkIsWildCard){
ModifyLink(spe_idx, link_id, epe_idx, new_link);
WildCardNum--;
}
}
//パターンエンティティとリンクを追加
void pattern::AddTriple(int pe_id, int link_id, patternentity& new_pe){
AddEntity(new_pe.GetId(), new_pe.GetIsLabel());
AddLink(pe_id, link_id, PatternentityList.size()-1);
}
//パターン構造を変更
void pattern::ChangeStructure(pattern& p){
PatternentityList.resize(p.GetPatternentityList().size());
for (int i=0, size_i=PatternentityList.size(); i<size_i; ++i) PatternentityList[i] = p.GetPatternentityList()[i];
WildCardNum = p.GetWildCardNum();
}
//MatchEntityリストを変更
void pattern::ModifyMatchEntity(int pe_idx, std::unordered_set<int>& ME){
PatternentityList[pe_idx].ModifyMatchEntity(ME);
}
//パターン構造に合致するエンティティを追加
void pattern::AddMatchEntity(int pe_idx, int id){
PatternentityList[pe_idx].AddMatchEntity(id);
}
//エンティティをLinkClassifiedMEに追加
void pattern::AddLinkClassifiedME(int pe_idx, int link_id, int entity_id){
PatternentityList[pe_idx].AddLinkClassifiedME(link_id, entity_id);
}
//CombinexxEntityを変更
void pattern::ModifyCombineElement(int pe_idx, std::unordered_map<int, std::unordered_map<int, int> >& CombineElement, int kind){
PatternentityList[pe_idx].ModifyCombineElement(CombineElement, kind);
}
//結合しているエンティティとして追加
void pattern::AddCombineEntity(int pe_idx, int link_id, int ee_id, std::unordered_set<int>& label){
PatternentityList[pe_idx].AddCombineEntity(link_id, ee_id, label);
}
//パターン構造に合致するリンクを追加
void pattern::AddCombineLink(int pe_idx, int link_id, int label){
PatternentityList[pe_idx].AddCombineLink(link_id, label);
}
//CombineXXをクリア
void pattern::ClearCombineElement(int pe_idx, int kind){
PatternentityList[pe_idx].ClearCombineElement(kind);
}
//同じpatternentityが存在するかどうか
bool pattern::ExistSameEntity(){
bool return_bool = false;
for (int i=0, size_i=PatternentityList.size()-1; i<size_i; ++i){
if (IsWildCardEntity(PatternentityList[i].GetId(), PatternentityList[i].GetIsLabel())) continue;
for (int j=i+1, size_j=PatternentityList.size(); j<size_j; ++j){
if (IsWildCardEntity(PatternentityList[j].GetId(), PatternentityList[j].GetIsLabel())) continue;
if (PatternentityList[i].SamePatternentity(PatternentityList[j])){
return_bool = true;
break;
}
}
if (return_bool) break;
}
return return_bool;
}
//入力パターンに対応するインデックス値を返す(map[i]でthisのi番目が入力パターンで何番目かを示す)
std::unordered_map<int, int> pattern::GetCorrespondingIndex(pattern& p){
std::unordered_map <int, int> return_map;
std::vector<patternentity>& pel = p.GetPatternentityList();
for (int i=0, size_i=PatternentityList.size(); i<size_i; ++i){
if (IsWildCardEntity(PatternentityList[i].GetId(), PatternentityList[i].GetIsLabel())) continue;
for (int j=0, size_j=pel.size(); j<size_j; ++j){
if (IsWildCardEntity(pel[j].GetId(), pel[j].GetIsLabel())) continue;
if (PatternentityList[i].SamePatternentity(pel[j])){
return_map[i] = j;
break;
}
}
}
return return_map;
}
//パターン識別子を返す
std::string pattern::GetPatternID(){
int tmp;
std::map<int, std::unordered_set<int> > map_content_orgidx; //パターンエンティティの中身とPatternentityListのインデックスを対応させるmap
std::vector<int> vec_prcidx_orgidx; //処理用の新しいインデックス値とPatternentityListのインデックス値を対応させるvector
std::unordered_map<int, int> map_orgidx_prcidx; //vec_prcidx_orgidxを逆対応させたmap
std::string ReturnStr = "";
std::map<int, std::unordered_set<int> >::iterator iter_oisei, end_oisei;
std::unordered_map<int, std::vector<int> >::iterator iter_ivi, end_ivi;
std::map<int, std::vector<int> >::iterator iter_oivi, end_oivi;
std::unordered_set<int>::iterator iter_sei, end_sei;
//パターン構造を整理 & パターン識別子のエンティティ部分を完成
for (int i=0, size_i=PatternentityList.size(); i<size_i; ++i){ //map_content_orgidxを作成
if (!IsWildCardEntity(PatternentityList[i].GetId(), PatternentityList[i].GetIsLabel())){
if (PatternentityList[i].GetIsLabel()) map_content_orgidx[PatternentityList[i].GetId()].insert(i);
else map_content_orgidx[LabelNum+PatternentityList[i].GetId()].insert(i);
}
}
for (iter_oisei=map_content_orgidx.begin(), end_oisei=map_content_orgidx.end(); iter_oisei!=end_oisei; ++iter_oisei){ //vec_*_*を作成