def process():
data = request.form
data_dictionary = data.copy()
print(data_dictionary)
final_models= []
model_option = data_dictionary["model_option"]
pretrained_models = data_dictionary["pretrained_models"].split(",")
if(model_option == 'yes'):
model_file = data_dictionary["model_file"]
final_models = pretrained_models
final_models.append('own_model')
else:
final_models = pretrained_models
email_user = data_dictionary["email_user"]
#print('final_models')
#print(model_file)
if(model_option == 'yes'):
#Verify model
print('empece a leer')
model = vm.load_model_cnn(model_file)
print('acabe a leer')
#Processing Images
x_test = dp.load_test_images()
y_test = dp.load_test_targets()
test_data, test_target = dp.process_data(x_test, y_test, 8)
#Generate metrics
m.generate_metrics(model, test_data, test_target, y_test, x_test)
#Generate pdf
fpr_micro, tpr_micro, fpr_macro, tpr_macro = pg.load_metrics_data_roc(final_models)
report_values = pg.load_metrics_data_report(final_models)
ruta_macro = pg.generate_graphs_macro(final_models, fpr_macro, tpr_macro)
ruta_micro = pg.generate_graphs_micro(final_models, fpr_micro, tpr_micro)
pg.generate_pdf(ruta_micro, ruta_macro, report_values)
#Send Email
#ec.zip(directory_results,name_destination)
ec.send_results(email_user)
if (data_dictionary) :
return jsonify({ 'success' : 'Successfully Process Please Ckeck your Email' })
else:
parametros=[]
return jsonify({'error' : 'Problemas with the process. Try Again'})
def test_get_unknown_metrics_type(self):
'''When no metrics types are specified an exception is thrown'''
from metrics import generate_metrics
res = generate_metrics(bibcodes=testset, metrics_types=[])
# An unknown metrics type should return an empty dictionary
self.assertEqual(res, {})
def create_model(x_train,
y_train,
x_test,
y_test,
numFolds=5,
c=1,
k='linear',
save=True,
baseName='femlpModel'):
"""
Model providing function:
Create Keras model with SVM as classifier, compile test and generate metrics.
"""
################# define SVM #################
clf = svm.SVC(kernel=k, C=c, probability=True, random_state=1337)
clf.fit(x_train, y_train)
# Classify
y = np_utils.to_categorical(y_test, 2)
classesPredictionList = clf.predict(x_test) # 0 or 1
classesProbaPredictionList = clf.predict_proba(x_test) # probability
sensitivity, specificity, accuracy, precision, recall, F1_score, auc = metrics.generate_metrics(
classesPredictionList, classesProbaPredictionList, y, verbose=False)
if (save):
joblib.dump(clf, "output/" + baseName + ".pkl")
print("Accuracy: {:.4f}".format(accuracy))
print("Sensitivity: {:.4f}".format(sensitivity))
print("Specificity: {:.4f}".format(specificity))
print("F1 Score: {:.4f}".format(F1_score))
print("AUC: {:.4f}".format(auc))
def init_train():
train_traders = {}
for j in range(0, 2):
id = str(uuid.uuid4())
train_traders[id] = [
generate_tracks("S{}".format(i)) for i in range(0, 10)
]
metrics = {}
for k in train_traders.keys():
tracks = pd.concat(train_traders[k], axis=1)
print(k)
for t in tracks.columns:
metrics[k + '-' + t] = generate_metrics(tracks[[t]])
# metrics[k]={t: generate_metrics(tracks[t]) for t in tracks.columns}
test_frame = pd.DataFrame(metrics).T
y = test_frame[['mean']]
X = test_frame[['expectancy', 'maxDD', 'sharpe']]
model = sm.OLS(y, X).fit()
predictions = model.predict(X) # make the predictions by the model
# Print out the statistics
return model.params.values.flatten().tolist()
def generate_trader_strategy_metrics(coefficients):
predicted_returns = []
traders = select_all('public', 'trader_tracks').traderid.unique().tolist()
for t in traders:
t_tracks = select_where('public', 'trader_tracks', 'traderid', '=', t)
strategies = t_tracks.strategyid.unique().tolist()
for s in strategies:
t_track = t_tracks.query('strategyid == @s', engine='python')[[
'dateindex', 'value'
]].set_index('dateindex')
metrics_test = generate_metrics(t_track)
y = [
metrics_test['expectancy'], metrics_test['maxDD'],
metrics_test['sharpe']
]
predicted_returns.append({
'traderid':
t,
'strategyid':
s,
'strategy_metrics':
metrics_test,
'predicted_return':
[i * j for i, j in list(zip(coefficients, y))][0]
})
return predicted_returns
def create_model(x_train, y_train, x_test, y_test, numberOfClasses=2, numberOfEpochs = 10, batchSize = 30, save=True, baseName='fftModel'):
"""
Model providing function:
Create Keras model with MLP as classifier, compile test and generate metrics.
"""
base_model = load_model()
# Compile
base_model.compile( loss='binary_crossentropy', optimizer= 'sgd', metrics=['accuracy'] )
# Train
base_model.fit(x_train,
y_train,
batch_size = batchSize,
epochs = numberOfEpochs,
verbose = 0,
validation_data=(x_test, y_test))
# Classify
classesPredictionList = base_model.predict_classes(x_test, verbose=0) # 0 or 1
classesProbaPredictionList = base_model.predict_proba(x_test) # probability
sensitivity, specificity, accuracy, precision, recall, F1_score, auc = metrics.generate_metrics(classesPredictionList,classesProbaPredictionList,y_test,verbose=False)
# Save Model
if(save):
save_model(base_model, baseName)
print("Accuracy: {:.4f}".format(accuracy))
print("Sensitivity: {:.4f}".format(sensitivity))
print("Specificity: {:.4f}".format(specificity))
print("F1 Score: {:.4f}".format(F1_score))
print("AUC: {:.4f}".format(auc))
def test_get_unknown_metrics_type(self):
'''When no metrics types are specified an exception is thrown'''
from metrics import generate_metrics
res = generate_metrics(bibcodes=testset, metrics_types=[])
# An unknown metrics type should return an empty dictionary
self.assertEqual(res, {})
def create_modelCV(x_train,
y_train,
x_test,
y_test,
numFolds=5,
c=1,
k='linear'):
"""
Model providing function:
Create Keras model with SVM as classifier, compile test and generate metrics.
"""
### Cross-validation
skf = StratifiedKFold(n_splits=numFolds, shuffle=True, random_state=1337)
X = x_train
Y = y_train
sensitivitys, specificitys, accuracys, precisions, recalls, F1_scores, aucs = [
[], [], [], [], [], [], []
]
#kpbar = tqdm(total=numFolds, desc="Kfold", leave=False)
y = np_utils.to_categorical(Y, 2)
Y = numpy.array(Y)
for train_index, test_index in skf.split(X, Y):
################# define SVM #################
clf = svm.SVC(kernel=k, C=c, probability=True, random_state=1337)
clf.fit(X[train_index], Y[train_index])
# Classify
classesPredictionList = clf.predict(X[test_index]) # 0 or 1
classesProbaPredictionList = clf.predict_proba(
X[test_index]) # probability
sensitivity, specificity, accuracy, precision, recall, F1_score, auc = metrics.generate_metrics(
classesPredictionList,
classesProbaPredictionList,
y[test_index],
verbose=False)
sensitivitys.append(sensitivity)
specificitys.append(specificity)
accuracys.append(accuracy)
precisions.append(precision)
recalls.append(recall)
F1_scores.append(F1_score)
aucs.append(auc)
sensitivitys = numpy.array(sensitivitys)
specificitys = numpy.array(specificitys)
accuracys = numpy.array(accuracys)
precisions = numpy.array(precisions)
recalls = numpy.array(recalls)
F1_scores = numpy.array(F1_scores)
aucs = numpy.array(aucs)
print("Mean Accuracy: {:.4f} (+/- {:.4f})".format(accuracys.mean(),
accuracys.std()))
print("Mean Sensitivity: {:.4f} (+/- {:.4f})".format(
sensitivitys.mean(), sensitivitys.std()))
print("Mean Specificity: {:.4f} (+/- {:.4f})".format(
specificitys.mean(), specificitys.std()))
print("Mean F1 Score: {:.4f} (+/- {:.4f})".format(F1_scores.mean(),
F1_scores.std()))
print("Mean AUC: {:.4f} (+/- {:.4f})".format(aucs.mean(), aucs.std()))
def test_no_identifiers_found(self):
'''When no identifiers are found an exception is thrown'''
from metrics import generate_metrics
res = generate_metrics(bibcodes=testset, metrics_types=[])
# No identifiers (i.e. no records found in database) should return
# an empty dictionary
self.assertEqual(res, {})
def test_no_identifiers_found(self):
'''When no identifiers are found an exception is thrown'''
from metrics import generate_metrics
res = generate_metrics(bibcodes=testset, metrics_types=[])
# No identifiers (i.e. no records found in database) should return
# an empty dictionary
self.assertEqual(res, {})
def post(self):
bibcodes = []
query = None
try:
include_tori = request.json['tori']
except:
include_tori = True
# Force that we either have a valid metrics type or all types
try:
types = [t for t in request.json['types'] if t in allowed_types]
except:
types = []
types = types or allowed_types
# Same with histogram type
try:
histograms = request.json['histograms']
except:
histograms = []
histograms = histograms or allowed_histograms
if 'bibcodes' in request.json:
bibcodes = map(str, request.json['bibcodes'])
if len(bibcodes) > current_app.config.get('METRICS_MAX_SUBMITTED'):
return {
'Error':
'Unable to get results!',
'Error Info':
'No results: number of submitted \
bibcodes exceeds maximum number'
}, 200
elif len(bibcodes) == 0:
return {
'Error': 'Unable to get results!',
'Error Info': 'No bibcodes found in POST body'
}, 200
elif 'query' in request.json:
query = request.json['query']
else:
return {
'Error': 'Unable to get results!',
'Error Info': 'Nothing to calculate metrics!'
}, 200
results = generate_metrics(bibcodes=bibcodes,
query=query,
tori=include_tori,
types=types,
histograms=histograms)
# If the results contain an error message something went boink
if "Error" in results:
return results, 500
# otherwise we have real results or an empty dictionary
if results:
return results
else:
return {
'Error': 'Unable to get results!',
'Error Info': 'No data available to generate metrics'
}, 200
def get(self, bibcode):
results = generate_metrics(bibcodes=[bibcode], types=["basic", "histograms"], histograms=["reads", "citations"])
# If the results contain an error message something went boink
if "Error" in results:
return results, 500
# otherwise we have real results or an empty dictionary
if results:
return results
else:
return {"Error": "Unable to get results!", "Error Info": "No data available to generate metrics"}, 200
def create_modelCV(x_train, y_train, x_test, y_test, numFolds= 5, numberOfClasses=2, numberOfEpochs = 10, batchSize = 30):
"""
Model providing function:
Create Keras model with SVM as classifier, compile test and generate metrics.
"""
### Cross-validation
skf = StratifiedKFold(n_splits=numFolds, shuffle=True, random_state=1337)
X = x_train
Y = y_train
sensitivitys, specificitys, accuracys, precisions, recalls, F1_scores, aucs = [[],[],[],[],[],[],[]]
#kpbar = tqdm(total=numFolds, desc="Kfold", leave=False)
y = np_utils.to_categorical(Y, 2)
for train_index, test_index in skf.split(X, Y):
base_model = load_model()
# Compile
base_model.compile( loss='binary_crossentropy', optimizer= 'sgd', metrics=['accuracy'] )
# Train
base_model.fit(X[train_index],
y[train_index],
batch_size = batchSize,
epochs = numberOfEpochs,
verbose = 0,
validation_data=(X[test_index], y[test_index]))
# Classify
classesPredictionList = base_model.predict_classes(X[test_index], verbose=0) # 0 or 1
classesProbaPredictionList = base_model.predict_proba(X[test_index]) # probability
sensitivity, specificity, accuracy, precision, recall, F1_score, auc = metrics.generate_metrics(classesPredictionList,classesProbaPredictionList,y[test_index],verbose=False)
sensitivitys.append(sensitivity)
specificitys.append(specificity)
accuracys.append(accuracy)
precisions.append(precision)
recalls.append(recall)
F1_scores.append(F1_score)
aucs.append(auc)
sensitivitys = numpy.array(sensitivitys)
specificitys = numpy.array(specificitys)
accuracys = numpy.array(accuracys)
precisions = numpy.array(precisions)
recalls = numpy.array(recalls)
F1_scores = numpy.array(F1_scores)
aucs = numpy.array(aucs)
print("Mean Accuracy: {:.4f} (+/- {:.4f})".format(accuracys.mean(), accuracys.std()))
print("Mean Sensitivity: {:.4f} (+/- {:.4f})".format(sensitivitys.mean(), sensitivitys.std()))
print("Mean Specificity: {:.4f} (+/- {:.4f})".format(specificitys.mean(), specificitys.std()))
print("Mean F1 Score: {:.4f} (+/- {:.4f})".format(F1_scores.mean(), F1_scores.std()))
print("Mean AUC: {:.4f} (+/- {:.4f})".format(aucs.mean(), aucs.std()))
def get(self, bibcode):
results = generate_metrics(bibcodes=[bibcode],
types=['basic', 'citations', 'histograms'],
histograms=['reads', 'citations'])
# If the results contain an error message something went boink
if "Error" in results:
return results, 500
# otherwise we have real results or an empty dictionary
if results:
return results
else:
return {'Error': 'Unable to get results!',
'Error Info': 'No data available to generate metrics'}, 200
def get(self, bibcode):
results = generate_metrics(bibcodes=[bibcode],
types=['basic', 'histograms'],
histograms=['reads', 'citations'])
# If the results contain an error message something went boink
if "Error" in results:
return results, 500
# otherwise we have real results or an empty dictionary
if results:
return results
else:
return {
'Error': 'Unable to get results!',
'Error Info': 'No data available to generate metrics'
}, 200
def post(self):
bibcodes = []
query = None
try:
include_tori = request.json["tori"]
except:
include_tori = True
# Force that we either have a valid metrics type or all types
try:
types = [t for t in request.json["types"] if t in allowed_types]
except:
types = []
types = types or allowed_types
# Same with histogram type
try:
histograms = request.json["histograms"]
except:
histograms = []
histograms = histograms or allowed_histograms
if "bibcodes" in request.json:
bibcodes = map(str, request.json["bibcodes"])
if len(bibcodes) > current_app.config.get("METRICS_MAX_SUBMITTED"):
return (
{
"Error": "Unable to get results!",
"Error Info": "No results: number of submitted \
bibcodes exceeds maximum number",
},
200,
)
elif len(bibcodes) == 0:
return {"Error": "Unable to get results!", "Error Info": "No bibcodes found in POST body"}, 200
elif "query" in request.json:
query = request.json["query"]
else:
return {"Error": "Unable to get results!", "Error Info": "Nothing to calculate metrics!"}, 200
results = generate_metrics(
bibcodes=bibcodes, query=query, tori=include_tori, types=types, histograms=histograms
)
# If the results contain an error message something went boink
if "Error" in results:
return results, 500
# otherwise we have real results or an empty dictionary
if results:
return results
else:
return {"Error": "Unable to get results!", "Error Info": "No data available to generate metrics"}, 200
def main():
args = parser.parse_args()
metrics = generate_metrics(args.sma_samples)
if args.serial_port:
ser = connect(args.serial_port, 1 / args.polling_rate,
args.connect_timeout)
while True:
for metric, func in metrics.items():
data = func()
if data:
message = "%s %s" % (metric, " ".join(map(repr, func())))
if args.serial_port:
try:
send(message, ser)
except Exception as e:
print(e, file=sys.stderr)
ser.close()
ser = connect(args.serial_port, 1 / args.polling_rate,
args.connect_timeout)
else:
print(message)
time.sleep(1 / args.polling_rate)
monitoring.update()
def post(self):
bibcodes = []
query = None
stime = time.time()
try:
include_tori = request.json['tori']
except:
include_tori = True
# Force that we either have a valid metrics type or all types
try:
types = [t for t in request.json['types'] if t in allowed_types]
except:
types = []
types = types or allowed_types
# If "simple" metrics are requested, more records are allowed
if len(types) == 1 and types[0] == 'simple':
max_records = current_app.config.get('METRICS_MAX_SIMPLE')
types = ['basic', 'citations', 'indicators', 'histograms']
include_tori = False
else:
max_records = current_app.config.get('METRICS_MAX_SUBMITTED')
# Same with histogram type
try:
histograms = request.json['histograms']
except:
histograms = []
histograms = histograms or allowed_histograms
if 'bibcodes' in request.json:
if 'query' in request.json and request.json['query']:
current_app.logger.warning('Metrics requested, but both bibcodes and query specified!')
return {'Error': 'Unable to get results!',
'Error Info': 'Cannot send both bibcodes and query'}, 403
bibcodes = map(str, request.json['bibcodes'])
current_app.logger.info('Metrics requested for %s bibcodes'%len(bibcodes))
if len(bibcodes) > max_records:
current_app.logger.warning('Metrics requested for %s bibcodes. Maximum is: %s!'%(len(bibcodes), max_records))
return {'Error': 'Unable to get results!',
'Error Info': 'No results: number of submitted \
bibcodes exceeds maximum number'}, 403
elif len(bibcodes) == 0:
current_app.logger.warning('Metrics requested, but no bibcodes supplied!')
return {'Error': 'Unable to get results!',
'Error Info': 'No bibcodes found in POST body'}, 403
elif len(bibcodes) == 1:
current_app.logger.debug('Metrics requested for single record')
if len(types) > 0:
types = [t for t in types if t in ['basic', 'citations', 'histograms']]
if len(types) == 0:
types=['basic', 'citations', 'histograms']
if len(histograms) > 0:
histograms = [h for h in histograms if h in ['reads', 'citations']]
if len(histograms) == 0:
histograms=['reads', 'citations']
elif 'query' in request.json:
query = request.json['query']
current_app.logger.info('Metrics requested for query: %s'%query)
else:
return {'Error': 'Unable to get results!',
'Error Info': 'Nothing to calculate metrics!'}, 403
results = generate_metrics(
bibcodes=bibcodes, query=query, tori=include_tori,
types=types, histograms=histograms)
# If the results contain an error message something went boink
if "Error" in results:
current_app.logger.error('Metrics request request blew up')
return results, 500
# otherwise we have real results or an empty dictionary
if results:
duration = time.time() - stime
current_app.logger.info('Metrics request successfully completed in %s real seconds'%duration)
return results
else:
current_app.logger.info('Metrics request returned empty result')
return {'Error': 'Unable to get results!',
'Error Info': 'No data available to generate metrics'}, 200
actual = []
print("Fetching metric data... ")
for pred in predictionList:
if pred == 'DNA':
prediction.append(bin(0))
elif pred == 'RNA':
prediction.append(bin(1))
elif pred == 'DRNA':
prediction.append(bin(2))
else:
prediction.append(bin(3))
for true in trueList:
if true == 'DNA':
actual.append(bin(0))
elif true == 'RNA':
actual.append(bin(1))
elif true == 'DRNA':
actual.append(bin(2))
else:
actual.append(bin(3))
metricList = m.generate_metrics(prediction, actual)
print("Printing...")
for m in metricList:
print(m)
print("Done.")
def create_modelCV(x_train,
y_train,
x_test,
y_test,
numFolds=5,
numberOfClasses=2,
MLP1=100,
MLP2=200,
numberOfEpochs=20,
batchSize=30):
"""
Model providing function:
Create Keras model with SVM as classifier, compile test and generate metrics.
"""
### Cross-validation
skf = StratifiedKFold(n_splits=numFolds, shuffle=True, random_state=1337)
X = x_train
Y = y_train
sensitivitys, specificitys, accuracys, precisions, recalls, F1_scores, aucs = [
[], [], [], [], [], [], []
]
#kpbar = tqdm(total=numFolds, desc="Kfold", leave=False)
y = np_utils.to_categorical(Y, 2)
Y = numpy.array(Y)
for train_index, test_index in skf.split(X, Y):
################ define MLP #################
# create my MLP
top_model = Sequential()
top_model.add(
Flatten(input_shape=(8, 8, 50))
) # shape of last layer or my_model. Couldn´t get it automatically properly using my_model.output_shape
top_model.add(Dense(MLP1))
top_model.add(Activation(
'relu',
name='act_1')) # set name, otherwise duplicate names appear
top_model.add(Dropout(0.5))
top_model.add(Dense(MLP2))
top_model.add(Activation('relu', name='act_2'))
top_model.add(Dense(numberOfClasses))
top_model.add(Activation('softmax', name='softmax'))
# Compile
top_model.compile(loss='binary_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
# Train
top_model.fit(X[train_index],
y[train_index],
batch_size=batchSize,
epochs=numberOfEpochs,
verbose=0,
validation_data=(X[test_index], y[test_index]))
# Classify
classesPredictionList = top_model.predict_classes(X[test_index],
verbose=0) # 0 or 1
classesProbaPredictionList = top_model.predict_proba(
X[test_index]) # probability
sensitivity, specificity, accuracy, precision, recall, F1_score, auc = metrics.generate_metrics(
classesPredictionList,
classesProbaPredictionList,
y[test_index],
verbose=False)
sensitivitys.append(sensitivity)
specificitys.append(specificity)
accuracys.append(accuracy)
precisions.append(precision)
recalls.append(recall)
F1_scores.append(F1_score)
aucs.append(auc)
sensitivitys = numpy.array(sensitivitys)
specificitys = numpy.array(specificitys)
accuracys = numpy.array(accuracys)
precisions = numpy.array(precisions)
recalls = numpy.array(recalls)
F1_scores = numpy.array(F1_scores)
aucs = numpy.array(aucs)
print("Mean Accuracy: {:.4f} (+/- {:.4f})".format(accuracys.mean(),
accuracys.std()))
print("Mean Sensitivity: {:.4f} (+/- {:.4f})".format(
sensitivitys.mean(), sensitivitys.std()))
print("Mean Specificity: {:.4f} (+/- {:.4f})".format(
specificitys.mean(), specificitys.std()))
print("Mean F1 Score: {:.4f} (+/- {:.4f})".format(F1_scores.mean(),
F1_scores.std()))
print("Mean AUC: {:.4f} (+/- {:.4f})".format(aucs.mean(), aucs.std()))
def create_model(x_train,
y_train,
x_test,
y_test,
numberOfClasses=2,
MLP1=100,
MLP2=200,
numberOfEpochs=20,
batchSize=30,
save=True,
baseName='femlpModel'):
"""
Model providing function:
Create Keras model with MLP as classifier, compile test and generate metrics.
"""
################# define MLP #################
# create my MLP
top_model = Sequential()
top_model.add(
Flatten(input_shape=(8, 8, 50))
) # shape of last layer or my_model. Couldn´t get it automatically properly using my_model.output_shape
top_model.add(Dense(MLP1))
top_model.add(Activation(
'relu', name='act_1')) # set name, otherwise duplicate names appear
top_model.add(Dropout(0.5))
top_model.add(Dense(MLP2))
top_model.add(Activation('relu', name='act_2'))
top_model.add(Dense(numberOfClasses))
top_model.add(Activation('softmax', name='softmax'))
# Compile
top_model.compile(loss='binary_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
# Train
top_model.fit(x_train,
y_train,
batch_size=batchSize,
epochs=numberOfEpochs,
verbose=0,
validation_data=(x_test, y_test))
# Classify
classesPredictionList = top_model.predict_classes(x_test,
verbose=0) # 0 or 1
classesProbaPredictionList = top_model.predict_proba(x_test) # probability
sensitivity, specificity, accuracy, precision, recall, F1_score, auc = metrics.generate_metrics(
classesPredictionList,
classesProbaPredictionList,
y_test,
verbose=False)
# Save Model
if (save):
save_model(top_model, baseName)
print("Accuracy: {:.4f}".format(accuracy))
print("Sensitivity: {:.4f}".format(sensitivity))
print("Specificity: {:.4f}".format(specificity))
print("F1 Score: {:.4f}".format(F1_score))
print("AUC: {:.4f}".format(auc))
def evaluate(fileName):
print('\n ' + fileName)
#Create a directory for the rasterized testing points
subprocess.call('mkdir rasterized', shell=True)
#Make a geodataframe, then create an ID column
points = gpd.read_file('testData/testingPoints.shp')
points = points.to_crs({'init': 'epsg:26916'})
points['Point_ID'] = points.index
#Open the template raster for template information
template = rasterio.open('predictions/' + fileName)
meta = template.meta.copy()
meta['nodata'] = 9999
#Create an individual file for each point
for index, row in points.iterrows():
#Create a new raster for writing.
with rasterio.open('rasterized/' + str(row.Point_ID) + '.tif', 'w',
**meta) as out:
out_arr = out.read(1)
#Transform and rasterize shape data
shapes = ((geom, value)
for geom, value in zip([row.geometry], [row['OM']]))
burned = features.rasterize(shapes=shapes,
fill=0,
out=out_arr,
transform=out.transform)
#Write the data out as a raster
out.write_band(1, burned)
out.close()
#Get the filenames for each individual raster
individuals = os.listdir('rasterized')
#Get the index and value of each individual rasterized point
point_data = {}
for individual in individuals:
#Open the input raster
raster = rasterio.open('rasterized/' + individual)
array = raster.read(1)
#Get the index for the min value (the datapoint)
flat_index = np.argmin(array)
index = np.unravel_index(flat_index, array.shape)
#Write the data to the dictionary
key = os.path.splitext(individual)[0]
point_data[key] = {'index': index, 'value': array[index]}
#Read the prediction file in as an array
raster = rasterio.open('predictions/' + fileName)
prediction = raster.read(1)
#Get the actual and predicted values
value_pairs = []
for point in list(point_data.keys()):
value_pairs.append([
point_data[point]['value'],
prediction[point_data[point]['index'][0],
point_data[point]['index'][1]]
])
#Get performance metrics
scores = metrics.generate_metrics(value_pairs)
print(' R2 Score: ' + str(scores[0]))
print(' RMSE: ' + str(scores[1]))
print(' ME: ' + str(scores[2]))
print(' MAE: ' + str(scores[3]))
#Remove the individual rasters
shutil.rmtree('rasterized/')
def validate(point_data, topo, buffers):
#Run the function for each filename
#############################################################
points = list(point_data.keys())
value_pairs = list()
iteration = 0
length = len(points)
for test_point in points:
#Take the validation point out of the training set
#############################################################
training_points = points.copy()
training_points.remove(test_point)
training_buffers = training_points
#Assemble the training set
#############################################################
training_set = list()
for training_point in training_points:
obs = list()
for feature in topo:
obs.append(feature[point_data[training_point]['index']])
for buffer_feature in training_buffers:
obs.append(buffers[buffer_feature][point_data[training_point]
['index']])
obs.append(point_data[training_point]['value'])
training_set.append(obs)
#Assemble the test set
#############################################################
testing_set = list()
obs = list()
for feature in topo:
obs.append(feature[point_data[test_point]['index']])
for buffer_feature in training_buffers:
obs.append(
buffers[buffer_feature][point_data[test_point]['index']])
testing_set.append(obs)
#Generate Prediction
#############################################################
prediction = train_predict(training_set, testing_set)
value_pairs.append([point_data[test_point]['value'], prediction[0]])
#Log Progress
#############################################################
iteration += 1
#print(str(int(iteration/length*90)+5)+'%')
scores = metrics.generate_metrics(value_pairs)
print(' R2 Score: ' + str(scores[0]))
print(' RMSE: ' + str(scores[1]))
print(' ME: ' + str(scores[2]))
print(' MAE: ' + str(scores[3]))
return {
'R2': scores[0],
'RMSE': scores[1],
'ME': scores[2],
'MAE': scores[3]
}
