def test_temperature_list_input(self):
"""
The test checks if the prediction returns an error when the value is passed as a list of multiple values
"""
with pytest.raises(TypeError):
predict({
"date": dt.datetime(2012, 1, 1, 0, 0, 0),
"weathersit": 4,
"temperature_C": [9.84, 9.0],
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
})
def test_month_greater_than_12(self):
"""
The test checks if month value entered greater than 12 returns ValueError
"""
with pytest.raises(ValueError):
predict({
"date": dt.datetime(2012, 25, 1, 0, 0, 0),
"weathersit": 1,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
})
def test_weathersit_5(self):
"""
"weathersit" has values between 1 and 4. The test checks if the prediction returns a valueError if the input for the weathersit is outside of the range
"""
with pytest.raises(ValueError):
predict({
"date": dt.datetime(2012, 1, 1, 0, 0, 0),
"weathersit": 5,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
})
def get_predict():
df = read_data()
weather_avg = df["weathersit"].mean()
temp_avg = df["temp"].mean()
feeling_avg = df["atemp"].mean()
humidity_avg = df["hum"].mean()
windspeed_avg = df["windspeed"].mean()
parameters = dict(request.args)
parameters["date"] = dt.datetime.fromisoformat(
parameters.get("date", "2011-01-01"))
parameters["weathersit"] = int(parameters.get("weathersit", weather_avg))
parameters["temperature_C"] = float(
parameters.get("temperature_C", temp_avg))
parameters["feeling_temperature_C"] = float(
parameters.get("feeling_temperature_C", feeling_avg))
parameters["humidity"] = float(parameters.get("humidity", humidity_avg))
parameters["windspeed"] = float(parameters.get("windspeed", windspeed_avg))
start_prediction = dt.datetime.now()
result = predict(parameters, model=parameters.get("model"))
end_prediction_time = dt.datetime.now() - start_prediction
return {
"result": result,
"date": parameters["date"],
"computation time/seconds": end_prediction_time.total_seconds(),
}
def get_predict():
hour_train = read_data(hour_path)
hour_train = preprocess(hour_train)
hour_train = dummify(hour_train)
hour_train = postprocess(hour_train)
m_weathersit = hour_train["weathersit"].mean
m_temperature_C = hour_train["temperature_C"].mean
m_feeling_temperature_C = hour_train["feeling_temperature_C"].mean
m_humidity = hour_train["humidity"].mean
m_windspeed = hour_train["windspeed"].mean
inicial_time = dt.datetime.now()
parameters = dict(request.args)
parameters["date"] = dt.datetime.fromisoformat(parameters["date"])
parameters["weathersit"] = int(parameters.get("weathersit", m_weathersit))
parameters["temperature_C"] = float(
parameters.get("temperature_C", m_temperature_C)
)
parameters["feeling_temperature_C"] = float(
parameters.get("feeling_temperature_C", m_feeling_temperature_C)
)
parameters["humidity"] = float(parameters.get("humidity", m_humidity))
parameters["windspeed"] = float(parameters.get("windspeed", m_windspeed))
model = parameters.get("model", "xgboost")
result = predict(parameters, model=model)
total_time = dt.datetime.now() - inicial_time
return {"result": result, "time": total_time}
def get_predict():
parameters = dict(request.args)
hour_original = read_data()
if "date" not in parameters:
parameters["date"] = "2012-01-01T18:00:00"
if "weathersit" not in parameters:
parameters["weathersit"] = hour_original["weathersit"].median()
if "temperature_C" not in parameters:
parameters["temperature_C"] = 41.0 * hour_original["temp"].mean()
if "feeling_temperature_C" not in parameters:
parameters["feeling_temperature_C"] = 50.0 * hour_original["atemp"].mean()
if "humidity" not in parameters:
parameters["humidity"] = 100.0 * hour_original["hum"].mean()
if "windspeed" not in parameters:
parameters["windspeed"] = 67.0 * hour_original["windspeed"].mean()
parameters["date"] = dt.datetime.fromisoformat(parameters["date"])
parameters["weathersit"] = int(parameters["weathersit"])
parameters["temperature_C"] = float(parameters["temperature_C"])
parameters["feeling_temperature_C"] = float(parameters["feeling_temperature_C"])
parameters["humidity"] = float(parameters["humidity"])
parameters["windspeed"] = float(parameters["windspeed"])
if "model" in parameters:
model = str(parameters["model"])
del parameters["model"]
else:
model = "xgboost"
result = predict(parameters, model=model)
return {"result": result}
def get_predict():
parameters = dict(request.args)
parameters["date"] = dt.datetime.fromisoformat(parameters["date"])
parameters["weathersit"] = int(parameters["weathersit"])
parameters["temperature_C"] = float(parameters["temperature_C"])
parameters["feeling_temperature_C"] = float(
parameters["feeling_temperature_C"])
parameters["humidity"] = float(parameters["humidity"])
parameters["windspeed"] = float(parameters["windspeed"])
result = predict(parameters, model=parameters.get("model", "xgboost"))
return {"result": result}
def test_date_2013(self):
"""
The test checks if the prediction for year 2013 returns valid output
"""
return_value = predict({
"date": dt.datetime(2013, 1, 1, 0, 0, 0),
"weathersit": 1,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
})
assert isinstance(return_value, int)
def test_weathersit_4(self):
"""
"weathersit" has values between 1 and 4. The test checks if the prediction returns a valid output for the edge case
"""
return_value = predict({
"date": dt.datetime(2012, 1, 1, 0, 0, 0),
"weathersit": 4,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
})
assert isinstance(return_value, int)
def test_predict_returns_expected_output():
parameters = {
"date": dt.datetime(2011, 1, 1, 0, 0, 0),
"weathersit": 1,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
}
# int(np.round(xgb.predict(hour_d_test_x.iloc[0:1]) ** 2))
expected_result = 1
result = predict(parameters)
assert result == expected_result
def get_predict():
parameters = dict(request.args)
parameters["date"] = dt.datetime.fromisoformat(parameters["date"])
parameters["weathersit"] = int(parameters["weathersit"])
parameters["temperature_C"] = float(parameters["temperature_C"])
parameters["feeling_temperature_C"] = float(parameters["feeling_temperature_C"])
parameters["humidity"] = float(parameters["humidity"])
parameters["windspeed"] = float(parameters["windspeed"])
parameters["model"] = parameters["model"]
result = predict(parameters, model=parameters["model"])
return {
"Number of bike-users predicted": result,
"model": parameters["model"],
"To check train score follow": "http://127.0.0.1:5000/score?model="
+ parameters["model"],
}
def test_predict_returns_expected_list():
import datetime as dt
dict = {
"date": dt.datetime(2011, 1, 1, 0, 0, 0),
"weathersit": 1,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
}
expected_array = [11]
pred = predict(dict)
print("pred output: ", pred)
print("expected array type", type(expected_array))
print("pred type", type(pred))
assert pred == expected_array
def test_wrong_file_path(self):
"""
The test checks if the model does not exists in the given file path,
then the function still returns a prediction.
"""
return_value = predict(
{
"date": dt.datetime(2012, 1, 1, 0, 0, 0),
"weathersit": 1,
"temperature_C": 9.84,
"feeling_temperature_C": 14.395,
"humidity": 81.0,
"windspeed": 0.0,
},
model_path="/",
)
assert isinstance(return_value, int)
def predict_function():
"""predicting outcome based on URL parameters"""
args = dict(request.args)
parameters = {
"date": dt.datetime.strptime(args.get("date"), "%Y-%m-%dT%H:%M:%S"),
"weathersit": int(args.get("weathersit")),
"temperature_C": float(args.get("temperature_C")),
"feeling_temperature_C": float(args.get("feeling_temperature_C")),
"humidity": float(args.get("humidity")),
"windspeed": float(args.get("windspeed")),
}
start = timeit.timeit()
prediction = predict(parameters)
time = timeit.timeit() - start
if parameters := parameters:
return {
"result": prediction,
"elapsed_time": time,
"parameters": parameters,
}
def get_predict():
# Input means
df = read_data()
weather_avg = df['weathersit'].mean()
temp_avg = df['temp'].mean()
feeling_avg = df['atemp'].mean()
humidity_avg = df["hum"].mean()
windspeed_avg = df["windspeed"].mean()
parameters = dict(request.args)
parameters["date"] = dt.datetime.fromisoformat(parameters["date"])
parameters["weathersit"] = int(parameters.get("weathersit", weather_avg))
parameters["temperature_C"] = float(
parameters.get("temperature_C", temp_avg))
parameters["feeling_temperature_C"] = float(
parameters.get("feeling_temperature_C", feeling_avg))
parameters["humidity"] = float(parameters.get("humidity", humidity_avg))
parameters["windspeed"] = float(parameters.get("windspeed", windspeed_avg))
#parameters["weathersit"] = int(parameters["weathersit"])
#parameters["date"] = dt.datetime.fromisoformat(parameters["date"])
#parameters["temperature_C"] = float(parameters["temperature_C"])
#parameters["feeling_temperature_C"] = float(parameters["feeling_temperature_C"])
#parameters["humidity"] = float(parameters["humidity"])
#parameters["windspeed"] = float(parameters["windspeed"])
model = str(parameters["model"])
start_prediction = dt.datetime.now()
result = predict(parameters, model=model)
#parameters.get('model'))
end_prediction = dt.datetime.now() - start_prediction
return {
"result": result,
"computation time": end_prediction.total_seconds()
}
def get_predict():
hour_original = read_data()
parameters = dict()
# I decided not to impute parameters["date"] in case it's not given, because it doesn't make any sense that a user would try to predict
# cnt on a random date, it makes more sense that he doesn't know other parameters of that date but he should know the date
parameters["date"] = dt.datetime.fromisoformat(request.args.get("date"))
parameters["weathersit"] = (1 if request.args.get("weathersit") is None
else int(request.args.get("weathersit"))
) # 1 is the most frequent value
parameters["temperature_C"] = (np.mean(hour_original["temp"])
if request.args.get("temperature_C") is None
else float(
request.args.get("temperature_C")))
parameters["feeling_temperature_C"] = (
np.mean(hour_original["atemp"])
if request.args.get("feeling_temperature_C") is None else float(
request.args.get("feeling_temperature_C")))
parameters["humidity"] = (np.mean(hour_original["hum"]) if
request.args.get("humidity") is None else float(
request.args.get("humidity")))
parameters["windspeed"] = (np.mean(hour_original["windspeed"])
if request.args.get("windspeed") is None else
float(request.args.get("windspeed")))
model = str(request.args.get("model", "xgboost"))
result = predict(parameters, model_name=model)
# Return RMSE
hour_test = read_data().iloc[15212:17379]
hour_test_y = hour_test["cnt"]
RMSE = np.sqrt(np.mean((hour_test_y * 2 - result * 2)**2))
return {
"Model": model,
"Number of bikes": result,
"Test RMSE": RMSE.round(3)
}
def get_predict():
tomorrow = dt.datetime.now() + dt.timedelta(days=1)
hour_original = read_data()
hour_original = hour_original[hour_original.mnth == tomorrow.month]
weathersit_avg = hour_original["weathersit"].median()
temperature_C_avg = hour_original.temp.mean() * 41.0
feeling_temperature_C_avg = hour_original.atemp.mean() * 50.0
humiditiy_avg = hour_original.hum.mean() * 100.0
windspeed_avg = hour_original.windspeed.mean() * 67.0
parameters = dict(request.args)
parameters["date"] = dt.datetime.fromisoformat(
parameters.get("date", tomorrow.isoformat()))
parameters["weathersit"] = int(parameters.get("weathersit",
weathersit_avg))
parameters["temperature_C"] = float(
parameters.get("temperature_C", temperature_C_avg))
parameters["feeling_temperature_C"] = float(
parameters.get("feeling_temperature_C", feeling_temperature_C_avg))
parameters["humidity"] = float(parameters.get("humidity", humiditiy_avg))
parameters["windspeed"] = float(parameters.get("windspeed", windspeed_avg))
start = dt.datetime.now()
result = predict(parameters, model=parameters.get("model", "xgboost"))
prediction_time = dt.datetime.now() - start
return {
"result": result,
"prediction time (seconds)": prediction_time.total_seconds(),
"date": parameters["date"],
}
def predict():
mydict = dict()
"""
check if passing parameters are wrong; if yes return error 400
"""
try:
if request.args.get("date") is not None:
mydict["date"] = dt.datetime.fromisoformat(
request.args.get("date"))
else:
mydict["date"] = dt.datetime(2011, 1, 1, 0, 0, 0)
except ValueError:
abort(400, "date parameter is not valid date format!")
try:
if request.args.get("weathersit") is not None:
mydict["weathersit"] = int(request.args.get("weathersit"))
else:
mydict["weathersit"] = 1
except ValueError:
abort(400, "weathersit parameter is not integer !")
try:
if request.args.get("temperature_C") is not None:
mydict["temperature_C"] = float(request.args.get("temperature_C"))
else:
mydict["temperature_C"] = 9.84
except ValueError:
abort(400, "temperature_C parameter is not float !")
try:
if request.args.get("feeling_temperature_C") is not None:
mydict["feeling_temperature_C"] = float(
request.args.get("feeling_temperature_C"))
else:
mydict["feeling_temperature_C"] = 14.395
except ValueError:
abort(400, "feeling_temperature_C parameter is not float !")
try:
if request.args.get("humidity") is not None:
mydict["humidity"] = float(request.args.get("humidity"))
else:
mydict["humidity"] = 81.0
except ValueError:
abort(400, "humidity parameter is not float !")
try:
if request.args.get("windspeed") is not None:
mydict["windspeed"] = float(request.args.get("windspeed"))
else:
mydict["windspeed"] = 0.0
except ValueError:
abort(400, "windspeed parameter is not float !")
start_time = time.time()
result = bike_model.predict(mydict)
elapsed_time_secs = time.time() - start_time
return {
"result": result,
"elapsed_time": round(elapsed_time_secs, 3),
}
def test_predict(dct, result_instance):
assert isinstance(
model.predict(dct),
result_instance), "Returned object is not {}".format(result_instance)
def test_predict_type():
output = type(predict(loading_data()))
expected_output = str
assert output == expected_output
def test_predict_output_len():
output = len(predict(loading_data()))
expected_output = 21
assert output == expected_output
