def __getitem__(self, key):
return Expression(self, OP.HKEY, Param(key))
def slice(self, *args):
return fn.slice(self, Param(list(args)))
def contains(self, value):
if isinstance(value, dict):
return Expression(self, OP.HCONTAINS_DICT, Param(value))
elif isinstance(value, (list, tuple)):
return Expression(self, OP.HCONTAINS_KEYS, Param(value))
return Expression(self, OP.HCONTAINS_KEY, value)
def contains_any(self, *keys):
return Expression(self, OP.HCONTAINS_ANY_KEY, Param(list(keys)))
#nn = mega_nn.nn
root_name = '/megarun1/nndb_nn/'
query = (Network.select(Network.target_names).distinct().tuples())
for query_res in query:
target_names, = query_res
if len(target_names) == 1:
target_name = target_names[0]
else:
NotImplementedError('Multiple targets not implemented yet')
print(target_name)
parent_name = root_name + target_name + '/'
subquery = (Network.select(
Network.id,
NetworkJSON.network_json).where(Network.target_names == Param(
target_names)).join(NetworkJSON).tuples())
for subquery_res in subquery:
id, json_dict = subquery_res
nn = QuaLiKizNDNN(json_dict)
network_name = parent_name + str(id)
if len(nn.feature_names) != features:
print('Skipping', id, ': has', len(nn.feature_names),
'features instead of', features)
continue
if network_name in store:
pass
else:
def delete(self, *keys):
return fn.delete(self, Param(list(keys)))
def test_blob_field_mysql(self):
data = bytes(bytearray(range(256)))
blob = BlobModel.create(data=Param(data))
res = BlobModel.get(BlobModel.id == blob.id)
self.assertEqual(blob.data, data)
def contains_any(self, *keys):
return Expr(self, OP_HCONTAINS_ANY_KEY, Param(value))
'efeETG_GB': 'Electron ETG Heat Flux',
'efeITG_GB': 'Electron ITG Heat Flux',
'efeTEM_GB': 'Electron TEM Heat Flux',
'efiITG_GB': 'Ion ITG Heat Flux',
'efiTEM_GB': 'Ion TEM Heat Flux'
}
feature_names = ['An', 'Ate', 'Ati', 'Ti_Te', 'qx', 'smag', 'x']
feature_names2 = ['Ati', 'Ate', 'An', 'qx', 'smag', 'x', 'Ti_Te']
query = (Network.select(Network.target_names).distinct().tuples())
#df = pd.DataFrame(columns=['target_names', 'id','rms'])
results = pd.DataFrame()
for ii, query_res in enumerate(query):
target_names = query_res[0]
subquery = (Network.select(
Network.id, NetworkMetadata.rms_validation).where(
Network.target_names == Param(target_names)).where(
(Network.feature_names == Param(feature_names))
| (Network.feature_names == Param(feature_names2))).join(
NetworkMetadata).order_by(
NetworkMetadata.rms_validation).tuples())
df = pd.DataFrame(list(subquery), columns=['id', 'rms'])
index = pd.MultiIndex.from_product([[tuple(target_names)], df.index])
df.index = index
#df.loc[ii] = list(chain([target_names], subquery.get()))
results = pd.concat([results, df])
results['id'] = results['id'].astype('int64')
#for row in results.iterrows():
# results.set_value(row[0], 'target_names', target_to_fancy[row[1]['target_names']])
#results = results[['target_names', 'l2_norm', 'rms', 'rms_rel']]
#results.columns = ['Training Target', 'L_2 norm', 'RMS error [GB]', 'RMS error [%]']
def contains_any(self, *items):
return Expression(self, OP.ACONTAINS_ANY, Param(items))
def contains(self, *items):
return Expression(self, OP.ACONTAINS, Param(items))
