You can deploy this model and start earning money today!

Rogudev/
whiskey_classificator_model

Name: whiskey_classificator_model
Availability: InStock

mit

Views

No views yet

Whiskey classifier model

Model overview

This model is a SVM model with Linear Kernel which has the objective of predict the appropriate category based on various features. There are 5 different categories:

Basic
Standard
Premium
Exclusive
Luxury

How is the dataset created?

The dataset is being created using a function which these lists and dictionaries:

Python

     brands = ["Macallan", "Glenfiddich", "Yamazaki", "Lagavulin", "Jack Daniel's", 
              "Buffalo Trace", "Balvenie", "Ardbeg", "Jameson", "Highland Park"]
    types = ["Scotch", "Bourbon", "Rye", "Japanese", "Irish"]
    regions = {
        "Scotch": ["Islay", "Speyside", "Highlands", "Lowlands"],
        "Bourbon": ["Kentucky", "Tennessee"],
        "Rye": ["Canada", "USA"],
        "Japanese": ["Honshu", "Hokkaido"],
        "Irish": ["Dublin", "Cork"]
    }
    cask_types = ["Sherry", "Bourbon", "Port", "Wine", "Rum", "Tequila"]
    bottling_types = ["Single Malt", "Blended", "Single Cask", "Cask Strength"]
    category_definitions = {
        "Basic": (25, 49),
        "Standard": (50, 88),
        "Premium": (89, 128),
        "Exclusive": (129, 278),
        "Luxury": (279, 500)
    }

And these are all the dataset independent variables with the dependent variable "category":

Python

    columns = [
        "whiskey_name", "brand", "type", "age", "abv", "region", "cask_type",
        "bottling_type", "retail_price_usd", "is_limited_edition",
        "release_year", "average_rating", "award_wins", "rating_category", "category"
    ]

And then the iteration function start creating rows and append them into data list, returning the dataframe.

Python

    data = []

    for _ in range(num_rows):
        brand = random.choice(brands)
        w_type = random.choice(types)
        region = random.choice(regions[w_type])
        age = np.random.choice([0, *range(3, 31)], p=[0.1] + [0.9 / 28] * 28)
        abv = round(random.uniform(40, 60), 1)

        if random.random() < 0.03:
            age = random.choice([0, 50])
            abv = round(random.uniform(30, 75), 1)
            region = "Unknown"
            cask = "Tequila"
        else:
            cask = random.choice(cask_types)

        bottling = random.choice(bottling_types)
        limited = np.random.rand() < 0.15
        release_year = random.randint(1990, 2025)
        awards = np.random.poisson(1.5)
        base_rating = 85 + (age / 30) * 10 + awards
        avg_rating = round(np.random.normal(base_rating, 1.5), 1)

        base_price = round(np.random.uniform(25, 500), 2)
        noise = np.random.normal(0, base_price * 0.1)
        price = round(base_price + noise, 2)
        price = max(20, price)

        category = next((k for k, (lo, hi) in category_definitions.items() if lo <= price <= hi), "Luxury")

        if avg_rating < 85:
            rating_category = "Low"
        elif avg_rating < 90:
            rating_category = "Medium"
        elif avg_rating < 95:
            rating_category = "High"
        else:
            rating_category = "Excellent"

        whiskey_name = f"{brand} {age if age else 'NAS'} {cask} Cask"

        data.append([
            whiskey_name, brand, w_type, age, abv, region, cask,
            bottling, price, limited, release_year, avg_rating,
            awards, rating_category, category
        ])

        df = pd.DataFrame(data, columns=columns)
        df = df.sample(frac=1, random_state=42).reset_index(drop=True)
        return df

How is the model trained?

To train the model, first of all the dataset must be properly prepared, that means applying One Hot Encoding, Labeling Encoding, normalization...

Python

    # process dataset

    # 1. apply label encoding in target df creation
    label_encoder = LabelEncoder()
    target_df_encoded = label_encoder.fit_transform(df['category'])

    # 2. drop unneeded cols to create the features_df
    features_df = df.drop(['category', 'whiskey_name'], axis=1)

    # 3. apply One Hot to categorical independent columns

    #     3.1 identify categorical and numerical columns
    categorical_cols = features_df.select_dtypes(include=['object', 'bool']).columns
    numeric_cols = features_df.select_dtypes(include=['int64', 'float64']).columns

    #     3.2 apply One Hot to categorical columns
    OH_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
    OH_encoded = OH_encoder.fit_transform(features_df[categorical_cols])

    OH_feature_names = OH_encoder.get_feature_names_out(categorical_cols)
    OH_df = pd.DataFrame(OH_encoded, columns=OH_feature_names)

    #     3.3 keep numerical columns
    numeric_df = features_df[numeric_cols].reset_index(drop=True)

    # 4. concat both dataframes
    features_df = pd.concat([numeric_df, OH_df], axis=1)

    # 5. save the feature columns (this includes both categorical ones and numerical ones)
    feature_columns = list(numeric_cols) + list(OH_encoder.get_feature_names_out(categorical_cols))

    # 6. normalize data, this is because SVM needs the data being normalized
    scaler = MinMaxScaler()
    normalized_features = scaler.fit_transform(features_df)
    normalized_df = pd.DataFrame(normalized_features, columns=features_df.columns)

    # 7. add back target
    normalized_df['category'] = target_df_encoded

Then, in prediction phase, the model would need the same columns as the training phase, so the utils should be saved to use them in prediction phase

