def test_stacked_neg_ensemble(): stacked = [model.LinearModel()] evaluation.estimate(model.StackedEnsembleModel( learners=stacked, next_model=model.LinearModel(), min_neg_recall=0.88), X_train, X_test, y_train, y_test, use_confusion_matrix=False)
def test_ensemble(): for md in [ model.LinearEnsemble([model.LinearModel(), model.LinearModel()]), ]: try: evaluation.cross_validation(md, X, y, scoring='both', n_jobs=1, n_splits=2) except Exception as e: print(md.__class__) raise e
def test_data_split_identical(): X_, y_ = X[:40], np.array([0] * 20 + [1] * 20) for md in [ model.SVM(), model.KNN(), model.XGBoost(), model.LinearModel(), model.DecisionTree() ]: a = evaluation.estimate(md, X_train, X_test, y_train, y_test) b = evaluation.estimate(md, X_train, X_test, y_train, y_test) assert a == b a = evaluation.cross_validation(md, X_, y_, scoring='both', n_splits=2, n_jobs=1) b = evaluation.cross_validation(md, X_, y_, scoring='both', n_splits=2, n_jobs=1) assert np.all(a['f1'] == b['f1']) assert np.all(a['roc_auc'] == b['roc_auc'])
def TestLinearMnistModel(): mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) training_set, training_label = mnist.train.next_batch(60000) mnist_dataset = dataset.DataSet() mnist_dataset.Set(training_set, training_label) with model.LinearModel() as mdl: mdl.Train(mnist_dataset, 100)
def test_estimate(): for md in [ model.SVM(), model.KNN(), model.XGBoost(), model.LinearModel(), model.DecisionTree() ]: evaluation.estimate(md, X_train, X_test, y_train, y_test)
def TestLinearModel(): test_dataset = dataset.NpyDataSet() dir_path = os.path.join(common.DataDir(), "systest-prototype-small-npy") print(dir_path) test_dataset.Load(dir_path) with model.LinearModel() as linear_model: linear_model.Train(test_dataset, 10, 1) first_row = test_dataset.x[0] first_row = first_row.reshape(1, first_row.shape[0]) infer_result = linear_model.Infer(first_row) logging.info("infer result: %d", infer_result)
def test_clone(): models = [ model.LinearModel(), model.SVM(), model.DecisionTree(), model.MultiClassesLearner('KNN', {'n_neighbors': 1}), model.KNN(), model.XGBoost(), ] from sklearn.base import clone for md in models: clone(md)
def predict(): tournaments = nx.tournament_names() print(tournaments) # download dataset from numerai data = nx.download('numerai_dataset.zip', load=False) print('data downloaded') data = nx.load_zip('numerai_dataset.zip', single_precision=True) print('data loaded') for tournament_name in tournaments: saved_model_name = 'model_trained_' + tournament_name if os.path.exists(saved_model_name): print("using saved model for", tournament_name) m = model.LinearModel.load(saved_model_name) else: print("saved model not found for", tournament_name) m = model.LinearModel(verbose=True) print("training model for", tournament_name) m.fit(data['train'], tournament_name) print("running predictions for", tournament_name, flush=True) # fit model with train data and make predictions for tournament data prediction = nx.production(m, data, tournament=tournament_name) # save predictions to csv file prediction_filename = '/tmp/prediction_' + tournament_name + '.csv' prediction.to_csv(prediction_filename, verbose=True) # submit the prediction # Numerai API key # You will need to create an API key by going to https://numer.ai/account and clicking "Add" under the "Your API keys" section. # Select the following permissions for the key: "Upload submissions", "Make stakes", "View historical submission info", "View user info" public_id = os.environ["NUMERAI_PUBLIC_ID"] secret_key = os.environ["NUMERAI_SECRET_KEY"] for tournament_name in tournaments: prediction_filename = '/tmp/prediction_' + tournament_name + '.csv' api = NumerAPI(public_id=public_id, secret_key=secret_key) model_id = api.get_models() api.upload_predictions(prediction_filename, model_id=model_id['akrimedes_2'])
def test_cross_validation(): for md in [ model.SVM(), model.MultiClassesLearner('KNN', {'n_neighbors': 1}), model.KNN(), model.XGBoost(), model.LinearModel(), model.DecisionTree(), ]: try: evaluation.cross_validation(md, X, y, scoring='both', n_jobs=1, n_splits=2) except Exception as e: print(md.__class__) raise e
def pf_run(infile, outfile, posnoise, velnoise, PARTICLEN, FRAMEN, NOISE, log): np.random.seed(0) print "Loading data..." d = pickle.load(open(infile)) print "done!" env = util.Environmentz((1.5, 2), (240, 320)) eo = likelihood.EvaluateObj(240, 320) eo.set_params(10, 4, 2) le = likelihood.LikelihoodEvaluator(env, eo, log) model_inst = model.LinearModel(env, le, POS_NOISE_STD=posnoise, VELOCITY_NOISE_STD=velnoise) y = d['video'][:FRAMEN] weights, particles = pf.particle_filter(y, model_inst, len(y), PARTICLEN) np.savez_compressed(outfile, weights=weights, particles=particles)
def main(): # 取数据 mgr = BusinessManager('data/') # 生成训练模型需要的train_data, test_data train_data, test_data = mgr.generate_model_data() # feature_builder = model.FeatureBuilder('tfidf') X_train, y_train, X_test, y_test = feature_builder.get_feature(train_data,\ test_data) lrmodel = model.LinearModel() lrmodel.train(X_train, y_train) lrmodel.save(model_path) mgr.set_sentiment_model(lrmodel) business_ids = mgr.get_business_ids() # return list for bid in business_ids: summary = mgr.aspect_based_summary(bid) print(summary)
def test_get_params(): models = [ model.LinearModel(), model.SVM(), model.DecisionTree(), model.MultiClassesLearner('KNN', {'n_neighbors': 1}), model.KNN(), model.XGBoost(), ] for md in models: params = md.get_params() try: assert 'normalizer_name' in params assert 'sample_method' in params if not isinstance(md, model.KNN): assert 'balanced_learning' in params except AssertionError as e: print(params) print(md.__class__) raise e
def test_logistic_regression(): m = model.LinearModel() X = np.random.normal(size=(1000, 10)) y = np.array(X.sum(axis=1) > 0, dtype=np.int8) scores = evaluation.cross_validation(m, X, y, n_jobs=1) assert np.all(scores > 0.9)
# None # Project-specific Imports import model # Start the actual test # Declare a system model: spec = { "use_library" : 0, "model_name" : 'Ballbot', "time_sample" : 0.01, "disc_flag" : 1 } ball_model = model.LinearModel(spec) print(ball_model.model_name) # print out the model name print(ball_model.u) # print out the symbolic vector of model control print(ball_model.cont_model) # print out the continous dynamic equations print(ball_model.disc_model) # print out the discrete time dynamic equations print(ball_model.measure_func) # print out the measurement function print('Testing the process time') start1 = time.process_time() # get an initial start time to check to the see the computational time needed for subs-based system evaluation evaled = ball_model.evaluate_dynamics([1, 2, 3, 4], [1,1], [2]) # Evaluate using the subs command end1 = (time.process_time()-start1) # get the end time to check computational cost print(' ') # Blank line print('Number of Seconds for Subs Method') print(end1) print('Value of the state when placed in the dynamics') print(evaled)
from business import BusinessManager import model def main(): mgr = BusinessManager('data/') train_data, test_data = mgr.generate_model_data() feature_builder = model.FeatureBuilder('tfidf') X_train, y_train, X_test, y_test = feature_builder.get_feature(train_data, test_data) lrmodel = model.LinearModel() lrmodel.train(X_train, y_train) lrmodel.save(model_path) mgr.set_sentiment_model(lrmodel) business_ids = get_business_ids() for bid in business_ids: summary = mgr.aspect_based_summary(business_ids) print(summary) if __name__ == "__main__": main()
import model tournaments = nx.tournament_names() print(tournaments) # download dataset from numerai data = nx.download('numerai_dataset.zip') for tournament_name in tournaments: saved_model_name = 'model_trained_' + tournament_name if os.path.exists(saved_model_name): print("using saved model for", tournament_name) m = model.LinearModel.load(saved_model_name) else: print("saved model not found for", tournament_name) m = model.LinearModel(verbose=True) print("training model for", tournament_name) m.fit(data['train'], tournament_name) print("running predictions for", tournament_name, flush=True) # fit model with train data and make predictions for tournament data prediction = nx.production(m, data, tournament=tournament_name) # save predictions to csv file prediction_filename = '/tmp/prediction_' + tournament_name + '.csv' prediction.to_csv(prediction_filename, verbose=True) # submit the prediction # Numerai API key
import likelihood import util import model np.random.seed(0) d = pickle.load(open('simulate.pickle')) env = util.Environment((1.5, 2), (240, 320)) eo = likelihood.EvaluateObj(240, 320) eo.set_params(10, 4, 2) le = likelihood.LikelihoodEvaluator(env, eo) model_inst = model.LinearModel(env, le) PARTICLEN = 4000 for frameno in range(1, 300, 30): print "frame", frameno prior_states = model_inst.sample_latent_from_prior(PARTICLEN) img = d['video'][frameno] scores = np.zeros(PARTICLEN) for si, state in enumerate(prior_states): scores[si] = model_inst.score_obs(img, state) score_sort_idx = np.argsort(scores)