def graph_feature(path, xs, learners):
step = math.ceil((xs[1] - xs[0]) / 10)
xs = range(xs[0], xs[1], step)
fig = plt.figure()
for learner in learners:
train_error = []
test_error = []
for n in xs:
train_x, test_x, train_y, test_y = get_data(n)
l = learner["learner"]
l.fit(train_x, train_y)
train_score = l.score(train_x, train_y)
test_score = l.score(test_x, test_y)
cv_score = cross_val_score(l, train_x, train_y, cv=10).mean()
train_error.append(1 - train_score)
# test_error.append(1 - test_score)
test_error.append(1 - cv_score)
#endfor
name = learner["name"]
plt.plot(xs, train_error, ".--", label="{} Train".format(name))
plt.plot(xs, test_error, ".-", label="{} Test".format(name))
#endfor
filename = "graphs/{}.png".format(path)
print(filename)
plt.title(path)
plt.xlabel("Instances")
plt.ylabel("Error")
plt.ylim(0, 1)
plt.legend()
fig.savefig(filename)
def __init__(self, username, min_num): self.users, self.anime = get_data() self.username = username self.train = remove_users(self.users, min_num) self.add_to_users(username)
print("non-cholesky:")
print((comp_0, comp_1))
print("cholesky:")
print(complexity(sigma, c, num_samples))
print()
## Check kernel compared to random networks
depth = 3
width = 5000
num_train_examples = 5
num_networks = 10**3
_, _, train_loader, _ = get_data(num_train_examples=num_train_examples,
num_test_examples=None,
batch_size=num_train_examples,
random_labels=False,
binary_digits=False)
for data, target in train_loader:
data, target = normalize_data(data, target)
out_matrix = np.zeros((num_train_examples, num_networks))
with torch.no_grad():
print(f"Sampling {num_networks} random networks")
for network_idx in tqdm(range(num_networks)):
model = SimpleNet(depth, width)
for p in model.parameters():
p.data = torch.randn_like(p) / math.sqrt(p.shape[1])
parser.add_argument('--weight_decay', type=float, default=0)
parser.add_argument('--preserve_case', action='store_false', dest='lower')
parser.add_argument('--word_embedding', type=str, default='glove.840B.300d')
parser.add_argument('--early_stopping_patience', type=int, default=3)
parser.add_argument('--save_path', type=str, default='results')
parser.add_argument('--seed', type=int, default=1234)
parser.add_argument('--max_len', type=int, default=42)
parser.add_argument('--use_glove', type=str, default=True)
parser.add_argument('--data_path', type=str, default='data/snli/')
parser.add_argument('--train_embedding', type=str, default=True)
config = parser.parse_args()
data_path = config.data_path
training = get_data(data_path + 'snli_1.0_train.jsonl')
validation = get_data(data_path + 'snli_1.0_dev.jsonl')
test = get_data(data_path + 'snli_1.0_test.jsonl')
tokenizer = Tokenizer(lower=False, filters='')
tokenizer.fit_on_texts(training[0] + training[1])
tokenizer.fit_on_texts(validation[0] + validation[1])
VOCAB = len(tokenizer.word_counts) + 1
LABELS = {'contradiction': 0, 'neutral': 1, 'entailment': 2}
to_seq = lambda X: pad_sequences(tokenizer.texts_to_sequences(X),
maxlen=config.max_len)
prepare_data = lambda data: (to_seq(data[0]), to_seq(data[1]), data[2])
training = prepare_data(training)
seed_list)
for params in param_product:
print('\n', params)
num_train_examples, random_labels, binary_digits, depth, width, seed = params
### Set random seed
torch.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(seed)
### Get data
full_batch_train_loader, _, train_loader, test_loader = get_data(
num_train_examples=num_train_examples,
num_test_examples=None,
batch_size=batch_size,
random_labels=random_labels,
binary_digits=binary_digits)
### Train network
train_acc, test_acc, model = train_network(train_loader=train_loader,
test_loader=test_loader,
depth=depth,
width=width,
init_lr=init_lr,
decay=decay,
break_on_fit=False)
print(f"Train acc: {train_acc[-1]}")
print(f"Test acc: {test_acc}")