def bias_n_li(self, theta): #接收一个list类型的theta参数；返回【所有级】的结果
runout = self.runout
r = self.r
H = self.H
p = [0] * (len(theta))
for i in range(len(theta)):
vector_down = pre.pfit(
self.gcfl(r[i * 4], runout[i * 4], 0, theta[i]))
vector_up = pre.pfit(
self.gcfl(r[i * 4 + 1], runout[i * 4 + 1], 0, theta[i]))
center_down = pre.circ(
self.gcra(r[i * 4 + 2], runout[i * 4 + 2], 0, theta[i]))
center_up = pre.circ(
self.gcra(r[i * 4 + 3], runout[i * 4 + 3], 0, theta[i]))
results = pre.eccentric(center_down[1], center_down[2],
center_up[1], center_up[2], vector_down[0],
vector_down[1], vector_down[2],
vector_up[0], vector_up[1], vector_up[2],
H[i])
p[i] = np.array([[1, 0, results[2], results[0]],
[0, 1, results[3], results[1]],
[-results[2], -results[3], 1, H[i]], [0, 0, 0,
1]])
e, phase = [0] * (len(p)), [0] * (len(p))
m = 1
for i in range(len(p)):
m = np.dot(m, p[i])
#偏心量
e[i] = np.sqrt(m[0, 3]**2 + m[1, 3]**2)
#偏心相位
phase[i] = self.get_phase(m[0, 3], m[1, 3])
return np.stack((e, phase), axis=1)
def predict_test(src, dir_name):
dict_type = 'mix'
docs = 'test'
prediction = Prediction(src, dir_name, dict_type)
prediction.predict(docs)
def Development():
global data
global lsa
global prediction
global testing
data = PreprocessingData()
data.DataSplit(0.3)
data.WordMapper()
data.SwapWordByMapper()
data.CategorizeForEach()
data.CatergorizeForAll()
lsa = LSA(data)
lsa.TF_IDF()
lsa.TopWords()
prediction = Prediction(lsa, data)
predictedOutput = prediction.predictMany(data.TestingData['input'])
actualOutput = data.TestingData['output']
testing = Testing(actualOutput, predictedOutput, list(data.keys))
testing.ConfusionMatrix()
testing.Score()
x = 'Label Accuracy Precision Recall F1_Score Support\n'
x += '_________________________________________________________________________________________________\n'
for key in data.keys:
x += '{:30}'.format(key)
for score in testing.score[key]:
x += '{:15}'.format(str(round(testing.score[key][score], 2)))
x += '\n'
return x
def bias_2(self, part1_theta, part2_theta):
runout = self.runout
r = self.r
H = self.H
#生成坐标
part1_flat_coordinate_down = self.gcfl(r[0], runout[0], 0, part1_theta)
part1_flat_coordinate_up = self.gcfl(r[1], runout[1], 0, part1_theta)
part1_radial_coordinate_down = self.gcra(r[2], runout[2], 0,
part1_theta)
part1_radial_coordinate_up = self.gcra(r[3], runout[3], 0, part1_theta)
#part1两端圆心及法向量
part1_center_down = pre.circ(part1_radial_coordinate_down)
part1_center_up = pre.circ(part1_radial_coordinate_up)
part1_vector_down = pre.pfit(part1_flat_coordinate_down)
part1_vector_up = pre.pfit(part1_flat_coordinate_up)
#生成坐标
part2_flat_coordinate_down = self.gcfl(r[4], runout[4], 0, part2_theta)
part2_flat_coordinate_up = self.gcfl(r[5], runout[5], 0, part2_theta)
part2_radial_coordinate_down = self.gcra(r[6], runout[6], 0,
part2_theta)
part2_radial_coordinate_up = self.gcra(r[7], runout[7], 0, part2_theta)
#part2两端圆心及法向量
part2_center_down = pre.circ(part2_radial_coordinate_down)
part2_center_up = pre.circ(part2_radial_coordinate_up)
part2_vector_down = pre.pfit(part2_flat_coordinate_down)
part2_vector_up = pre.pfit(part2_flat_coordinate_up)
#求出装配后偏心偏斜量
part1_results = pre.eccentric(
part1_center_down[1], part1_center_down[2], part1_center_up[1],
part1_center_up[2], part1_vector_down[0], part1_vector_down[1],
part1_vector_down[2], part1_vector_up[0], part1_vector_up[1],
part1_vector_up[2], H[0])
part2_results = pre.eccentric(
part2_center_down[1], part2_center_down[2], part2_center_up[1],
part2_center_up[2], part2_vector_down[0], part2_vector_down[1],
part2_vector_down[2], part2_vector_up[0], part2_vector_up[1],
part2_vector_up[2], H[1])
part1_x_center = part1_results[0]
part1_y_center = part1_results[1]
part1_theta_y = part1_results[2]
part1_theta_x = part1_results[3]
part2_x_center = part2_results[0]
part2_y_center = part2_results[1]
part2_theta_y = part2_results[2]
part2_theta_x = part2_results[3]
p1 = np.array([[1, 0, part1_theta_y, part1_x_center],
[0, 1, part1_theta_x, part1_y_center],
[-part1_theta_y, -part1_theta_x, 1, H[0]], [0, 0, 0,
1]])
p2 = np.array([[1, 0, part2_theta_y, part2_x_center],
[0, 1, part2_theta_x, part2_y_center],
[-part2_theta_y, -part2_theta_x, 1, H[1]], [0, 0, 0,
1]])
m = np.matmul(p1, p2)
#偏心量
e = np.sqrt(m[0, 3]**2 + m[1, 3]**2)
#偏心相位
phase = self.get_phase(m[0, 3], m[1, 3])
return [e, phase]
def flask_button_click():
# text = get text from flask text box
proc = DataPreprocessing()
load_data = proc.load_pickle("TokenizerData")
predictor = Prediction(load_data)
encoder_model = predictor.load_model('models\\encoder_model.json',
'models\\encoder_model_weights.h5')
decoder_model = predictor.load_model('models\\decoder_model.json',
'models\\decoder_model_weights.h5')
summary = predictor.generated_summaries(text, encoder_model, decoder_model)
def __init__(self):
'''
Constructor
'''
source = "E:/corpus/bionlp2011/project_data"
dir_name = "test-model-01"
dict_type = "train"
self.label = ["Gene_expression","Transcription","Protein_catabolism","Phosphorylation","Localization","Binding","Regulation","Positive_regulation","Negative_regulation"]
self.prediction = Prediction(source, dir_name, dict_type)
def main():
#f = FilteredTwitsBuilder()
print("starting configuration..")
#Filtered = f.read_from_csv()
pred = Prediction(1382, 1778)
ans=pred.predict(pred._start, pred._end)
print("The winner predicted to win according given quarter is " + ans)
App = QApplication(sys.argv)
window = Window()
sys.exit(App.exec())
def prediction():
if request.method == "GET" or request.method == "POST":
WindSpeed = request.args.get('WindSpeed')
MinTemp = request.args.get('MinTemp')
MaxTemp = request.args.get('MaxTemp')
Humidity = request.args.get('Humidity')
Predict = Prediction()
Probability = Predict.genratePredictions(WindSpeed, MinTemp, MaxTemp,
Humidity)
return json.dumps({'results': Probability})
return json.dumps(
{'Message': "Oops there is a problem in your request try later"})
def test2(self):
dir_name_eval = "test-model-002-cause"
doc_ids = ['PMC-2222968-04-Results-03']
dict_type = 'train'
prediction = Prediction(self.source, dir_name_eval, dict_type)
prediction.predict(doc_ids)
o_doc = prediction.docs[doc_ids[0]]
for sen in o_doc.sen:
sen.test()
self.a2writter.write(o_doc)
def feed(fileFood):
"""This function create an object to predict which word may come next and to store that object in a pickle file."""
if os.path.isfile(fileFood):
if os.path.isfile('feed.p'):
predictions = pickle.load(open('feed.p', 'rb'))
newPredictions = Prediction(fileFood)
predictions = predictions + newPredictions
print(predictions.bigram)
pickle.dump(predictions, open('feed.p', 'wb'))
else:
predictions = Prediction(fileFood)
pickle.dump(predictions, open('feed.p', 'wb'))
def test2(self):
dir_name_eval = "test-model-002-cause"
doc_ids = ['PMC-2222968-04-Results-03']
dict_type = 'train'
prediction = Prediction(self.source, dir_name_eval, dict_type)
prediction.predict(doc_ids)
o_doc = prediction.docs[doc_ids[0]]
for sen in o_doc.sen:
sen.test()
self.a2writter.write(o_doc)
def test3(self):
dir_name_eval = "test-model-013"
doc_ids = ['PMID-1763325']
dict_type = 'train'
prediction = Prediction(self.source, dir_name_eval, dict_type)
prediction.predict(doc_ids, write_result=False)
o_doc = prediction.docs[doc_ids[0]]
for sen in o_doc.sen:
sen.test()
self.a2writter.write(o_doc)
def test3(self):
dir_name_eval = "test-model-013"
doc_ids = ['PMID-1763325']
dict_type = 'train'
prediction = Prediction(self.source, dir_name_eval, dict_type)
prediction.predict(doc_ids, write_result=False)
o_doc = prediction.docs[doc_ids[0]]
for sen in o_doc.sen:
sen.test()
self.a2writter.write(o_doc)
def __init__(self):
self.n = 3
self.N = self.n * self.n
self.init = np.arange(1, self.N + 1).reshape(self.n, self.n)
self.qipan = self.init.copy()
self.bk_x = self.n - 2
self.bk_y = self.n - 2
self.bk_x_p = -1
self.bk_y_p = -1
self.pre = Prediction()
self.started = False # 标记是否开始
self.X = [-1, 0, 1, 0]
self.Y = [0, -1, 0, 1]
def prediction():
global lsa
global data
global prediction
# if not prediction:
prediction = Prediction(lsa, data)
request_new_data = request.get_json()
request_new_data = request_new_data['data']
# Input = numpy.array(list(map(lambda x: x[1], request_new_data.items())))
predicted = prediction.predictMany(request_new_data)
return jsonify({"prediction": dict(zip([i for i in range(len(request_new_data))], predicted))})
def check_t2(self):
valid_docs = 'dev'
# validation
validation = Prediction(self.src, self.dir_name, self.dict_type)
validation.set_prediction_docs(valid_docs, is_test=False)
Ypred, Ytest, _ = validation.predict_t2(grid_search=True)
# print result
print "\n\n====================================================================================="
print "Theme2 prediction"
self.print_matrix(Ytest, Ypred, [1])
def check_tt(self):
valid_docs = 'dev'
# validation
validation = Prediction(self.src, self.dir_name, self.dict_type)
validation.set_prediction_docs(valid_docs, is_test=False)
Ypred, Ytest, _ = validation.predict_tt(grid_search=True)
# print result
print "\n\n====================================================================================="
print "Regulation Positive_regulation Negative_regulation\n"
self.print_matrix(Ytest, Ypred, [7, 8, 9])
def check_t2(self):
valid_docs = 'dev'
# validation
validation = Prediction(self.src, self.dir_name, self.dict_type)
validation.set_prediction_docs(valid_docs, is_test = False)
Ypred,Ytest,_ = validation.predict_t2(grid_search = True)
# print result
print "\n\n====================================================================================="
print "Theme2 prediction"
self.print_matrix(Ytest, Ypred, [1])
def check_tt(self):
valid_docs = 'dev'
# validation
validation = Prediction(self.src, self.dir_name, self.dict_type)
validation.set_prediction_docs(valid_docs, is_test = False)
Ypred,Ytest,_ = validation.predict_tt(grid_search = True)
# print result
print "\n\n====================================================================================="
print "Regulation Positive_regulation Negative_regulation\n"
self.print_matrix(Ytest, Ypred, [7,8,9])
def check_tp(self):
valid_docs = 'dev'
# validation
validation = Prediction(self.src, self.dir_name, self.dict_type)
validation.set_prediction_docs(valid_docs, is_test = False)
Ypred,Ytest,_ = validation.predict_tp(grid_search = True)
# print result
print "\n\n====================================================================================="
print "Gene_expression Transcription Protein_catabolism Phosphorylation Localization Binding"
print "Regulation Positive_regulation Negative_regulation\n"
self.print_matrix(Ytest, Ypred, [1,2,3,4,5,6,7,8,9])
def input():
# getting text from user
if request.method=='POST':
text=request.form.get("text_in")
# creating summary
proc = DataPreprocessing()
load_data = proc.load_pickle("TokenizerData")
predictor = Prediction(load_data)
encoder_model = predictor.load_model('models/encoder_model.json', 'models/encoder_model_weights.h5')
decoder_model = predictor.load_model('models/decoder_model.json', 'models/decoder_model_weights.h5')
summary = predictor.generated_summaries(text, encoder_model, decoder_model)
return render_template("summary.html",summary=summary)
def check_tp(self):
valid_docs = 'dev'
# validation
validation = Prediction(self.src, self.dir_name, self.dict_type)
validation.set_prediction_docs(valid_docs, is_test=False)
Ypred, Ytest, _ = validation.predict_tp(grid_search=True)
# print result
print "\n\n====================================================================================="
print "Gene_expression Transcription Protein_catabolism Phosphorylation Localization Binding"
print "Regulation Positive_regulation Negative_regulation\n"
self.print_matrix(Ytest, Ypred, [1, 2, 3, 4, 5, 6, 7, 8, 9])
def testing():
global lsa
global data
global testing
global prediction
# if not prediction:
prediction = Prediction(lsa, data)
predictedOutput = prediction.predictMany(data.TestingData['input'])
actualOutput = data.TestingData['output']
testing = Testing(actualOutput, predictedOutput, list(data.keys))
return 'Setup for Testing Done'
def prepare_data(dataset, elo, elo_ave):
print(dataset.shape)
print(len(elo))
print(len(elo_ave))
dataset["Elo"] = elo
print(dataset)
drop_data = [
'Date', 'Open', 'High', 'Low', 'Close', 'Sma', 'Stdev',
'Adj Close', 'backward_ewm', 'Macd', 'macd_strike'
]
dataset = dataset.drop(drop_data, axis=1)
dataset = dataset.iloc[1:]
prediction = Prediction(dataset)
print(dataset)
prediction.initiate_training()
def medicine():
if request.method == "GET" or request.method == "POST":
WindSpeed = request.args.get('WindSpeed')
MinTemp = request.args.get('MinTemp')
MaxTemp = request.args.get('MaxTemp')
Humidity = request.args.get('Humidity')
Predict = Prediction()
Disease_Probability = Predict.genratePredictions(
WindSpeed, MinTemp, MaxTemp, Humidity)
GenerateMedicine = Medicine()
medicines_List = GenerateMedicine.Generate_Medicine(
Disease_Probability)
return json.dumps({'results': medicines_List})
return json.dumps(
{'Message': "Oops there is a problem in your request try later"})
def bias_n_li_fast_sum(
self, theta): #接收一个list类型的theta参数；分别返回【所有级】的偏心值和偏心相位结果【之和】
# runout = self.runout
# r = self.r
H = self.H
para = self.para
p = [0] * (len(theta))
for i in range(len(theta)):
vector_down = para[i * 4][int(theta[i] / 10)]
vector_up = para[i * 4 + 1][int(theta[i] / 10)]
center_down = para[i * 4 + 2][int(theta[i] / 10)]
center_up = para[i * 4 + 3][int(theta[i] / 10)]
results = pre.eccentric(center_down[1], center_down[2],
center_up[1], center_up[2], vector_down[0],
vector_down[1], vector_down[2],
vector_up[0], vector_up[1], vector_up[2],
H[i])
p[i] = np.array([[1, 0, results[2], results[0]],
[0, 1, results[3], results[1]],
[-results[2], -results[3], 1, H[i]], [0, 0, 0,
1]])
e, phase = [0] * (len(p)), [0] * (len(p))
m = 1
for i in range(len(p)):
m = np.dot(m, p[i])
#偏心量
e[i] = np.sqrt(m[0, 3]**2 + m[1, 3]**2)
#偏心相位
phase[i] = self.get_phase(m[0, 3], m[1, 3])
sum_e, sum_phase = 0, 0
for i in range(len(e) - 1):
sum_e += abs(e[i + 1] - e[i])
for i in range(len(phase) - 1):
sum_phase += abs(phase[i + 1] - phase[i])
return [sum_e, sum_phase]
def bias_n_li_fast_dert_phase(
self, theta): #接收一个list类型的theta参数；分别返回【所有级】的dert_phase【之和】
# runout = self.runout
# r = self.r
H = self.H
para = self.para
p = [0] * (len(theta))
for i in range(len(theta)):
vector_down = para[i * 4][int(theta[i] / 10)]
vector_up = para[i * 4 + 1][int(theta[i] / 10)]
center_down = para[i * 4 + 2][int(theta[i] / 10)]
center_up = para[i * 4 + 3][int(theta[i] / 10)]
results = pre.eccentric(center_down[1], center_down[2],
center_up[1], center_up[2], vector_down[0],
vector_down[1], vector_down[2],
vector_up[0], vector_up[1], vector_up[2],
H[i])
p[i] = np.array([[1, 0, results[2], results[0]],
[0, 1, results[3], results[1]],
[-results[2], -results[3], 1, H[i]], [0, 0, 0,
1]])
e, phase = [0] * (len(p)), [0] * (len(p))
m = 1
for i in range(len(p)):
m = np.dot(m, p[i])
e[i] = np.sqrt(m[0, 3]**2 + m[1, 3]**2)
phase[i] = self.get_phase(m[0, 3], m[1, 3])
dert_phase = np.zeros((len(phase) - 1, 1))
for i in range(len(phase) - 1):
dert_phase[i] = np.arctan(
abs(phase[i + 1] - phase[i])) * 180 / np.pi
return dert_phase
def bias_n_li_fast(self, theta): #接收一个list类型的theta参数；返回【所有级】的结果
# runout = self.runout
# r = self.r
H = self.H
para = self.para
p = [0] * (len(theta))
for i in range(len(H)):
vector_down = para[i * 4][int(theta[i] / 10)]
vector_up = para[i * 4 + 1][int(theta[i] / 10)]
center_down = para[i * 4 + 2][int(theta[i] / 10)]
center_up = para[i * 4 + 3][int(theta[i] / 10)]
results = pre.eccentric(center_down[1], center_down[2],
center_up[1], center_up[2], vector_down[0],
vector_down[1], vector_down[2],
vector_up[0], vector_up[1], vector_up[2],
H[i])
p[i] = np.array([[1, 0, results[2], results[0]],
[0, 1, results[3], results[1]],
[-results[2], -results[3], 1, H[i]], [0, 0, 0,
1]])
e, phase = [0] * (len(p)), [0] * (len(p))
m = 1
for i in range(len(p)):
m = np.dot(m, p[i])
#偏心量
e[i] = np.sqrt(m[0, 3]**2 + m[1, 3]**2)
#偏心相位
phase[i] = self.get_phase(m[0, 3], m[1, 3])
return np.stack((e, phase), axis=1)
def get_rot_axis(self, theta): #确定一个回转轴线
H = self.H
para = self.para
p = [0] * (len(theta))
for i in range(len(H)):
vector_down = para[i * 4][int(theta[i] / 10)]
vector_up = para[i * 4 + 1][int(theta[i] / 10)]
center_down = para[i * 4 + 2][int(theta[i] / 10)]
center_up = para[i * 4 + 3][int(theta[i] / 10)]
results = pre.eccentric(center_down[1], center_down[2],
center_up[1], center_up[2], vector_down[0],
vector_down[1], vector_down[2],
vector_up[0], vector_up[1], vector_up[2],
H[i])
p[i] = np.array([[1, 0, results[2], results[0]],
[0, 1, results[3], results[1]],
[-results[2], -results[3], 1, H[i]], [0, 0, 0,
1]])
# 保存各级零件偏心坐标
center = np.zeros((len(p) + 1, 3))
m = 1
M = []
M.append(np.zeros((4, 4)))
for i in range(len(p)):
m = np.dot(m, p[i])
rot_axis_vector = np.array([m[0, 3], m[1, 3], m[2, 3]]) # 实际回转轴线法向量
return rot_axis_vector
def predict():
# data = request.get_json(force = True)
# predictor = Prediction()
# model, vectorizer = predictor.prediction()
# result = predictor.predict(data['input'], model, vectorizer)
# return jsonify(result)
text = request.form["input"]
predictor = Prediction()
model, vectorizer = predictor.prediction()
result = predictor.predict(text, model, vectorizer)
if result == 1:
str = "Positive Review"
else:
str = "Negative Review"
return render_template("result.html", result=str)
def create_strike_profit_chart(self, event=None):
self.close_button.focus_force()
self.status_var.set("Creating strike chart...")
self.update()
self.update_idletasks()
def training_event(message):
self.status_var.set(message)
self.update()
self.update_idletasks()
if bool(self.shadow_expiration) and self.strike_var.get() != "":
self.clear_plot_frame()
fig = Figure(figsize=(10, 6))
canvas = FigureCanvasTkAgg(fig, master=self.plot_frame)
chart = ChartOptions()
row = self.shadow_expiration[self.expiration_var.get()]
strike = self.strike_var.get()
forecast = Prediction(self.options_db,
self.symbol_var.get(),
row["option_expire_id"],
row["expire_date"],
strike,
"CALL",
"bid",
training_event)
last_day_predictions, next_day_predictions = forecast.calculate_predictions()
success = chart.create_strike_profit_chart(self.options_db,
fig,
self.symbol_var.get(),
self.options_db.get_name_for_symbol(self.symbol_var.get()),
row["option_expire_id"],
strike,
row["expire_date"],
last_day_predictions, next_day_predictions,
put_call="CALL",
start_date=self.start_date,
end_date=self.end_date,
option_type='extrinsic' if self.bid_extrinsic_value.get() == 1 else 'bid')
if success:
self.show_figure(canvas)
self.status_var.set("Done")
else:
self.status_var.set("No data available")
def __init__(self):
self.n = 3
self.N = self.n * self.n
self.bk = 8 # ----------空格所对应的原图片的位置
self.init = np.arange(1, self.N + 1).reshape(
self.n, self.n) #二维矩阵最终的目标[[1,2,3],[4,5,6],[7,8,9]]
# self.qipan = self.init.copy()
# self.bk_x = self.n - 1
# self.bk_y = self.n - 1
self.qipan = np.array([[9, 5, 1], [8, 2, 4], [3, 6,
7]]) # ----需求解的二维矩阵
self.bk_x = 1 # ---------------------#空白块在矩阵中的位置
self.bk_y = 0 # ---------------------
self.bk_x_p = -1 #空白块之前的位置，当下一步是与之前位置相同则不选择此方向
self.bk_y_p = -1
self.step = 0 #共计步数
self.pre = Prediction() #预测类
self.started = False # 标记是否开始
self.X = [-1, 0, 1, 0] #i=0时X=-1，Y=0即空白块向上移动
self.Y = [0, -1, 0, 1]
self.stepout = [] #存储步骤
def bias_n_li_fast_dert_e_projection(
self, theta): #接收一个list类型的theta参数；分别返回【所有级】的e和dert_e【之和】
# runout = self.runout
# r = self.r
H = self.H
para = self.para
p = [0] * (len(theta))
for i in range(len(theta)):
vector_down = para[i * 4][int(theta[i] / 10)]
vector_up = para[i * 4 + 1][int(theta[i] / 10)]
center_down = para[i * 4 + 2][int(theta[i] / 10)]
center_up = para[i * 4 + 3][int(theta[i] / 10)]
results = pre.eccentric(center_down[1], center_down[2],
center_up[1], center_up[2], vector_down[0],
vector_down[1], vector_down[2],
vector_up[0], vector_up[1], vector_up[2],
H[i])
p[i] = np.array([[1, 0, results[2], results[0]],
[0, 1, results[3], results[1]],
[-results[2], -results[3], 1, H[i]], [0, 0, 0,
1]])
# 保存各级零件偏心坐标
center = np.zeros((len(p) + 1, 3))
m = 1
e, phase = [0] * (len(p)), [0] * (len(p))
M = []
M.append(np.zeros((4, 4)))
for i in range(len(p)):
m = np.dot(m, p[i])
center[i + 1, :] = m[0:3, 3]
e[i] = np.sqrt(m[0, 3]**2 + m[1, 3]**2)
phase[i] = self.get_phase(m[0, 3], m[1, 3])
M.append(m)
# alpha = np.arctan(np.sqrt(m[0, 3] ** 2 + m[1, 3] ** 2) / m[2, 3]) # 轴线偏斜角
# rot_x =
# rot_y =
# rot_z =
rot_axis_vector = np.array([m[0, 3], m[1, 3], m[2, 3]]) # 实际回转轴线法向量
a, b, c = rot_axis_vector
e_projection = np.zeros((len(p), 1))
for i in range(len(p)):
le = np.sqrt((center[i + 1, 0] - center[0, 0])**2 +
(center[i + 1, 1] - center[0, 1])**2 +
(center[i + 1, 2] - center[0, 2])**2)
d = abs(a * center[i + 1, 0] + b * center[i + 1, 1] + c *
center[i + 1, 2]) / np.sqrt(a**2 + b**2 + c**2) # 点到平面距离
e_projection[i] = np.sqrt(le**2 - d**2)
dert_e_projection = np.zeros((len(p), 1))
for i in range(len(e_projection) - 1):
dert_e_projection[i] = (e_projection[i + 1] - e_projection[i])
return dert_e_projection
def spin_cen(self, args):
center = args[0]
theta = args[1]
x = center[1]
y = center[2]
r = np.sqrt(x**2 + y**2)
alpha = pre.get_phase(x, y) # 角度值
beta = -(theta - alpha) # 角度值
beta_2 = beta * np.pi / 180 # 转换为弧度
spin_cen = []
spin_cen.append(center[0])
spin_cen.append(r * np.cos(beta_2))
spin_cen.append(r * np.sin(beta_2))
return spin_cen
def createPrediction(self, saveFile=""):
prediction = Prediction()
# On parcourt tous les fichiers
for nameFile, extract in self.getDSSPFile(self.cathFile,
self.dataFolder):
resSeq, resStruc = self.loadDSSPFile(nameFile, extract)
prediction.addSeqAndStruc(resSeq, resStruc)
# On sauvegarde si cela a été précisé précédemment
if (saveFile != ""):
prediction.saveInFile(saveFile)
return prediction
def getPara2(self):
runout = self.runout
r = self.r
para = [[]] * len(r)
for i in range(int(len(r) / 4)):
vector_down = pre.pfit(pre.gcfl(r[i * 4], runout[i * 4], 0))
vector_up = pre.pfit(pre.gcfl(r[i * 4 + 1], runout[i * 4 + 1], 0))
args_1 = list(zip([vector_down] * 36,
[-i * 10
for i in range(36)])) # 需对相位取负结果才和之前一样，原因未知？？
args_2 = list(zip([vector_up] * 36, [-i * 10 for i in range(36)]))
para[i * 4] = [i for i in map(self.spin_vec, args_1)]
para[i * 4 + 1] = [i for i in map(self.spin_vec, args_2)]
center_down = pre.circ(pre.gcra(r[i * 4 + 2], runout[i * 4 + 2],
0))
center_up = pre.circ(pre.gcra(r[i * 4 + 3], runout[i * 4 + 3], 0))
args_3 = list(zip([center_down] * 36, [i * 10 for i in range(36)]))
args_4 = list(zip([center_up] * 36, [i * 10 for i in range(36)]))
para[i * 4 + 2] = [i for i in map(self.spin_cen, args_3)]
para[i * 4 + 3] = [i for i in map(self.spin_cen, args_4)]
return para
class PredictionTest(object):
'''
classdocs
'''
def __init__(self):
'''
Constructor
'''
source = "E:/corpus/bionlp2011/project_data"
dir_name = "test-model-01"
dict_type = "train"
self.label = ["Gene_expression","Transcription","Protein_catabolism","Phosphorylation","Localization","Binding","Regulation","Positive_regulation","Negative_regulation"]
self.prediction = Prediction(source, dir_name, dict_type)
def run(self):
self.test1()
self.test2()
def print_doc_info(self, o_doc):
print "doc id:", o_doc.doc_id
print "is test:", o_doc.is_test
for i in range(0, len(o_doc.sen)):
o_sen = o_doc.sen[i]
print "sen:", i
print "-------------------------------"
# list of word number which is marked as trigger candidate
print "trigger candidate:"
print o_sen.trigger_candidate
# list of protein word number
print "protein:"
print o_sen.protein
# list of trigger word number
print "trigger:"
print o_sen.trigger
# relation representation
print "relation:"
if o_sen.rel != None:
print o_sen.rel.data
def test1(self):
doc_ids = "dev"
print "Test 1: Trigger-Protein prediction on dev corpus"
print "Print precision recall and f1 score for each class"
print "========================================================="
self.prediction.set_prediction_docs(doc_ids, is_test = False)
Ypred, Ytest, info = self.prediction.predict_tp(grid_search = True)
result = precision_recall_fscore_support(Ytest, Ypred, labels = [1,2,3,4,5,6,7,8,9])
print self.label
print "precision"
print result[0]
print "recall"
print result[1]
print "f1-score"
print result[2]
print "support"
print result[3]
def test2(self):
doc_ids = "dev"
print "\n\nTrigger-Trigger prediction on dev corpus"
print "Print precision recall and f1 score for each class"
print "========================================================="
self.prediction.set_prediction_docs(doc_ids, is_test = False)
Ypred, Ytest, info = self.prediction.predict_tt(grid_search = True)
result = precision_recall_fscore_support(Ytest, Ypred, labels = [7,8,9])
print self.label[6:9]
print "precision"
print result[0]
print "recall"
print result[1]
print "f1-score"
print result[2]
print "support"
print result[3]
def test3(self):
doc_ids = ["PMID-7747447", "PMID-7749985", "PMID-7759875", "PMID-7759956","PMC-1920263-04-MATERIALS_AND_METHODS-03","PMC-2222968-04-Results-03"]
print "\n\nTrigger-Protein prediction on 6 docs from dev corpus"
print "Print info result"
print "========================================================="
self.prediction.set_prediction_docs(doc_ids, is_test = False)
Ypred, Ytest, info = self.prediction.predict_tt(grid_search = True)
for i in range(0, len(Ypred)):
if Ypred[i] > 0 or Ytest[i] > 0:
print info[i], Ypred[i], Ytest[i]
self.prediction.update_doc_info(info, Ypred, "Theme", "P")
self.print_doc_info(self.prediction.docs['PMC-2222968-04-Results-03'])
def test4(self):
doc_ids = ["PMID-7747447", "PMID-7749985", "PMID-7759875", "PMID-7759956","PMC-1920263-04-MATERIALS_AND_METHODS-03","PMC-2222968-04-Results-03"]
#self.prediction.predict(doc_ids)
# create document object for prediction
self.prediction.set_prediction_docs(doc_ids)
# predict trigger-protein relation
Ypred, _, info = self.prediction.predict_tp(grid_search = True)
# update document
self.prediction.update_doc_info(info, Ypred, "Theme", "P")
for i in range(0, len(Ypred)):
if Ypred[i] > 0:
print info[i], Ypred[i]
self.print_doc_info(self.prediction.docs['PMC-2222968-04-Results-03'])
# predict trigger-trigger relation
Ypred, _, info = self.prediction.predict_tt(grid_search = True)
self.prediction.update_doc_info(info, Ypred, "Theme", "E")
for i in range(0, len(Ypred)):
if Ypred[i] > 0:
print info[i], Ypred[i]
self.print_doc_info(self.prediction.docs['PMC-2222968-04-Results-03'])
# write a2
self.prediction.write_result()
def predict_dev(src, dir_name):
dict_type = 'train'
docs = 'dev'
""" ----- print validation score for each step ----- """
validation = Prediction(src, dir_name, dict_type)
# validation score for tp
validation.set_prediction_docs(docs, is_test = False)
Ypred,Ytest,_ = validation.predict_tp(grid_search = True)
print "Gene_expression Transcription Protein_catabolism Phosphorylation Localization Binding"
print "Regulation Positive_regulation Negative_regulation"
print_matrix(Ytest, Ypred, [1,2,3,4,5,6,7,8,9])
# validation score for tt
validation.set_prediction_docs(docs, is_test = False)
Ypred,Ytest,_ = validation.predict_tt(grid_search = True)
print "Regulation Positive_regulation Negative_regulation"
print_matrix(Ytest, Ypred, [7,8,9])
# validation score for tc
validation.set_prediction_docs(docs, is_test = False)
Ypred,Ytest,_ = validation.predict_tc(grid_search = True)
print "Trigger-Argument-Cause prediction"
print_matrix(Ytest, Ypred, [1])
# validation score for t2
validation.set_prediction_docs(docs, is_test = False)
Ypred,Ytest,_ = validation.predict_t2(grid_search = True)
print "Trigger-Theme1-Theme2 prediction"
print_matrix(Ytest, Ypred, [1])
""" ----- make a prediction for dev corpus ----- """
prediction = Prediction(src, dir_name, dict_type)
prediction.predict(docs)
def makeClusters(self,IncomingDict,grid,decision,threshold,old_wt):
#print "Incoming Dict : " ,IncomingDict
nxtCells = []
noneCells =[]
cnt = 0
for trajID in IncomingDict:
#Adding the cells to a list to be clustered
nxtCell = IncomingDict[trajID].get('nextKey')
weight = IncomingDict[trajID].get('weight')
#noneCells.append(nxtCell)
if nxtCell is not None and weight > 4.0:
x = int(nxtCell%4456)
y = int(nxtCell/4456)
nxtCells.append((x,y))
#nxtCells.append(nxtCell)
cnt = cnt +1
#print "Next Cells : ",nxtCells
#print "None Cells : ",noneCells
print "\nNext Cells : ",nxtCells
print "\nNumber of Points to be clustered : ",cnt
print "\nStart Clustering : ",datetime.datetime.now()
if nxtCells != []:
distances = scipy.spatial.distance.cdist(nxtCells, nxtCells, 'cityblock') #Create a matrix of distance between points
print "\nMatrix Size : ",distances.shape
finalClusters = scipy.cluster.hierarchy.fclusterdata(distances,1)
#print "Final Cluters : ",finalClusters
# To form dict for Prediction Input
clusterID = 0
#currentCluster ={}
max = 0
dup = 0
predictionInput ={}
# To form dict for Prediction Input
for clusterKey in finalClusters:
if clusterKey in predictionInput:
dup = dup +1
#currentCluster.setdefault(clusterKey,[]).append(nxtCells[i]) #To append row,col to the dict
cellKey = FunctionLib().reverseCell(nxtCells[clusterID])
predictionInput.setdefault(clusterKey,[]).append(cellKey) #To append cellKey to the dict
if clusterKey > max :
max = clusterKey
clusterID=clusterID+1
#print "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
decision = decision+1
print "\nMaximum Key : ",max
print "\nDuplicates : ",dup
print "\nTotal Points clustered : ",max+dup
print "\nTally Correct : ",max+dup==clusterID
print "\nCluster Output :",predictionInput
print "\nEnd Clustering : ",datetime.datetime.now()
#print predictionInput
predictObject = Prediction()
prob,IncomingDict,t_wt = predictObject.predict(IncomingDict,predictionInput,grid)
print "Total weight is :",t_wt
print "\nDecision taken: ",decision , " as ",prob
if(decision == threshold or (old_wt/t_wt)>2):
return prob,decision
else:
print "\nInside else for prediction\n"
prob,decision = self.makeClusters(IncomingDict,grid,decision,threshold,t_wt)
return prob,decision
def __init__(self,predictions,probabilities):
Prediction.__init__(self)
self.predictions=predictions
self.probabilities=probabilities
