# Chapter 6: Introduction to Neural Networks and Deep Learning

## 6.4 Practical Exercises of Chapter 6: Introduction to Neural Networks and Deep Learning

**Exercise 1: Implement a Perceptron**

Implement a simple perceptron using Python. Use it to classify a binary dataset of your choice. You can create your own dataset or use a simple one from a library like Scikit-learn.

`import numpy as np`

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Define the Perceptron model

class Perceptron:

def __init__(self, learning_rate=0.01, n_iters=1000):

self.lr = learning_rate

self.n_iters = n_iters

self.activation_func = self._unit_step_func

self.weights = None

self.bias = None

def fit(self, X, y):

n_samples, n_features = X.shape

# init parameters

self.weights = np.zeros(n_features)

self.bias = 0

y_ = np.where(y <= 0, -1, 1)

for _ in range(self.n_iters):

for idx, x_i in enumerate(X):

linear_output = np.dot(x_i, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

# Perceptron update rule

update = self.lr * (y_[idx] - y_predicted)

self.weights += update * x_i

self.bias += update

def predict(self, X):

linear_output = np.dot(X, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

return y_predicted

def _unit_step_func(self, x):

return np.where(x >= 0, 1, -1)

# Training the Perceptron model

p = Perceptron(learning_rate=0.01, n_iters=1000)

p.fit(X_train, y_train)

# Making predictions on the test data

predictions = p.predict(X_test)

# Evaluate the model

accuracy = accuracy_score(y_test, predictions)

print("Perceptron classification accuracy: ", accuracy)

**Exercise 2: Implement Gradient Descent**

Implement the gradient descent algorithm from scratch in Python. Use it to find the minimum of a simple function (like f(x) = x^2 + 5x + 6), and plot the steps of the algorithm along the way.

`import numpy as np`

import matplotlib.pyplot as plt

# Define the function and its derivative

def f(x):

return x**2 + 5*x + 6

def df(x):

return 2*x + 5

# Gradient descent algorithm

def gradient_descent(x_start, learning_rate, n_iters):

x = x_start

history = [x]

for _ in range(n_iters):

grad = df(x)

x -= learning_rate * grad

history.append(x)

return history

# Run the algorithm and plot the steps

history = gradient_descent(x_start=-10, learning_rate=0.1, n_iters=50)

plt.plot(history, [f(x) for x in history], 'o-')

plt.xlabel('x')

plt.ylabel('f(x)')

plt.title('Gradient Descent Steps')

plt.show()

**Exercise 3: Regularization Techniques**

Using a dataset of your choice, build a deep learning model with Keras. Apply L1, L2, and dropout regularization, and compare the results. Which method works best for your dataset?

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.regularizers import l1, l2

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer with L1 regularization

model.add(Dense(32, input_dim=8, activation='relu', kernel_regularizer=l1(0.01)))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer with L2 regularization

model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(0.01)))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Fit the model

model.fit(X, y, epochs=150, batch_size=10)

**Exercise 4: Early Stopping and Dropout**

Using a dataset of your choice, build a deep learning model with Keras. Implement early stopping and dropout, and observe how they affect the model's performance.

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.callbacks import EarlyStopping

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer

model.add(Dense(32, input_dim=20, activation='relu'))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer

model.add(Dense(1, activation='sigmoid'))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Define the early stopping monitor

early_stopping_monitor = EarlyStopping(patience=3)

# Fit the model

model.fit(X_train, y_train, epochs=150, batch_size=10, validation_split=0.2, callbacks=[early_stopping_monitor])

In this exercise, you will observe how early stopping and dropout can help prevent overfitting and improve the model's ability to generalize to new data.

## Chapter 6 Conclusion

In this chapter, we embarked on a fascinating journey into the world of neural networks and deep learning. We started with the fundamental building block of neural networks, the perceptron, and explored how it forms the basis for more complex neural network architectures. We learned how a perceptron takes a set of inputs, applies weights, and uses an activation function to produce an output. We also saw how multiple perceptrons can be combined to form a multi-layer perceptron, capable of solving more complex problems.

