Prediction of Wine type using Deep Learning

Deep learning is used for analyzing large datasets but to understand the foundational concepts it's often helpful to start with smaller and more manageable datasets. One such dataset is the wine quality dataset which contains information about various chemical properties of wines and their quality ratings. In this article we will explore how deep learning can be used to predict wine quality.

But before loading the data it is important to understand its features. The dataset consists of 12 variables. Here are a few of them:

• Fixed Acidity: This refers to the non-volatile acids in the wine, which contribute to the wine's tartness.
• Volatile Acidity: This refers to acetic acid content which can contribute to a vinegar-like taste in wine.
• Citric Acid: Citric acid is one of the fixed acids in wine.
• Residual Sugar: This is the sugar that remains after fermentation stops.
• Chlorides: Chlorides can contribute to saltiness in wine.
• Free Sulfur Dioxide: This is the sulfur dioxide that is added to wine.
• Total Sulfur Dioxide: This is the sum of bound and free sulfur dioxide.

Implementing Prediction of Wine type

We will be making deep learning model with the help of following steps:

1. Importing Required Libraries

We will be importing numpy, pandas, matplotlib, scikit learn and keras for model building.

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense

  
2. Loading and Preprocessing Data

We will be loading dataset from provided url. After that we will preprocess it so that model can use this cleaned dataset for training and making prediction.

red = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv", sep=';')
white = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv", sep=';')

red['type'] = 1
white['type'] = 0

wines = pd.concat([red, white], ignore_index=True)
wines.dropna(inplace=True)

• 'type': is added to distinguish between red and white wine: 1 for red wine and 0 for white wine.
• pd.concat(): using this two datasets (red and white) are concatenated into a single dataframe wine.
• dropna(): Any rows with missing values are dropped using this to ensure clean data for training the model.

3. Plotting Distribution of Alcohol  

We will use matplotlib to create a visual representation of the distribution of alcohol content for red and white wines.

fig, ax = plt.subplots(1, 2, figsize=(10, 5))
ax[0].hist(wines[wines['type'] == 1].alcohol, bins=10, facecolor='red', alpha=0.5, label='Red wine')
ax[1].hist(wines[wines['type'] == 0].alcohol, bins=10, facecolor='white', edgecolor='black', lw=0.5, alpha=0.5, label='White wine')

for a in ax:
    a.set_ylim([0, 1000])
    a.set_xlabel('Alcohol in % Vol')
    a.set_ylabel('Frequency')

ax[0].set_title('Alcohol Content in Red Wine')
ax[1].set_title('Alcohol Content in White Wine')

fig.suptitle('Distribution of Alcohol by Wine Type')
plt.tight_layout()
plt.show()

• A histogram is created for each wine type (red and white) with a specified number of bins (10).

Output:

4. Splitting Data into Training and Testing Sets

X = wines.iloc[:, :-1]
y = wines['type']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.34, random_state=45)

• X contains all columns except the target variable ('type'), which is represented by y.
• train_test_split(): splits the dataset into training (66%) and testing (34%) sets.
• random_state=45: ensures that the split is reproducible.

5. Creating Neural Network Model

model = Sequential()
model.add(Dense(12, activation='relu', input_dim=12))
model.add(Dense(9, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

The function create_model defines a neural network with 3 layers:

• Input layer: Dense(12) with 12 neurons and ReLU activation function, where input_dim=12 matches the number of features (columns) in the input data.
• Hidden layer: Dense(9) with 9 neurons and ReLU activation.
• Output layer: Dense(1) with a single neuron and a sigmoid activation function, since this is a binary classification problem (predicting red or white wine).
• The model is compiled using the binary crossentropy loss function and the Adam optimizer.

6. Training the Model and Making Predictions

model.fit(X_train, y_train, epochs=3, batch_size=1, verbose=1)

y_pred = model.predict(X_test)

print("Predictions: ", y_pred)

• Trains the model using the training data (X_train, y_train) for 3 epochs with a batch size of 1.
• After training the model is used to make predictions on the test data (X_test).
• The predictions (y_pred) are returned.

Output:

The output shows the accuracy improves from 89.93% in the first epoch to 94.87% in the third while the loss decreases from 0.3280 to 0.1415 indicating better performance. The model makes predictions with probabilities close to 0 or 1 where values near 0 indicate white wine and values near 1 indicate red wine. This shows the model's effective learning and improvement in predicting wine types as training progresses.