')
128 | .appendTo('body')
129 | .addClass('alert ' + style)
130 | .html(message)
131 | .show()
132 | .delay(time)
133 | .fadeOut();
134 | };
135 |
136 | // 成功提示
137 | const success_prompt = function (message, time) {
138 | prompt(message, 'alert-success', time);
139 | };
140 |
141 | // 警告提示
142 | const warning_prompt = function (message, time) {
143 | prompt(message, 'alert-warning', time);
144 | };
145 |
146 |
147 |
148 |
149 |
150 |
--------------------------------------------------------------------------------
/toolbox/exp/classic/train_CartPole.py:
--------------------------------------------------------------------------------
1 | import gym
2 | import numpy as np
3 | import torch
4 | import torch.nn as nn
5 | import torch.nn.functional as F
6 |
7 | # Hyper Parameters
8 | BATCH_SIZE = 32
9 | LR = 0.01 # learning rate
10 | EPSILON = 0.9 # greedy policy
11 | GAMMA = 0.9 # reward discount
12 | TARGET_REPLACE_ITER = 100 # target update frequency
13 | MEMORY_CAPACITY = 2000
14 | env = gym.make('CartPole-v0')
15 | env = env.unwrapped
16 | N_ACTIONS = env.action_space.n
17 | N_STATES = env.observation_space.shape[0]
18 | ENV_A_SHAPE = 0 if isinstance(env.action_space.sample(), int) else env.action_space.sample().shape # to confirm the shape
19 |
20 |
21 | class Net(nn.Module):
22 | def __init__(self, ):
23 | super(Net, self).__init__()
24 | self.fc1 = nn.Linear(N_STATES, 50)
25 | self.fc1.weight.data.normal_(0, 0.1) # initialization
26 | self.out = nn.Linear(50, N_ACTIONS)
27 | self.out.weight.data.normal_(0, 0.1) # initialization
28 |
29 | def forward(self, x):
30 | x = self.fc1(x)
31 | x = F.relu(x)
32 | actions_value = self.out(x)
33 | return actions_value
34 |
35 |
36 | class DQN(object):
37 | def __init__(self):
38 | self.eval_net, self.target_net = Net(), Net()
39 |
40 | self.learn_step_counter = 0 # for target updating
41 | self.memory_counter = 0 # for storing memory
42 | self.memory = np.zeros((MEMORY_CAPACITY, N_STATES * 2 + 2)) # initialize memory
43 | self.optimizer = torch.optim.Adam(self.eval_net.parameters(), lr=LR)
44 | self.loss_func = nn.MSELoss()
45 |
46 | def choose_action(self, x):
47 | x = torch.unsqueeze(torch.FloatTensor(x), 0)
48 | # input only one sample
49 | if np.random.uniform() < EPSILON: # greedy
50 | actions_value = self.eval_net.forward(x)
51 | action = torch.max(actions_value, 1)[1].data.numpy()
52 | action = action[0] if ENV_A_SHAPE == 0 else action.reshape(ENV_A_SHAPE) # return the argmax index
53 | else: # random
54 | action = np.random.randint(0, N_ACTIONS)
55 | action = action if ENV_A_SHAPE == 0 else action.reshape(ENV_A_SHAPE)
56 | return action
57 |
58 | def store_transition(self, s, a, r, s_):
59 | transition = np.hstack((s, [a, r], s_))
60 | # replace the old memory with new memory
61 | index = self.memory_counter % MEMORY_CAPACITY
62 | self.memory[index, :] = transition
63 | self.memory_counter += 1
64 |
65 | def learn(self):
66 | # target parameter update
67 | if self.learn_step_counter % TARGET_REPLACE_ITER == 0:
68 | self.target_net.load_state_dict(self.eval_net.state_dict())
69 | self.learn_step_counter += 1
70 |
71 | # sample batch transitions
72 | sample_index = np.random.choice(MEMORY_CAPACITY, BATCH_SIZE)
73 | b_memory = self.memory[sample_index, :]
74 | b_s = torch.FloatTensor(b_memory[:, :N_STATES])
75 | b_a = torch.LongTensor(b_memory[:, N_STATES:N_STATES + 1].astype(int))
76 | b_r = torch.FloatTensor(b_memory[:, N_STATES + 1:N_STATES + 2])
77 | b_s_ = torch.FloatTensor(b_memory[:, -N_STATES:])
78 |
79 | # q_eval w.r.t the action in experience
80 | q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)
81 | q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate
82 | q_target = b_r + GAMMA * q_next.max(1)[0].view(BATCH_SIZE, 1) # shape (batch, 1)
83 | loss = self.loss_func(q_eval, q_target)
84 |
85 | self.optimizer.zero_grad()
86 | loss.backward()
87 | self.optimizer.step()
88 |
89 |
90 | dqn = DQN()
91 |
92 | print('\nCollecting experience...')
93 | for i_episode in range(400):
94 | s = env.reset()
95 | ep_r = 0
96 | while True:
97 | env.render()
98 | a = dqn.choose_action(s)
99 |
100 | # take action
101 | s_, r, done, info = env.step(a)
102 |
103 | # modify the reward
104 | x, x_dot, theta, theta_dot = s_
105 | r1 = (env.x_threshold - abs(x)) / env.x_threshold - 0.8
106 | r2 = (env.theta_threshold_radians - abs(theta)) / env.theta_threshold_radians - 0.5
107 | r = r1 + r2
108 |
109 | dqn.store_transition(s, a, r, s_)
110 |
111 | ep_r += r
112 | if dqn.memory_counter > MEMORY_CAPACITY:
113 | dqn.learn()
114 | if done:
115 | print('Ep: ', i_episode,
116 | '| Ep_r: ', round(ep_r, 2))
117 |
118 | if done:
119 | break
120 | s = s_
121 |
--------------------------------------------------------------------------------
/toolbox/web/log_app/app.py:
--------------------------------------------------------------------------------
1 | import os
2 | import time
3 | import uuid
4 | from collections import deque
5 | from threading import Timer
6 | from urllib import request as urequest
7 |
8 | from flask import Flask, url_for, redirect
9 | from flask import jsonify
10 | from flask import request
11 | from flask import send_from_directory
12 |
13 | from .chart_app import chart_page
14 | from .folder_app import folder_page
15 | from .line_app import line_page
16 | from .log_read import log_agent
17 | from .multi_char_app import multi_chart_page
18 | from .server.app_utils import ServerWatcher
19 | from .server.app_utils import get_usage_port
20 | from .server.data_container import all_data
21 | from .server.data_container import handler_watcher
22 | from .server.table_utils import prepare_data
23 | from .server.table_utils import save_all_data
24 | from .server.utils import check_uuid, colored_string
25 | from .summary_app import summary_page
26 | from .table_app import table_page
27 |
28 | app = Flask(__name__)
29 |
30 | app.register_blueprint(chart_page)
31 | app.register_blueprint(table_page)
32 | app.register_blueprint(summary_page)
33 | app.register_blueprint(line_page)
34 | app.register_blueprint(multi_chart_page)
35 | app.register_blueprint(folder_page)
36 |
37 | LEAST_REQUEST_TIMESTAMP = deque(maxlen=1)
38 | LEAST_REQUEST_TIMESTAMP.append(time.time())
39 |
40 |
41 | @app.route('/')
42 | def index():
43 | return redirect(url_for('table_page.table'))
44 |
45 |
46 | @app.before_request
47 | def update_last_request_ms():
48 | global LEAST_REQUEST_TIMESTAMP
49 | LEAST_REQUEST_TIMESTAMP.append(time.time())
50 |
51 |
52 | @app.route('/kill', methods=['POST'])
53 | def seriouslykill():
54 | time.sleep(1)
55 | func = request.environ.get('werkzeug.server.shutdown')
56 | if func is None:
57 | raise RuntimeError('Not running with the Werkzeug Server')
58 | func()
59 | return "stopping"
60 |
61 |
62 | @app.route('/arange_kill', methods=['POST'])
63 | def arange_kill():
64 | res = check_uuid(all_data['uuid'], request.json['uuid'])
65 | if res is not None:
66 | return jsonify(res)
67 |
68 | def shutdown():
69 | req = urequest.Request('http://127.0.0.1:{}/kill'.format(all_data['port']), headers={}, data=''.encode('utf-8'))
70 | page = urequest.urlopen(req).read().decode('utf-8')
71 |
72 | print("Shutting down from the frontend...")
73 | Timer(1.0, shutdown).start()
74 | return jsonify(status='success', msg='')
75 |
76 |
77 | @app.route('/table.ico')
78 | def get_table_ico():
79 | return send_from_directory(os.path.join('.', 'static', 'img'), 'table.ico')
80 |
81 |
82 | @app.route('/chart.ico')
83 | def get_chart_ico():
84 | return send_from_directory(os.path.join('.', 'static', 'img'), 'chart.ico')
85 |
86 |
87 | def start_app(log_dir, log_config_name, standby_hours, start_port, ip='0.0.0.0', token=None):
88 | """
89 | log_dir app日志目录
90 | log_config_name app的配置文件名
91 | start_port 端口。如果该端口不可用，会自动选一个可用的
92 | standby_hours 空转小时数。如果超过这个时间没有任何操作，会自动停止运行，防止资源浪费
93 | """
94 | os.chdir(os.path.dirname(os.path.abspath(__file__))) # 可能需要把运行路径移动到这里
95 | all_data['root_log_dir'] = log_dir # will be used by chart_app
96 | server_wait_seconds = int(standby_hours * 3600)
97 | print("This server will automatically shutdown if no api access for {} hours.".format(standby_hours))
98 | all_data['log_config_name'] = log_config_name
99 | all_data['log_agent'] = log_agent
100 | if token is None:
101 | all_data['token'] = None
102 | else:
103 | all_data['token'] = str(token)
104 | print(colored_string(f"You specify token:{all_data['token']}, remember to add this token when access your table.", color='red'))
105 |
106 | # 准备数据
107 | all_data.update(prepare_data(log_agent, all_data['root_log_dir'], all_data['log_config_name']))
108 | print(f"Finish preparing data. Found {len(all_data['data'])} records in {log_dir}.")
109 | all_data['uuid'] = str(uuid.uuid1())
110 |
111 | port = get_usage_port(start_port=start_port)
112 | all_data['port'] = port
113 |
114 | server_watcher = ServerWatcher(LEAST_REQUEST_TIMESTAMP, port)
115 | server_watcher.set_server_wait_seconds(server_wait_seconds)
116 | server_watcher.start()
117 | app.run(host=ip, port=port, debug=False, threaded=True)
118 |
119 | # TODO 输出访问的ip地址
120 | print("Shutting down server...")
121 | save_all_data(all_data, all_data['root_log_dir'], all_data['log_config_name'])
122 | handler_watcher.stop()
123 | server_watcher.stop()
124 |
125 |
126 | if __name__ == '__main__':
127 | from .server.app_utils import cmd_parser
128 |
129 | parser = cmd_parser()
130 | args = parser.parse_args()
131 | start_app(args.log_dir, args.log_config_name, args.port, 1, '123')
132 |
--------------------------------------------------------------------------------
/toolbox/web/log_app/folder_app.py:
--------------------------------------------------------------------------------
1 | r"""
2 | 主要用于显示log folder下的文件
3 |
4 |
5 | """
6 | import base64
7 | import os
8 | import time
9 |
10 | from flask import Blueprint
11 | from flask import make_response, send_file
12 | from flask import render_template, redirect, url_for
13 | from flask import request, jsonify
14 |
15 | from .server.data_container import all_data
16 | from .server.folder_utils import get_image_size
17 | from .server.utils import check_uuid
18 |
19 | folder_page = Blueprint('folder_page', __name__, template_folder='templates')
20 |
21 |
22 | @folder_page.route('/folder', methods=['POST', 'GET'])
23 | def show_folder():
24 | if request.method == 'POST':
25 | uuid = request.values['uuid']
26 | id = request.values['id'] if 'id' in request.values else ''
27 | subdir = request.values['subdir'] if 'subdir' in request.values else ''
28 | else:
29 | uuid = request.args.get('uuid')
30 | id = request.args.get('id')
31 | subdir = request.args.get('subdir')
32 | res = check_uuid(all_data['uuid'], uuid)
33 | if res is not None:
34 | return jsonify(res)
35 | if id:
36 | # TODO 远程日志服务器
37 | log_dir = all_data['root_log_dir']
38 | folder = os.path.join(log_dir, id)
39 | if os.path.relpath(folder, log_dir).startswith('.'):
40 | return jsonify(status='fail', msg='Permission denied.')
41 |
42 | if subdir == '': # 如果为空，说明还是需要访问folder
43 | pass
44 | elif os.path.isfile(os.path.join(folder, subdir)): # 文件直接发送
45 | if os.path.splitext(subdir)[1][1:] in ('jpg', 'png', 'jpeg', 'fig'):
46 | return redirect(url_for('folder_page.show_image', uuid=uuid, id=id, subdir=subdir), code=301)
47 | resp = make_response(send_file(os.path.join(folder, subdir)))
48 | resp.headers["Content-type"] = "text/plan;charset=UTF-8"
49 | return resp
50 | elif os.path.isdir(os.path.join(folder, subdir)): # 如果是directory
51 | folder = os.path.join(folder, subdir)
52 | else:
53 | return jsonify(status='fail', msg="Invalid file.")
54 |
55 | if os.path.relpath(folder, log_dir).startswith('.'):
56 | return jsonify(status='fail', msg='Permission denied.')
57 |
58 | current_list = os.listdir(folder)
59 | contents = []
60 | for i in sorted(current_list):
61 | fullpath = folder + os.sep + i
62 | # 如果是目录，在后面添加一个sep
63 | if os.path.isdir(fullpath):
64 | extra = os.sep
65 | else:
66 | extra = ''
67 | content = {}
68 | content['filename'] = i + extra
69 | content['mtime'] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(os.stat(fullpath).st_mtime))
70 | content['size'] = str(round(os.path.getsize(fullpath) / 1024)) + 'k'
71 | content['isfile'] = os.path.isfile(fullpath)
72 | if extra:
73 | contents.insert(0, content)
74 | else:
75 | contents.append(content)
76 | subdir = os.path.relpath(os.path.abspath(folder), start=os.path.abspath(os.path.join(log_dir, id)))
77 | if subdir.startswith('.'):
78 | subdir = ''
79 | else:
80 | if not subdir.endswith(os.sep):
81 | subdir += os.sep
82 | return render_template('folder.html', contents=contents, subdir=subdir, ossep=os.sep,
83 | uuid=all_data['uuid'], id=id)
84 | else:
85 | return jsonify(status='fail', msg="The request lacks id or filename.")
86 |
87 |
88 | @folder_page.route('/folder/show_image', methods=['GET'])
89 | def show_image():
90 | uuid = request.args.get('uuid')
91 | id = request.args.get('id')
92 | subdir = request.args.get('subdir')
93 | res = check_uuid(all_data['uuid'], uuid)
94 | if res is not None:
95 | return jsonify(res)
96 | if id:
97 | log_dir = all_data['root_log_dir']
98 | folder = os.path.join(log_dir, id)
99 | if os.path.splitext(subdir)[1][1:] in ('jpg', 'png', 'jpeg', 'fig'):
100 | img_stream = ''
101 | with open(os.path.join(folder, subdir), 'rb') as img_f:
102 | img_stream = img_f.read()
103 | img_stream = base64.b64encode(img_stream).decode('ascii')
104 | try:
105 | width = get_image_size(os.path.join(folder, subdir))[0]
106 | except:
107 | width = -1
108 | if width == -1:
109 | width = 1000
110 | return render_template('folder_img.html', img_stream=img_stream, img_path=subdir, width=width)
111 | return jsonify(status='fail', msg=f"Fail to show {os.path.relpath(os.path.join(folder, subdir)), log_dir}")
112 |
--------------------------------------------------------------------------------
/toolbox/nn/ParamE.py:
--------------------------------------------------------------------------------
1 | import torch
2 | import torch.nn.functional as F
3 | from torch import nn
4 |
5 |
6 | class CoreParamEGate(nn.Module):
7 | def __init__(self, entity_dim, hidden_dim=100):
8 | super(CoreParamEGate, self).__init__()
9 | self.entity_dim = entity_dim
10 | self.hidden_dim = hidden_dim
11 | self.linear = nn.Linear(hidden_dim, entity_dim)
12 |
13 | def forward(self, h, r1, r2):
14 | h = h.view(-1, 1, self.entity_dim)
15 | r1 = r1.view(-1, self.entity_dim, self.hidden_dim)
16 | r2 = r2.view(-1, self.entity_dim, self.hidden_dim)
17 | gate = torch.sigmoid(torch.bmm(h, r1).squeeze(dim=1))
18 | value = torch.tanh(torch.bmm(h, r2).squeeze(dim=1))
19 | x = (1 - gate) * value
20 | x = self.linear(x)
21 | x = F.relu(x)
22 | return x
23 |
24 |
25 | class CoreParamECNN(nn.Module):
26 | def __init__(self, entity_dim,
27 | conv_num_channels=32,
28 | conv_num_channels2=64,
29 | conv_filter_height=3, conv_filter_width=3,
30 | hidden_dropout1: float = 0.2,
31 | hidden_dropout2: float = 0.2):
32 | super(CoreParamECNN, self).__init__()
33 | self.entity_dim = entity_dim
34 |
35 | self.conv_in_height = 10
36 | self.conv_in_width = self.entity_dim // 10
37 |
38 | self.conv_filter_height = conv_filter_height
39 | self.conv_filter_width = conv_filter_width
40 | self.conv_num_channels = conv_num_channels
41 | self.conv_num_channels2 = conv_num_channels2
42 |
43 | self.conv_out_height = self.conv_in_height - self.conv_filter_height + 1
44 | self.conv_out_width = self.conv_in_width - self.conv_filter_width + 1
45 |
46 | self.conv_out_height2 = self.conv_out_height - self.conv_filter_height + 1
47 | self.conv_out_width2 = self.conv_out_width - self.conv_filter_width + 1
48 |
49 | self.hidden_dropout1 = nn.Dropout(hidden_dropout1)
50 | self.hidden_dropout2 = nn.Dropout(hidden_dropout2)
51 |
52 | hidden_dim = self.conv_num_channels * self.conv_num_channels2 * self.conv_out_height2 * self.conv_out_width2
53 | self.hidden_dim = hidden_dim
54 | self.linear = nn.Linear(hidden_dim, entity_dim)
55 |
56 | def forward(self, h, r1, r2):
57 | img = h.view(1, -1, self.conv_in_height, self.conv_in_width)
58 | batch_size = img.size(1)
59 | conv_weight1 = r1.view(batch_size * self.conv_num_channels, 1, self.conv_filter_height, self.conv_filter_width)
60 | conv_weight2 = r2.view(batch_size * self.conv_num_channels2, 1, self.conv_filter_height, self.conv_filter_width)
61 |
62 | x = F.conv2d(img, weight=conv_weight1, groups=batch_size)
63 | x = F.relu(x)
64 | x = self.hidden_dropout1(x)
65 | x = x.view(-1, batch_size, self.conv_out_height, self.conv_out_width)
66 |
67 | x = F.conv2d(x, weight=conv_weight2, groups=batch_size)
68 | x = F.relu(x)
69 | x = self.hidden_dropout2(x)
70 | x = x.view(batch_size, self.hidden_dim)
71 |
72 | x = self.linear(x)
73 | x = F.relu(x)
74 | return x
75 |
76 |
77 | class ParamE(nn.Module):
78 | def __init__(self, num_entities, num_relations, entity_dim, relation_dim, hidden_dropout=0.2):
79 | super(ParamE, self).__init__()
80 | self.entity_dim = entity_dim
81 | self.relation_dim = relation_dim
82 | self.E = nn.Embedding(num_entities, entity_dim)
83 |
84 | conv_num_channels = 32
85 | conv_num_channels2 = 64
86 | conv_filter_height = 3
87 | conv_filter_width = 3
88 | self.R1 = nn.Embedding(num_relations, conv_num_channels * conv_filter_height * conv_filter_width)
89 | self.R2 = nn.Embedding(num_relations, conv_num_channels2 * conv_filter_height * conv_filter_width)
90 |
91 | self.core = CoreParamECNN(entity_dim,
92 | conv_num_channels, conv_num_channels2,
93 | conv_filter_height, conv_filter_width)
94 | self.dropout = nn.Dropout(hidden_dropout)
95 | self.b = nn.Parameter(torch.zeros(num_entities))
96 | self.m = nn.PReLU()
97 |
98 | self.loss = nn.BCELoss()
99 |
100 | def init(self):
101 | nn.init.xavier_normal_(self.E.weight.data)
102 | nn.init.xavier_normal_(self.R1.weight.data)
103 | nn.init.xavier_normal_(self.R2.weight.data)
104 |
105 | def forward(self, h_idx, r_idx):
106 | h = self.E(h_idx) # Bxd
107 | r1 = self.R1(r_idx) # Bxd
108 | r2 = self.R2(r_idx) # Bxd
109 |
110 | t = self.core(h, r1, r2)
111 | t = t.view(-1, self.entity_dim)
112 |
113 | x = torch.mm(t, self.dropout(self.E.weight).transpose(1, 0))
114 | x = x + self.b.expand_as(x)
115 | x = torch.sigmoid(x)
116 | return x # batch_size x E
117 |
--------------------------------------------------------------------------------
/toolbox/nn/ComplexTuckER.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import torch
3 | from torch import nn
4 |
5 | from toolbox.nn.ComplexEmbedding import ComplexEmbedding, ComplexDropout, ComplexScoringAll, ComplexBatchNorm1d
6 |
7 |
8 | class CoreTuckER(nn.Module):
9 | def __init__(self, entity_dim, relation_dim, hidden_dropout1=0.4):
10 | super(CoreTuckER, self).__init__()
11 | self.entity_dim = entity_dim
12 | self.relation_dim = relation_dim
13 |
14 | self.W = nn.Parameter(torch.FloatTensor(np.random.uniform(-0.01, 0.01, (relation_dim, entity_dim, entity_dim))))
15 |
16 | self.hidden_dropout1 = nn.Dropout(hidden_dropout1)
17 |
18 | def forward(self, h, r):
19 | h = h.view(-1, 1, self.entity_dim)
20 |
21 | W = self.W.view(self.relation_dim, -1)
22 | W = torch.mm(r.view(-1, self.relation_dim), W)
23 | W = W.view(-1, self.entity_dim, self.entity_dim)
24 | W = self.hidden_dropout1(W)
25 |
26 | t = torch.bmm(h, W)
27 | t = t.view(-1, self.entity_dim)
28 | return t
29 |
30 | def w(self, h, r):
31 | h = torch.cat([h.transpose(1, 0).unsqueeze(dim=0)] * r.size(0), dim=0) # BxdxE
32 |
33 | W = self.W.view(self.relation_dim, -1)
34 | W = torch.mm(r.view(-1, self.relation_dim), W)
35 | W = W.view(-1, self.entity_dim, self.entity_dim) # Bxdxd
36 | W = self.hidden_dropout1(W)
37 | t = torch.bmm(W, h) # BxdxE
38 | return t
39 |
40 |
41 | class ComplexTuckER(nn.Module):
42 | def __init__(self, entity_dim, relation_dim, hidden_dropout=0.4):
43 | super(ComplexTuckER, self).__init__()
44 | self.entity_dim = entity_dim
45 | self.relation_dim = relation_dim
46 |
47 | self.Wa = CoreTuckER(entity_dim, relation_dim, hidden_dropout)
48 | self.Wb = CoreTuckER(entity_dim, relation_dim, hidden_dropout)
49 |
50 | self.bn0 = nn.BatchNorm1d(entity_dim)
51 | self.bn1 = nn.BatchNorm1d(entity_dim)
52 | self.bn3 = nn.BatchNorm1d(relation_dim)
53 | self.bn4 = nn.BatchNorm1d(relation_dim)
54 | self.bn5 = nn.BatchNorm1d(entity_dim)
55 | self.bn6 = nn.BatchNorm1d(entity_dim)
56 | self.ma = nn.PReLU()
57 | self.mb = nn.PReLU()
58 |
59 | def forward(self, h, r):
60 | h_a, h_b = h
61 | h_a = self.bn0(h_a)
62 | h_b = self.bn1(h_b)
63 | r_a, r_b = r
64 | r_a = self.bn3(r_a)
65 | r_b = self.bn4(r_b)
66 | t_a = self.Wa(h_a, r_a) - self.Wb(h_a, r_b) - self.Wb(h_b, r_a) - self.Wa(h_b, r_b)
67 | t_b = self.Wb(h_a, r_a) + self.Wa(h_a, r_b) + self.Wa(h_b, r_a) - self.Wb(h_b, r_b)
68 | t_a = self.bn5(t_a)
69 | t_b = self.bn6(t_b)
70 | t_a = self.ma(t_a)
71 | t_b = self.mb(t_b)
72 | return t_a, t_b
73 |
74 | class TuckER(nn.Module):
75 | def __init__(self, num_entities, num_relations, entity_dim, relation_dim, input_dropout=0.3, hidden_dropout=0.3, hidden_dropout2=0.3):
76 | super(TuckER, self).__init__()
77 | self.entity_dim = entity_dim
78 | self.relation_dim = relation_dim
79 | self.flag_hamilton_mul_norm = True
80 |
81 | self.E = ComplexEmbedding(num_entities, entity_dim)
82 | self.R = ComplexEmbedding(num_relations, relation_dim)
83 |
84 | self.core = ComplexTuckER(entity_dim, relation_dim, hidden_dropout)
85 | self.E_bn = ComplexBatchNorm1d(entity_dim, 2)
86 | self.E_dropout = ComplexDropout([input_dropout, input_dropout])
87 | self.R_dropout = ComplexDropout([input_dropout, input_dropout])
88 | self.hidden_dp = ComplexDropout([hidden_dropout, hidden_dropout])
89 |
90 | self.scoring_all = ComplexScoringAll()
91 | self.bce = nn.BCELoss()
92 | self.b1 = nn.Parameter(torch.zeros(num_entities))
93 | self.b2 = nn.Parameter(torch.zeros(num_entities))
94 |
95 | def init(self):
96 | self.E.init()
97 | self.R.init()
98 |
99 | def forward(self, h_idx, r_idx):
100 | return self.forward_head_batch(h_idx.view(-1), r_idx.view(-1))
101 |
102 | def forward_head_batch(self, h_idx, r_idx):
103 | """
104 | Completed.
105 | Given a head entity and a relation (h,r), we compute scores for all possible triples,i.e.,
106 | [score(h,r,x)|x \in Entities] => [0.0,0.1,...,0.8], shape=> (1, |Entities|)
107 | Given a batch of head entities and relations => shape (size of batch,| Entities|)
108 | """
109 | h = self.E(h_idx)
110 | r = self.R(r_idx)
111 |
112 | t = self.core(h, r)
113 |
114 | if self.flag_hamilton_mul_norm:
115 | score_a, score_b = self.scoring_all(t, self.E.get_embeddings()) # a + b i
116 | else:
117 | score_a, score_b = self.scoring_all(self.E_dropout(t), self.E_dropout(self.E_bn(self.E.get_embeddings())))
118 | score_a = score_a + self.b1.expand_as(score_a)
119 | score_b = score_b + self.b2.expand_as(score_b)
120 |
121 | y_a = torch.sigmoid(score_a)
122 | y_b = torch.sigmoid(score_b)
123 |
124 | return y_a, y_b
125 |
126 | def loss(self, target, y):
127 | y_a, y_b = target
128 | return self.bce(y_a, y) + self.bce(y_b, y)
129 |
--------------------------------------------------------------------------------
/toolbox/utils/AutoML.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 |
3 |
4 | def config_tuning_space(tuning_space_raw):
5 | from hyperopt import hp
6 | from hyperopt.pyll.base import scope
7 | if tuning_space_raw is None:
8 | return None
9 |
10 | hyper_obj = {}
11 | if "learning_rate" in tuning_space_raw:
12 | hyper_obj = {**hyper_obj, **{
13 | "learning_rate": hp.loguniform('learning_rate', np.log(tuning_space_raw['learning_rate']['min']),
14 | np.log(tuning_space_raw['learning_rate']['max']))}}
15 | if "hidden_size" in tuning_space_raw:
16 | hyper_obj = {**hyper_obj, **{"hidden_size": scope.int(
17 | hp.qloguniform('hidden_size', np.log(tuning_space_raw['hidden_size']['min']),
18 | np.log(tuning_space_raw['hidden_size']['max']), 1))}}
19 | if "ent_hidden_size" in tuning_space_raw:
20 | hyper_obj = {**hyper_obj, **{"ent_hidden_size": scope.int(
21 | hp.qloguniform("ent_hidden_size", np.log(tuning_space_raw['ent_hidden_size']['min']),
22 | np.log(tuning_space_raw['ent_hidden_size']['max']), 1))}}
23 | if "rel_hidden_size" in tuning_space_raw:
24 | hyper_obj = {**hyper_obj, **{"rel_hidden_size": scope.int(
25 | hp.qloguniform("rel_hidden_size", np.log(tuning_space_raw['rel_hidden_size']['min']),
26 | np.log(tuning_space_raw['rel_hidden_size']['max']), 1))}}
27 | if "batch_size" in tuning_space_raw:
28 | hyper_obj = {**hyper_obj, **{"batch_size": scope.int(
29 | hp.qloguniform("batch_size", np.log(tuning_space_raw['batch_size']['min']),
30 | np.log(tuning_space_raw['batch_size']['max']), 1))}}
31 | if "margin" in tuning_space_raw:
32 | hyper_obj = {**hyper_obj, **{
33 | "margin": hp.uniform("margin", tuning_space_raw["margin"]["min"], tuning_space_raw["margin"]["max"])}}
34 | if "lmbda" in tuning_space_raw:
35 | hyper_obj = {**hyper_obj, **{"lmbda": hp.loguniform('lmbda', np.log(tuning_space_raw["lmbda"]["min"]),
36 | np.log(tuning_space_raw["lmbda"]["max"]))}}
37 | if "distance_measure" in tuning_space_raw:
38 | hyper_obj = {**hyper_obj,
39 | **{"distance_measure": hp.choice('distance_measure', tuning_space_raw["distance_measure"])}}
40 | if "cmax" in tuning_space_raw:
41 | hyper_obj = {**hyper_obj, **{"cmax": hp.loguniform('cmax', np.log(tuning_space_raw["cmax"]["min"]),
42 | np.log(tuning_space_raw["cmax"]["max"]))}}
43 | if "cmin" in tuning_space_raw:
44 | hyper_obj = {**hyper_obj, **{"cmin": hp.loguniform('cmin', np.log(tuning_space_raw["cmin"]["min"]),
45 | np.log(tuning_space_raw["cmin"]["max"]))}}
46 | if "optimizer" in tuning_space_raw:
47 | hyper_obj = {**hyper_obj, **{"optimizer": hp.choice("optimizer", tuning_space_raw["optimizer"])}}
48 | if "bilinear" in tuning_space_raw:
49 | hyper_obj = {**hyper_obj, **{"bilinear": hp.choice('bilinear', tuning_space_raw["bilinear"])}}
50 | if "epochs" in tuning_space_raw:
51 | hyper_obj = {**hyper_obj, **{"epochs": hp.choice("epochs", tuning_space_raw["epochs"])}}
52 | if "feature_map_dropout" in tuning_space_raw:
53 | hyper_obj = {**hyper_obj, **{
54 | "feature_map_dropout": hp.choice('feature_map_dropout', tuning_space_raw["feature_map_dropout"])}}
55 | if "input_dropout" in tuning_space_raw:
56 | hyper_obj = {**hyper_obj,
57 | **{"input_dropout": hp.choice('input_dropout', tuning_space_raw["input_dropout"])}}
58 | if "hidden_dropout" in tuning_space_raw:
59 | hyper_obj = {**hyper_obj,
60 | **{"hidden_dropout": hp.choice('hidden_dropout', tuning_space_raw["hidden_dropout"])}}
61 | if "use_bias" in tuning_space_raw:
62 | hyper_obj = {**hyper_obj, **{"use_bias": hp.choice('use_bias', tuning_space_raw["use_bias"])}}
63 | if "label_smoothing" in tuning_space_raw:
64 | hyper_obj = {**hyper_obj,
65 | **{"label_smoothing": hp.choice('label_smoothing', tuning_space_raw["label_smoothing"])}}
66 | if "lr_decay" in tuning_space_raw:
67 | hyper_obj = {**hyper_obj, **{"lr_decay": hp.choice('lr_decay', tuning_space_raw["lr_decay"])}}
68 | if "l1_flag" in tuning_space_raw:
69 | hyper_obj = {**hyper_obj, **{"l1_flag": hp.choice('l1_flag', tuning_space_raw["l1_flag"])}}
70 | if "sampling" in tuning_space_raw:
71 | hyper_obj = {**hyper_obj, **{"sampling": hp.choice('sampling', tuning_space_raw["sampling"])}}
72 |
73 | return hyper_obj
74 |
75 |
76 | def grid_search(config, run):
77 | # config = {
78 | # "embedding_dim": [100 * i for i in range(1, 6)],
79 | # "input_dropout": [0.1 * i for i in range(2)],
80 | # "hidden_dropout": [0.1 * i for i in range(2)],
81 | # }
82 | from sklearn.model_selection import ParameterGrid
83 | for i, setting in enumerate(ParameterGrid(config)):
84 | # input_dropout = setting["input_dropout"]
85 | # hidden_dropout = setting["hidden_dropout"]
86 | # embedding_dim = setting["embedding_dim"]
87 | run(i, setting)
88 |
--------------------------------------------------------------------------------
/toolbox/web/log_app/templates/multi_chart.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
chart-{{ log_dir }}
8 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
33 |
55 |
75 |
76 |
77 |
78 |
82 |
84 |
85 | Progress:
86 |
87 |
94 |
95 |
96 |
97 |
99 |
100 |
101 |
103 |
104 |
105 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
142 |
143 |
144 |
145 |
--------------------------------------------------------------------------------
/toolbox/data/ScoringAllDataset.py:
--------------------------------------------------------------------------------
1 | import random
2 | from typing import List, Tuple, Dict, Set
3 |
4 | import torch
5 | from torch.utils.data import Dataset
6 |
7 | from toolbox.data.functional import build_map_hr_t, with_inverse_relations
8 |
9 |
10 | class ScoringAllDataset(Dataset):
11 | def __init__(self, train_triples_ids: List[Tuple[int, int, int]], entity_count: int):
12 | self.hr_t = build_map_hr_t(train_triples_ids)
13 | self.hr_pairs = list(self.hr_t.keys())
14 | self.entity_count = entity_count
15 |
16 | def __len__(self):
17 | return len(self.hr_pairs)
18 |
19 | def __getitem__(self, idx):
20 | h, r = self.hr_pairs[idx]
21 | data = torch.zeros(self.entity_count).float()
22 | data[list(self.hr_t[(h, r)])] = 1.
23 | h = torch.LongTensor([h])
24 | r = torch.LongTensor([r])
25 | return h, r, data
26 |
27 |
28 | class ScoringNegativeDataset(Dataset):
29 | def __init__(self, train_triples_ids: List[Tuple[int, int, int]], entity_count: int, negative_sample_size: int = 32):
30 | self.hr_t = build_map_hr_t(train_triples_ids)
31 | self.hr_pairs = list(self.hr_t.keys())
32 | self.entity_count = entity_count
33 | self.negative_sample_size = negative_sample_size
34 |
35 | def __len__(self):
36 | return len(self.hr_pairs)
37 |
38 | def __getitem__(self, idx):
39 | h, r = self.hr_pairs[idx]
40 | data = torch.zeros(self.entity_count).float()
41 | data[list(self.hr_t[(h, r)])] = 1.
42 | idx = torch.randperm(self.entity_count)[:self.negative_sample_size]
43 | targets = data[idx]
44 | h = torch.LongTensor([h])
45 | r = torch.LongTensor([r])
46 | return h, r, idx, targets
47 |
48 |
49 | class ScoringOneVsNegativeDataset(Dataset):
50 | def __init__(self, train_triples_ids: List[Tuple[int, int, int]], max_relation_id: int, entity_count: int, negative_sample_size: int = 32):
51 | self.train_triples_ids = train_triples_ids
52 | train_triples, _, _ = with_inverse_relations(train_triples_ids, max_relation_id)
53 | self.hr_t = build_map_hr_t(train_triples)
54 | self.entity_count = entity_count
55 | self.max_relation_id = max_relation_id
56 | self.negative_sample_size = negative_sample_size
57 |
58 | def __len__(self):
59 | return len(self.train_triples_ids)
60 |
61 | def __getitem__(self, idx):
62 | h, r, t = self.train_triples_ids[idx]
63 | reverse_r = self.max_relation_id + r
64 | t_sample, t_target = self.sampling(h, r, t)
65 | h_sample, h_target = self.sampling(t, reverse_r, h)
66 | h = torch.LongTensor([h])
67 | r = torch.LongTensor([r])
68 | t = torch.LongTensor([t])
69 | reverse_r = torch.LongTensor([reverse_r])
70 | return h, r, t_sample, t_target, t, reverse_r, h_sample, h_target
71 |
72 | def sampling(self, h, r, answer_idx):
73 | valid_negative = list(set(range(self.entity_count)) - self.hr_t[(h, r)])
74 | sample_negative = random.choices(valid_negative, k=self.negative_sample_size)
75 | sample_idx = torch.LongTensor([answer_idx] + sample_negative) # (1, 1 + num_negative)
76 | target = torch.zeros(1 + self.negative_sample_size).float() # (1, 1 + num_negative)
77 | target[0] = 1
78 | return sample_idx, target
79 |
80 |
81 | class ComplementaryScoringAllDataset(Dataset):
82 | def __init__(self, hr_t: Dict[Tuple[int, int], Set[int]], all_keys: List[Tuple[int, int]], entity_count: int):
83 | self.hr_t = hr_t
84 | self.hr_pairs = all_keys
85 | self.entity_count = entity_count
86 |
87 | def __len__(self):
88 | return len(self.hr_pairs)
89 |
90 | def __getitem__(self, idx):
91 | h, r = self.hr_pairs[idx]
92 | data = torch.ones(self.entity_count).float()
93 | value = list(self.hr_t[(h, r)])
94 | if len(value) > 0:
95 | data[value] = 0.
96 | h = torch.LongTensor([h])
97 | r = torch.LongTensor([r])
98 | return h, r, data
99 |
100 |
101 | class BidirectionalScoringAllDataset(Dataset):
102 | def __init__(self, test_triples_ids: List[Tuple[int, int, int]], hr_t: Dict[Tuple[int, int], Set[int]], max_relation_id: int, entity_count: int):
103 | """
104 | test_triples_ids: without reverse r
105 | hr_t: all hr->t, MUST with reverse r
106 | """
107 | self.test_triples_ids = test_triples_ids
108 | self.hr_t = hr_t
109 | self.entity_count = entity_count
110 | self.max_relation_id = max_relation_id
111 |
112 | def __len__(self):
113 | return len(self.test_triples_ids)
114 |
115 | def __getitem__(self, idx):
116 | h, r, t = self.test_triples_ids[idx]
117 | reverse_r = r + self.max_relation_id
118 |
119 | predict_for_hr = torch.zeros(self.entity_count).float()
120 | predict_for_hr[list(self.hr_t[(h, r)])] = 1.
121 |
122 | predict_for_tReverser = torch.zeros(self.entity_count).float()
123 | predict_for_tReverser[list(self.hr_t[(t, reverse_r)])] = 1.
124 |
125 | h = torch.LongTensor([h])
126 | r = torch.LongTensor([r])
127 | t = torch.LongTensor([t])
128 | reverse_r = torch.LongTensor([reverse_r])
129 |
130 | return h, r, predict_for_hr, t, reverse_r, predict_for_tReverser
131 |
--------------------------------------------------------------------------------
/toolbox/exp/OutputSchema.py:
--------------------------------------------------------------------------------
1 | """
2 | @author: lxy
3 | @email: linxy59@mail2.sysu.edu.cn
4 | @date: 2021/10/26
5 | @description: 输出目录管理
6 | """
7 | from pathlib import Path
8 | from typing import Union
9 |
10 | from toolbox.utils.Log import Log
11 |
12 |
13 | class OutputPathSchema:
14 | """
15 | 输出目录 下的路径
16 | """
17 |
18 | def __init__(self, output_path: Union[Path, str]):
19 | self.output_path: Path = output_path if output_path is Path else Path(output_path)
20 |
21 | self.dir_path_log = self.output_path / 'logs'
22 | self.dir_path_visualize = self.output_path / 'visualize'
23 | self.dir_path_checkpoint = self.output_path / 'checkpoint'
24 | self.dir_path_latex = self.output_path / 'latex'
25 | self.dir_path_deploy = self.output_path / 'deploy'
26 | self.dir_path_scripts = self.output_path / 'scripts'
27 |
28 | self.build_dir_structure()
29 |
30 | def log_path(self, filename) -> Path:
31 | return self.dir_path_log / filename
32 |
33 | def visualize_path(self, filename) -> Path:
34 | return self.dir_path_visualize / filename
35 |
36 | def checkpoint_path(self, filename="checkpoint.tar") -> Path:
37 | return self.dir_path_checkpoint / filename
38 |
39 | def latex_path(self, filename="best.tex") -> Path:
40 | return self.dir_path_latex / filename
41 |
42 | def deploy_path(self, filename="model.tar") -> Path:
43 | return self.dir_path_deploy / filename
44 |
45 | def scripts_path(self, filename) -> Path:
46 | return self.dir_path_scripts / filename
47 |
48 | def build_dir_structure(self):
49 | self.output_path.mkdir(parents=True, exist_ok=True)
50 | self.dir_path_log.mkdir(parents=True, exist_ok=True)
51 | self.dir_path_visualize.mkdir(parents=True, exist_ok=True)
52 | self.dir_path_checkpoint.mkdir(parents=True, exist_ok=True)
53 | self.dir_path_latex.mkdir(parents=True, exist_ok=True)
54 | self.dir_path_deploy.mkdir(parents=True, exist_ok=True)
55 | self.dir_path_scripts.mkdir(parents=True, exist_ok=True)
56 |
57 | def clean(self):
58 | # clean the dir, and recreate dir structure
59 | import shutil
60 | shutil.rmtree(self.output_path)
61 | self.build_dir_structure()
62 |
63 |
64 | class OutputSchema:
65 | """
66 | 输出目录
67 | ./output
68 | - experiment name
69 | - visualize Tensorboard 可视化
70 | - events...
71 | - logs log 日志，包含超参数、指标、最佳指标等日志，配合 toolbox.web.log_app 使用
72 | - config.log
73 | - loss.log
74 | - checkpoint 检查点，用于恢复训练
75 | - checkpoint_score_xx.tar
76 | - deploy 部署模型，基于 checkpoint ，不同的是这里的 tar 文件内只包含模型，不包含优化器梯度等信息
77 | - model_score_xx.tar
78 | - config.yaml
79 | - output.log 打印到命令行的日志
80 |
81 | Args:
82 | experiment_name (str): Name of your experiment
83 | overwrite (bool): If True, it will delete the folder and create new one.
84 |
85 | Examples:
86 | >>> from toolbox.exp.OutputSchema import OutputSchema
87 | >>> output = OutputSchema("output_name")
88 | >>> output.dump()
89 |
90 | """
91 |
92 | def __init__(self, experiment_name: str, overwrite=False):
93 | self.name = experiment_name
94 | self.home_path = self.output_home_path()
95 | self.pathSchema = OutputPathSchema(self.home_path)
96 | if overwrite:
97 | self.pathSchema.clean()
98 | self.logger = Log(str(self.home_path / "output.log"), name_scope=experiment_name + "output")
99 |
100 | def output_home_path(self) -> Path:
101 | data_home_path: Path = Path('.') / 'output'
102 | data_home_path.mkdir(parents=True, exist_ok=True)
103 | data_home_path = data_home_path.resolve()
104 | return data_home_path / self.name
105 |
106 | def output_path_child(self, child_dir_name: str) -> Path:
107 | return self.home_path / child_dir_name
108 |
109 | def child_log(self, name: str, write_to_console=False) -> Log:
110 | return Log(str(self.pathSchema.log_path(name)), name_scope=self.name + "output-" + name, write_to_console=write_to_console)
111 |
112 | def dump(self):
113 | """ Displays all the metadata of the knowledge graph"""
114 | for key, value in self.__dict__.items():
115 | self.logger.info("%s %s" % (key, value))
116 |
117 | def __repr__(self):
118 | return f"{self.__class__.__name__}({self.home_path})"
119 |
120 |
121 | class Cleaner:
122 | def __init__(self, pathSchema: OutputPathSchema):
123 | self.pathSchema: OutputPathSchema = pathSchema
124 |
125 | def remove_non_best_checkpoint_and_model(self):
126 | def remove_non_best(dir_path: Path):
127 | dir_name = str(dir_path)
128 | import os
129 | print("In", dir_name)
130 | filenames = os.listdir(dir_name)
131 | to_delete_files = set([f for f in filenames if "best" not in f])
132 | for filename in to_delete_files:
133 | print(" remove", filename)
134 | os.remove(str(dir_path / filename))
135 |
136 | remove_non_best(self.pathSchema.dir_path_checkpoint)
137 | remove_non_best(self.pathSchema.dir_path_deploy)
138 |
--------------------------------------------------------------------------------
/toolbox/web/log_app/static/css/table.css:
--------------------------------------------------------------------------------
1 |
2 | .word-wrap {
3 | word-break: break-all;
4 | max-width: 80px;
5 | word-wrap: break-word;
6 | overflow-wrap: break-word;
7 | min-width: 30px;
8 | }
9 |
10 | #columns_dialogue div {
11 | margin-top: 2px;
12 | padding: 1px 0px 1px 10px;
13 | margin-bottom: 2px;
14 | }
15 |
16 | #add_row_dialogue div {
17 | margin-top: 2px;
18 | padding: 1px 0px 1px 10px;
19 | margin-bottom: 2px;
20 | }
21 |
22 |
23 |
24 | /* 以下内容用于checkbox*/
25 |
26 | /*
27 | P.S: if you like my content maybe you will become a donator and donate some money? That helps me to create new awesome materials. https://www.paypal.me/melnik909
28 | */
29 |
30 | /*
31 | I've used nested span elements for creating an animation of square turn and creating an arrow animation. But if you know other a solution please email me
32 | melnik909@ya.ru
33 | */
34 |
35 | /*
36 | =====
37 | LEVEL 1. CORE STYLES
38 | =====
39 | */
40 |
41 | .toggle{
42 | --uiToggleSize: var(--toggleSize, 20px);
43 | --uiToggleIndent: var(--toggleIndent, .4em);
44 | --uiToggleBorderWidth: var(--toggleBorderWidth, 2px);
45 | --uiToggleColor: var(--toggleColor, #000);
46 | --uiToggleDisabledColor: var(--toggleDisabledColor, #868e96);
47 | --uiToggleBgColor: var(--toggleBgColor, #fff);
48 | --uiToggleArrowWidth: var(--toggleArrowWidth, 2px);
49 | --uiToggleArrowColor: var(--toggleArrowColor, #fff);
50 |
51 | display: inline-block;
52 | position: relative;
53 | }
54 |
55 | .toggle__input{
56 | position: absolute;
57 | left: -99999px;
58 | }
59 |
60 | .toggle__label{
61 | display: inline-flex;
62 | cursor: pointer;
63 | min-height: var(--uiToggleSize);
64 | padding-left: calc(var(--uiToggleSize) + var(--uiToggleIndent));
65 | }
66 |
67 | .toggle__label:before, .toggle__label:after{
68 | content: "";
69 | box-sizing: border-box;
70 | width: 1em;
71 | height: 1em;
72 | font-size: var(--uiToggleSize);
73 |
74 | position: absolute;
75 | left: 0;
76 | top: 0;
77 | }
78 |
79 | .toggle__label:before{
80 | border: var(--uiToggleBorderWidth) solid var(--uiToggleColor);
81 | z-index: 2;
82 | }
83 |
84 | .toggle__input:disabled ~ .toggle__label:before{
85 | border-color: var(--uiToggleDisabledColor);
86 | }
87 |
88 | /*.toggle__input:focus ~ .toggle__label:before{*/
89 | /*box-shadow: 0 0 0 2px var(--uiToggleBgColor), 0 0 0px 4px var(--uiToggleColor);*/
90 | /*}*/
91 |
92 | /*.toggle__input:not(:disabled):checked:focus ~ .toggle__label:after{*/
93 | /*box-shadow: 0 0 0 2px var(--uiToggleBgColor), 0 0 0px 4px var(--uiToggleColor);*/
94 | /*}*/
95 |
96 | .toggle__input:not(:disabled) ~ .toggle__label:after{
97 | background-color: var(--uiToggleColor);
98 | opacity: 0;
99 | }
100 |
101 | .toggle__input:not(:disabled):checked ~ .toggle__label:after{
102 | opacity: 1;
103 | }
104 |
105 | .toggle__text{
106 | margin-top: auto;
107 | margin-bottom: auto;
108 | }
109 |
110 | /*
111 | The arrow size and position depends from sizes of square because I needed an arrow correct positioning from the top left corner of the element toggle
112 | */
113 |
114 | .toggle__text:before{
115 | content: "";
116 | box-sizing: border-box;
117 | width: 0;
118 | height: 0;
119 | font-size: var(--uiToggleSize);
120 |
121 | border-left-width: 0;
122 | border-bottom-width: 0;
123 | border-left-style: solid;
124 | border-bottom-style: solid;
125 | border-color: var(--uiToggleArrowColor);
126 |
127 | position: absolute;
128 | top: .5428em;
129 | left: .2em;
130 | z-index: 3;
131 |
132 | transform-origin: left top;
133 | transform: rotate(-40deg) skew(10deg);
134 | }
135 |
136 | .toggle__input:not(:disabled):checked ~ .toggle__label .toggle__text:before{
137 | width: .5em;
138 | height: .25em;
139 | border-left-width: var(--uiToggleArrowWidth);
140 | border-bottom-width: var(--uiToggleArrowWidth);
141 | will-change: width, height;
142 | transition: width .1s ease-out .2s, height .2s ease-out;
143 | }
144 |
145 | /*
146 | =====
147 | LEVEL 2. PRESENTATION STYLES
148 | =====
149 | */
150 |
151 | /*
152 | The demo skin
153 | */
154 |
155 | .toggle__label:before, .toggle__label:after{
156 | border-radius: 2px;
157 | }
158 |
159 | /*
160 | The animation of switching states
161 | */
162 |
163 | .toggle__input:not(:disabled) ~ .toggle__label:before,
164 | .toggle__input:not(:disabled) ~ .toggle__label:after{
165 | opacity: 1;
166 | transform-origin: center center;
167 | will-change: transform;
168 | transition: transform .2s ease-out;
169 | }
170 |
171 | .toggle__input:not(:disabled) ~ .toggle__label:before{
172 | transform: rotateY(0deg);
173 | transition-delay: .2s;
174 | }
175 |
176 | .toggle__input:not(:disabled) ~ .toggle__label:after{
177 | transform: rotateY(90deg);
178 | }
179 |
180 | .toggle__input:not(:disabled):checked ~ .toggle__label:before{
181 | transform: rotateY(-90deg);
182 | transition-delay: 0s;
183 | }
184 |
185 | .toggle__input:not(:disabled):checked ~ .toggle__label:after{
186 | transform: rotateY(0deg);
187 | transition-delay: .2s;
188 | }
189 |
190 | .toggle__text:before{
191 | opacity: 0;
192 | }
193 |
194 | .toggle__input:not(:disabled):checked ~ .toggle__label .toggle__text:before{
195 | opacity: 1;
196 | transition: opacity .1s ease-out .3s, width .1s ease-out .5s, height .2s ease-out .3s;
197 | }
198 |
199 | /*
200 | =====
201 | LEVEL 3. SETTINGS
202 | =====
203 | */
204 |
205 | .toggle{
206 | --toggleColor: #008490;
207 | --toggleBgColor: #0d49b6;
208 | /*--toggleSize: 15px;*/
209 | }
210 |
211 |
212 |
213 |
--------------------------------------------------------------------------------
/toolbox/utils/Progbar.py:
--------------------------------------------------------------------------------
1 | """
2 | @author: lxy
3 | @email: linxy59@mail2.sysu.edu.cn
4 | @date: 2022/2/19
5 | @description: 进度条
6 | """
7 | import sys
8 | import time
9 | from typing import Dict, Any, Union, Tuple, List
10 | import datetime
11 | import numpy as np
12 |
13 |
14 | class Progbar(object):
15 | """Progress bar class inspired by keras 进度条
16 |
17 | Examples:
18 | >>> from toolbox.utils.Progbar import Progbar
19 | >>> progbar = Progbar(max_step=100)
20 | >>> for i in range(100):
21 | >>> progbar.update(i, [("step", i), ("next", i+1)])
22 | """
23 |
24 | def __init__(self, max_step: int, width: int = 15, mode: str = "instant"):
25 | self.max_step: int = max_step
26 | self.width: int = width
27 | self.mode: str = mode
28 | self.last_width: int = 0
29 |
30 | self.sum_values: Dict[str, Any] = {}
31 |
32 | self.start: float = time.time()
33 | self.last_step: int = 0
34 |
35 | self.info: str = ""
36 | self.bar: str = ""
37 |
38 | def _update_values(self, curr_step: int, values: List[Tuple[str, Union[float, str, int]]]):
39 | for k, v in values:
40 | if k not in self.sum_values:
41 | if isinstance(v, float) or isinstance(v, int):
42 | if self.mode == "instant":
43 | self.sum_values[k] = v
44 | else:
45 | self.sum_values[k] = [v * (curr_step - self.last_step), curr_step - self.last_step]
46 | elif isinstance(v, str):
47 | self.sum_values[k] = (v + " ")[:20]
48 | else:
49 | self.sum_values[k] = (str(v) + " ")[:20]
50 | else:
51 | if isinstance(v, float) or isinstance(v, int):
52 | if self.mode == "instant":
53 | self.sum_values[k] = v
54 | else:
55 | self.sum_values[k][0] += v * (curr_step - self.last_step)
56 | self.sum_values[k][1] += (curr_step - self.last_step)
57 | elif isinstance(v, str):
58 | self.sum_values[k] = (v + " ")[:20]
59 | else:
60 | self.sum_values[k] = (str(v) + " ")[:20]
61 |
62 | def _write_bar(self, curr_step: int):
63 | last_width = self.last_width
64 | sys.stdout.write("\b" * last_width)
65 | sys.stdout.write("\r")
66 |
67 | numdigits = int(np.floor(np.log10(self.max_step))) + 1
68 | barstr = '%%%dd/%%%dd [' % (numdigits, numdigits)
69 | bar = barstr % (curr_step, self.max_step)
70 | prog = float(curr_step) / self.max_step
71 | prog_width = int(self.width * prog)
72 | if prog_width > 0:
73 | bar += ('=' * (prog_width - 1))
74 | if curr_step < self.max_step:
75 | bar += '>'
76 | else:
77 | bar += '='
78 | bar += ('.' * (self.width - prog_width))
79 | bar += ']'
80 | sys.stdout.write(bar)
81 |
82 | return bar
83 |
84 | def _get_eta(self, curr_step: int):
85 | now = time.time()
86 | if curr_step:
87 | time_per_step = (now - self.start) / curr_step
88 | else:
89 | time_per_step = 0
90 | eta = time_per_step * (self.max_step - curr_step)
91 |
92 | if curr_step < self.max_step:
93 | info = ' - ETA: %s' % str(datetime.timedelta(seconds=eta))
94 | else:
95 | info = ' - %s' % str(datetime.timedelta(seconds=now - self.start))
96 |
97 | return info
98 |
99 | def _get_values_sum(self):
100 | info = ""
101 | for name, value in self.sum_values.items():
102 | if isinstance(value, str):
103 | info += ' - %s: %s' % (name, value)
104 | else:
105 | if self.mode == "instant":
106 | if isinstance(value, int):
107 | info += ' - %s: %d' % (name, value)
108 | else:
109 | info += ' - %s: %.6f' % (name, value)
110 | else:
111 | info += ' - %s: %.6f' % (name, value[0] / max(1, value[1]))
112 | return info
113 |
114 | def _write_info(self, curr_step: int):
115 | info = ""
116 | info += self._get_eta(curr_step)
117 | info += self._get_values_sum()
118 |
119 | sys.stdout.write(info)
120 |
121 | return info
122 |
123 | def _update_width(self, curr_step: int):
124 | curr_width = len(self.bar) + len(self.info)
125 | if curr_width < self.last_width:
126 | sys.stdout.write(" " * (self.last_width - curr_width))
127 |
128 | if curr_step >= self.max_step:
129 | sys.stdout.write("\n")
130 |
131 | sys.stdout.flush()
132 |
133 | self.last_width = curr_width
134 |
135 | def update(self, curr_step: int, values: Union[Dict[str, Any], List[Tuple[str, Any]]]):
136 | """Updates the progress bar.
137 | The progress bar will display averages for these values.
138 |
139 | Args:
140 | values: Dict or List of tuples (name, value_for_last_step).
141 | """
142 | if isinstance(values, dict):
143 | values = [(k, v) for k, v in values.items()]
144 | self._update_values(curr_step, values)
145 | self.bar = self._write_bar(curr_step)
146 | self.info = self._write_info(curr_step)
147 | self._update_width(curr_step)
148 | self.last_step = curr_step
149 | return values
150 |
--------------------------------------------------------------------------------
/toolbox/utils/Framework.py:
--------------------------------------------------------------------------------
1 | import importlib
2 | import logging
3 | import os
4 | import sys
5 | from functools import wraps
6 |
7 | import numpy as np
8 | from packaging import version
9 |
10 | if sys.version_info < (3, 8):
11 | import importlib_metadata
12 | else:
13 | import importlib.metadata as importlib_metadata
14 |
15 | logger = logging.getLogger(__name__) # pylint: disable=invalid-name
16 |
17 | ENV_VARS_TRUE_VALUES = {"1", "ON", "YES", "TRUE"}
18 | ENV_VARS_TRUE_AND_AUTO_VALUES = ENV_VARS_TRUE_VALUES.union({"AUTO"})
19 |
20 | USE_TF = os.environ.get("USE_TF", "AUTO").upper()
21 | USE_TORCH = os.environ.get("USE_TORCH", "AUTO").upper()
22 | USE_JAX = os.environ.get("USE_FLAX", "AUTO").upper()
23 |
24 | if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
25 | _torch_available = importlib.util.find_spec("torch") is not None
26 | if _torch_available:
27 | try:
28 | _torch_version = importlib_metadata.version("torch")
29 | logger.info(f"PyTorch version {_torch_version} available.")
30 | except importlib_metadata.PackageNotFoundError:
31 | _torch_available = False
32 | else:
33 | logger.info("Disabling PyTorch because USE_TF is set")
34 | _torch_available = False
35 |
36 | if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
37 | _tf_available = importlib.util.find_spec("tensorflow") is not None
38 | if _tf_available:
39 | candidates = (
40 | "tensorflow",
41 | "tensorflow-cpu",
42 | "tensorflow-gpu",
43 | "tf-nightly",
44 | "tf-nightly-cpu",
45 | "tf-nightly-gpu",
46 | "intel-tensorflow",
47 | )
48 | _tf_version = None
49 | # For the metadata, we have to look for both tensorflow and tensorflow-cpu
50 | for pkg in candidates:
51 | try:
52 | _tf_version = importlib_metadata.version(pkg)
53 | break
54 | except importlib_metadata.PackageNotFoundError:
55 | pass
56 | _tf_available = _tf_version is not None
57 | if _tf_available:
58 | if version.parse(_tf_version) < version.parse("2"):
59 | logger.info(f"TensorFlow found but with version {_tf_version}. Transformers requires version 2 minimum.")
60 | _tf_available = False
61 | else:
62 | logger.info(f"TensorFlow version {_tf_version} available.")
63 | else:
64 | logger.info("Disabling Tensorflow because USE_TORCH is set")
65 | _tf_available = False
66 |
67 | _is_offline_mode = True if os.environ.get("TRANSFORMERS_OFFLINE", "0").upper() in ENV_VARS_TRUE_VALUES else False
68 |
69 |
70 | def is_offline_mode():
71 | return _is_offline_mode
72 |
73 |
74 | def is_torch_available():
75 | return _torch_available
76 |
77 |
78 | def is_torch_cuda_available():
79 | if is_torch_available():
80 | import torch
81 |
82 | return torch.cuda.is_available()
83 | else:
84 | return False
85 |
86 |
87 | def is_tf_available():
88 | return _tf_available
89 |
90 |
91 | def is_deepspeed_available():
92 | return importlib.util.find_spec("deepspeed") is not None
93 |
94 |
95 | def is_psutil_available():
96 | return importlib.util.find_spec("psutil") is not None
97 |
98 |
99 | class cached_property(property):
100 | """
101 | Descriptor that mimics @property but caches output in member variable.
102 |
103 | From tensorflow_datasets
104 |
105 | Built-in in functools from Python 3.8.
106 | """
107 |
108 | def __get__(self, obj, objtype=None):
109 | # See docs.python.org/3/howto/descriptor.html#properties
110 | if obj is None:
111 | return self
112 | if self.fget is None:
113 | raise AttributeError("unreadable attribute")
114 | attr = "__cached_" + self.fget.__name__
115 | cached = getattr(obj, attr, None)
116 | if cached is None:
117 | cached = self.fget(obj)
118 | setattr(obj, attr, cached)
119 | return cached
120 |
121 |
122 | def torch_required(func):
123 | # Chose a different decorator name than in tests so it's clear they are not the same.
124 | @wraps(func)
125 | def wrapper(*args, **kwargs):
126 | if is_torch_available():
127 | return func(*args, **kwargs)
128 | else:
129 | raise ImportError(f"Method `{func.__name__}` requires PyTorch.")
130 |
131 | return wrapper
132 |
133 |
134 | def tf_required(func):
135 | # Chose a different decorator name than in tests so it's clear they are not the same.
136 | @wraps(func)
137 | def wrapper(*args, **kwargs):
138 | if is_tf_available():
139 | return func(*args, **kwargs)
140 | else:
141 | raise ImportError(f"Method `{func.__name__}` requires TF.")
142 |
143 | return wrapper
144 |
145 |
146 | def is_tensor(x):
147 | """ Tests if ``x`` is a :obj:`torch.Tensor`, :obj:`tf.Tensor` or :obj:`np.ndarray`. """
148 | if is_torch_available():
149 | import torch
150 |
151 | if isinstance(x, torch.Tensor):
152 | return True
153 | if is_tf_available():
154 | import tensorflow as tf
155 |
156 | if isinstance(x, tf.Tensor):
157 | return True
158 | return isinstance(x, np.ndarray)
159 |
160 |
161 | def _is_numpy(x):
162 | return isinstance(x, np.ndarray)
163 |
164 |
165 | def _is_torch(x):
166 | import torch
167 |
168 | return isinstance(x, torch.Tensor)
169 |
170 |
171 | def _is_torch_device(x):
172 | import torch
173 |
174 | return isinstance(x, torch.device)
175 |
176 |
177 | def _is_tensorflow(x):
178 | import tensorflow as tf
179 |
180 | return isinstance(x, tf.Tensor)
181 |
--------------------------------------------------------------------------------
/toolbox/nn/MobiusE.py:
--------------------------------------------------------------------------------
1 | import torch
2 | import torch.nn as nn
3 | import torch.nn.functional as F
4 |
5 | from toolbox.nn.ComplexEmbedding import ComplexEmbedding, ComplexDropout, ComplexScoringAll, ComplexBatchNorm1d, ComplexMult, ComplexAdd, ComplexDiv, ComplexAlign
6 | from toolbox.nn.MobiusEmbedding import MobiusEmbedding, MobiusDropout, MobiusBatchNorm1d
7 | from toolbox.nn.Regularizer import N3
8 |
9 |
10 | def mobius_mul_with_unit_norm(Q_1, Q_2):
11 | a_h = Q_1 # = {a_h + b_h i + c_h j + d_h k : a_r, b_r, c_r, d_r \in R^k}
12 | a_r, b_r, c_r, d_r = Q_2 # = {a_r + b_r i + c_r j + d_r k : a_r, b_r, c_r, d_r \in R^k}
13 |
14 | # Normalize the relation to eliminate the scaling effect
15 | denominator = torch.sqrt(a_r ** 2 + b_r ** 2 + c_r ** 2 + d_r ** 2)
16 | p = a_r / denominator
17 | q = b_r / denominator
18 | u = c_r / denominator
19 | v = d_r / denominator
20 | # Q'=E Hamilton product R
21 | h_r = (a_h * p + q) / (a_h * u + v)
22 | return h_r
23 |
24 |
25 | def mobius_mul(Q_1, Q_2):
26 | a_h = Q_1 # = {a_h : a_r, b_r, c_r, d_r \in R^k}
27 | a_r, b_r, c_r, d_r = Q_2 # = {a_r + b_r i + c_r j + d_r k : a_r, b_r, c_r, d_r \in R^k}
28 | h_r = (a_h * a_r + b_r) / (a_h * c_r + d_r)
29 | return h_r
30 |
31 |
32 | class MobiusMult(nn.Module):
33 | """
34 | a_r * h + b_r
35 | h * r = -------------
36 | c_r * h + d_r
37 | h in CP^d
38 | r_a, r_b, r_c, r_d in C^d
39 | """
40 |
41 | def __init__(self, norm_flag=False):
42 | super(MobiusMult, self).__init__()
43 | self.flag_hamilton_mul_norm = norm_flag
44 | self.complex_mul = ComplexMult(norm_flag)
45 | self.complex_add = ComplexAdd()
46 | self.complex_div = ComplexDiv()
47 |
48 | def forward(self, h, r):
49 | r_a, r_b, r_c, r_d = r
50 | hr_top = self.complex_add(self.complex_mul(h, r_a), r_b)
51 | hr_bottom = self.complex_add(self.complex_mul(h, r_c), r_d)
52 | h_r = self.complex_div(hr_top, hr_bottom)
53 | return h_r
54 |
55 |
56 | class MobiusE(nn.Module):
57 |
58 | def __init__(self,
59 | num_entities, num_relations,
60 | embedding_dim,
61 | norm_flag=False, input_dropout=0.2, hidden_dropout=0.3, regularization_weight=0.1):
62 | super(MobiusE, self).__init__()
63 | self.embedding_dim = embedding_dim
64 | self.num_entities = num_entities
65 | self.num_relations = num_relations
66 | self.loss = nn.BCELoss()
67 | self.flag_hamilton_mul_norm = norm_flag
68 | self.E = ComplexEmbedding(self.num_entities, self.embedding_dim, 2) # a + bi
69 | self.R = MobiusEmbedding(self.num_relations, self.embedding_dim, 4) # 4 numbers: a + bi
70 | self.E_dropout = ComplexDropout([input_dropout, input_dropout])
71 | self.R_dropout = MobiusDropout([[input_dropout, input_dropout]] * 4)
72 | self.hidden_dp = ComplexDropout([hidden_dropout, hidden_dropout])
73 | self.E_bn = ComplexBatchNorm1d(self.embedding_dim, 2)
74 | self.R_bn = MobiusBatchNorm1d(self.embedding_dim, 4)
75 | self.b = nn.Parameter(torch.zeros(num_entities))
76 |
77 | self.mul = MobiusMult(norm_flag)
78 | self.scoring_all = ComplexScoringAll()
79 | self.align = ComplexAlign()
80 | self.regularizer = N3(regularization_weight)
81 |
82 | def forward(self, h_idx, r_idx):
83 | h_idx = h_idx.view(-1)
84 | r_idx = r_idx.view(-1)
85 | return self.forward_head_batch(h_idx, r_idx)
86 |
87 | def forward_head_batch(self, h_idx, r_idx):
88 | """
89 | Completed.
90 | Given a head entity and a relation (h,r), we compute scores for all possible triples,i.e.,
91 | [score(h,r,x)|x \in Entities] => [0.0,0.1,...,0.8], shape=> (1, |Entities|)
92 | Given a batch of head entities and relations => shape (size of batch,| Entities|)
93 | """
94 | h = self.E(h_idx)
95 | r = self.R(r_idx)
96 |
97 | t = self.mul(h, r)
98 |
99 | if self.flag_hamilton_mul_norm:
100 | score_a, score_b = self.scoring_all(t, self.E.get_embeddings()) # a + b i
101 | else:
102 | score_a, score_b = self.scoring_all(self.E_dropout(t), self.E_dropout(self.E_bn(self.E.get_embeddings())))
103 | x = score_a + score_b
104 | x = x + self.b.expand_as(x)
105 | x = torch.sigmoid(x)
106 |
107 | return x
108 |
109 | def regular_loss(self, h_idx, r_idx):
110 | h = self.E(h_idx)
111 | r = self.R(r_idx)
112 | h_a, h_a_i = h
113 | (r_a, r_a_i), (r_b, r_b_i), (r_c, r_c_i), (r_d, r_d_i) = r
114 | factors = (
115 | torch.sqrt(h_a ** 2 + h_a_i ** 2),
116 | torch.sqrt(r_a ** 2 + r_a_i ** 2 + r_c ** 2 + r_c_i ** 2 + r_b ** 2 + r_b_i ** 2 + r_d ** 2 + r_d_i ** 2),
117 | )
118 | regular_loss = self.regularizer(factors)
119 | return regular_loss
120 |
121 | def reverse_loss(self, h_idx, r_idx, max_relation_idx):
122 | h = self.E(h_idx)
123 | h_a, h_b = h
124 | h = (h_a.detach(), h_b.detach())
125 |
126 | r = self.R(r_idx)
127 | reverse_rel_idx = (r_idx + max_relation_idx) % (2 * max_relation_idx)
128 |
129 | t = self.mul(h, r)
130 | reverse_r = self.R(reverse_rel_idx)
131 | reverse_t = self.mul(t, reverse_r)
132 | reverse_a, reverse_b = self.align(reverse_t, h) # a + b i
133 | reverse_score = reverse_a + reverse_b
134 | reverse_score = torch.mean(F.relu(reverse_score))
135 |
136 | return reverse_score
137 |
138 | def init(self):
139 | self.E.init()
140 | self.R.init()
141 |
142 | #
143 | # TRAIN: {'MRR': 0.3367987126111984, 'hits@[1,3,10]': tensor([0.2347, 0.3808, 0.5365])}
144 | # VALID : {'MRR': 0.28631188720464706, 'hits@[1,3,10]': tensor([0.2089, 0.3107, 0.4430])}
145 | #
146 | #
147 | # TEST : ({'rhs': 0.38042595982551575, 'lhs': 0.1826966404914856}, {'rhs': tensor([0.2927, 0.4182, 0.5544]), 'lhs': tensor([0.1148, 0.1959, 0.3186])})
148 |
--------------------------------------------------------------------------------
/toolbox/nn/TuckerMobiusE.py:
--------------------------------------------------------------------------------
1 | import torch
2 | import torch.nn as nn
3 | import torch.nn.functional as F
4 |
5 | from toolbox.nn.ComplexEmbedding import ComplexEmbedding, ComplexDropout, ComplexBatchNorm1d, ComplexMult, ComplexAdd, ComplexDiv, ComplexAlign
6 | from toolbox.nn.MobiusEmbedding import MobiusEmbedding, MobiusDropout, MobiusBatchNorm1d
7 | from toolbox.nn.Regularizer import N3
8 | from toolbox.nn.TuckER import CoreTuckER
9 |
10 |
11 | def mobius_mul_with_unit_norm(Q_1, Q_2):
12 | a_h = Q_1 # = {a_h + b_h i + c_h j + d_h k : a_r, b_r, c_r, d_r \in R^k}
13 | a_r, b_r, c_r, d_r = Q_2 # = {a_r + b_r i + c_r j + d_r k : a_r, b_r, c_r, d_r \in R^k}
14 |
15 | # Normalize the relation to eliminate the scaling effect
16 | denominator = torch.sqrt(a_r ** 2 + b_r ** 2 + c_r ** 2 + d_r ** 2)
17 | p = a_r / denominator
18 | q = b_r / denominator
19 | u = c_r / denominator
20 | v = d_r / denominator
21 | # Q'=E Hamilton product R
22 | h_r = (a_h * p + q) / (a_h * u + v)
23 | return h_r
24 |
25 |
26 | def mobius_mul(Q_1, Q_2):
27 | a_h = Q_1 # = {a_h : a_r, b_r, c_r, d_r \in R^k}
28 | a_r, b_r, c_r, d_r = Q_2 # = {a_r + b_r i + c_r j + d_r k : a_r, b_r, c_r, d_r \in R^k}
29 | h_r = (a_h * a_r + b_r) / (a_h * c_r + d_r)
30 | return h_r
31 |
32 |
33 | class MobiusMult(nn.Module):
34 | """
35 | a_r * h + b_r
36 | h * r = -------------
37 | c_r * h + d_r
38 | h in CP^d
39 | r_a, r_b, r_c, r_d in C^d
40 | """
41 |
42 | def __init__(self, norm_flag=False):
43 | super(MobiusMult, self).__init__()
44 | self.flag_hamilton_mul_norm = norm_flag
45 | self.complex_mul = ComplexMult(norm_flag)
46 | self.complex_add = ComplexAdd()
47 | self.complex_div = ComplexDiv()
48 |
49 | def forward(self, h, r):
50 | r_a, r_b, r_c, r_d = r
51 | hr_top = self.complex_add(self.complex_mul(h, r_a), r_b)
52 | hr_bottom = self.complex_add(self.complex_mul(h, r_c), r_d)
53 | h_r = self.complex_div(hr_top, hr_bottom)
54 | return h_r
55 |
56 |
57 | class BatchComplexScoringAll(nn.Module):
58 | def forward(self, complex_numbers, embeddings):
59 | out = []
60 | for idx, complex_number in enumerate(list(complex_numbers)):
61 | ans = torch.bmm(complex_number.unsqueeze(dim=1), embeddings[idx]).squeeze(dim=1)
62 | out.append(ans)
63 | return tuple(out)
64 |
65 |
66 | class TuckerMobiusE(nn.Module):
67 |
68 | def __init__(self,
69 | num_entities, num_relations,
70 | embedding_dim,
71 | norm_flag=False, input_dropout=0.2, hidden_dropout=0.3, regularization_weight=0.1):
72 | super(TuckerMobiusE, self).__init__()
73 | self.embedding_dim = embedding_dim
74 | self.num_entities = num_entities
75 | self.num_relations = num_relations
76 | self.loss = nn.BCELoss()
77 | self.flag_hamilton_mul_norm = norm_flag
78 | self.E = ComplexEmbedding(self.num_entities, self.embedding_dim, 2) # a + bi
79 | self.R = MobiusEmbedding(self.num_relations, self.embedding_dim, 4) # 4 numbers: a + bi
80 | self.R2 = nn.Embedding(num_relations, embedding_dim)
81 | self.real_tucker = CoreTuckER(embedding_dim, embedding_dim, hidden_dropout)
82 | self.img_tucker = CoreTuckER(embedding_dim, embedding_dim, hidden_dropout)
83 | self.E_dropout = ComplexDropout([input_dropout, input_dropout])
84 | self.R_dropout = MobiusDropout([[input_dropout, input_dropout]] * 4)
85 | self.hidden_dp = ComplexDropout([hidden_dropout, hidden_dropout])
86 | self.E_bn = ComplexBatchNorm1d(self.embedding_dim, 2)
87 | self.R_bn = MobiusBatchNorm1d(self.embedding_dim, 4)
88 |
89 | self.mul = MobiusMult(norm_flag)
90 | self.scoring_all = BatchComplexScoringAll()
91 | self.align = ComplexAlign()
92 | self.regularizer = N3(regularization_weight)
93 |
94 | def forward(self, h_idx, r_idx):
95 | h_idx = h_idx.view(-1)
96 | r_idx = r_idx.view(-1)
97 | return self.forward_head_batch(h_idx, r_idx)
98 |
99 | def forward_head_batch(self, h_idx, r_idx):
100 | """
101 | Completed.
102 | Given a head entity and a relation (h,r), we compute scores for all possible triples,i.e.,
103 | [score(h,r,x)|x \in Entities] => [0.0,0.1,...,0.8], shape=> (1, |Entities|)
104 | Given a batch of head entities and relations => shape (size of batch,| Entities|)
105 | """
106 | h = self.E(h_idx)
107 | r = self.R(r_idx)
108 | r2 = self.R2(r_idx)
109 |
110 | h_a, h_b = h
111 | t_a = self.real_tucker(h_a, r2)
112 | t_b = self.img_tucker(h_b, r2)
113 | h = (t_a, t_b)
114 |
115 | t = self.mul(h, r)
116 | # (re_relation_a, im_relation_a), (re_relation_c, im_relation_c), (re_relation_b, im_relation_b), (re_relation_d, im_relation_d) = r
117 |
118 | E_a, E_b = self.E.get_embeddings()
119 | E_a = self.real_tucker.w(E_a, r2)
120 | E_b = self.img_tucker.w(E_b, r2)
121 | E = (E_a, E_b)
122 | # E = self.E.get_embeddings()
123 | if self.flag_hamilton_mul_norm:
124 | score_a, score_b = self.scoring_all(t, E) # a + b i
125 | else:
126 | score_a, score_b = self.scoring_all(self.E_dropout(t), self.E_dropout(self.E_bn(E)))
127 | score = score_a + score_b
128 | score = torch.sigmoid(score)
129 |
130 | return score
131 |
132 | def reverse_loss(self, h_idx, r_idx, max_relation_idx):
133 | h = self.E(h_idx)
134 | h_a, h_b = h
135 | h = (h_a.detach(), h_b.detach())
136 |
137 | r = self.R(r_idx)
138 | reverse_rel_idx = (r_idx + max_relation_idx) % (2 * max_relation_idx)
139 |
140 | t = self.mul(h, r)
141 | reverse_r = self.R(reverse_rel_idx)
142 | reverse_t = self.mul(t, reverse_r)
143 | reverse_a, reverse_b = self.align(reverse_t, h) # a + b i
144 | reverse_score = reverse_a + reverse_b
145 | reverse_score = torch.mean(F.relu(reverse_score))
146 |
147 | return reverse_score
148 |
149 | def init(self):
150 | self.E.init()
151 | self.R.init()
152 |
--------------------------------------------------------------------------------