We then delved into the concept of backpropagation and gradient descent, two crucial components in training a neural network. We learned how backpropagation works by calculating the gradient of the loss function with respect to the weights of the network, allowing us to understand how much each weight contributes to the error. This information is then used by the gradient descent algorithm to adjust the weights and minimize the error.

In our discussion of overfitting, underfitting, and regularization, we explored the challenges of training a model that generalizes well to unseen data. We learned about the bias-variance trade-off and how overfitting and underfitting represent two extremes of this spectrum. We also discussed several regularization techniques, including L1 and L2 regularization, dropout, and early stopping, which can help mitigate overfitting and improve the model's generalization performance.

The practical exercises provided throughout the chapter allowed us to apply these concepts and gain hands-on experience with implementing and training neural networks. These exercises not only reinforced our understanding of the material but also gave us a taste of what it's like to work with neural networks in a practical setting.

As we conclude this chapter, it's important to reflect on the power and versatility of neural networks and deep learning. These techniques have revolutionized the field of machine learning and have found applications in a wide range of domains, from image and speech recognition to natural language processing and autonomous driving. However, with great power comes great responsibility. As practitioners, it's crucial that we use these tools ethically and responsibly, ensuring that our models are fair, transparent, and respectful of privacy.

Looking ahead, we will dive deeper into the world of deep learning, exploring more advanced concepts and techniques. We will learn about different types of neural networks, including convolutional neural networks (CNNs) and recurrent neural networks (RNNs), and how they can be used to tackle complex machine learning tasks. We will also explore popular deep learning frameworks, such as TensorFlow, Keras, and PyTorch, and learn how to use them to build and train our own neural networks. So, stay tuned for an exciting journey ahead!

## 6.4 Practical Exercises of Chapter 6: Introduction to Neural Networks and Deep Learning

**Exercise 1: Implement a Perceptron**

Implement a simple perceptron using Python. Use it to classify a binary dataset of your choice. You can create your own dataset or use a simple one from a library like Scikit-learn.

`import numpy as np`

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Define the Perceptron model

class Perceptron:

def __init__(self, learning_rate=0.01, n_iters=1000):

self.lr = learning_rate

self.n_iters = n_iters

self.activation_func = self._unit_step_func

self.weights = None

self.bias = None

def fit(self, X, y):

n_samples, n_features = X.shape

# init parameters

self.weights = np.zeros(n_features)

self.bias = 0

y_ = np.where(y <= 0, -1, 1)

for _ in range(self.n_iters):

for idx, x_i in enumerate(X):

linear_output = np.dot(x_i, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

# Perceptron update rule

update = self.lr * (y_[idx] - y_predicted)

self.weights += update * x_i

self.bias += update

def predict(self, X):

linear_output = np.dot(X, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

return y_predicted

def _unit_step_func(self, x):

return np.where(x >= 0, 1, -1)

# Training the Perceptron model

p = Perceptron(learning_rate=0.01, n_iters=1000)

p.fit(X_train, y_train)

# Making predictions on the test data

predictions = p.predict(X_test)

# Evaluate the model

accuracy = accuracy_score(y_test, predictions)

print("Perceptron classification accuracy: ", accuracy)

**Exercise 2: Implement Gradient Descent**

Implement the gradient descent algorithm from scratch in Python. Use it to find the minimum of a simple function (like f(x) = x^2 + 5x + 6), and plot the steps of the algorithm along the way.

`import numpy as np`

import matplotlib.pyplot as plt

# Define the function and its derivative

def f(x):

return x**2 + 5*x + 6

def df(x):

return 2*x + 5

# Gradient descent algorithm

def gradient_descent(x_start, learning_rate, n_iters):

x = x_start

history = [x]

for _ in range(n_iters):

grad = df(x)

x -= learning_rate * grad

history.append(x)

return history

# Run the algorithm and plot the steps

history = gradient_descent(x_start=-10, learning_rate=0.1, n_iters=50)

plt.plot(history, [f(x) for x in history], 'o-')

plt.xlabel('x')

plt.ylabel('f(x)')

plt.title('Gradient Descent Steps')

plt.show()

**Exercise 3: Regularization Techniques**

Using a dataset of your choice, build a deep learning model with Keras. Apply L1, L2, and dropout regularization, and compare the results. Which method works best for your dataset?

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.regularizers import l1, l2

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer with L1 regularization

model.add(Dense(32, input_dim=8, activation='relu', kernel_regularizer=l1(0.01)))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer with L2 regularization

model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(0.01)))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Fit the model

