Pre-process – python

The init function doesn’t do anything here but the file starts with imports that you need. imported are pandas, numpy and from sklearn import the StandardScaler

The request function:

class Deployment:
# init function
def request(self, data):
diabetes_data = pd.read_csv(data["data"])
diabetes_data[['Glucose','BloodPressure','SkinThickness','Insulin','BMI']] = diabetes_data[['Glucose','BloodPressure','SkinThickness','Insulin','BMI']].replace(0,np.NaN)
diabetes_data['Glucose'].fillna(diabetes_data['Glucose'].mean(), inplace = True)
diabetes_data['BloodPressure'].fillna(diabetes_data['BloodPressure'].mean(), inplace = True)
diabetes_data['SkinThickness'].fillna(diabetes_data['SkinThickness'].median(), inplace = True)
diabetes_data['Insulin'].fillna(diabetes_data['Insulin'].median(), inplace = True)
diabetes_data['BMI'].fillna(diabetes_data['BMI'].median(), inplace = True)
if data["training"] == True:
X = diabetes_data.drop(["Outcome"], axis = 1)
y = diabetes_data.Outcome
else:
X = diabetes_data
y = pd.DataFrame([1])
sc_X = StandardScaler()
X = pd.DataFrame(sc_X.fit_transform(X,),
columns=['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin',
'BMI', 'DiabetesPedigreeFunction', 'Age'])
X.to_csv('X.csv', index = False)
y.to_csv('y.csv', index = False, header = False)
return {
"cleaned_data": 'X.csv', "target_data": 'y.csv'
}

Pre-process – r

I could have done the same thing as within python, setting the library() calls at the top of the file. But in this case I set them up in the init(). I load {readr} and {recipes} {readr} adds some dependencies, but I feel they largely overlap with {recipes} and so it’s a nice addition because it is faster and more consistent then standard read.csv().

request <- function(input_data, base_directory, context) {
diabetes_data <- read_csv(input_data[['data']])
diabetes_recipe <-
recipe(diabetes_data, Outcome~.) %>%
step_mutate(
Glucose = ifelse(Glucose ==0 , NA_real_, Glucose),
BloodPressure = ifelse(BloodPressure ==0 , NA_real_, BloodPressure),
SkinThickness = ifelse(SkinThickness ==0 , NA_real_, SkinThickness),
Insulin = ifelse(Insulin ==0 , NA_real_, Insulin),
BMI = ifelse(BMI ==0 , NA_real_, BMI)
) %>%
step_impute_mean(Glucose, BloodPressure) %>%
step_impute_median(SkinThickness, Insulin, BMI) %>%
step_normalize(all_predictors()) %>%
prep()
diabetes_preprocessed <-
diabetes_recipe %>%
bake(diabetes_data)
if(input_data[["training"]]){
Y <- diabetes_preprocessed %>% select(Outcome)
X <- diabetes_preprocessed %>% select(-Outcome)
}else{
X <- diabetes_data
Y <- tibble(1)
}
write_csv(X, file = 'x.csv')
write_csv(Y, file = "y.csv", col_names = FALSE)
list(
"cleaned_data"= 'x.csv',
"target_data"= 'y.csv'
)
}

Pre-process differences and similarities

I chose to move the selection based on ‘training’==TRUE to the end and so when you call training==FALSE in the python version, the Outcome column is also standardized while in the R version it will never be standardized. In the R version I first only create the recipe and run it in the next step, you could chain the bake() step directly to the previous steps, so it behaves like the fit_transform() method from sklearn.

train knn model python

The python version initializes with pandas, numpy, and imports train_test_split, KNeighborsClassifier and classification_report.

class Deployment:
# init function
def request(self, data):
X = pd.read_csv(data["cleaned_data"])
y = pd.read_csv(data["target_data"], header = None)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.4,random_state=42, stratify=y)
knn = KNeighborsClassifier(n_neighbors=7)
knn.fit(X_train,y_train)
score = knn.score(X_test,y_test)
y_pred = knn.predict(X_test)
print(classification_report(y_test,y_pred))
with open('knn.joblib', 'wb') as f:
dump(knn, 'knn.joblib')
return {
"trained_model": 'knn.joblib', "model_score": score
}

train knn model R

library calls: {readr},{kknn},{magrittr},{rsample},{parsnip},{yardstick}

request <- function(input_data, base_directory, context){
X <- read_csv(input_data[["cleaned_data"]])
y <- read_csv(input_data[["target_data"]],col_names = "Outcome")
input_dataset <- X %>%
dplyr::bind_cols(y)
input_dataset$Outcome <- as.factor(input_dataset$Outcome)
set.seed(42)
split_object <- initial_split(input_dataset, prop = 0.6,strata = Outcome)
library("kknn") # bug? it works without this call on my machine, but not on ubiops.
modelspec <-
nearest_neighbor(mode = "classification",neighbors = 7) %>%
set_engine("kknn")
trained_model <- modelspec %>% fit(Outcome~., data=training(split_object))
test_results <-
testing(split_object) %>%
dplyr::bind_cols(
trained_model %>% predict(testing(split_object))
)
acc <- test_results %>% accuracy(truth=Outcome, estimate = .pred_class) %>% dplyr::pull(.estimate)
classification_report <- metric_set(precision, recall, f_meas)
class_results <-
test_results %>%
classification_report(truth=Outcome, estimate = .pred_class)
print(glue::glue_data(class_results,"{.metric}: {round(.estimate,4)}"))
modelname <- 'knnmodel.RDS'
write_rds(trained_model, modelname)
list(trained_model = modelname, model_score=acc)
}

Training differences and similarities

In R I don’t need to supply the seed to the split function because it picks up the generic set.seed. There is not a classification_report function in the packages I use, but looking at the sklearn documentation this classification_report contains the precision, recall and f1-measure. So I used the metric_set function from yardstick to create a similar thing.

predict python

The init function loads the model from disk.

class Deployment:
# init function
def request(self, data):
input_data = pd.read_csv(data['data'])
prediction = self.model.predict(input_data)
diabetes_instances = sum(prediction)
pd.DataFrame(prediction).to_csv('prediction.csv', header = ['diabetes_prediction'], index_label= 'index')
return {
"prediction": 'prediction.csv', "predicted_diabetes_instances": diabetes_instances
}

predict R

The init function loads the model from disk.

request <- function(input_data, base_directory, context){
input_data = read_csv(input_data[['data']])
predictions <-
model %>%
predict(input_data)
diabetes_instances = sum(predictions$.pred_class == 1)
predictions %>%
mutate(index=row_number()) %>%
select(index, diabetes_prediction = .pred_class) %>%
write_csv(file="prediction.csv")
list(prediction="prediction.csv",predicted_diabetes_instances=diabetes_instances)
}

predict differences and similarities

The index doesn’t make sense to me, but i added it anyways.

references

• image by Alex Loup from unsplash