def getRecSongsForAllHybrid(songDict, topN, arimaDict, similarDict, avgDict,
count):
"""Get recommended songs list of a playlist for all hybrid comparing with three dicts.
Input:
songDict - song dictionaries with sid as key and Song as value.
topN - count of recommendation.
tarDict - predicted topic dict.
Output:
result - a list of songs.
"""
print count
alpha = count / (count + 15.0)
beta = 0.5 * (1 - alpha)
lamda = 0.5 * (1 - alpha)
recDict = {}
for sid in songDict.keys():
song = songDict[sid]
topicDict = song.getTopicDict()
arimaSim = 0.37 * util.similarity(topicDict, arimaDict)
similarSim = 0.17 * util.similarity(topicDict, similarDict)
avgSim = 0.36 * util.similarity(topicDict, avgDict)
sim = arimaSim + similarSim + avgSim
recDict[sid] = sim
recList = sorted(recDict.iteritems(), key=lambda x: x[1])
result = []
for i in range(0, topN):
result.append(recList[i][0])
return result
def getRecSongsForAllHybrid(songDict,topN,arimaDict,similarDict,avgDict,count):
"""Get recommended songs list of a playlist for all hybrid comparing with three dicts.
Input:
songDict - song dictionaries with sid as key and Song as value.
topN - count of recommendation.
tarDict - predicted topic dict.
Output:
result - a list of songs.
"""
print count
alpha = count / (count + 15.0)
beta = 0.5 * (1 - alpha)
lamda = 0.5 * (1 - alpha)
recDict = {}
for sid in songDict.keys():
song = songDict[sid]
topicDict = song.getTopicDict()
arimaSim = 0.37 * util.similarity(topicDict,arimaDict)
similarSim = 0.17 * util.similarity(topicDict,similarDict)
avgSim = 0.36 * util.similarity(topicDict,avgDict)
sim = arimaSim + similarSim + avgSim
recDict[sid] = sim
recList = sorted(recDict.iteritems(),key=lambda x:x[1])
result = []
for i in range(0,topN):
result.append(recList[i][0])
return result
def run(q_img, steps_nbr=10):
golden_point = gen.get_init_point()
vset_golden = gen.get_vedges(golden_point,0)
print 'GOLDEN:',golden_point
point = gen.get_init_point()
u_curr = 0. # initial similarity
i = 0
points = []
while i < steps_nbr:
i += 1
if i%100 == 0: print("round: ", i)
new_point = gen.get_proposal(point)
vset = gen.get_vedges(new_point,1)
u = util.similarity(vset, vset_golden)
if point_accepted(u,u_curr):
#print 'new point:', new_point
point = new_point
points.append((u,new_point))
u_curr = u
print [ u for (u,p) in points ]
print 'best:',max(points)
def judge(input_smiles, candidate_smiles, input_drd, input_logp, threshold_similarity = 0.3, threshold_qed = 0.82, drd_gap_threshold = 0.1, logp_gap_threshold = 0.3, \
threshold_drd = 0.8):
sim = similarity(input_smiles, candidate_smiles)
drd_score = drd2(candidate_smiles)
logp_score = penalized_logp(candidate_smiles)
return sim >= threshold_similarity \
and (drd_score >= threshold_drd or drd_score - input_drd >=drd_gap_threshold) \
and (logp_score - input_logp > logp_gap_threshold)
def test_single_smiles(input_smiles, model_list):
drd_score = drd2(input_smiles)
logp_score = penalized_logp(input_smiles)
success_list = multiple_iteration(input_smiles, model_list)
for smiles in success_list:
print(smiles, "similar: {:1.3f}; origin drd: {:1.3f}; drd improvement: {:1.2f}, logp improvement: {:2.2f}".format(\
similarity(input_smiles, smiles), drd_score,\
drd2(smiles) - drd_score, \
penalized_logp(smiles) - logp_score))
return len(success_list)
def evaluate(input_smiles,
candidate_smiles,
input_drd,
input_logp,
coefficient_similarity=1.0,
coefficient_drd=0.3,
coefficient_qed=0.3,
coefficient_logp=0.3):
score = similarity(input_smiles, candidate_smiles) * coefficient_similarity \
+ (drd2(candidate_smiles) - input_drd) * coefficient_drd \
+ (penalized_logp(candidate_smiles) - input_logp) * coefficient_logp
return score
def judge(input_smiles, candidate_smiles, threshold_similarity = 0.3, threshold_qed = 0.82, qed_gap_threshold = 0.1, logp_gap_threshold = 0.3, \
threshold_drd = 0.7):
sim = similarity(input_smiles, candidate_smiles)
qed_score0 = qed(input_smiles)
qed_score = qed(candidate_smiles)
#drd_score0 = drd2(candidate_smiles)
#drd_score = drd2(candidate_smiles)
logp_score0 = penalized_logp(input_smiles)
logp_score = penalized_logp(candidate_smiles)
return sim >= threshold_similarity \
and (qed_score >= threshold_qed or qed_score - qed_score0 >=qed_gap_threshold) \
and (logp_score - logp_score0 > logp_gap_threshold)
def errorTest():
songDict = persist.readSongFromFile()
print len(songDict)
disDict = {}
tarDict = songDict[672661981].getTopicDict()
for sid in songDict:
song = songDict[sid]
topicDict = song.getTopicDict()
dis = util.similarity(tarDict,topicDict)
disDict[sid] = dis
disList = sorted(disDict.iteritems(),key=lambda x:x[1])
for i in range(0,100):
print disList[i]
def errorTest():
songDict = persist.readSongFromFile()
print len(songDict)
disDict = {}
tarDict = songDict[672661981].getTopicDict()
for sid in songDict:
song = songDict[sid]
topicDict = song.getTopicDict()
dis = util.similarity(tarDict, topicDict)
disDict[sid] = dis
disList = sorted(disDict.iteritems(), key=lambda x: x[1])
for i in range(0, 100):
print disList[i]
def getRecSongs(songDict, topN, tarDict):
"""Get recommended songs list of a playlist comparing with target dict.
Input:
songDict - song dictionaries with sid as key and Song as value.
topN - count of recommendation.
tarDict - predicted topic dict.
Output:
result - a list of songs.
"""
recDict = {}
for sid in songDict.keys():
song = songDict[sid]
topicDict = song.getTopicDict()
sim = util.similarity(topicDict, tarDict)
recDict[sid] = sim
recList = sorted(recDict.iteritems(), key=lambda x: x[1])
result = []
for i in range(0, topN):
result.append(recList[i][0])
return result
def getRecSongs(songDict, topN, tarDict):
"""Get recommended songs list of a playlist comparing with target dict.
Input:
songDict - song dictionaries with sid as key and Song as value.
topN - count of recommendation.
tarDict - predicted topic dict.
Output:
result - a list of songs.
"""
recDict = {}
for sid in songDict.keys():
song = songDict[sid]
topicDict = song.getTopicDict()
sim = util.similarity(topicDict, tarDict)
recDict[sid] = sim
recList = sorted(recDict.iteritems(), key=lambda x: x[1])
result = []
for i in range(0, topN):
result.append(recList[i][0])
return result
def run(q_img, steps_nbr=10):
bpy.data.scenes['Scene'].render.filepath = 'rendered'
bpy.ops.render.render(write_still=True)
## delete default Cubes
boxes = get_boxes()
for b in boxes:
b.select = True
bpy.data.objects['Lamp'].select = False
bpy.data.objects['Camera'].select = False
bpy.ops.object.delete()
init_camera()
init_light()
q_profile = util.get_profile(q_img)
u_curr = 0.0
xy0, obj_nbr = scn.estimate_img(q_img, MY_XYZ, MY_EULER)
scene = gen.init_scn(xy0, obj_nbr)
build(scene)
boxes = get_boxes()
print("nbr of boxes:", len(boxes))
i = 0
while i < steps_nbr:
i += 1
print("round: ", i)
p_scn = gen.get_proposal(scene)
set_params(boxes, p_scn)
p_img = take_image()
print("image shape:", p_img.shape)
#misc.imsave('rendered.jpg',p_img)
u = util.similarity(p_img, q_profile)
if point_accepted(u, u_curr):
scene = p_scn
u_curr = u
def single_iteration(input_smiles,
model_list,
topk=3,
similarity_threshold=0.3,
is_print=False):
rdkit_mol = AllChem.MolFromSmiles(input_smiles)
data = mol_to_graph_data_obj_simple(rdkit_mol)
model, linear_pred_atoms = model_list
### data_x, data_edge_index, data_edge_attr = data.x, data.edge_index, data.edge_attr
### shape: [24, 2], [2, 52], [52, 2] 24--#atom; 52--#bond;
num_atoms = data.x.size()[0]
mask_edge = True
whole_smiles = []
proposal_smiles = []
if is_print:
t1 = time()
##### add atom
for mask_idx in range(num_atoms):
graph_data = add_atom(data, mask_idx, mask_edge)
sorted_idx = atom_GNN_predict(graph_data, model, linear_pred_atoms,
topk)
smiles_list = generate_new_smiles_for_add(data, graph_data, sorted_idx)
whole_smiles.extend(smiles_list)
if is_print:
t2 = time()
print("\t\tsingle_iteration::1 cost {:1.2f} seconds".format(t2 - t1))
#### replace atom
for mask_idx in range(num_atoms):
graph_data = masking_atom(data, mask_idx, mask_edge)
sorted_idx = atom_GNN_predict(graph_data, model, linear_pred_atoms,
topk)
smiles_list = generate_new_smiles_for_mask(data, graph_data,
sorted_idx)
whole_smiles.extend(smiles_list)
if is_print:
t3 = time()
print("\t\tsingle_iteration::2 cost {:1.2f} seconds".format(t3 - t2))
#### delete atom
for delete_idx in range(num_atoms):
smiles = delete_atom_generate_smiles(data, delete_idx)
if smiles is not None:
whole_smiles.extend(smiles)
if is_print:
t4 = time()
print("\t\tsingle_iteration::3 cost {:1.2f} seconds".format(t4 - t3))
whole_smiles = list(set(whole_smiles) - set([input_smiles]))
for smiles in whole_smiles:
try:
sim = similarity(smiles, input_smiles)
if (sim < similarity_threshold):
continue
proposal_smiles.append((smiles, sim))
except exception as e:
continue
if is_print:
t5 = time()
print("\t\tsingle_iteration::4 cost {:1.2f} seconds".format(t5 - t4))
#print("valid rate is {:2.2f} %, valid number is {:5d}".format(len(proposal_smiles) / max(1,len(whole_smiles)) * 100,
# len(proposal_smiles)))
sim_value = [sim for smiles, sim in proposal_smiles]
smiles_list = [smiles for smiles, sim in proposal_smiles]
return smiles_list
def evaluate(input_smiles, candidate_smiles, coefficient_similarity = 1.0, coefficient_drd = 0.3, coefficient_qed = 0.3, coefficient_logp = 0.3):
score = similarity(input_smiles, candidate_smiles) * coefficient_similarity \
+ (qed(candidate_smiles) - qed(input_smiles)) * coefficient_qed \
+ (penalized_logp(candidate_smiles) - penalized_logp(input_smiles)) * coefficient_logp
return score
