def reusing_code_random_forest_on_iris() -> Dict:
"""
Again I will run a regression on the iris dataset, but reusing
the existing code from assignment1. I am also including the species column as a one_hot_encoded
value for the prediction. Use this to check how different the results are (score and
predictions).
"""
df = read_dataset(Path('..', '..', 'iris.csv'))
for c in list(df.columns):
df = fix_outliers(df, c)
df = fix_nans(df, c)
df[c] = normalize_column(df[c])
ohe = generate_one_hot_encoder(df['species'])
df = replace_with_one_hot_encoder(df, 'species', ohe,
list(ohe.get_feature_names()))
'''
!!!My Results!!!
When comparing the two regression functions together, it seems that the raw data will typically have a higher
accuracy compared to the processed data, but they are essentially the same.
I believe this is due to the same reasons I mentioned in the classification file, the data is essentially the same,
the only preprocessing which was done fixed the outliers and removed the missing values in the dataset, but this
dataset does not actually have too many outliers or nans, thus we are left with a very similar dataset.
The normalization and one hot encoding changes in the dataset in a way that processing it with a model may be more
efficient, but it will not actually change the meaning of the data!
So, although the datasets are essentially the same, I would still choose to use the preprocessed data, as the
normalization and one hot encoding may make the model process the data more efficiently compared to just the
raw data.
'''
X, y = df.iloc[:, 1:], df.iloc[:, 0]
model = simple_random_forest_regressor(X, y)
print(model)
return model
def reusing_code_random_forest_on_iris() -> Dict:
"""
Again I will run a regression on the iris dataset, but reusing
the existing code from assignment1. I am also including the species column as a one_hot_encoded
value for the prediction. Use this to check how different the results are (score and
predictions).
"""
df = read_dataset(Path('..', '..', 'iris.csv'))
for c in list(df.columns):
df = fix_outliers(df, c)
df = fix_nans(df, c)
df[c] = normalize_column(df[c])
ohe = generate_one_hot_encoder(df['species'])
df = replace_with_one_hot_encoder(df, 'species', ohe, list(ohe.get_feature_names()))
X, y = df.iloc[:, 1:], df.iloc[:, 0]
return simple_random_forest_regressor(X, y)
def reusing_code_random_forest_on_iris() -> Dict:
"""
Again I will run a classification on the iris dataset, but reusing
the existing code from assignment1. Use this to check how different the results are (score and
predictions).
"""
df = read_dataset(Path('..', '..', 'iris.csv'))
for c in list(df.columns):
# Notice that I am now passing though all columns.
# If your code does not handle normalizing categorical columns, do so now (just return the unchanged column)
df = fix_outliers(df, c)
df = fix_nans(df, c)
df[c] = normalize_column(df[c])
X, y = df.iloc[:, :4], df.iloc[:, 4]
le = generate_label_encoder(y)
# Be careful to return a copy of the input with the changes, instead of changing inplace the inputs here!
y_encoded = replace_with_label_encoder(y.toframe(),
column='species',
le=le)
return simple_random_forest_classifier(X, y_encoded['species'])
def iris_clusters() -> Dict:
"""
Let's use the iris dataset and clusterise it:
"""
df = pd.read_csv(Path('..', '..', 'iris.csv'))
for c in list(df.columns):
df = fix_outliers(df, c)
df = fix_nans(df, c)
df[c] = normalize_column(df[c])
# Let's generate the clusters considering only the numeric columns first
no_species_column = simple_k_means(df.iloc[:, :4])
ohe = generate_one_hot_encoder(df['species'])
df_ohe = replace_with_one_hot_encoder(df, 'species', ohe,
list(ohe.get_feature_names()))
# Notice that here I have binary columns, but I am using euclidean distance to do the clustering AND score evaluation
# This is pretty bad
no_binary_distance_clusters = simple_k_means(df_ohe)
# Finally, lets use just a label encoder for the species.
# It is still bad to change the labels to numbers directly because the distances between them does not make sense
le = generate_label_encoder(df['species'])
df_le = replace_with_label_encoder(df, 'species', le)
labeled_encoded_clusters = simple_k_means(df_le)
# See the result for yourself:
print(no_species_column['score'], no_binary_distance_clusters['score'],
labeled_encoded_clusters['score'])
ret = no_species_column
if no_binary_distance_clusters['score'] > ret['score']:
print('no binary distance')
ret = no_binary_distance_clusters
if labeled_encoded_clusters['score'] > ret['score']:
print('labeled encoded')
ret = labeled_encoded_clusters
return ret