def showStudentData(self):
string = self.search_input.get()
data = dt.getInfor(string, 'student')
if data == None:
tkm.showwarning(title='系统提示', message='未查找到任何信息')
return
rank = dt.getRank(name=string, id=string)
data = dt.normalization(data)
infor_label = ttk.Label(self.infor_frame, text=data)
rank_label = ttk.Label(self.infor_frame, text=' 排名\t' + str(rank))
infor_label.grid(row=4, column=2, pady=10)
rank_label.grid(row=5, column=2, sticky='w')
return
def searchPage(self):
#销毁前一次界面
self.infor_frame.destroy()
self.infor_frame = ttk.Frame(self.root,
padding=(10, 10, 10, 10),
relief='sunken')
self.infor_frame.pack()
data = dt.getInfor(self.id, self.user)
rank = dt.getRank(id=self.id)
data = dt.normalization(data)
data_label = ttk.Label(self.infor_frame, text=data)
rank_label = ttk.Label(self.infor_frame, text='排名')
rank_num_label = ttk.Label(self.infor_frame, text=str(rank))
return_button = ttk.Button(self.infor_frame,
text='返回',
command=self.return_menu)
data_label.grid(row=1, column=1)
rank_label.grid(row=2, column=1, sticky='w', pady=10)
rank_num_label.grid(row=2, column=2, sticky='n', pady=10)
return_button.grid(row=3, column=1)
pass
device = "cuda" if torch.cuda.is_available() else "cpu"
model = GCN_Net().to(device)
criterion = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(),
lr=learning_rate,
weight_decay=weight_decay)
dataset = dgl.data.CiteseerGraphDataset()
graph = dataset[0]
tensor_x = graph.ndata['feat'].to(device)
tensor_y = graph.ndata['label'].to(device)
tensor_train_mask = graph.ndata['train_mask'].to(device)
tensor_val_mask = graph.ndata['val_mask'].to(device)
tensor_test_mask = graph.ndata['test_mask'].to(device)
graph = read_data(osp.join("citeseer", "raw", "ind.citeseer.graph"))
normalize_adjacency = normalization(build_adjacency(graph))
indices = torch.from_numpy(
np.asarray([normalize_adjacency.row,
normalize_adjacency.col]).astype('int64')).long()
values = torch.from_numpy(normalize_adjacency.data.astype(np.float32))
tensor_adjacency = torch.sparse.FloatTensor(indices, values,
(3327, 3327)).to(device)
def train():
loss_history = []
val_acc_history = []
model.train()
train_y = tensor_y[tensor_train_mask]
for epoch in range(epochs):
criterion = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
dataset = dgl.data.CiteseerGraphDataset()
graph = dataset[0]
tensor_x = graph.ndata['feat'].to(device)
tensor_y = graph.ndata['label'].to(device)
tensor_train_mask = graph.ndata['train_mask'].to(device)
tensor_val_mask = graph.ndata['val_mask'].to(device)
tensor_test_mask = graph.ndata['test_mask'].to(device)
graph = read_data(osp.join("citeseer", "raw", "ind.citeseer.graph"))
normalized_Laplacian = normalization(build_adjacency(graph))
indices = torch.from_numpy(np.asarray([normalized_Laplacian.row,
normalized_Laplacian.col]).astype('int64')).long()
values = torch.from_numpy(normalized_Laplacian.data.astype(np.float32))
Laplacian_tensor_ = torch.sparse.FloatTensor(indices, values,
(ncount, ncount)).to(device)
identity_list_ = [1 for i in range(ncount)]
identity_coo_ = sp.spdiags(identity_list_, diags=[0], m=ncount, n=ncount, format="coo")
indices = torch.from_numpy(np.asarray([identity_coo_.row,
identity_coo_.col]).astype('int64')).long()
values = torch.from_numpy(identity_coo_.data.astype(np.float32))
identity_tensor_ = torch.sparse.FloatTensor(indices, values,
(ncount, ncount)).to(device)
poly_item1 = 1 * identity_tensor_
def main(isplot=False):
"""
Main function
:param isplot: if True plot the prediction and errors
:return:
"""
# --------------------------------------------------------------------------------------------------
# PARAMETERS
# --------------------------------------------------------------------------------------------------
nb_samples = 1000
iteration = 10
# Model
input_dim = 2
output_dim = 2
hidden_dim = 25
# Training
nb_epochs = 200
learning_rate = 1e-2
batch_size = 10
saved_train_error = []
saved_train_time = []
saved_test_error = []
saved_prediction_time = []
for i in range(iteration):
print('\n------- ITERATION - %d -------' % (i + 1))
# --------------------------------------------------------------------------------------------------
# DATASET
# --------------------------------------------------------------------------------------------------
# Generate data
train_input, train_label = generate_data(nb_samples)
train_label = convert_to_one_hot_labels(train_label)
test_input, test_label_vector = generate_data(nb_samples)
test_label = convert_to_one_hot_labels(test_label_vector)
print('Training data dimension: ', train_input.size())
print('Training labels dimension: ', train_label.size())
# Normalize data
train_input = normalization(train_input)
test_input = normalization(test_input)
# --------------------------------------------------------------------------------------------------
# MODEL
# --------------------------------------------------------------------------------------------------
model = Sequential(Linear(input_dim, hidden_dim), Tanh(),
Linear(hidden_dim, hidden_dim), Tanh(),
Linear(hidden_dim, hidden_dim), Tanh(),
Linear(hidden_dim, output_dim))
# Xavier initialization
for i in range(0, len(model.param()), 2):
xavier_initialization(model.param()[i][0],
model.param()[i + 1][0], 'relu')
# --------------------------------------------------------------------------------------------------
# TRAINING
# --------------------------------------------------------------------------------------------------
start_train_time = time.time()
training(model,
train_input,
train_label,
batch_size=batch_size,
nb_epochs=nb_epochs,
lr=learning_rate)
end_train_time = time.time()
# ERROR
train_error = compute_error(model, train_input, train_label,
batch_size) / train_input.size(0) * 100
saved_train_error.append(train_error)
test_error = compute_error(model, test_input, test_label,
batch_size) / test_input.size(0) * 100
saved_test_error.append(test_error)
# Prediction time
start_pred_time = time.time()
for batch in range(0, test_input.size(0), batch_size):
prediction(model, (test_input.narrow(0, batch, batch_size)))
end_pred_time = time.time()
train_time = end_train_time - start_train_time
saved_train_time.append(train_time)
prediction_time = end_pred_time - start_pred_time
saved_prediction_time.append(prediction_time)
print('\nTrain error {:.02f}% --- Train time {:.02f}s '
'\nTest error {:.02f}% --- Prediction time {:.08f}s'.format(
train_error, train_time, test_error, prediction_time))
# --------------------------------------------------------------------------------------------------
# PLOT
# --------------------------------------------------------------------------------------------------
if isplot:
test_predictions = prediction(model, test_input)
prediction_errors = test_predictions != test_label_vector
test_prediction_errors = test_predictions.clone()
test_prediction_errors[prediction_errors] = 2
plt.figure(figsize=(10, 3))
plt.subplot(1, 3, 1)
plt.scatter(test_input[:, 0],
test_input[:, 1],
s=5,
c=test_label_vector,
cmap=matplotlib.colors.ListedColormap(
['deepskyblue', 'mediumblue']))
plt.title('Labels', fontsize=10)
plt.gca().set_aspect('equal', adjustable='box')
plt.gca().axes.get_xaxis().set_ticks([])
plt.gca().axes.get_yaxis().set_ticks([])
plt.subplot(1, 3, 2)
plt.scatter(test_input[:, 0],
test_input[:, 1],
s=5,
c=test_predictions,
cmap=matplotlib.colors.ListedColormap(
['deepskyblue', 'mediumblue']))
plt.title('Predictions', fontsize=10)
plt.gca().set_aspect('equal', adjustable='box')
plt.gca().axes.get_xaxis().set_ticks([])
plt.gca().axes.get_yaxis().set_ticks([])
plt.subplot(1, 3, 3)
plt.scatter(test_input[:, 0],
test_input[:, 1],
s=5,
c=test_prediction_errors,
cmap=matplotlib.colors.ListedColormap(
['deepskyblue', 'mediumblue', 'r']))
plt.title('Errors', fontsize=10)
plt.gca().set_aspect('equal', adjustable='box')
plt.gca().axes.get_xaxis().set_ticks([])
plt.gca().axes.get_yaxis().set_ticks([])
plt.show()
print('\nTRAIN: Mean {:.02f} --- Std {:.02f} --- time {:.02f}s '
'\nTEST: Mean {:.02f}% --- Std {:.02f} --- time {:.08f}s'.format(
torch.FloatTensor(saved_train_error).mean(),
torch.FloatTensor(saved_train_error).std(),
torch.FloatTensor(saved_train_time).mean(),
torch.FloatTensor(saved_test_error).mean(),
torch.FloatTensor(saved_test_error).std(),
torch.FloatTensor(saved_prediction_time).mean()))
def main():
""" Main function """
# --------------------------------------------------------------------------------------------------
# PARAMETERS
# --------------------------------------------------------------------------------------------------
nb_samples = 1000
iteration = 10
# Model
input_dim = 2
output_dim = 2
hidden_dim = 25
# Training
number_epochs = 200
learning_rate = 1e-2
mini_batch_size = 10
saved_train_error = []
saved_train_time = []
saved_test_error = []
saved_prediction_time = []
for i in range(iteration):
print('\n------- ITERATION - %d -------' % (i + 1))
# --------------------------------------------------------------------------------------------------
# DATASET
# --------------------------------------------------------------------------------------------------
# Generate data
train_input, train_label = generate_data(nb_samples)
train_label = convert_to_one_hot_labels(train_label)
test_input, test_label = generate_data(nb_samples)
test_label = convert_to_one_hot_labels(test_label)
print('Training data dimension: ', train_input.size())
print('Training labels dimension: ', train_label.size())
# Normalize data
train_input = normalization(train_input)
test_input = normalization(test_input)
# --------------------------------------------------------------------------------------------------
# MODEL
# --------------------------------------------------------------------------------------------------
model = nn.Sequential(
nn.Linear(input_dim, hidden_dim),
nn.Tanh(),
nn.Linear(hidden_dim, hidden_dim),
nn.Tanh(),
nn.Linear(hidden_dim, hidden_dim),
nn.Tanh(),
nn.Linear(hidden_dim, output_dim),
)
# Xavier initialization
model.apply(init_weights)
# --------------------------------------------------------------------------------------------------
# TRAINING
# --------------------------------------------------------------------------------------------------
start_train_time = time.time()
training(model,
train_input,
train_label,
batch_size=mini_batch_size,
nb_epochs=number_epochs,
lr=learning_rate)
end_train_time = time.time()
# ERROR
train_error = compute_error(
model, train_input, train_label,
mini_batch_size) / train_input.size(0) * 100
saved_train_error.append(train_error)
test_error = compute_error(model, test_input, test_label,
mini_batch_size) / test_input.size(0) * 100
saved_test_error.append(test_error)
# Prediction time
start_pred_time = time.time()
for batch in range(0, test_input.size(0), mini_batch_size):
prediction(model, (test_input.narrow(0, batch, mini_batch_size)))
end_pred_time = time.time()
train_time = end_train_time - start_train_time
saved_train_time.append(train_time)
prediction_time = end_pred_time - start_pred_time
saved_prediction_time.append(prediction_time)
print('\nTrain error {:.02f}% --- Train time {:.02f}s '
'\nTest error {:.02f}% --- Prediction time {:.08f}s'.format(
train_error, train_time, test_error, prediction_time))
print('\nTRAIN: Mean {:.02f} --- Std {:.02f} --- time {:.02f}s '
'\nTEST: Mean {:.02f}% --- Std {:.02f} --- time {:.08f}s'.format(
torch.FloatTensor(saved_train_error).mean(),
torch.FloatTensor(saved_train_error).std(),
torch.FloatTensor(saved_train_time).mean(),
torch.FloatTensor(saved_test_error).mean(),
torch.FloatTensor(saved_test_error).std(),
torch.FloatTensor(saved_prediction_time).mean()))