Search for a command to run...
Building and Training a Machine Learning Model from Scratch: A Beginner's Guide with Real-World Examples
Our company comprises seasoned professionals, each an expert in their field. Customer satisfaction is our top priority, exceeding clients' needs. We ensure competitive pricing and quality in web and mobile development without compromise.
Hi. Because I’m really new at this. Having an issue and need to ask for help. I am getting this error from line
accuracy = accuracy_score(y_test, x_test)
ValueError: Classification metrics can’t handle a mix of multiclass and continuous-multioutput targets
Any help is appreciated. Alex.
"Join us on a journey into the world of machine learning, where we unravel the complexities of algorithms, data processing, and model building."
Learn how to develop a Python tool that uses deep learning and medical imaging to diagnose diseases through X-rays, MRIs, and CT scans
A modern community for developers to learn, share, and grow together.
Discover the most practical AI tools that save time, boost productivity, and actually work.
Unlock Productivity, Creativity, and Growth Using These Free AI Tools in 2025
"A Developer’s Guide to the Best Payment Processors for Modern Web Apps"
Protect your privacy, secure your data, and browse with peace of mind.
Machine learning (ML) has revolutionized the way we approach problem-solving, enabling computers to learn from data and make decisions or predictions. In this blog, we’ll walk through the process of creating and training a machine learning model from scratch using Python and its popular libraries like scikit-learn.
Before we begin, we need to set up the tools necessary to build a machine learning model. We'll use popular Python libraries like pandas for data handling, scikit-learn for machine learning algorithms, and matplotlib for visualization.
Run the following command in your terminal or command prompt to install these libraries:
pip install numpy pandas scikit-learn matplotlib seaborn
Creating a machine learning model can be broken down into these core steps:
Problem Definition: What are you trying to solve or predict?
Data Collection: Gather or load the dataset.
Data Preprocessing: Clean and prepare the data.
Model Selection: Choose the appropriate algorithm.
Model Training: Train the model using your data.
Model Evaluation: Test the model's performance.
Model Tuning: Optimize the model for better accuracy.
Deployment: Use the model in real-world applications.
For this guide, we'll use the famous Iris dataset from scikit-learn. This dataset contains information about flowers and their classifications into three species based on the length and width of their petals and sepals.
Here’s how you can load and view the data:
import pandas as pd
from sklearn.datasets import load_iris
# Load the dataset
iris = load_iris()
# Convert to DataFrame for easy visualization
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target
# Display the first few rows
print(df.head())
Explanation:
pandas DataFrame so we can easily explore it. The dataset includes columns like petal and sepal measurements and a target column indicating the flower species.Data is rarely perfect, so we need to clean it before training the model. This includes handling missing data, scaling the features (so they're on the same scale), and encoding categorical variables.
Luckily, the Iris dataset is already clean, so we only need to scale the features:
from sklearn.preprocessing import StandardScaler
# Separate the features and target
X = df.drop('species', axis=1)
y = df['species']
# Standardize the features (scaling)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
Explanation:
Now that the data is clean and scaled, we need to split it into two parts:
Training set (80%): This data will be used to train the model.
Test set (20%): This data will be used to evaluate the model.
from sklearn.model_selection import train_test_split
# Split the dataset
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
print(f"Training samples: {X_train.shape[0]}, Testing samples: {X_test.shape[0]}")
Explanation:
We’ll start by using a simple algorithm, K-Nearest Neighbors (KNN), which classifies a new point based on its closest neighbors in the dataset.
from sklearn.neighbors import KNeighborsClassifier
# Initialize the model
knn = KNeighborsClassifier(n_neighbors=3)
# Train the model on the training data
knn.fit(X_train, y_train)
Explanation:
After training, it's crucial to test the model on the unseen test data to measure its accuracy and other performance metrics.
from sklearn.metrics import accuracy_score
# Make predictions on the test data
y_pred = knn.predict(X_test)
# Calculate accuracy
accuracy = accuracy_score(y_test, y_pred)
print(f"Model Accuracy: {accuracy * 100:.2f}%")
Explanation:
If you’re not satisfied with the initial accuracy, you can tune the model by adjusting its parameters (hyperparameters). For example, we can experiment with different values of k in the KNN model.
# Try with different number of neighbors (k)
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
# Evaluate the model again
y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Model Accuracy with k=5: {accuracy * 100:.2f}%")
Explanation:
k), we can potentially improve the accuracy of the KNN model. You can experiment with different values to see what works best.Once you're happy with the model's performance, you can save it and deploy it for real-world applications. In Python, you can use the joblib library to save the trained model and later load it when needed.
import joblib
# Save the model to a file
joblib.dump(knn, 'knn_model.pkl')
# Load the model back
knn_loaded = joblib.load('knn_model.pkl')
# Now you can use it to make predictions
y_new_pred = knn_loaded.predict(X_test)
Explanation:
Here’s a recap of the process:
Prepare the data: Clean, scale, and split it into training and test sets.
Choose a model: Select an algorithm like KNN, Decision Trees, etc.
Train the model: Use the training set to fit the model.
Evaluate the model: Check its accuracy and performance on the test set.
Tune the model: Adjust parameters to improve accuracy.
Deploy the model: Save it for later use in real-world applications.
Machine learning is a powerful tool that can solve a wide range of problems, and by mastering the basics, you’re well on your way to building intelligent systems. Happy coding!