model.fit(X, y, epochs=150, batch_size=10)

**Exercise 4: Early Stopping and Dropout**

Using a dataset of your choice, build a deep learning model with Keras. Implement early stopping and dropout, and observe how they affect the model's performance.

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.callbacks import EarlyStopping

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer

model.add(Dense(32, input_dim=20, activation='relu'))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer

model.add(Dense(1, activation='sigmoid'))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Define the early stopping monitor

early_stopping_monitor = EarlyStopping(patience=3)

# Fit the model

model.fit(X_train, y_train, epochs=150, batch_size=10, validation_split=0.2, callbacks=[early_stopping_monitor])

In this exercise, you will observe how early stopping and dropout can help prevent overfitting and improve the model's ability to generalize to new data.

## Chapter 6 Conclusion

In this chapter, we embarked on a fascinating journey into the world of neural networks and deep learning. We started with the fundamental building block of neural networks, the perceptron, and explored how it forms the basis for more complex neural network architectures. We learned how a perceptron takes a set of inputs, applies weights, and uses an activation function to produce an output. We also saw how multiple perceptrons can be combined to form a multi-layer perceptron, capable of solving more complex problems.

We then delved into the concept of backpropagation and gradient descent, two crucial components in training a neural network. We learned how backpropagation works by calculating the gradient of the loss function with respect to the weights of the network, allowing us to understand how much each weight contributes to the error. This information is then used by the gradient descent algorithm to adjust the weights and minimize the error.

In our discussion of overfitting, underfitting, and regularization, we explored the challenges of training a model that generalizes well to unseen data. We learned about the bias-variance trade-off and how overfitting and underfitting represent two extremes of this spectrum. We also discussed several regularization techniques, including L1 and L2 regularization, dropout, and early stopping, which can help mitigate overfitting and improve the model's generalization performance.

The practical exercises provided throughout the chapter allowed us to apply these concepts and gain hands-on experience with implementing and training neural networks. These exercises not only reinforced our understanding of the material but also gave us a taste of what it's like to work with neural networks in a practical setting.

As we conclude this chapter, it's important to reflect on the power and versatility of neural networks and deep learning. These techniques have revolutionized the field of machine learning and have found applications in a wide range of domains, from image and speech recognition to natural language processing and autonomous driving. However, with great power comes great responsibility. As practitioners, it's crucial that we use these tools ethically and responsibly, ensuring that our models are fair, transparent, and respectful of privacy.

Looking ahead, we will dive deeper into the world of deep learning, exploring more advanced concepts and techniques. We will learn about different types of neural networks, including convolutional neural networks (CNNs) and recurrent neural networks (RNNs), and how they can be used to tackle complex machine learning tasks. We will also explore popular deep learning frameworks, such as TensorFlow, Keras, and PyTorch, and learn how to use them to build and train our own neural networks. So, stay tuned for an exciting journey ahead!

## 6.4 Practical Exercises of Chapter 6: Introduction to Neural Networks and Deep Learning

**Exercise 1: Implement a Perceptron**

Implement a simple perceptron using Python. Use it to classify a binary dataset of your choice. You can create your own dataset or use a simple one from a library like Scikit-learn.

`import numpy as np`

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Define the Perceptron model

class Perceptron:

def __init__(self, learning_rate=0.01, n_iters=1000):

self.lr = learning_rate

self.n_iters = n_iters

self.activation_func = self._unit_step_func

self.weights = None

self.bias = None

def fit(self, X, y):

n_samples, n_features = X.shape

# init parameters

self.weights = np.zeros(n_features)

self.bias = 0

y_ = np.where(y <= 0, -1, 1)

for _ in range(self.n_iters):

for idx, x_i in enumerate(X):

