def load_saved_attributes():
global model
model = XGBRegressor()
booster = Booster()
booster.load_model('./ny_taxi_fare')
model._Booster = booster
def load(filename):
'''
Loads in an xgboost model from the given file location
Parameters
----------
filename : string
path of model file to be loaded
Returns
-------
booster : xgboost.Booster()
model that is loaded
metadata : dict
parameter metadata for model in the form of json data.
Use get_params() function to use in model prediction.
'''
booster = Booster({'nthread': 4})
# Check if model file exists as it has been writen by user.
# If not, add model_ to filename like it designated in save()
if not path.exists(filename):
model_file = filename.split('/')
model_file[-1] = 'model_' + model_file[-1]
model_file = '/'.join(model_file)
else:
model_file = filename
config_file = model_file.replace('model_', 'config_')
booster.load_model(model_file)
with open(config_file, 'r', encoding='utf-8') as f:
config = f.read()
config = json.loads(config)
booster.load_config(config)
metadata = json.loads(config)
return booster, metadata
def get_results(X):
categoricals = X.select_dtypes(include='object')
categoricals = categoricals.astype(str)
categoricals = categoricals.apply(label.fit_transform)
label_encoding = categoricals['country']
categoricals.drop(['country'], axis=1, inplace=True)
X_one = enc.transform(categoricals)
encoded_data = pd.DataFrame(X_one.todense())
encoded_data.reset_index(drop=True, inplace=True)
categoricals.reset_index(drop=True, inplace=True)
original_numeric = X.select_dtypes(include='number')
original_numeric.reset_index(drop=True, inplace=True)
X = pd.concat([original_numeric, encoded_data, label_encoding],
axis=1).values
Xp = pca.transform(X)
clf = XGBClassifier()
booster = Booster()
booster.load_model('xgb.model')
clf._Booster = booster
classes = clf.predict_proba(Xp)
y_pred = [0 if c[0] > 0.5 else 1 for c in classes]
return y_pred
def analyze(self, event):
array_list = [
"lepJet_llpdnnx_-1_isLLP_QMU_QQMU",
"lepJet_llpdnnx_0_isLLP_QMU_QQMU",
"lepJet_llpdnnx_1_isLLP_QMU_QQMU",
"lepJet_llpdnnx_2_isLLP_QMU_QQMU", "dimuon_mass", "dimuon_deltaR",
"lepJet_pt", "lepJet_eta", "lepJet_deltaR", "MET_pt", "MET_phi",
"looseMuons_pt", "looseMuons_eta", "looseMuons_dxy",
"tightMuons_pt", "tightMuons_eta", "tightMuons_dxy"
]
data = pd.DataFrame(data={
"lepJet_llpdnnx_-1_isLLP_QMU_QQMU":
getattr(event, "lepJet_llpdnnx_-1_isLLP_QMU_QQMU"),
"lepJet_llpdnnx_0_isLLP_QMU_QQMU":
event.lepJet_llpdnnx_0_isLLP_QMU_QQMU,
"lepJet_llpdnnx_1_isLLP_QMU_QQMU":
event.lepJet_llpdnnx_1_isLLP_QMU_QQMU,
"lepJet_llpdnnx_2_isLLP_QMU_QQMU":
event.lepJet_llpdnnx_2_isLLP_QMU_QQMU,
"dimuon_mass":
event.dimuon_mass,
"dimuon_deltaR":
event.dimuon_deltaR,
"lepJet_pt":
event.lepJet_pt,
"lepJet_eta":
event.lepJet_eta,
"lepJet_deltaR":
event.lepJet_deltaR,
"MET_pt":
event.MET_pt,
"MET_phi":
event.MET_phi,
"looseMuons_pt":
event.looseMuons_pt,
"looseMuons_eta":
event.looseMuons_eta,
"looseMuons_dxy":
event.looseMuons_dxy,
"tightMuons_pt":
event.tightMuons_pt,
"tightMuons_eta":
event.tightMuons_eta,
"tightMuons_dxy":
event.tightMuons_dxy,
},
columns=array_list,
index=[0])
model = XGBClassifier()
booster = Booster()
#model._le = LabelEncoder().fit([1])
booster.load_model(self.modelPath)
booster.feature_names = array_list
model._Booster = booster
bdt_score = model.predict_proba(data)
setattr(event, "bdt_score", bdt_score[:, 1])
return True
def get_model(cls, algorithm_name: str, model_path: str):
if algorithm_name == 'xgboost':
model = xgb.XGBClassifier()
booster = Booster()
booster.load_model(model_path)
model._Booster = booster
else:
model = joblib.load(model_path)
return model
def test(x,modelFile):
model = Booster() #init model
model.load_model(modelFile) # load data
maps=np.load("Map.npy",allow_pickle=True)
x_enc=encode([x])
y_enc=model.predict(DMatrix(x_enc))
y_pred=np.argmax(y_enc)
inverseMap=maps.item().get("inverseMap")
y_hat=inverseMap[y_pred]
print(y_hat)
def create_predictor_infos():
word_index = {}
n_tokens = 0
with open('../data/output/word_frequency.pkl', 'rb') as f:
word_frequency = cPickle.load(f)
assert type(word_frequency) == dict
for k, v in sorted(word_frequency.items(), key=lambda x: x[1]):
if v > THRESHOLD_FREQ:
word_index[k] = n_tokens
n_tokens += 1
bst = Booster()
bst.load_model('../data/model/xgboost_model.model')
return word_index, n_tokens, bst
def xgb_latest() -> (Booster, Dict[str, pandas.Categorical]):
base_path = '/var/opt/pcsml/devel/training_data/dumps/debug004/2017-12-27T18-30-59'
model = Booster()
model.load_model(os.path.join(base_path, 'model_2017-12-27T18-30-59.xgb'))
with gzip.open(
os.path.join(
base_path,
'model_2017-12-27T18-30-59_column_categories.pickle.gz'),
'rb') as f:
column_categories = pickle.load(f)
return model, column_categories
def load_saved_attributes():
global host_response_time_values
global neighbourhood_values
global property_type_values
global room_type_values
global cancellation_policy_values
global model
with open("columns.json", "r") as f:
resp = json.load(f)
host_response_time_values = resp["host_response_time"]
neighbourhood_values = resp["neighbourhood"]
property_type_values = resp["property_type"]
room_type_values = resp["room_type"]
cancellation_policy_values = resp["cancellation_policy"]
model = XGBRegressor()
booster = Booster()
booster.load_model('airbnb_price_predictor')
model._Booster = booster
"like_pppprepost": [float(sys.argv[19])],
"happiness": [float(sys.argv[20])],
"love": [float(sys.argv[21])],
"sadness": [float(sys.argv[22])],
"travel": [float(sys.argv[23])],
"food": [float(sys.argv[24])],
"pet": [float(sys.argv[25])],
"angry": [float(sys.argv[26])],
"music": [float(sys.argv[27])],
"party": [float(sys.argv[28])],
"sport": [float(sys.argv[29])],
"hashtags_pop_1": [0],
"hashtags_pop_2": [0],
"hashtags_pop_3": [0],
"hashtags_pop_4": [0],
"hashtags_pop_5": [0],
"hashtags_pop_6": [0],
"hashtags_pop_7": [0],
"hashtags_pop_8": [0],
"hashtags_pop_9": [0],
"hashtags_pop_10": [0],
"baseline": [float(sys.argv[30])]
}
df = pd.DataFrame.from_dict(input_item)
model = Booster()
model.load_model('Predictor/xgb_if_model_2020_v1.json')
output = model.predict(xgboost.DMatrix(df))
print(output)
from xgboost import XGBClassifier, Booster
model = XGBClassifier()
booster = Booster()
booster.load_model('model.pkl')
model._Booster = booster
print(model.predict([[0, 0, 0, 0, 0, 00]]))
def load_model(model_path):
clf = XGBClassifier()
booster = Booster()
booster.load_model(model_path)
clf._Booster = booster
return clf
#objective='multi:softprob',
nthread=4)
"""
model = XGBClassifier()
if not os.path.isfile('model.bin'):
print('start training')
model.fit(x_train,
y_train,
eval_set=evallist,
verbose=True,
early_stopping_rounds=20)
print('validation result')
print(model.score(x_valid, y_valid))
model.save_model('model.bin')
else:
booster = Booster()
booster.load_model('model.bin')
model._Booster = booster
print('check Nematostella vectensis seq')
nv_seq = "TSPDIMSSSFYIDSLISKAKSVPTSTSEPRHTYESPVPCSCCWTPTQPDPSSLCQLCIPTSASVHPYMHHVRGASIPSGAGLYSRELQKDHILLQQHYAATEEERLHLASYASSRDPDSPSRGGNSRSKRIRTAYTSMQLLELEKEFSQNRYLSRLRRIQIAALLDLSEKQVKIWFQNRRVKWKKDKKAAQHGTTTETSSCPSSPASTGRMDGV"
nv_vec = dataset.one_hot(nv_seq)
predict_data = np.asarray([nv_vec] * 2)
prediction = model.predict_proba(predict_data)
print('prediction: ')
print(prediction)
ipdb.set_trace()
print('finished execution')
import pandas as pd
x = pd.read_csv('for_predictPY.csv')
# XgBoost
import xgboost as xgb
from xgboost import Booster
# Load model
xgbost_model = xgb.XGBRegressor()
booster = Booster()
model = booster.load_model("Predict_model-version[0.1].model")
xgbost_model._Booster = booster
xgbost_predict = xgbost_model.predict(data=x)
print(xgbost_predict)
import datetime
import pickle
from xgboost import Booster
import xgboost as xgb
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
# from keras.models import model_from_json
# from keras_retinanet.models import load_model
# from sklearn.preprocessing import StandardScaler
app = Flask(__name__)
win_loss_draw = Booster()
win_loss_draw.load_model('./static/models/win_loss_draw.model')
win_type = Booster()
win_type.load_model('./static/models/win_type.model')
print('model loaded')
# def loadmodel(modelname,weightname):
# json_file = open(modelname, 'r')
# loaded_model_json = json_file.read()
# json_file.close()
# loaded_model = model_from_json(loaded_model_json)
# # load weights into new model
# loaded_model.load_weights(weightname)
# print("Loaded model from disk")
# return loaded_model
