def main(): #---------------data generation--------------------- B_true, W_true, X, train_loader = load_data(args) # --------------graph estimation-------------------- w_est = Mis_dag(args, train_loader) # --------------accuracy calculation---------------- acc = count_accuracy(B_true, w_est != 0) print(acc)
emb_query = emb_query.reshape(opt.episodes_per_batch, train_n_query, -1) logit_query = cls_head(emb_query, emb_support, labels_support, opt.train_way, opt.train_shot) smoothed_one_hot = one_hot(labels_query.reshape(-1), opt.train_way) smoothed_one_hot = smoothed_one_hot * (1 - opt.eps) + ( 1 - smoothed_one_hot) * opt.eps / (opt.train_way - 1) log_prb = F.log_softmax(logit_query.reshape(-1, opt.train_way), dim=1) loss = -(smoothed_one_hot * log_prb).sum(dim=1) loss = loss.mean() acc = count_accuracy(logit_query.reshape(-1, opt.train_way), labels_query.reshape(-1)) train_accuracies.append(acc.item()) train_losses.append(loss.item()) if (i % 100 == 0): train_acc_avg = np.mean(np.array(train_accuracies)) log( log_file_path, 'Train Epoch: {}\tBatch: [{}/{}]\tLoss: {:.4f}\tAccuracy: {:.2f} % ({:.2f} %)' .format(epoch, i, len(dloader_train), loss.item(), train_acc_avg, acc)) optimizer.zero_grad() loss.backward() optimizer.step()
emb_support = IAM(emb_support, emb_query, emb_query, labels_support) # PSM for _ in range(opt.psm_iters): logit_query = cls_head(emb_query, emb_support, labels_support, opt.way, opt.shot) labels_pseudo = torch.argmax(logit_query, dim=2) # (1, n_query) labels_pseudo_one_hot = one_hot(labels_pseudo, opt.way) # (1, n_query, way) proto_query = torch.bmm(labels_pseudo_one_hot.transpose(1, 2), emb_query) # (1, way, d) proto_query = proto_query.div( labels_pseudo_one_hot.transpose(1, 2).sum( dim=2, keepdim=True).expand_as(proto_query) + 1e-5) labels_pseudo = torch.arange(opt.way).unsqueeze(0).cuda() emb_support = torch.cat([emb_support, proto_query], dim=1) labels_support = torch.cat([labels_support, labels_pseudo], dim=1) logits = cls_head(emb_query, emb_support, labels_support, opt.way, opt.shot) acc = count_accuracy(logits.reshape(-1, opt.way), labels_query.reshape(-1)) test_accuracies.append(acc.item()) avg = np.mean(np.array(test_accuracies)) std = np.std(np.array(test_accuracies)) ci95 = 1.96 * std / np.sqrt(i + 1) if i % 50 == 0: print( 'Episode [{}/{}]:\t\t\tAccuracy: {:.2f} ± {:.2f} % ({:.2f} %)'. format(i, opt.episode, avg, ci95, acc))
if h_new > 0.25 * h: rho *= 10 else: break w_est, h = w_new, h_new alpha += rho * h if h <= h_tol or rho >= rho_max: break W_est = _adj(w_est) W_est[np.abs(W_est) < w_threshold] = 0 return W_est if __name__ == '__main__': import utils as ut ut.set_random_seed(1) n, d, s0, graph_type, sem_type = 100, 20, 20, 'ER', 'gauss' B_true = ut.simulate_dag(d, s0, graph_type) W_true = ut.simulate_parameter(B_true) np.savetxt('W_true.csv', W_true, delimiter=',') X = ut.simulate_linear_sem(W_true, n, sem_type) np.savetxt('X.csv', X, delimiter=',') W_est = notears_linear_l1(X, lambda1=0.1, loss_type='l2') assert ut.is_dag(W_est) np.savetxt('W_est.csv', W_est, delimiter=',') acc = ut.count_accuracy(B_true, W_est != 0) print(acc)
import glog as log import networkx as nx import utils # configurations n, d = 1000, 10 graph_type, degree, sem_type = 'erdos-renyi', 4, 'linear-gauss' log.info('Graph: %d node, avg degree %d, %s graph', d, degree, graph_type) log.info('Data: %d samples, %s SEM', n, sem_type) # graph log.info('Simulating graph ...') G = utils.simulate_random_dag(d, degree, graph_type) log.info('Simulating graph ... Done') # data log.info('Simulating data ...') X = utils.simulate_sem(G, n, sem_type) log.info('Simulating data ... Done') # solve optimization problem log.info('Solving equality constrained problem ...') W_est = notears_simple(X) G_est = nx.DiGraph(W_est) log.info('Solving equality constrained problem ... Done') # evaluate fdr, tpr, fpr, shd, nnz = utils.count_accuracy(G, G_est) log.info('Accuracy: fdr %f, tpr %f, fpr %f, shd %d, nnz %d', fdr, tpr, fpr, shd, nnz)
rho *= 10 else: break w_est, h = w_new, h_new alpha += rho * h if h <= h_tol or rho >= rho_max: break W_est = _adj(w_est) W_est[np.abs(W_est) < w_threshold] = 0 return W_est if __name__ == '__main__': import utils as ut ut.set_random_seed(1) n, d, s0, graph_type, sem_type = 100, 20, 20, 'ER', 'gauss' B_true = ut.simulate_dag(d, s0, graph_type) W_true = ut.simulate_parameter(B_true) np.savetxt('W_true.csv', W_true, delimiter=',') X = ut.simulate_linear_sem(W_true, n, sem_type) np.savetxt('X.csv', X, delimiter=',') W_est = notears_linear_l1(X, lambda1=0.1, loss_type='l2') import igraph as ig assert ig.Graph.Weighted_Adjacency(W_est.tolist()).is_dag() np.savetxt('W_est.csv', W_est, delimiter=',') acc = ut.count_accuracy(W_true, W_est) print(acc)
labels = torch.cat([lab1,lab2,lab3,lab4], 0) for j in range(labels.shape[0]): labels[j]=label_dict[labels[j].item()] labels=labels.cuda() outputs = embedding_net(images) logit_query = cls_head(outputs) loss = criterion(logit_query, labels) if opt.feature_clustering_coeff > 0.0: loss = loss + opt.feature_clustering_coeff * feature_clustering(outputs) if opt.hyperplane_variation_coeff > 0.0: loss = loss + opt.hyperplane_variation_coeff * hyperplane_variation(outputs) acc = count_accuracy(logit_query, labels) train_accuracies.append(acc.item()) train_losses.append(loss.item()) if (i % 100 == 0): train_acc_avg = np.mean(np.array(train_accuracies)) log(log_file_path, 'Train Epoch: {}\tBatch: [{}/{}]\tLoss: {:.4f}\tAccuracy: {:.2f} % ({:.2f} %)'.format( epoch, i, len(dloader_train), loss.item(), train_acc_avg, acc)) optimizer.zero_grad() loss.backward() optimizer.step() lr_scheduler.step()