linear_output = np.dot(x_i, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

# Perceptron update rule

update = self.lr * (y_[idx] - y_predicted)

self.weights += update * x_i

self.bias += update

def predict(self, X):

linear_output = np.dot(X, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

return y_predicted

def _unit_step_func(self, x):

return np.where(x >= 0, 1, -1)

# Training the Perceptron model

p = Perceptron(learning_rate=0.01, n_iters=1000)

p.fit(X_train, y_train)

# Making predictions on the test data

predictions = p.predict(X_test)

# Evaluate the model

accuracy = accuracy_score(y_test, predictions)

print("Perceptron classification accuracy: ", accuracy)

**Exercise 2: Implement Gradient Descent**

Implement the gradient descent algorithm from scratch in Python. Use it to find the minimum of a simple function (like f(x) = x^2 + 5x + 6), and plot the steps of the algorithm along the way.

`import numpy as np`

import matplotlib.pyplot as plt

# Define the function and its derivative

def f(x):

return x**2 + 5*x + 6

def df(x):

return 2*x + 5

# Gradient descent algorithm

def gradient_descent(x_start, learning_rate, n_iters):

x = x_start

history = [x]

for _ in range(n_iters):

grad = df(x)

x -= learning_rate * grad

history.append(x)

return history

# Run the algorithm and plot the steps

history = gradient_descent(x_start=-10, learning_rate=0.1, n_iters=50)

plt.plot(history, [f(x) for x in history], 'o-')

plt.xlabel('x')

plt.ylabel('f(x)')

plt.title('Gradient Descent Steps')

plt.show()

**Exercise 3: Regularization Techniques**

Using a dataset of your choice, build a deep learning model with Keras. Apply L1, L2, and dropout regularization, and compare the results. Which method works best for your dataset?

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.regularizers import l1, l2

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer with L1 regularization

model.add(Dense(32, input_dim=8, activation='relu', kernel_regularizer=l1(0.01)))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer with L2 regularization

model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(0.01)))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Fit the model

model.fit(X, y, epochs=150, batch_size=10)

**Exercise 4: Early Stopping and Dropout**

Using a dataset of your choice, build a deep learning model with Keras. Implement early stopping and dropout, and observe how they affect the model's performance.

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.callbacks import EarlyStopping

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer

model.add(Dense(32, input_dim=20, activation='relu'))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer

model.add(Dense(1, activation='sigmoid'))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Define the early stopping monitor

early_stopping_monitor = EarlyStopping(patience=3)

# Fit the model

model.fit(X_train, y_train, epochs=150, batch_size=10, validation_split=0.2, callbacks=[early_stopping_monitor])

In this exercise, you will observe how early stopping and dropout can help prevent overfitting and improve the model's ability to generalize to new data.

## Chapter 6 Conclusion

In this chapter, we embarked on a fascinating journey into the world of neural networks and deep learning. We started with the fundamental building block of neural networks, the perceptron, and explored how it forms the basis for more complex neural network architectures. We learned how a perceptron takes a set of inputs, applies weights, and uses an activation function to produce an output. We also saw how multiple perceptrons can be combined to form a multi-layer perceptron, capable of solving more complex problems.

We then delved into the concept of backpropagation and gradient descent, two crucial components in training a neural network. We learned how backpropagation works by calculating the gradient of the loss function with respect to the weights of the network, allowing us to understand how much each weight contributes to the error. This information is then used by the gradient descent algorithm to adjust the weights and minimize the error.

In our discussion of overfitting, underfitting, and regularization, we explored the challenges of training a model that generalizes well to unseen data. We learned about the bias-variance trade-off and how overfitting and underfitting represent two extremes of this spectrum. We also discussed several regularization techniques, including L1 and L2 regularization, dropout, and early stopping, which can help mitigate overfitting and improve the model's generalization performance.

The practical exercises provided throughout the chapter allowed us to apply these concepts and gain hands-on experience with implementing and training neural networks. These exercises not only reinforced our understanding of the material but also gave us a taste of what it's like to work with neural networks in a practical setting.

