| Name | knertia JSON |
| Version |
0.0.5
JSON |
| download |
| home_page | |
| Summary | K-Inertia: A User-Friendly Machine Learning Library K-Inertia or Kavish Inertia is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering. |
| upload_time | 2023-12-15 20:20:19 |
| maintainer | |
| docs_url | None |
| author | Kavish Tomar |
| requires_python | |
| license | MIT |
| keywords |
machine learning
k_inertia
k-inertia
learning
ai
ai
ml
ml
k-inertia
machine learning
|
| VCS |
|
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# K-Inertia (Kavish Inertia)
**K-Inertia: A User-Friendly Machine Learning Library**
K-Inertia or ***Kavish Inertia*** is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering.
**Key Features:**
+ **Diverse Algorithms:**
K-Inertia offers a range of algorithms, covering both supervised and unsupervised learning tasks. Users can seamlessly implement regression, classification (logistic regression, k-nearest neighbors, naive Bayes, support vector machines), and clustering (k-means) with minimal effort.
+ **User-Friendly Interface:**
K-Inertia is designed to be user-friendly, making it accessible for both beginners and experienced users. The library provides clear and intuitive APIs for easy integration into machine learning workflows.
+ **Simplified Usage:**
Users can leverage the library's simplified syntax to perform complex machine learning tasks without extensive coding. K-Inertia aims to streamline the implementation process, reducing the learning curve for users new to machine learning.
+ **Flexibility:**
K-Inertia allows users to experiment with different algorithms and easily switch between them based on their specific needs. The library's flexibility encourages exploration and experimentation with various machine learning techniques.
K-Inertia strives to empower users with a straightforward and accessible machine learning experience. Whether you are building predictive models, classifying data, or clustering patterns, K-Inertia is designed to be a reliable companion for your machine learning endeavors.
***
# Documentation
## Regression
```
class k_inertia.supervised.Regression(learning_rate=0.0001, iterations=1000)
```
Ordinary least squares Linear Regression.
LinearRegression fits a linear model with coefficients w = (w1, …, wp) to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation.
#### Parameters:
`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.
`iterations` : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model
`predict(X)` : Takes the independent features of data as parameter and predicts the result
`mse(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the mean squared error for accuracy of Regression. The less the value of mse, the more accurate model is.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying regression
from k_inertia.supervised import Regression
regresion = Regression(learning_rate=0.005)
regresion.fit(x_train, y_train)
predict = regresion.predict(x_test)
```
***
## Logistic Regression
```
class k_inertia.supervised.LogisticRegression(learning_rate=0.0001, iterations=1000)
```
For binary logistic regression, the logistic function (also called the sigmoid function) is employed to map the output of a linear combination of features into a range between 0 and 1.
#### Parameters:
`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.
`iterations` : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying Logistic regression
from k_inertia.supervised import LogisticRegression
lr = LogisitcRegression(learning_rate=0.005)
lr.fit(x_train, y_train)
predict = lr.predict(x_test)
```
***
## K-Nearest Neighbors
```
class k_inertia.supervised.KNN(k=3)
```
K-Nearest Neighbors (KNN) is a supervised machine learning algorithm used for both classification and regression tasks. It's a simple and intuitive algorithm that makes predictions based on the majority class (for classification) or the average (for regression) of the k-nearest data points in the feature space. The key idea behind KNN is that instances with similar feature values are likely to belong to the same class or have similar target values.
#### Parameters:
`k` : This parameter defines how many neighbors will be checked to determine the classification of a specific query point.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying KNN
from k_inertia.supervised import KNN
knn = KNN(k=3)
knn.fit(x_train, y_train)
predict = knn.predict(x_test)
```
***
## Naive Bayes
```
class k_inertia.supervised.NaiveBayes()
```
The "naive" part of Naive Bayes comes from the assumption of independence among features, given the class label. This means that the presence or absence of a particular feature is assumed to be unrelated to the presence or absence of any other feature. While this assumption is often not strictly true in real-world data, it simplifies the calculation and makes the algorithm computationally efficient.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying Naive Bayes
from k_inertia.supervised import NaiveBayes
bayes = NaiveBayes()
bayes.fit(x_train, y_train)
predict = bayes.predict(x_test)
```
***
## Support Vector Machine
```
class k_inertia.supervised.SVM(learning_rate = 0.001, lambda_param = 0.01, iterations = 1000)
```
Support Vector Machines (SVMs) are supervised machine learning models used for both classification and regression tasks. SVMs are particularly effective in high-dimensional spaces and are widely used in various applications, including image classification, text categorization, and bioinformatics. The primary objective of SVM is to find a hyperplane that best separates the data into different classes while maximizing the margin between the classes.
#### Parameters:
`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.
`lambda_param` : Thid parameter serves as a degree of importance that is given to miss-classifications.
`iterations` : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`fit(X,y)` : This method takes the training set of data as parameter and trains the model.
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Splitting the data for training and testing samples
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
#Applying Support Vector Machine
from k_inertia.supervised import SVM
svm = SVM(learning_rate = 0.0001, lambda_param = 0.01)
svm.fit(x_train, y_train)
predict = svm.predict(x_test)
```
***
## K-Means Clustering
```
class k_inertia.unsupervised.KMeans(k=5, max_iters=100)
```
K-Means Clustering is an unsupervised machine learning algorithm used for partitioning a dataset into K distinct, non-overlapping subsets (clusters). Each data point belongs to the cluster with the nearest mean, and the mean of each cluster serves as a representative or centroid of that cluster. K-Means is commonly used for grouping data points based on similarity and is widely applied in various fields, including image segmentation, customer segmentation, and anomaly detection.
#### Parameters:
'k' : Number of clusters
'max_iters' : This parameter, defines the number of times the iterations takes place to train this model.
#### Methods:
`predict(X)` : Takes the independent features of data as parameter and predicts the result.
``` py
#Reading the data through csv
import pandas as pd
data = pd.read_csv("example.csv")
x = data.iloc[:, :-1].values
y = data.iloc[:, -1].values
#Applying K-Means Clustering
from k_inertia.unsupervised import KMeans
means = KMeans(k = 3)
predict = svm.predict(x)
```
***
Raw data
{
"_id": null,
"home_page": "",
"name": "knertia",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "machine learning,k_inertia,k-inertia,learning,ai,AI,ml,ML,K-Inertia,Machine Learning",
"author": "Kavish Tomar",
"author_email": "kavishtomar2@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/bb/bf/5ee0d1423901eeaa84b9340bfbf49b09ef09464088ad11e30614d5c53911/knertia-0.0.5.tar.gz",
"platform": null,
"description": "# K-Inertia (Kavish Inertia)\r\n\r\n\r\n**K-Inertia: A User-Friendly Machine Learning Library**\r\nK-Inertia or ***Kavish Inertia*** is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering.\r\n\r\n**Key Features:**\r\n\r\n+ **Diverse Algorithms:**\r\nK-Inertia offers a range of algorithms, covering both supervised and unsupervised learning tasks. Users can seamlessly implement regression, classification (logistic regression, k-nearest neighbors, naive Bayes, support vector machines), and clustering (k-means) with minimal effort.\r\n\r\n+ **User-Friendly Interface:**\r\nK-Inertia is designed to be user-friendly, making it accessible for both beginners and experienced users. The library provides clear and intuitive APIs for easy integration into machine learning workflows.\r\n\r\n+ **Simplified Usage:**\r\nUsers can leverage the library's simplified syntax to perform complex machine learning tasks without extensive coding. K-Inertia aims to streamline the implementation process, reducing the learning curve for users new to machine learning.\r\n\r\n+ **Flexibility:**\r\nK-Inertia allows users to experiment with different algorithms and easily switch between them based on their specific needs. The library's flexibility encourages exploration and experimentation with various machine learning techniques.\r\n\r\nK-Inertia strives to empower users with a straightforward and accessible machine learning experience. Whether you are building predictive models, classifying data, or clustering patterns, K-Inertia is designed to be a reliable companion for your machine learning endeavors.\r\n\r\n***\r\n\r\n# Documentation\r\n\r\n## Regression\r\n```\r\nclass k_inertia.supervised.Regression(learning_rate=0.0001, iterations=1000)\r\n```\r\nOrdinary least squares Linear Regression.\r\n\r\nLinearRegression fits a linear model with coefficients w = (w1, \u00e2\u20ac\u00a6, wp) to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation.\r\n\r\n#### Parameters:\r\n`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.\r\n\r\n`iterations` : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result\r\n\r\n`mse(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the mean squared error for accuracy of Regression. The less the value of mse, the more accurate model is.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying regression\r\nfrom k_inertia.supervised import Regression\r\nregresion = Regression(learning_rate=0.005)\r\nregresion.fit(x_train, y_train)\r\npredict = regresion.predict(x_test)\r\n```\r\n***\r\n## Logistic Regression\r\n```\r\nclass k_inertia.supervised.LogisticRegression(learning_rate=0.0001, iterations=1000)\r\n```\r\nFor binary logistic regression, the logistic function (also called the sigmoid function) is employed to map the output of a linear combination of features into a range between 0 and 1.\r\n\r\n#### Parameters:\r\n`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.\r\n\r\n`iterations` : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying Logistic regression\r\nfrom k_inertia.supervised import LogisticRegression\r\nlr = LogisitcRegression(learning_rate=0.005)\r\nlr.fit(x_train, y_train)\r\npredict = lr.predict(x_test)\r\n```\r\n***\r\n## K-Nearest Neighbors\r\n```\r\nclass k_inertia.supervised.KNN(k=3)\r\n```\r\nK-Nearest Neighbors (KNN) is a supervised machine learning algorithm used for both classification and regression tasks. It's a simple and intuitive algorithm that makes predictions based on the majority class (for classification) or the average (for regression) of the k-nearest data points in the feature space. The key idea behind KNN is that instances with similar feature values are likely to belong to the same class or have similar target values.\r\n\r\n#### Parameters:\r\n`k` : This parameter defines how many neighbors will be checked to determine the classification of a specific query point.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying KNN\r\nfrom k_inertia.supervised import KNN\r\nknn = KNN(k=3)\r\nknn.fit(x_train, y_train)\r\npredict = knn.predict(x_test)\r\n```\r\n***\r\n## Naive Bayes\r\n```\r\nclass k_inertia.supervised.NaiveBayes()\r\n```\r\nThe \"naive\" part of Naive Bayes comes from the assumption of independence among features, given the class label. This means that the presence or absence of a particular feature is assumed to be unrelated to the presence or absence of any other feature. While this assumption is often not strictly true in real-world data, it simplifies the calculation and makes the algorithm computationally efficient.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying Naive Bayes\r\nfrom k_inertia.supervised import NaiveBayes\r\nbayes = NaiveBayes()\r\nbayes.fit(x_train, y_train)\r\npredict = bayes.predict(x_test)\r\n```\r\n***\r\n## Support Vector Machine\r\n```\r\nclass k_inertia.supervised.SVM(learning_rate = 0.001, lambda_param = 0.01, iterations = 1000)\r\n```\r\nSupport Vector Machines (SVMs) are supervised machine learning models used for both classification and regression tasks. SVMs are particularly effective in high-dimensional spaces and are widely used in various applications, including image classification, text categorization, and bioinformatics. The primary objective of SVM is to find a hyperplane that best separates the data into different classes while maximizing the margin between the classes.\r\n\r\n#### Parameters:\r\n`learning_rate` : This parameter is a hyper-parameter used to govern the pace at which an algorithm updates or learns the values of a parameter estimate.\r\n\r\n`lambda_param` : Thid parameter serves as a degree of importance that is given to miss-classifications.\r\n\r\n`iterations` : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`fit(X,y)` : This method takes the training set of data as parameter and trains the model.\r\n\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n`accuracy(y_predicted, y_true)` : Takes the predicted and actual value of outcomes as parameter and gives the accuracy percentage.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Splitting the data for training and testing samples \r\nfrom sklearn.model_selection import train_test_split\r\nx_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)\r\n\r\n#Applying Support Vector Machine\r\nfrom k_inertia.supervised import SVM\r\nsvm = SVM(learning_rate = 0.0001, lambda_param = 0.01)\r\nsvm.fit(x_train, y_train)\r\npredict = svm.predict(x_test)\r\n```\r\n***\r\n## K-Means Clustering\r\n```\r\nclass k_inertia.unsupervised.KMeans(k=5, max_iters=100)\r\n```\r\nK-Means Clustering is an unsupervised machine learning algorithm used for partitioning a dataset into K distinct, non-overlapping subsets (clusters). Each data point belongs to the cluster with the nearest mean, and the mean of each cluster serves as a representative or centroid of that cluster. K-Means is commonly used for grouping data points based on similarity and is widely applied in various fields, including image segmentation, customer segmentation, and anomaly detection.\r\n\r\n#### Parameters:\r\n'k' : Number of clusters\r\n\r\n'max_iters' : This parameter, defines the number of times the iterations takes place to train this model.\r\n\r\n#### Methods:\r\n`predict(X)` : Takes the independent features of data as parameter and predicts the result.\r\n\r\n``` py\r\n#Reading the data through csv\r\nimport pandas as pd\r\ndata = pd.read_csv(\"example.csv\")\r\nx = data.iloc[:, :-1].values\r\ny = data.iloc[:, -1].values\r\n\r\n#Applying K-Means Clustering\r\nfrom k_inertia.unsupervised import KMeans\r\nmeans = KMeans(k = 3)\r\npredict = svm.predict(x)\r\n```\r\n***\r\n\r\n\r\n\r\n\r\n\r\n\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "K-Inertia: A User-Friendly Machine Learning Library K-Inertia or Kavish Inertia is a Python machine learning library designed for simplicity and ease of use. With a focus on user-friendly interfaces, K-Inertia provides implementations of various machine learning algorithms, including regression, logistic regression, k-nearest neighbors, naive Bayes, support vector machines, and k-means clustering.",
"version": "0.0.5",
"project_urls": null,
"split_keywords": [
"machine learning",
"k_inertia",
"k-inertia",
"learning",
"ai",
"ai",
"ml",
"ml",
"k-inertia",
"machine learning"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "6424894ff4e0410761f6ca4651eb0352b383ddbde899eaaefa55bc936c9f8f25",
"md5": "c811cf7bd0550463aaa2b76fe10fa95e",
"sha256": "ab84e5cf8943946b8fe670e79bcf87234f19bd557de9f21d42da4b227c03cc58"
},
"downloads": -1,
"filename": "knertia-0.0.5-py3-none-any.whl",
"has_sig": false,
"md5_digest": "c811cf7bd0550463aaa2b76fe10fa95e",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 7374,
"upload_time": "2023-12-15T20:20:15",
"upload_time_iso_8601": "2023-12-15T20:20:15.565095Z",
"url": "https://files.pythonhosted.org/packages/64/24/894ff4e0410761f6ca4651eb0352b383ddbde899eaaefa55bc936c9f8f25/knertia-0.0.5-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "bbbf5ee0d1423901eeaa84b9340bfbf49b09ef09464088ad11e30614d5c53911",
"md5": "1f6ee9a2bd50d2c4b12c2ec7dd08291e",
"sha256": "025aa617c8c9ec6014450b7438b02c6778277fb1d60bfbfd28baab36cf46036d"
},
"downloads": -1,
"filename": "knertia-0.0.5.tar.gz",
"has_sig": false,
"md5_digest": "1f6ee9a2bd50d2c4b12c2ec7dd08291e",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 8002,
"upload_time": "2023-12-15T20:20:19",
"upload_time_iso_8601": "2023-12-15T20:20:19.704836Z",
"url": "https://files.pythonhosted.org/packages/bb/bf/5ee0d1423901eeaa84b9340bfbf49b09ef09464088ad11e30614d5c53911/knertia-0.0.5.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-12-15 20:20:19",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "knertia"
}