Python

    # save utils for later
    dirname = "model_files"
    # encoder
    with open(f'{dirname}/label_encoder.pkl', 'wb') as f:
        pickle.dump(label_encoder, f)
    # OH encoded columns
    with open(f'{dirname}/feature_columns.pkl', 'wb') as f:
        pickle.dump(feature_columns, f)
    # OH Encoder
    with open(f'{dirname}/one_hot_encoder.pkl', 'wb') as f:
        pickle.dump(OH_encoder, f)
    # Normalizer
    with open(f'{dirname}/scaler.pkl', 'wb') as f:
        pickle.dump(scaler, f)

Also the data should be splitted in train and test data

Python

    # split data and save
    df_X_normalized = normalized_df.drop(columns=['category'])
    df_Y = df[['category']]

    df_X_normalized_train, df_X_normalized_test, df_Y_train, df_Y_test = train_test_split(df_X_normalized, df_Y, test_size=0.2, random_state=100)

In training phase the model would be created and trained with the splitted data to be saved later.

Python

    # algorithm method creation
    svm_classifier = SVC(kernel='linear', C=50)

    # train model with the classifier method
    svm_model = svm_classifier.fit(df_X_normalized_train, df_Y_train['category'])

    modelname = "svm_model.pkl"
    try:
        with open(modelname, 'wb') as file:
            pickle.dump(svm_model, file)

        print(f"Model saved as {modelname}")
    except Exception as e:
        print(f"An error occurred while saving the model: {e}")

Also this model was tested with a new dataset, using the same function to create it and the same encoders as training, in this case we used a new dataset of 500 rows, but it also has been tested with a new dataset with 50K rows.

Python

    from sklearn.preprocessing import LabelEncoder
    from sklearn.metrics import accuracy_score
    import pickle
    import pandas as pd
    import random

    # load processors
    dirname = "model_files"
    with open(f'{dirname}/label_encoder.pkl', 'rb') as f:
        label_encoder = pickle.load(f)
    with open(f'{dirname}/one_hot_encoder.pkl', 'rb') as f:
        OH_encoder = pickle.load(f)
    with open(f'{dirname}/scaler.pkl', 'rb') as f:
        scaler = pickle.load(f)
    with open(f'{dirname}/feature_columns.pkl', 'rb') as f:
        feature_columns = pickle.load(f)

    # load model
    with open('whiskey_classificator_model.pkl', 'rb') as f:
        svm_model = pickle.load(f)
        
    print("Model has been loaded")


    n_tests = 100
    accuracy_results = {}
    accuracies = []
    for i in range(0, n_tests):

        # generate new dataset
        nr = random.randint(500, 50000)
        df = generate_whiskey(num_rows=nr)

        # separate target
        target_df = df['category'].reset_index(drop=True)
        # drop uneeded columns
        features_df = df.drop(['category', 'whiskey_name'], axis=1)
        
        # identify categorical and numerical columns
        categorical_cols = features_df.select_dtypes(include=['object', 'bool']).columns
        numeric_cols = features_df.select_dtypes(include=['int64', 'float64']).columns
        
        # apply One Hot to categorical columns
        OH_encoded = OH_encoder.transform(features_df[categorical_cols])  # Use transform, no fit
        OH_feature_names = OH_encoder.get_feature_names_out(categorical_cols)
        OH_df = pd.DataFrame(OH_encoded, columns=OH_feature_names)
        
        # keep numerical columns
        numeric_df = features_df[numeric_cols].reset_index(drop=True)
        
        # concat both dataframes
        features_df = pd.concat([numeric_df, OH_df], axis=1)
        
        # get the missing columns in new dataset using the list saved
        missing_cols = set(feature_columns) - set(features_df.columns)
        for col in missing_cols:
            features_df[col] = 0   # add columns with value = 0
        
        # re order the columns
        features_df = features_df[feature_columns]
        
        # normalize using the scaler loaded (use transform, not fit_transform)
        normalized_features = scaler.transform(features_df)
        normalized_df = pd.DataFrame(normalized_features, columns=feature_columns)
        
        # add back encoded target
        normalized_df['category'] = target_df.reset_index(drop=True)
        # apply label encoder to target column
        normalized_df['category'] = label_encoder.transform(normalized_df['category'])

        # drop category before predict
        normalized_df = normalized_df.drop(['category'], axis=1)
        
        # predict with normalized_df
        predictions = svm_model.predict(normalized_df)
        
        # create a df with the results
        result_df = df.copy()
        
        result_df['Predicted category'] = predictions
        
        # apply label encoder to target column
        result_df['category'] = label_encoder.transform(result_df['category'])

        
        # calculate the accuracy (prediction rate)
        accuracy = accuracy_score(result_df['category'], result_df['Predicted category'])

        # save to results dict
        accuracy_results[f"test {i+1}"] = {
            "Rows": nr,
            "Accuracy": f"{accuracy * 100:.2f}%"
        }
        accuracies.append(accuracy)

    # show the results
    results_df = pd.DataFrame.from_dict(accuracy_results, orient='index')
    print("\nSummary Table:")
    display(results_df)

    # show average accuracy
    mean_accuracy = np.mean(accuracies)
    print(f"\nAverage Accuracy across {n_tests} tests: {mean_accuracy * 100:.2f}%")

10 Test process have been done and these are the results

Dataset used in trainning

The dataset was created using a function which emulates the data that could be used in a real whiskey classification.

Rogudev/whiskey_classificator_model

Whiskey classifier model

Model overview

How is the dataset created?

How is the model trained?

Dataset used in trainning

Rogudev/
whiskey_classificator_model