As we conclude this chapter, it's important to reflect on the power and versatility of neural networks and deep learning. These techniques have revolutionized the field of machine learning and have found applications in a wide range of domains, from image and speech recognition to natural language processing and autonomous driving. However, with great power comes great responsibility. As practitioners, it's crucial that we use these tools ethically and responsibly, ensuring that our models are fair, transparent, and respectful of privacy.

Looking ahead, we will dive deeper into the world of deep learning, exploring more advanced concepts and techniques. We will learn about different types of neural networks, including convolutional neural networks (CNNs) and recurrent neural networks (RNNs), and how they can be used to tackle complex machine learning tasks. We will also explore popular deep learning frameworks, such as TensorFlow, Keras, and PyTorch, and learn how to use them to build and train our own neural networks. So, stay tuned for an exciting journey ahead!

## 6.4 Practical Exercises of Chapter 6: Introduction to Neural Networks and Deep Learning

**Exercise 1: Implement a Perceptron**

`import numpy as np`

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Define the Perceptron model

class Perceptron:

def __init__(self, learning_rate=0.01, n_iters=1000):

self.lr = learning_rate

self.n_iters = n_iters

self.activation_func = self._unit_step_func

self.weights = None

self.bias = None

def fit(self, X, y):

n_samples, n_features = X.shape

# init parameters

self.weights = np.zeros(n_features)

self.bias = 0

y_ = np.where(y <= 0, -1, 1)

for _ in range(self.n_iters):

for idx, x_i in enumerate(X):

linear_output = np.dot(x_i, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

# Perceptron update rule

update = self.lr * (y_[idx] - y_predicted)

self.weights += update * x_i

self.bias += update

def predict(self, X):

linear_output = np.dot(X, self.weights) + self.bias

y_predicted = self.activation_func(linear_output)

return y_predicted

def _unit_step_func(self, x):

return np.where(x >= 0, 1, -1)

# Training the Perceptron model

p = Perceptron(learning_rate=0.01, n_iters=1000)

p.fit(X_train, y_train)

# Making predictions on the test data

predictions = p.predict(X_test)

# Evaluate the model

accuracy = accuracy_score(y_test, predictions)

print("Perceptron classification accuracy: ", accuracy)

**Exercise 2: Implement Gradient Descent**

`import numpy as np`

import matplotlib.pyplot as plt

# Define the function and its derivative

def f(x):

return x**2 + 5*x + 6

def df(x):

return 2*x + 5

# Gradient descent algorithm

def gradient_descent(x_start, learning_rate, n_iters):

x = x_start

history = [x]

for _ in range(n_iters):

grad = df(x)

x -= learning_rate * grad

history.append(x)

return history

# Run the algorithm and plot the steps

history = gradient_descent(x_start=-10, learning_rate=0.1, n_iters=50)

plt.plot(history, [f(x) for x in history], 'o-')

plt.xlabel('x')

plt.ylabel('f(x)')

plt.title('Gradient Descent Steps')

plt.show()

**Exercise 3: Regularization Techniques**

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.regularizers import l1, l2

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer with L1 regularization

model.add(Dense(32, input_dim=8, activation='relu', kernel_regularizer=l1(0.01)))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer with L2 regularization

model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(0.01)))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Fit the model

model.fit(X, y, epochs=150, batch_size=10)

**Exercise 4: Early Stopping and Dropout**

`from keras.models import Sequential`

from keras.layers import Dense, Dropout

from keras.callbacks import EarlyStopping

from sklearn.datasets import make_classification

from sklearn.model_selection import train_test_split

# Create a binary classification dataset

X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=7)

# Split the dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=7)

# Create a Sequential model

model = Sequential()

# Add an input layer and a hidden layer

model.add(Dense(32, input_dim=20, activation='relu'))

# Add dropout layer

model.add(Dropout(0.5))

# Add an output layer

model.add(Dense(1, activation='sigmoid'))

# Compile the model

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Define the early stopping monitor

early_stopping_monitor = EarlyStopping(patience=3)

# Fit the model

model.fit(X_train, y_train, epochs=150, batch_size=10, validation_split=0.2, callbacks=[early_stopping_monitor])