def get_columns_form():
try:
class_name = request.args.get("className")
if class_name == "DatasetSurveyBalance":
r = API.get_class(class_name)
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data_create_model = pd.DataFrame(r_json["results"])
index_columns = data_create_model.columns[3:]
list_index = list(index_columns)
array_index_json = json.dumps(list_index)
return array_index_json
elif class_name == "DatasetObesity":
r = API.get_class(class_name)
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data_create_model = pd.DataFrame(r_json["results"])
index_columns = data_create_model.columns[3:]
list_index = list(index_columns)
array_index_json = json.dumps(list_index)
return array_index_json
except:
print("[Error] (getColumnsFrom function app.py)")
return "[Error] BAD REQUEST can't det columns form"
def get_system_model():
try:
r_mx = API.get_class("SystemModelMx")
arr_mx = str(r_mx.data, "utf-8")
r_json_mx = json.loads(arr_mx)
model_mx_id = r_json_mx['results'][len(r_json_mx)]['objectId']
r_vn = API.get_class("SystemModelVn")
arr_vn = str(r_vn.data, "utf-8")
r_json_vn = json.loads(arr_vn)
model_vn_id = r_json_vn['results'][len(r_json_vn)]['objectId']
model_system = {"modelVn": model_vn_id, "modelMx": model_mx_id}
return model_system
except:
print("[error] (createModel function app.py)")
data = {"error": "can't create model"}
return data
def get_params():
try:
className = request.args.get("className")
r = API.get_class(className)
return r
except:
print("[Error] (getParams function app.py)")
return "[Error] BAD REQUEST can't get params"
def get_algorithm():
try:
class_name = request.args.get("className")
r = API.get_class(class_name)
return r.data
except:
print("[Error] (getAlgorithm function app.py)")
return "[Error] BAD REQUEST can't get algorithm"
def get_datasets():
try:
class_name = request.args.get("className")
# class_name = "Dataset"
r = API.get_class(class_name)
return r.data
except:
print("[Error] (getDataModels function app.py)")
return "[Error] BAD REQUEST can't get datamodel"
def load_model():
try:
model_id = request.args.get("modelId")
classModel = request.args.get("classModel")
if (classModel == "SystemModelVn"):
r = API.get_class("DatasetSurveyBalance")
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data = r_json["results"]
dataFrame = pd.DataFrame(data)
dataFrame = dataFrame.iloc[:, 3:]
dataFrame.drop('obesity', inplace=True, axis=1)
new_record = request.args.get("record")
new_record = new_record.split(",")
df_new_record = pd.DataFrame([new_record])
df_new_record.columns = dataFrame.columns
for i in range(len(df_new_record)):
for feature in list(df_new_record.columns):
if df_new_record[feature][i] == "":
df_new_record[feature][i] = list(
dataFrame[feature].value_counts().index)[list(
dataFrame[feature].value_counts()).index(
min(dataFrame[feature].value_counts()))]
if model_id == None:
return "[error] modelId not found check (keys) modelId and values"
else:
r = API.get_model(classModel, model_id)
modelUrl = r["modelFile"]["url"]
Nu_SVC_classifier = joblib.load(urlopen(modelUrl))
data_transform = {
"0": "Thiếu cân (Insufficient weight)",
"1": "Bình thường (Normal weight)",
"2": "Thừa cân loại 1 (Overweight level 1)",
"3": "Thừa cân loại 2 (Overweight level 2)",
"4": "Béo phì loại 1 (Obesity type I)",
"5": "Béo phì loại 2 (Obesity type II)",
"6": "Béo phì loại 3 (Obesity type III)",
}
KQ = np.array(Nu_SVC_classifier.predict(df_new_record))
dataReturn = {
"dataPredict": [],
}
for rs in KQ:
dataReturn["dataPredict"].append(data_transform[str(rs)])
return dataReturn
except:
print("[error] check key (inputColumns) and value")
return "[error] check key (inputColumns) and value (check type inputColumns)"
pass
def get_data_charts():
try:
class_name = request.args.get("className")
r = API.get_class(class_name)
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data = r_json["results"]
df = pd.DataFrame(data)
data_mealOfTheDay = DATA.get_data_chart(df, "mealOfTheDay")
data_breakfastOfTheWeek = DATA.get_data_chart(df, "breakfastOfTheWeek")
data_dinnerOfTheWeek = DATA.get_data_chart(df, "dinnerOfTheWeek")
data_fastfoodOfTheWeek = DATA.get_data_chart(df, "fastFoodOfTheWeek")
data_vegetableInMeal = DATA.get_data_chart(df, "vegetableInMeal")
data_proteinOfMeal = DATA.get_data_chart(df, "proteinOfMeal")
data_waterOfTheDay = DATA.get_data_chart(df, "waterOfTheDay")
data_timeDoExcerciseForWeek = DATA.get_data_chart(
df, "timeDoExcerciseForWeek")
data_sportTimeForWeek = DATA.get_data_chart(df, "sportTimeForWeek")
data_alcohol = DATA.get_data_chart(df, "alcohol")
data_nicotine = DATA.get_data_chart(df, "nicotine")
data_requireOfJob = DATA.get_data_chart(df, "requireOfJob")
data_park = DATA.get_data_chart(df, "park")
data_depression = DATA.get_data_chart(df, "depression")
data_result = {
"chart_meal_of_theday": data_mealOfTheDay,
"chart_breakfast_of_theweek": data_breakfastOfTheWeek,
"chart_dinner_of_theweek": data_dinnerOfTheWeek,
"chart_fastfood_of_theweek": data_fastfoodOfTheWeek,
"chart_vegetable_in_meal": data_vegetableInMeal,
"chart_protein_of_meal": data_proteinOfMeal,
"chart_water_of_the_day": data_waterOfTheDay,
"chart_time_doexcercise_for_week": data_timeDoExcerciseForWeek,
"chart_sporttime_for_week": data_sportTimeForWeek,
"chart_alcohol": data_alcohol,
"chart_nicotine": data_nicotine,
"chart_requireOfJob": data_requireOfJob,
"chart_park": data_park,
"chart_depression": data_depression,
}
# data_result = json.dumps(data_result)
return data_result
except:
print("[Error] (getDataModels function app.py)")
return "[Error] BAD REQUEST can't get datamodel"
def create_model():
try:
# Get opjectId, collabel, feature, algorithm and parameters
data_name = request.args.get("dataName")
class_name = request.args.get("className")
model_name = request.args.get("modelname")
col_label = int(request.args.get("label"))
col_feature_str = (request.args.get("feature")).split(",")
col_feature = []
for col in col_feature_str:
col_feature.append(int(col))
athm = request.args.get("algorithm")
athm_id = request.args.get("algorithmId")
params = json.loads(request.args.get("params"))
# print(params)
if params == {}:
params = None
test_size = 0.3
else:
test_size = float(params["testSize"])
if test_size >= 1.0 or test_size <= 0.0:
data = {"error": "0.0 < test size < 1.0"}
return data
# get data
r = API.get_class(class_name)
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data = r_json["results"]
dataFrame = pd.DataFrame(data)
if class_name == "DatasetSurveyBalance":
dataFrame = dataFrame.iloc[:, 3:]
elif class_name == "DatasetObesity":
dataFrame = dataFrame.iloc[:, 3:]
if "yearOfBirth" in list(dataFrame.columns):
del dataFrame["yearOfBirth"]
# dataFrame = dataFrame.dropna(axis="1",how = "any")
col_feature_name = np.array((dataFrame.iloc[:, col_feature]).columns)
col_feature_name_str = col_feature_name[0]
col_feature_name = list(col_feature_name)
col_feature_name.pop(0)
col_feature_name = np.array(col_feature_name)
for col in col_feature_name:
col_feature_name_str = col_feature_name_str + "," + col
col_label_name = str(
np.array(
pd.DataFrame(np.matrix(dataFrame.columns)).iloc[0, col_label]))
# get data train, test
X_train, X_test, y_train, y_test = DATA.get_data_train(
dataFrame, col_feature, col_label, test_size)
model, evalution, error, params = get_athm(athm, X_train, X_test,
y_train, y_test, params)
if error != "":
data = {"error": error}
return data
else:
# Create random id for file name
folder_model = "./upload_model"
randomId = str(uuid.uuid4())[:8]
file_name_model = (randomId + "_" + str(athm) + "_" +
str(class_name) + str(".pkl"))
pkl_filename = folder_model + "/" + file_name_model
joblib.dump(model, str(file_name_model))
custom_header = {}
custom_header[
"X-Parse-Application-Id"] = API.X_Parse_Application_Id
custom_header["X-Parse-REST-API-Key"] = API.X_Parse_REST_API_Key
custom_header["Content-Type"] = "application/x-binary"
desription = description = (
"Model " + " use " + str(athm) + " algorithm " + ". " +
"Dataset for model is " + str(data_name) +
", columns label is " + str(col_label_name) +
" and columns feature is " + str(col_feature_name))
r_upload = API.upload_model_file(
file_name_model,
model_name,
data_name,
athm_id,
params,
col_label,
col_label_name,
col_feature,
col_feature_name_str,
description,
evalution,
)
return r_upload
except:
print("[error] (createModel function app.py)")
data = {"error": "can't create model"}
return data
def create_model_system_mx():
try:
# Get opjectId, collabel, feature, algorithm and parameters
data_name = 'DatasetMX'
class_name = 'DatasetObesity'
model_name = "MODEL SYSTEM"
col_label = 7
col_feature_str = [
'0', '1', '2', '3', '4', '5', '6', '8', '9', '10', '11', '12',
'13', '14', '15', '16'
]
col_feature = []
for col in col_feature_str:
col_feature.append(int(col))
athm = 'SupportVectorMachine'
athm_id = 'ccn7ofeacm'
params = {
'C': '100000',
'degree': '3',
'gamma': '0.3',
'kernel': 'linear',
'testSize': '0.3'
}
if params == {}:
params = None
test_size = 0.3
else:
test_size = float(params["testSize"])
if test_size >= 1.0 or test_size <= 0.0:
data = {"error": "0.0 < test size < 1.0"}
return data
# get data
r = API.get_class(class_name)
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data = r_json["results"]
dataFrame = pd.DataFrame(data)
if class_name == "DatasetSurveyBalance":
dataFrame = dataFrame.iloc[:, 3:]
elif class_name == "DatasetObesity":
dataFrame = dataFrame.iloc[:, 3:]
if "yearOfBirth" in list(dataFrame.columns):
del dataFrame["yearOfBirth"]
# dataFrame = dataFrame.dropna(axis="1",how = "any")
col_feature_name = np.array((dataFrame.iloc[:, col_feature]).columns)
col_feature_name_str = col_feature_name[0]
col_feature_name = list(col_feature_name)
col_feature_name.pop(0)
col_feature_name = np.array(col_feature_name)
for col in col_feature_name:
col_feature_name_str = col_feature_name_str + "," + col
col_label_name = str(
np.array(
pd.DataFrame(np.matrix(dataFrame.columns)).iloc[0, col_label]))
# get data train, test
X_train, X_test, y_train, y_test = DATA.get_data_train(
dataFrame, col_feature, col_label, test_size)
model, evalution, error, params = get_athm(athm, X_train, X_test,
y_train, y_test, params)
if error != "":
data = {"error": error}
return data
else:
# Create random id for file name
folder_model = "./upload_model"
randomId = str(uuid.uuid4())[:8]
file_name_model = (randomId + "_" + str(athm) + "_" +
str(class_name) + str(".pkl"))
pkl_filename = folder_model + "/" + file_name_model
joblib.dump(model, str(file_name_model))
custom_header = {}
custom_header[
"X-Parse-Application-Id"] = API.X_Parse_Application_Id
custom_header["X-Parse-REST-API-Key"] = API.X_Parse_REST_API_Key
custom_header["Content-Type"] = "application/x-binary"
desription = description = (
"Model " + " use " + str(athm) + " algorithm " + ". " +
"Dataset for model is " + str(data_name) +
", columns label is " + str(col_label_name) +
" and columns feature is " + str(col_feature_name))
r_upload_2 = API.upload_model_file_system_mx(
file_name_model,
model_name,
data_name,
athm_id,
params,
col_label,
col_label_name,
col_feature,
col_feature_name_str,
description,
evalution,
)
return r_upload_2
except:
print("[error] (createModel function app.py)")
data = {"error": "can't create model"}
return data
def get_data_charts_obesity():
try:
class_name = request.args.get("className")
# class_name = "Dataset"
r = API.get_class(class_name)
arr = str(r.data, "utf-8")
r_json = json.loads(arr)
data = r_json["results"]
df = pd.DataFrame(data)
columns = list(df.columns)[4:]
columns.remove("weight")
for i in range(len(df)):
for column in list(columns):
try:
df[column][i] = int(round(df[column][i]))
except:
df[column][i] = str(df[column][i])
data_FAVC = DATA.get_data_chart(df, "FAVC")
data_gender = DATA.get_data_chart(df, "gender")
data_NCP = DATA.get_data_chart(df, "NCP")
data_FHWO = DATA.get_data_chart(df, "FHWO")
data_CAEC = DATA.get_data_chart(df, "CAEC")
data_CH2O = DATA.get_data_chart(df, "CH2O")
data_SMOKE = DATA.get_data_chart(df, "SMOKE")
data_FCVC = DATA.get_data_chart(df, "FCVC")
data_SCC = DATA.get_data_chart(df, "SCC")
data_FAF = DATA.get_data_chart(df, "FAF")
data_TUE = DATA.get_data_chart(df, "TUE")
data_CALC = DATA.get_data_chart(df, "CALC")
data_MTRANS = DATA.get_data_chart(df, "MTRANS")
data_NObeyesdad = DATA.get_data_chart(df, "NObeyesdad")
df1 = df.sort_values(by=["weight"],
ascending=True).reset_index(drop=True)
weight_values = {
"duoi_40": [],
"duoi_50": [],
"duoi_60": [],
"duoi_70": [],
"duoi_80": [],
"duoi_90": [],
"duoi_100": [],
"tren_100": [],
}
for i in range(len(df1)):
if float(df1["weight"][i]) < 40:
weight_values["duoi_40"].append(float(df1["height"][i]))
elif (float(df1["weight"][i]) >= 40) and (float(df1["weight"][i]) <
50):
weight_values["duoi_50"].append(float(df1["height"][i]))
elif (float(df1["weight"][i]) >= 50) and (float(df1["weight"][i]) <
60):
weight_values["duoi_60"].append(float(df1["height"][i]))
elif (float(df1["weight"][i]) >= 60) and (float(df1["weight"][i]) <
70):
weight_values["duoi_70"].append(float(df1["height"][i]))
elif (float(df1["weight"][i]) >= 70) and (float(df1["weight"][i]) <
80):
weight_values["duoi_80"].append(float(df1["height"][i]))
elif (float(df1["weight"][i]) >= 80) and (float(df1["weight"][i]) <
90):
weight_values["duoi_90"].append(float(df1["height"][i]))
elif (float(df1["weight"][i]) >= 90) and (float(df1["weight"][i]) <
100):
weight_values["duoi_100"].append(float(df1["height"][i]))
elif float(df1["weight"][i]) >= 100:
weight_values["tren_100"].append(float(df1["height"][i]))
data_height_weight = [
{
"name": "Ít hơn 40 kg",
"value": DATA.trung_binh(weight_values["duoi_40"]),
},
{
"name": "Từ 40 - 50 kg",
"value": DATA.trung_binh(weight_values["duoi_50"]),
},
{
"name": "Từ 50 - 60 kg",
"value": DATA.trung_binh(weight_values["duoi_60"]),
},
{
"name": "Từ 60 - 70 kg",
"value": DATA.trung_binh(weight_values["duoi_70"]),
},
{
"name": "Từ 70 - 80 kg",
"value": DATA.trung_binh(weight_values["duoi_80"]),
},
{
"name": "Từ 80 - 90 kg",
"value": DATA.trung_binh(weight_values["duoi_90"]),
},
{
"name": "Từ 90 - 100 kg",
"value": DATA.trung_binh(weight_values["duoi_100"]),
},
{
"name": "Trên 100 kg",
"value": DATA.trung_binh(weight_values["tren_100"]),
},
]
data_age = [
{
"name": "Dưới 20 tuổi",
"value": 0
},
{
"name": "Từ 20 - dưới 30 tuổi",
"value": 0
},
{
"name": "Từ 30 - dưới 40 tuổi",
"value": 0
},
{
"name": "Từ 40 - dưới 50 tuổi",
"value": 0
},
{
"name": "Từ 50 - dưới 60 tuổi",
"value": 0
},
{
"name": "Từ 60 trở lên",
"value": 0
},
]
data_result = {
"chart_gender": data_gender,
"chart_FAVC": data_FAVC,
"chart_NCP": data_NCP,
"chart_FHWO": data_FHWO,
"chart_CAEC": data_CAEC,
"chart_CH2O": data_CH2O,
"chart_SMOKE": data_SMOKE,
"chart_FCVC": data_FCVC,
"chart_SCC": data_SCC,
"chart_FAF": data_FAF,
"chart_TUE": data_TUE,
"chart_CALC": data_CALC,
"chart_MTRANS": data_MTRANS,
"chart_age": data_age,
"chart_obesity": data_NObeyesdad,
}
# data_result = json.dumps(data_result)
return data_result
except:
print("[Error] (getDataModels function app.py)")
return "[Error] BAD REQUEST can't get datamodel"