class TestTpshopReg(unittest.TestCase):
__session = None
@classmethod
def setUpClass(cls) -> None:
cls.tp_reg_api = TpshopRegApi()
cls.tp_login_api = TpshopLoginApi()
def setUp(self) -> None:
if self.__session is None:
self.__session = requests.Session()
def tearDown(self) -> None:
self.__session.close()
@parameterized.expand(get_test_data(app.BASE_PATH + '/data/reg_data.json'))
def test_reg(self, reg_data, http_code, status, msg):
"""注册用例"""
# 获取注册验证码
response_reg_verify = self.tp_reg_api.get_reg_verify(self.__session)
# 断言注册验证码获取成功
self.assertIn("image", response_reg_verify.headers.get('Content-Type'))
# 获取注册接口
response_reg = self.tp_reg_api.get_reg(self.__session, reg_data)
# 断言注册成功-status，msg，响应状态码与预期是否一致
print(response_reg.status_code)
if response_reg.json().get('status') == 1:
print(response_reg.json().get('result').get('mobile'))
print(response_reg.json().get('status'))
print(response_reg.json().get('msg'))
assert_reg(self, http_code, status, msg, reg_data.get('username'),
response_reg)
# 如果注册成功,执行登陆,否则不登录
if (response_reg.json().get('msg')) == "注册成功":
# 获取登陆验证码
response_login_verify = self.tp_login_api.get_login_verify(
self.__session)
# 断言登陆验证码获取成功
self.assertIn("image",
response_login_verify.headers.get('Content-Type'))
# 获取登陆接口
login_data = {
'username': reg_data.get('username'),
'verify_code': reg_data.get('verify_code'),
'password': reg_data.get('password')
}
response_login = self.tp_login_api.get_login(
self.__session, login_data)
# 断言登陆成功-断言status，msg，响应状态码与预期是否一致
print("登陆:", response_login.status_code)
print("登陆:", response_login.json().get('result').get('mobile'))
print("登陆:", response_login.json().get('status'))
print("登陆:", response_login.json().get('msg'))
assert_reg(self, http_code, status, msg, reg_data.get('username'),
response_login)
else:
print("反向用例,不做登陆")
def test(model, k, num_each_class):
model.eval() # TODO: notice there is a difference in L0 gate
base, test, label = utils.get_test_data(num_each_class=num_each_class)
latent_test = get_latent(test)
latent_base = get_latent(base)
pred = kNNClassifer(latent_base, latent_test, k)
acc = utils.get_accuracy(pred, label).tolist()
print('test acc of {}-NN is {}:'.format(k, acc))
def nn_baseline_predict(net): test_data = utils.get_test_data() test_examples = features.generate_feature_vectors(test_data, USE_GLOVE) #test_examples = np.array([np.array([random.uniform(-0.5, 0.5) for i in range(BASELINE_VECTOR_SIZE)]) for j in range(len(test_data))]) test_target = [1 if int(p[1]) > 2 else -1 for p in test_data] predictions = [] for ex in test_examples: pred = net.predict(ex) if pred > 0: predictions.append(1) else: predictions.append(-1) report_results(test_target, predictions, True)
def main():
parser = argparse.ArgumentParser(description='Pretraining argument parser')
parser = load_pretrain_args(parser)
parser = load_test_args(parser)
args = parser.parse_args()
set_seeds(args.seed)
train_data = get_train_data()
valid_data = get_valid_data()
test_data = get_test_data()
nnet = create_nnet(train_data, args)
optimizer = Adam(nnet.parameters(), lr=args.lr)
ce_loss = nn.CrossEntropyLoss()
mse_loss = nn.MSELoss()
action_space = ActionSpace()
tb = SummaryWriter()
best_score = 0
for epoch in range(1, args.update_epochs + 1):
print(f'Epoch {epoch}')
for indice in random_batch(len(train_data), args.train_batch_size):
batch = train_data[indice]
input_batch = to_input_batch(batch, torch.device('cuda'))
policies, values = nnet(input_batch)
target_policies = get_target_policies(batch, action_space).cuda()
target_values = get_target_values(batch).cuda()
policy_loss = ce_loss(policies, target_policies)
value_loss = mse_loss(values, target_values)
loss = policy_loss + value_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
accuracy = test(valid_data, nnet, args, tb, epoch)
if accuracy > best_score:
best_score = accuracy
torch.save(nnet.module.state_dict(), 'models/pretrained.pt')
nnet.module.load_state_dict(torch.load('models/pretrained.pt'))
test(test_data, nnet, args, tb, args.update_epochs + 1)
def evaluate_model(model, load_file, test_ind = None):
file_test = ['cb513_700', 'ts115_700', 'casp12_700']
if test_ind is None:
test_ind = range(len(file_test))
test_accs = []
names = []
for i in test_ind:
X_test_aug, y_test = get_test_data(file_test[i])
model.load_weights(load_file)
score = model.evaluate(X_test_aug, y_test, verbose=2, batch_size=1)
#print(file_test[i] +' test accuracy: ' + str(score[1]))
test_accs.append(score[1])
names.append(file_test[i])
return dict(zip(names, test_accs))
def run_svm_baseline(): raw_data = get_data() #input_data = np.array([np.array([random.uniform(-0.5, 0.5) for i in range(BASELINE_VECTOR_SIZE)]) for j in range(len(raw_data))]) input_data = features.generate_feature_vectors(raw_data, False, True) target_data = np.array([int(pair[1]) for pair in raw_data]) state = random.randint(0, int(time.time())) #X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(input_data, target_data, test_size=0.1, random_state=state) test_data = utils.get_test_data() target_test = np.array([int(pair[1]) for pair in test_data]) input_test = features.generate_feature_vectors(test_data, False, True) clf = svm.SVC(kernel='linear', C=1).fit(input_data, target_data) preds = [clf.predict(x)[0] for x in input_test] #x = clf.score(input_test, target_test) #print x print "reporting..." report_results(target_test, preds)
def main():
parser = argparse.ArgumentParser(description='Test argument parser')
parser = load_test_args(parser)
args = parser.parse_args()
set_seeds(args.seed)
test_data = get_test_data()
nnet = create_nnet(test_data, args)
nnet.module.load_state_dict(torch.load(f'models/{args.load}'))
tb = SummaryWriter()
start_time = time()
policy_test(test_data, nnet, args, tb, epoch=0)
print(f'test time: {time() - start_time:.3f} sec.')
def train():
# ======= paramter ==============
use_local_net = False
epoch = 20
num_epoches = 40
batch_size = 32
# =======net ================
model_path = 'model_without_sigmoid\\' + \
'model' + '_' + str(epoch - 1) + model_ext
if use_local_net:
model = load_model(model_path)
logger.info('use local model from %d epoch', epoch)
else:
model = net()
logger.info('model inited')
test_cells, test_masks = get_test_data()
# ===========train =============
while epoch < num_epoches:
logger.info('%s epoch %d started', now_str(), epoch)
generator = batch_data_generator(batch_size=batch_size,
use_shuffle=True)
batch_idx = 0
for cell_mask in generator:
cell_list = np.array([item[0] for item in cell_mask])
mask_list = np.array([item[1] for item in cell_mask])
model.train_on_batch(cell_list, mask_list)
batch_idx += 1
if batch_idx % 20:
logger.info('%s epoch %d batch_index %d', now_str(), epoch,
batch_idx)
batch_idx = 0
# ===========test==================
predict_masks = model.predict(test_cells, batch_size=64)
error = test_error(test_masks, predict_masks)
logger.info('predict error %f in epoch %d', error, epoch)
model.save('model_without_sigmoid\\' + 'model' + '_' + str(epoch) +
model_ext)
logger.info('%s epoch %d model saved', now_str(), epoch)
epoch += 1
def __init__(self, use_glove=False, unigrams=False): self.unigrams = unigrams self.submodels = [] self.use_glove = use_glove self.test_data = utils.get_test_data() self.ONEvALL = 0 self.TWOvALL = 1 self.THREEvALL = 2 self.FOURvALL = 3 self.FIVEvALL = 4 self.ONEvTWO = 5 self.ONEvTHREE = 6 self.ONEvFOUR = 7 self.ONEvFIVE = 8 self.TWOvTHREE = 9 self.TWOvFOUR = 10 self.TWOvFIVE = 11 self.THREEvFOUR = 12 self.THREEvFIVE = 13 self.FOURvFIVE = 14
def evaluate(self):
# get predictions for all species
X_test, y_true = get_test_data()
test_df = pd.read_csv("../plantbase/data/test_data.csv").drop(
columns="Unnamed: 0")
y_pred = self.model.predict(X_test)
y_pred_df = pd.DataFrame(y_pred,
columns=np.sort(test_df.genus.unique()))
# get species with top prediction and true species
y_pred_df['pred_genus'] = y_pred_df.idxmax(axis=1)
y_pred_df['true_genus'] = y_true[:, 0]
# measure success rate
prediction_review = (
y_pred_df['pred_genus'] == y_pred_df['true_genus'])
accuracy = prediction_review.value_counts(
)[True] / prediction_review.count()
print(f'test accuracy: {accuracy}')
def test(self, config):
input_ = get_test_data('test.h5')
images_shape = [1, 288, 288, 1]
labels_shape = [1, 288, 288, 1]
num = 200
results = np.zeros(
[num, input_.shape[1], input_.shape[2], input_.shape[3]])
for i in range(num):
_input_ = input_[i, :, :, :]
_input_ = np.expand_dims(_input_, 0)
self.build_model(images_shape, labels_shape)
tf.global_variables_initializer().run(session=self.sess)
self.load(config.checkpoint_dir, restore=True)
result = self.sess.run([self.pred],
feed_dict={self.images: _input_})
result = np.asarray(result)
print(result.shape)
self.sess.close()
tf.reset_default_graph()
self.sess = tf.Session()
results[i] = result[0][0]
save_test_results(results)
def run_experiment(num_models,
training_dir,
test_dir,
results_dir,
transform,
weights_file=None):
training_set = get_training_data(training_dir,
COLOURS,
IMG_ROWS,
IMG_COLS,
transform=transform)
test_set = get_test_data(test_dir,
COLOURS,
IMG_ROWS,
IMG_COLS,
transform=transform)
for epoch in range(num_models):
callbacks_list = []
if weights_file:
callbacks_list.append(
ModelCheckpoint(weights_file,
monitor='val_accuracy',
verbose=1,
save_best_only=True))
callbacks_list.append(
LearnedAccuracyWriter(COLOURS, test_set, epoch, PATIENCE,
results_dir))
callbacks_list.append(
EarlyStopping(monitor='val_accuracy', patience=PATIENCE))
model = colour_net(NUM_CLASSES, weights_file)
model.fit_generator(training_set,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=MAX_EPOCHS,
validation_data=test_set,
callbacks=callbacks_list,
verbose=1)
def evaluate(self):
#self.mlflow_log_metric("y_pred", y_pred)
# get predictions for all species
X_test, y_true = get_test_data()
test_df = pd.read_csv("../plantbase/data/test_data.csv").drop(
columns="Unnamed: 0")
y_pred = self.model.predict(X_test)
self.mlflow_log_metric("y_pred", y_pred)
estimator_params = self.kwargs.get("estimator_params", 'CNN_basic')
self.mlflow_log_param("estimator", estimator)
y_pred_df = pd.DataFrame(y_pred,
columns=np.sort(test_df.genus.unique()))
# get species with top prediction and true species
y_pred_df['pred_genus'] = y_pred_df.idxmax(axis=1)
y_pred_df['true_genus'] = y_true[:, 0]
# measure success rate
prediction_review = (
y_pred_df['pred_genus'] == y_pred_df['true_genus'])
accuracy = prediction_review.value_counts(
)[True] / prediction_review.count()
self.mlflow_log_metric("accuracy", accuracy)
print(f'test accuracy: {accuracy}')
rest_of_search_space = generate_parameters_search_space(rest_of_variations)
extended_search_space = []
for parameters in rest_of_search_space:
for value in variations[first_parameter]:
extended_parameters = copy(parameters)
extended_parameters[first_parameter] = value
extended_search_space.append(extended_parameters)
else:
extended_search_space.extend({
first_parameter: value
} for value in variations[first_parameter])
return extended_search_space
if __name__ == '__main__':
test_set, training_set = get_test_data()
stylized_facts = (
Return60,
Return30,
)
parameters_search_space = generate_parameters_search_space()
w = numpy.ones((2,))
optimal_parameters = smm_optimize(training_set, parameters_search_space, stylized_facts, w)
print(optimal_parameters)
error = smm_error(test_set, optimal_parameters, stylized_facts, w)
model_num_DR + '.ckpt')
print("Model DR restored.")
with sess2.as_default():
with NormNet_graph.as_default():
tf.global_variables_initializer().run()
saver2 = tf.train.Saver()
saver2 = tf.train.import_meta_graph(pre_ck_pnts_dir_NP + '/model_' +
model_num_NP + '/model_' +
model_num_NP + '.ckpt.meta')
saver2.restore(
sess2, pre_ck_pnts_dir_NP + '/model_' + model_num_NP + '/model_' +
model_num_NP + '.ckpt')
print("Model NP restored.")
# Read the test images and run the HDNet
test_files = get_test_data(data_main_path)
# Read the HUMBI test images and run the HDNet
#test_files = get_HUMBI_data(os.path.join(data_main_path, 'HUMBI_example.pkl'),'test')
for f in range(len(test_files)):
#for f in range(len(test_files[0])):
#time_stamp = test_files[3][f]
#data_name = str(test_files[6][f])
data_name = str(test_files[f])
#print('Processing time stamp: ', time_stamp)
print('Processing file: ', data_name)
print('\n')
#X,Z, Z3, DP = read_HUMBI_data(test_files,f,IMAGE_HEIGHT,IMAGE_WIDTH)
X, Z, Z3, _, _, _, _, _, _, _, _, DP = read_test_data(
data_main_path, data_name, IMAGE_HEIGHT, IMAGE_WIDTH)
def get_data(test_file_path):
data_list, target_list = utils.get_test_data(test_file_path)
data_int = [[residue_to_int.get(residue, residue_to_int["<UNK>"])
for residue in line] for line in data_list]
return data_int,target_list
def cross_val(fold):
#build model
model_loss = 'binary_crossentropy'
input_dim = (n_mels, 2 * context_len, 1)
clf = []
clf = utils.build_model(input_dim)
clf.compile(optimizer='adam', loss=model_loss, metrics=['accuracy'])
if fold == 0: print(clf.summary())
#test song indices
song_ids_val = song_ids[fold * fold_size:(fold + 1) * fold_size]
#split filenames into train and val
partition = {'train': np.array([]), 'val': np.array([])}
for song_id in np.arange(songdata.shape[0]):
if song_id not in song_ids_val:
partition['train'] = np.append(partition['train'],
dataset_ids[str(song_id)])
#load data files
data_train = {
'features':
np.zeros([
len(partition['train']), input_dim[0], input_dim[1], input_dim[2]
]),
'labels': []
}
for i_samp in range(len(partition['train'])):
data_train['features'][i_samp, ] = np.load(os.path.join(
datadir, partition['train'][i_samp] + '.npy'),
allow_pickle=True)
data_train['labels'].append(labels_all[partition['train'][i_samp]])
#shuffle data
data_train['features'], data_train['labels'] = shuffle(
data_train['features'], data_train['labels'], random_state=0)
#make labels one-hot
data_train['labels'] = keras.utils.to_categorical(data_train['labels'],
num_classes=2)
print('===\nCross-validation fold no. %d\n===\n' % song_ids_val[0])
#iteratively calling model fit function over batches and epochs
batch_size = 64
n_batches = int(data_train['features'].shape[0] / batch_size)
n_epochs = 20
train_losses = []
eval_losses = [1e5]
for i_epoch in range(n_epochs):
#train
train_loss = 0
for i_batch in range(n_batches):
data_batch = data_train['features'][i_batch *
batch_size:(i_batch + 1) *
batch_size]
labels_batch = data_train['labels'][i_batch *
batch_size:(i_batch + 1) *
batch_size]
train_loss_batch, _ = clf.train_on_batch(data_batch, labels_batch)
train_loss += train_loss_batch
train_losses.append(train_loss / n_batches)
#evaluate to save best model across epochs
eval_loss = 0
for song_id in song_ids_val:
boundaries = songdata['Boundaries'][song_id].split(',')
filepath = os.path.join(audio_dir,
songdata['Concert name'][song_id] + '.wav')
data_val = utils.get_test_data(audio_filepath=filepath,
samp_rate=sr,
gt_boundaries=boundaries,
offset=0)
data_val['labels'] = keras.utils.to_categorical(data_val['labels'],
num_classes=2)
eval_loss_song, _ = clf.evaluate(data_val['features'],
data_val['labels'],
verbose=0)
eval_loss += (eval_loss_song / len(song_ids_val))
if eval_loss < np.min(eval_losses):
clf.save_weights(
os.path.join(model_savepath, 'weights_fold%d.hdf5' % fold))
eval_losses.append(eval_loss)
print('\nEpoch %d/%d\tTrain Loss: %1.3f\tVal Loss: %1.3f' %
(i_epoch + 1, n_epochs, train_losses[-1], eval_losses[-1]))
#Validate saved model on left-out song
clf.load_weights(os.path.join(model_savepath,
'weights_fold%d.hdf5' % fold))
scores = []
for song_id in song_ids_val:
scores_song = []
for offset in audio_offset_list:
scores_offset = []
boundaries = songdata['Boundaries'][song_id].split(',')
filepath = os.path.join(audio_dir,
songdata['Concert name'][song_id] + '.wav')
data_val = utils.get_test_data(audio_filepath=filepath,
samp_rate=sr,
gt_boundaries=boundaries,
offset=offset)
out_probs = clf.predict(data_val['features'])[:, 1]
for predict_thresh in [0.5, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85]:
out_labels = (out_probs > predict_thresh).astype(int)
plot_name = 'fold%d_' % fold + songdata['Concert name'][
song_id] + '_thresh_' + str(predict_thresh)
scores_offset = np.append(
scores_offset,
utils.eval_output(out_labels, out_probs,
data_val['labels'], eval_tol,
context_len, plot_savepath, plot_name))
if len(scores_song) == 0: scores_song = scores_offset
else: scores_song += scores_offset
if len(scores) == 0:
scores = np.atleast_2d(scores_song)
else:
scores = np.vstack((scores, np.atleast_2d(scores_song)))
return scores
import sys
if __name__ == "__main__":
mode = sys.argv[1]
data_from = sys.argv[2]
data_path = sys.argv[3]
if data_from == "image":
data = utils.load_pie_jpg(data_path)
with open("./data/PIE/data.pkl", "wb") as fout:
pickle.dump(data, fout)
else:
with open("./data/PIE/data.pkl", "rb") as fin:
data = pickle.load(fin)
data = data.sample(frac=1).reset_index(drop=True)
train_data = utils.get_train_data(data)
test_data = utils.get_test_data(data)
del data
if mode == "train":
module = VGG11(64, 64, batch_size=32, learning_rate=0.001, mode=mode)
del test_data
gc.collect()
module.train(train_data[0], train_data[1])
elif mode == "eval":
module = VGG11(64, 64, batch_size=test_data[0].shape[0], mode=mode)
del train_data
gc.collect()
module.eval(test_data[0], test_data[1])
## Parameters
batch_size = 8
patch_h = 128
patch_w = 128
stride_h = 5
stride_w = 5
Batch_size = 8
Estimated_masks = []
True_masks = []
## Get the dataset for test
Dataset_add = './DIBCO/'
Te_d, Te_m = UT.get_test_data(Dataset_add, 2016)
## Model
model = M.BCDU_net_D3(input_size = (128, 128,1))
model.load_weights('weight_text.hdf5')
y_scores = []
y_true = []
## Mask estimation using batches
for idx in range(len(Te_d)):
IMG = Te_d[idx]
MSK = Te_m[idx]
patches , new_h, new_w = UT.extract_ordered_overlap(IMG, patch_h, patch_w, stride_h, stride_w)
patches = np.expand_dims(patches, axis = 3)
predictions = model.predict(patches, batch_size= Batch_size, verbose=1)
#args.load = "checkpoints/0402CP120.pth"
if args.load:
net.load_state_dict(torch.load(args.load))
print('Model loaded from {}'.format(args.load))
if args.gpu:
net.cuda()
#net = torch.nn.DataParallel(net, device_ids=args.gpu).cuda()
# cudnn.benchmark = True # faster convolutions, but more memory
input_path = '../data/train_feature.npy'
target_path = '../data/train_social_label.npy'
train_set = get_train_data(input_path, target_path)
test_set = get_test_data(input_path, target_path)
train_data_loader = DataLoader(dataset=train_set,
num_workers=4,
batch_size=args.batchsize,
shuffle=True)
test_data_loader = DataLoader(dataset=test_set,
num_workers=4,
batch_size=args.batchsize,
shuffle=False)
# predit(net=net,
# train_loader = train_data_loader,
# val_loader = test_data_loader,
# epochs=args.epochs,
# batch_size=args.batchsize,
import numpy as np
import pandas as pd
from skimage.transform import resize
from matplotlib import pyplot as plt
SIZE = 256
ORI_SIZE = 1024
TH = 0.5
parent_path = "E:/Kaggle/RSNA Pneumonia Detection Challenge/"
model_dir = os.path.join(parent_path, "seg_models/COORD_ASPP_UNET_DENSE/")
models = ["model_0.h5", "model_1.h5", "model_2.h5", "model_3.h5", "model_4.h5"]
#models=["model_0.h5","model_1.h5"]
test_dir = "E:/Kaggle/RSNA Pneumonia Detection Challenge/stage_1_test_images/"
#test_dir="E:/Kaggle/RSNA Pneumonia Detection Challenge/test/"
test_x, patient_ids = get_test_data(test_dir, SIZE)
model = MODEL(SIZE)
avg_preds = np.zeros((len(test_x), SIZE, SIZE, 1))
for model_p in models:
model_path = os.path.join(model_dir, model_p)
model = MODEL(SIZE)
model.load_weights(model_path)
preds = model.predict(test_x, verbose=1)
avg_preds += preds
avg_preds /= len(models)
import numpy as np
from sklearn import tree
import utils
X, Y = utils.get_train_data()
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X, Y)
test_images, test_labels = utils.get_test_data()
num_correct = 0
confusion_matrix = np.zeros((10, 10))
guesses = clf.predict(test_images)
for i in range(len(test_images)):
guess = guesses[i]
real = test_labels[i]
if guess == real:
num_correct += 1
confusion_matrix[real][guess] += 1
for i in range(10):
confusion_matrix[i] /= np.sum(confusion_matrix[i])
accuracy = num_correct / len(test_labels)
print("Accuracy: " + str(accuracy))
print(np.around(confusion_matrix, 3))
#if boundaries provided, read them
try:
boundaries = songs_data['Boundaries'][i_song].split(',')
except:
boundaries = []
scores = []
#loop over offset versions of test audio (test-time augmentation)
for offset in audio_offset_list:
if os.path.exists(song_name):
filepath = song_name
else:
filepath = os.path.join(audio_dir, song_name)
data_test = utils.get_test_data(audio_filepath=filepath,
gt_boundaries=boundaries,
offset=offset)
out_probs = clf.predict(data_test['features'])[:, 1]
out_probs /= np.max(out_probs)
out_labels = (out_probs > 0.3).astype(int)
out_labels = utils.smooth_predictions(out_labels, out_probs, eval_tol)
#if no boundaries available, plot output and save predicted boundaries to log
if len(boundaries) == 0:
#plt.plot(out_probs); plt.plot(out_labels); plt.show()
flog.write('Predicted boundaries:\t')
for item in np.where(out_labels == 1)[0]:
flog.write('%5.2f s, ' % (item * frame_len))
flog.write('\n')
#else, evaluate predictions
'oscillating_linear_oracle': simulate_oscillating_linear_oracle,
'identity': simulate_identity,
}
def get_growth_series(series: list):
last_price = series[0]
result = []
for i, number in enumerate(series):
result.append(number / last_price)
last_price = number
return result
if __name__ == '__main__':
test_data, _ = get_test_data(1)
divergences = defaultdict(list)
for trade in test_data:
real_time_series = get_time_series_from_trade(trade)
# pyplot.plot(range(len(real_time_series)), real_time_series, label='real')
for simulator_name, simulator in simulators.items():
simulated_time_series = simulator(real_time_series)
# pyplot.plot(range(len(simulated_time_series)), simulated_time_series, label=simulator_name)
divergences[simulator_name].append(
gsl_div(
numpy.array([get_growth_series(real_time_series)]),
numpy.array([get_growth_series(simulated_time_series)]),
))
# pyplot.legend()
# pyplot.show()
for simulator_name, divs in divergences.items():
# Quadratischer Fehler
def quadratic_error(y_true, y_pred):
return np.mean((y_true - y_pred)**2)
# Absoluter Fehler
def absolute_error(y_true, y_pred):
return np.mean(np.abs(y_true - y_pred))
# Daten erstellen und umformen
x_train, y_train = utils.get_train_data()
x_train = x_train[:, np.newaxis]
x_test, y_test = utils.get_test_data()
x_test = x_test[:, np.newaxis]
# Lineare Regression
model = lr()
model.fit(x_train, y_train)
### Fehler berechnen
y_pred_train = model.predict(x_train)
y_pred_test = model.predict(x_test)
# Trainingsfehler
quadratic_train_error = quadratic_error(y_train, y_pred_train)
absolute_train_error = absolute_error(y_train, y_pred_train)
# Testfehler
if config['use_hyperynm']:
num_labels = 3
test_sets = config['test_files']
batch_size = config['batch_size']
results_dir = config['results_dir']
eval_dir = config['eval_dir']
logging.info("Loading Model ...")
model = CrossEncoder(os.path.join(config['saved_model_dir'],
config['eval_base']),
num_labels=num_labels)
logging.info("Done Loading Model ...")
for test_set in test_sets:
test_name = test_set.split('.')[0]
logging.info("Reading " + test_name + " Data")
test_data, all_sentences, all_definitions = get_test_data(
os.path.join(eval_dir, test_set), True)
logging.info("Computing and Writing " + test_name + " Scores")
scores = get_crossencoder_scores(all_sentences, all_definitions,
batch_size, model)
populate_scores(test_data, scores)
scores_dict = compute_test_metrics(test_data, False)
out_dir = os.path.join(results_dir, config['eval_base'])
if not os.path.exists(out_dir):
os.makedirs(out_dir)
out_file = os.path.join(out_dir, test_name + '_results.csv')
write_scores(out_file, scores_dict)
logging.info("Done Writing Scores for " + test_name + " ....")
# 导包
import unittest, logging, app
import pymysql
import requests
from parameterized import parameterized
from api.emp_api import EmployeeApi
from utils import assert_utils, get_test_data
test_data = get_test_data(app.BASE_DIR + "/data/login.json")
# 创建测试类集成unittest.TestCase
class TestLogin(unittest.TestCase):
# 初始化unittest的函数
def setUp(self):
# 实例化EmployeeApi
self.emp_handle = EmployeeApi()
def tearDown(self):
pass
@parameterized.expand(test_data)
def test_01_login(self, mobile, password, http_code, success, code, message):
# 调用登陆
response = self.emp_handle.login(mobile, password)
# 打印登陆结果
logging.info("员工模块的登陆结果为：{}".format(response.json()))
assert_utils(self, response, http_code, success, code, message)
#!/usr/bin/env python
from numpy import exp
from sklearn.linear_model import ElasticNet
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
import utils
import encode as enc
best_ratio = .825
best_alpha = 0.00062
if __name__ == '__main__':
train = utils.get_train_data([], False)
test = utils.get_test_data(None, [])
ncols = [
c for c, d in zip(train.columns, train.dtypes)
if str(d) in ['float64', 'int64']
]
ncols.remove('SalePrice')
ncols.remove('GarageYrBlt')
ncols.remove('Id')
ids = test.Id
train, test = enc.fix_categorical(train.drop(utils.TEST_IGNORE, axis=1),
test.drop(utils.TEST_IGNORE, axis=1),
option='one_hot')
enc.fix_numeric(train, test, ncols, scaling='uniform')
clf3 = GradientBoostingRegressor()
cv = utils.run_cross_val(clf3, train)
print("GradientBoosting")
def test_nested_user(self):
for json in ['deal-detail.json', 'deal-detail-numeric-user-id.json']:
data = get_test_data(json)
model = dict_to_model(data, Deal)
self.assertTrue(isinstance(model.user, User))
return accuracy, confusion_matrix
# get most/least prototypical
def get_prototypical(self):
return self.most_prototypical, self.least_prototypical
# get odds ratio heatmap
def get_odds_ratio(self, a, b):
a_map = (self.black_count[a] + self.laplace_smoothing) / (self.digit_count[a] + 2.0 * self.laplace_smoothing)
b_map = (self.black_count[b] + self.laplace_smoothing) / (self.digit_count[b] + 2.0 * self.laplace_smoothing)
odds_map = a_map / b_map
return np.log(a_map), np.log(b_map), np.log(odds_map)
if __name__ == "__main__":
train_images, train_numbers = utils.get_train_data()
test_images, test_numbers = utils.get_test_data()
# train here
classifier = SinglePixelClassifier(train_images, train_numbers)
# classify here
accuracy, confusion_matrix = classifier.evaluate(test_images, test_numbers)
print("\nAccuracy over all of test data: {:.2%}".format(accuracy))
print("\nConfusion matrix: row - truth label, column - classifier output")
print(np.around(confusion_matrix, 3))
most_prototypical, least_prototypical = classifier.get_prototypical()
print("\nMost Prototypical: (index, prior, truth label, classifier output)")
def loss(self, prediction, target):
"""
"""
loss = nn.CrossEntropyLoss()
return loss(prediction, target)
if __name__ == '__main__':
root = Path('/data/FSDKaggle2018/FSDKaggle2018.audio_train')
train_fname = Path(
'/data/FSDKaggle2018/FSDKaggle2018.meta/train_post_competition.csv')
labels, label_dct = utils.get_dataset_meta(train_fname)
num_class = len(labels)
full_df = utils.get_test_data(train_fname)
train_df = full_df[full_df.test == False]
train_df.index = range(len(train_df))
test_df = full_df[full_df.test == True]
test_df.index = range(len(test_df))
config = parse_config('config.json')
input_length = config.input_length
train_dataset = utils.Dataset(root,
train_df,
input_length,
num_class=num_class,
label_dct=label_dct)
train_data_iter = data.DataLoader(train_dataset, batch_size=8)
class TestGmail:
"""
Check that email can be sent and received using gmail service
"""
def login(self, username, password):
"Login scenario implementation"
gmail_url = "https://mail.google.com/"
logging.info("Opening {}".format(gmail_url))
page = LoginPage(self.driver)
self.driver.get(page.url)
logging.info("Inserting username")
page.username.send_keys(username, Keys.RETURN)
time.sleep(1) # sleep to avoid 405 response
logging.info("Inserting password")
page.password.send_keys(password, Keys.RETURN)
@pytest.mark.parametrize(
"from_username, from_password, to_username, to_password",
get_test_data())
def test_mail(self, from_username, from_password, to_username,
to_password):
"Test mail sending using the data file specified in config.py"
logging.getLogger(__name__)
logging.info("TestGmail started for the dataset: {}".format(
(from_username, from_password, to_username, to_password)))
today = datetime.today()
from_email = "{}@gmail.com".format(from_username)
to_email = "{}@gmail.com".format(to_username)
options = Options()
options.add_argument("--headless")
self.driver = WebDriver(firefox_options=options)
browser = self.driver.desired_capabilities["browserName"]
mail_text = "{}-{}".format(browser, today)
self.login(from_username, from_password)
# send mail
page = MailPage(self.driver)
page.new_mail_button.click()
logging.info("Filling mail form")
page.recipient_field.click()
page.recipient_field.send_keys(to_email)
page.cc_link.click()
page.cc_field.send_keys(to_email)
page.bcc_link.click()
page.bcc_field.send_keys(to_email)
page.subject_field.send_keys(mail_text)
page.body_field.click()
page.body_field.send_keys(mail_text)
logging.info("Sending mail with text '{}'".format(mail_text))
page.send_button.click()
assert page.element("Your message has been sent")
# check mail in sent
url = "https://mail.google.com/mail/#sent"
self.driver.get(url)
page = MailPage(self.driver)
logging.info("Checking mail in sent")
assert page.element(mail_text)
self.driver.quit()
# login to second account
self.driver = WebDriver()
self.login(to_username, to_password)
page = MailPage(self.driver)
logging.info("Opening email")
page.received_email(mail_text).click()
logging.info("Checking text")
assert page.element(mail_text)
logging.info("Checking sender")
assert page.element(from_email)
logging.info("test passed")
def teardown(self):
self.driver.quit()
