matplotliblib 0.1__tar.gz → 0.3__tar.gz

{matplotliblib-0.1 → matplotliblib-0.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: matplotliblib
-Version: 0.1
+Version: 0.3
 Summary: Collection of machine learning tools
-Author: .
+Author: Anonymus
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7

{matplotliblib-0.1 → matplotliblib-0.3}/matplotliblib/__init__.py

@@ -6,9 +6,10 @@ __all__ = [
     "kmeans",
     "regression",
     "association",
+    "accociationm",
     "cnn",
     "recommendation",
     "timeseries",
     "anomaly",
     "text"
-]
+]

{matplotliblib-0.1 → matplotliblib-0.3}/matplotliblib/main.py

@@ -17,35 +17,25 @@ print("Description")
 df.describe()
 
 print("Null values: \n", df.isnull().sum())
-df.hist(figsize=(10,6))
-plt.show()
 
-
-#Hisogram:
 df.hist(figsize=(10,6))
 plt.show()
 
-#Boxplot
 sns.boxplot(data=df)
 plt.show()
 
-
-#Countplot
 sns.countplot(x='species', data=df)
 plt.show()
 
-
 #Scatter Plot
 plt.scatter(df['sepal_length'], df['sepal_width'])
 plt.xlabel('Sepal Length')
 plt.ylabel('Sepal Width')
 plt.show()
 
-#Pairplot
 sns.pairplot(df, hue='species')
 plt.show()
 
-#Scatter Multiple
 plt.figure(figsize=(10,6))
 plt.scatter(df['petal_length'], df['sepal_length'], label='Sepal Length')
 plt.scatter(df['petal_length'], df['sepal_width'], label='Sepal Width')
@@ -57,13 +47,11 @@ plt.title('Scatter Multiple Plot (Iris Dataset)')
 plt.legend()
 plt.show()
 
-#Scatter Matrix
 from pandas.plotting import scatter_matrix
 plt.figure(figsize=(10,8))
 scatter_matrix(df.iloc[:, :4], figsize=(10,8), diagonal='hist')
 plt.show()
 
-#Parallel Coordinates plot
 from pandas.plotting import parallel_coordinates
 
 plt.figure(figsize=(10,6))
@@ -93,7 +81,7 @@ plt.show()
 
 def decisiontree():
     print('''
-    import pandas as pd
+import pandas as pd
 import numpy as np
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.model_selection import train_test_split
@@ -124,7 +112,7 @@ plot_tree(dt_model, feature_names=iris.feature_names,
           class_names=iris.target_names, filled=True)
 plt.show()
 
-# Create decision tree model on mtcars dataset
+# mtcars dataset
 import pandas as pd
 import numpy as np
 from sklearn.tree import DecisionTreeClassifier
@@ -192,7 +180,7 @@ plt.ylabel("Petal Width")
 plt.title("K-Means Clustering on Iris Dataset")
 plt.show()
 
-# DBSCAN using Iris Dataset
+# DBSCAN 
 import numpy as np
 import matplotlib.pyplot as plt
 from sklearn.datasets import load_iris
@@ -216,42 +204,30 @@ plt.xlabel("Sepal Length")
 plt.ylabel("Sepal Width")
 plt.title("DBSCAN Clustering on Iris Dataset")
 plt.show()
-
-
-
-
     ''')
 
 def regression():
     print('''
-#Simple Linear Regression
-
-# Basic operations
+#Slr
 import numpy as np
 import pandas as pd
 
-# Plotting
 import matplotlib.pyplot as plt
 import seaborn as sns
 
-# sklearn for model building & evaluation
 from sklearn.linear_model import LinearRegression
 from sklearn.model_selection import train_test_split, cross_val_score, KFold
 from sklearn.metrics import mean_squared_error, r2_score
 
-# statsmodels for detailed regression output (p-values, std err, etc.)
+#(p-values, std err)
 import statsmodels.api as sm
-
-# For VIF (multicollinearity)
 from statsmodels.stats.outliers_influence import variance_inflation_factor
 
-# For qqplot
 import scipy.stats as stats 
 
 hours = np.array([1, 2, 4, 5, 5, 6])
 score = np.array([64, 66, 76, 73, 74, 81])
 
-# Put into a DataFrame for convenience
 df = pd.DataFrame({"hours": hours, "score": score})
 
 # Scatter plot with regression line visually
@@ -262,37 +238,32 @@ plt.xlabel("Hours studied")
 plt.ylabel("Exam Score")
 plt.show()
 
-# Boxplot to check distribution & outliers (response variable)
+# Boxplot 
 plt.figure()
 sns.boxplot(y=df["score"])
 plt.title("Boxplot of Exam Scores")
 plt.show()
 
-# Prepare X and y
 X = df[["hours"]]  # 2D array (n_samples, n_features)
 y = df["score"]
 
-# Fit model (sklearn)
 lr = LinearRegression()
 lr.fit(X, y)
 
-# Coefficients
 b0 = lr.intercept_
 b1 = lr.coef_[0]
 print(f"Intercept (b0): {b0:.4f}")
 print(f"Slope (b1): {b1:.4f}")
 
-# Add constant for intercept term
-X_sm = sm.add_constant(X)  # adds column of 1s for intercept
+X_sm = sm.add_constant(X) 
 model_sm = sm.OLS(y, X_sm).fit()
 print(model_sm.summary())
 
-# Predict with sklearn model (single value)
+#(single value)
 new_hours = pd.DataFrame({"hours": [3]})
 predicted_score = lr.predict(new_hours)
 print("Predicted score for 3 hours:", predicted_score[0])
 
-# For presentation: create a DataFrame with a range and show predictions
 grid = pd.DataFrame({"hours": np.linspace(df.hours.min(), df.hours.max(), 50)})
 grid["predicted_score"] = lr.predict(grid)
 grid.head()
@@ -309,19 +280,19 @@ plt.ylabel("Residuals")
 plt.title("Residuals vs Fitted")
 plt.show()
 
-# QQ-plot of residuals
+#QQ
 plt.figure()
 sm.qqplot(df["residuals"], line='45', fit=True)
 plt.title("Q-Q plot of residuals")
 plt.show()
 
-# Histogram of residuals (optional)
+#Hist
 plt.figure()
 sns.histplot(df["residuals"], kde=True)
 plt.title("Histogram of residuals")
 plt.show()
 
-# Multiple Linear Regression
+#mlr
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -338,23 +309,21 @@ from statsmodels.stats.stattools import durbin_watson
 import scipy.stats as stats
 
 house = pd.read_csv("index.csv")
-# Quick peek
 house.head()
 house.shape
 
-house.info()          # data types and non-null counts
-house.describe().T    # mean, std, min, max, quartiles
-house.columns         # column names
+house.info()          
+house.describe().T    
+house.columns      
 
-# Check missing values
 house.isnull().sum()
 
-# Pairwise relationships 
+#Pairwiserelation
 sns.pairplot(house[['death_rate','doctor_avail','hosp_avail','annual_income','density_per_capita']])
 plt.suptitle("Pairwise plots", y=1.02)
 plt.show()
 
-# Correlation matrix (helpful for collinearity)
+# Correlation matrix
 corr = house[['death_rate','doctor_avail','hosp_avail','annual_income','density_per_capita']].corr()
 print(corr)
 sns.heatmap(corr, annot=True, fmt=".2f")
@@ -364,10 +333,8 @@ plt.show()
 X = house[['death_rate','doctor_avail','hosp_avail','annual_income']]
 y = house['density_per_capita']
 
-# (Optional) Train-test split for validation
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
-# Fit with sklearn (fast, gives coefficients)
 lr = LinearRegression()
 lr.fit(X_train, y_train)
 
@@ -376,20 +343,16 @@ print("Coefficients (sklearn):")
 for name, coef in zip(X.columns, lr.coef_):
     print(f"  {name}: {coef:.6f}")
 
-# Fit with statsmodels to get p-values, std errors, R-squared etc.
-X_sm = sm.add_constant(X)           # adds intercept column
+# p-values, std errors, R-squared etc.
+X_sm = sm.add_constant(X)           
 model_sm = sm.OLS(y, X_sm).fit()
 
-# Use statsmodels' summary (detailed regression table)
 print(model_sm.summary())
 
-# Predict on training data or new data
 house['predicted'] = model_sm.predict(X_sm)   # statsmodels predict expects same X with constant
 
-# If using sklearn model (trained on X_train)
 y_test_pred = lr.predict(X_test)
 
-# Example: predict for a new observation (replace with real numbers)
 new_obs = pd.DataFrame({'death_rate':[2.0], 'doctor_avail':[1.5], 'hosp_avail':[0.7], 'annual_income':[35000]})
 pred_new = lr.predict(new_obs)   # sklearn
 print("Predicted density_per_capita for new_obs:", pred_new[0])
@@ -399,7 +362,6 @@ r2 = r2_score(y_test, y_test_pred)
 print("Test RMSE:", rmse)
 print("Test R2:", r2)
 
-# Step 6 - Visualize the model
 for col in X.columns:
     plt.figure()
     sns.scatterplot(x=house[col], y=house['density_per_capita'])
@@ -419,7 +381,7 @@ plt.ylabel('Actual')
 plt.title('Actual vs Predicted')
 plt.show()
 
-# Residuals vs Fitted (diagnose heteroscedasticity / non-linearity)
+# Residuals vs Fitted (heteroscedasticity / non-linearity)
 residuals = house['density_per_capita'] - house['predicted']
 plt.figure()
 sns.scatterplot(x=house['predicted'], y=residuals)
@@ -429,22 +391,17 @@ plt.ylabel('Residuals')
 plt.title('Residuals vs Fitted')
 plt.show()
 
-# Q-Q Plot for residuals (normality)
+# Q-Q Plot
 sm.qqplot(residuals, line='45', fit=True)
 plt.title('Q-Q plot of residuals')
 plt.show()
 
-# Shapiro test (numeric)
 stat, pval = stats.shapiro(residuals)
 print("Shapiro-Wilk: stat=%.4f, p=%.4f" % (stat, pval))
 
 # Influence / Leverage plot (outliers & influential points)
 sm.graphics.influence_plot(model_sm, criterion="cooks")
 plt.show()
-
-
-
-
     ''')
 
 def association():
@@ -477,8 +434,23 @@ rules = association_rules(
 print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])
 
 
-# USING FP-Growth ALgorithm
+# FP-Growth
+import pandas as pd
+from mlxtend.preprocessing import TransactionEncoder
+from mlxtend.frequent_patterns import apriori, association_rules
 from mlxtend.frequent_patterns import fpgrowth
+
+transactions = [
+    ['Milk', 'Bread'],
+    ['Bread', 'Diaper', 'Beer', 'Eggs'],
+    ['Milk', 'Diaper', 'Beer', 'Cola'],
+    ['Bread', 'Milk', 'Diaper', 'Beer'],
+    ['Bread', 'Milk', 'Diaper', 'Cola']
+]
+
+te = TransactionEncoder()
+te_array = te.fit(transactions).transform(transactions)
+df = pd.DataFrame(te_array, columns=te.columns_)
 print(df)
 frequent_itemsets_fp = fpgrowth(df, min_support=0.4, use_colnames=True)
 print(frequent_itemsets_fp)
@@ -621,33 +593,26 @@ plt.plot(forecast, label='Forecast', color='red')
 plt.legend()
 plt.show()
 
-
-
-
-
     ''')
 
 def anomaly():
     print('''
+# Z-Score
 import pandas as pd
 from scipy.stats import zscore
 
-# Salary data
 df = pd.DataFrame({
     'Employee_ID': ['E01','E02','E03','E04','E05','E06','E07'],
     'Salary': [48000, 52000, 50500, 49200, 51000, 120000, 18000]
 })
 
-# Z-score calculation
 df['Z_Score'] = zscore(df['Salary'])
 print(df['Z_Score'])
 
-# Detect outliers
 outliers = df[abs(df['Z_Score']) > 2]
 print(outliers)
 
 # IQR Method
-# Employee salary data
 data = {
     'Employee_ID': ['E01','E02','E03','E04','E05','E06','E07'],
     'Salary': [48000, 52000, 50500, 49200, 51000, 120000, 18000]
@@ -655,18 +620,14 @@ data = {
 
 df = pd.DataFrame(data)
 
-# Calculate Q1 and Q3
 Q1 = df['Salary'].quantile(0.25)
 Q3 = df['Salary'].quantile(0.75)
 
-# Calculate IQR
 IQR = Q3 - Q1
 
-# Define lower and upper bounds
 lower_bound = Q1 - 1.5 * IQR
 upper_bound = Q3 + 1.5 * IQR
 
-# Detect outliers
 outliers = df[
     (df['Salary'] < lower_bound) |
     (df['Salary'] > upper_bound)
@@ -677,8 +638,52 @@ print("Upper Bound:", upper_bound)
 print("\nDetected Outliers:")
 print(outliers)
 
+#IsolationForest 
+from sklearn.ensemble import IsolationForest
+import pandas as pd
+
+df = pd.DataFrame({
+    'Amount': [2800, 3200, 3500, 2900, 3100, 18000, 50]
+})
+
+model = IsolationForest(contamination=0.2, random_state=42)
+df['Anomaly'] = model.fit_predict(df)
+
+print(df)
+
+#KNN
+from sklearn.neighbors import NearestNeighbors
+import pandas as pd
+
+df = pd.DataFrame({
+    'Delivery_Time': [46, 48, 50, 47, 49, 95, 10]
+})
+
+nbrs = NearestNeighbors(n_neighbors=3)
+nbrs.fit(df)
+
+distances, _ = nbrs.kneighbors(df)
+df['Avg_Distance'] = distances.mean(axis=1)
+
+threshold = df['Avg_Distance'].mean() + 2*df['Avg_Distance'].std()
+outliers = df[df['Avg_Distance'] > threshold]
+
+print(outliers)
+
+#LOF
+from sklearn.neighbors import LocalOutlierFactor
+import pandas as pd
+
+df = pd.DataFrame({
+    'Spending_Score': [45, 50, 48, 52, 49, 98, 5],
+    'Purchase_Frequency': [18, 20, 22, 19, 21, 65, 2]
+})
 
+lof = LocalOutlierFactor(n_neighbors=3)
+df['Outlier'] = lof.fit_predict(df)
 
+outliers = df[df['Outlier'] == -1]
+print(outliers)
     ''')
 
 def text():
@@ -783,3 +788,214 @@ print(similarity)
 
     ''')
 
+def associationm():
+    print('''
+# apriori Algorithm
+transactions = [
+    {'Milk', 'Bread'},
+    {'Bread', 'Diaper', 'Beer', 'Eggs'},
+    {'Milk', 'Diaper', 'Beer', 'Cola'},
+    {'Bread', 'Milk', 'Diaper', 'Beer'},
+    {'Bread', 'Milk', 'Diaper', 'Cola'}
+]
+
+total_transactions = len(transactions)
+min_support = 0.4
+min_confidence = 0.6
+
+def calculate_support(itemset):
+    count = 0
+    for transaction in transactions:
+        if itemset.issubset(transaction):
+            count += 1
+    return count / total_transactions
+
+items = set().union(*transactions)
+frequent_1 = {}
+
+for item in items:
+    sup = calculate_support({item})
+    if sup >= min_support:
+        frequent_1[frozenset([item])] = sup
+
+print("Frequent 1-Itemsets:")
+for k, v in frequent_1.items():
+    print(set(k), ":", v)
+
+from itertools import combinations
+
+frequent_2 = {}
+
+for pair in combinations(items, 2):
+    sup = calculate_support(set(pair))
+    if sup >= min_support:
+        frequent_2[frozenset(pair)] = sup
+
+print("\nFrequent 2-Itemsets:")
+for k, v in frequent_2.items():
+    print(set(k), ":", v)
+
+frequent_3 = {}
+
+for triple in combinations(items, 3):
+    sup = calculate_support(set(triple))
+    if sup >= min_support:
+        frequent_3[frozenset(triple)] = sup
+
+print("\nFrequent 3-Itemsets:")
+for k, v in frequent_3.items():
+    print(set(k), ":", v)
+
+def calculate_confidence(A, B):
+    return calculate_support(A.union(B)) / calculate_support(A)
+
+rules = []
+
+for itemset in frequent_2:
+    for item in itemset:
+        A = frozenset([item])
+        B = itemset - A
+        conf = calculate_confidence(set(A), set(B))
+        if conf >= min_confidence:
+            rules.append((A, B, conf))
+
+print("\nAssociation Rules:")
+for rule in rules:
+    print(set(rule[0]), "→", set(rule[1]), "Confidence:", rule[2])
+
+def calculate_lift(A, B):
+    return calculate_confidence(A, B) / calculate_support(B)
+
+print("\nAssociation Rules with Lift:")
+for rule in rules:
+    lift = calculate_lift(set(rule[0]), set(rule[1]))
+    print(set(rule[0]), "→", set(rule[1]), "Lift:", lift)
+
+# FP-Growth Algorithm
+transactions = [
+    ['Milk', 'Bread'],
+    ['Bread', 'Diaper', 'Beer', 'Eggs'],
+    ['Milk', 'Diaper', 'Beer', 'Cola'],
+    ['Bread', 'Milk', 'Diaper', 'Beer'],
+    ['Bread', 'Milk', 'Diaper', 'Cola']
+]
+
+min_support = 2
+
+from collections import defaultdict
+
+item_count = defaultdict(int)
+
+for transaction in transactions:
+    for item in transaction:
+        item_count[item] += 1
+
+print("Item Frequencies:")
+for item, count in item_count.items():
+    print(item, ":", count)
+
+frequent_items = {item: count for item, count in item_count.items()
+                  if count >= min_support}
+
+print("\nFrequent Items:")
+print(frequent_items)
+
+sorted_transactions = []
+
+for transaction in transactions:
+    filtered = [item for item in transaction if item in frequent_items]
+    sorted_trans = sorted(filtered,
+                          key=lambda x: frequent_items[x],
+                          reverse=True)
+    sorted_transactions.append(sorted_trans)
+
+print("\nSorted Transactions:")
+for t in sorted_transactions:
+    print(t)
+
+class FPNode:
+    def __init__(self, item, count, parent):
+        self.item = item
+        self.count = count
+        self.parent = parent
+        self.children = {}
+
+root = FPNode(None, 0, None)
+
+def insert_tree(transaction, node):
+    if len(transaction) == 0:
+        return
+    first = transaction[0]
+    if first in node.children:
+        node.children[first].count += 1
+    else:
+        node.children[first] = FPNode(first, 1, node)
+    insert_tree(transaction[1:], node.children[first])
+
+for transaction in sorted_transactions:
+    insert_tree(transaction, root)
+
+def display_tree(node, indent=0):
+    for child in node.children.values():
+        print(" " * indent, child.item, ":", child.count)
+        display_tree(child, indent + 4)
+
+print("\nFP-Tree:")
+display_tree(root)
+
+frequent_patterns = {}
+
+for item, count in frequent_items.items():
+    frequent_patterns[(item,)] = count
+
+print("\nFrequent Patterns:")
+for pattern, count in frequent_patterns.items():
+    print(pattern, ":", count)
+
+''')
+
+def logreg():
+print('''
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
+
+df = sns.load_dataset("titanic")
+
+df = df[["survived", "pclass", "sex", "age", "sibsp", "parch", "fare"]]
+
+df["age"] = df["age"].fillna(df["age"].median())
+
+df["sex"] = df["sex"].map({"male": 0, "female": 1})
+
+X = df.drop("survived", axis=1)
+y = df["survived"]
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+model = LogisticRegression(max_iter=500)
+model.fit(X_train, y_train)
+
+y_pred = model.predict(X_test)
+
+acc = accuracy_score(y_test, y_pred)
+cm = confusion_matrix(y_test, y_pred)
+report = classification_report(y_test, y_pred)
+
+print("Accuracy:", acc)
+print("\nConfusion Matrix:\n", cm)
+print("\nClassification Report:\n", report)
+
+plt.figure(figsize=(6, 4))
+sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", cbar=False,
+ xticklabels=["Predicted 0", "Predicted 1"],
+ yticklabels=["Actual 0", "Actual 1"])
+plt.title("Confusion Matrix")
+plt.ylabel("Actual")
+plt.xlabel("Predicted")
+plt.show()
+''')

{matplotliblib-0.1 → matplotliblib-0.3}/matplotliblib.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: matplotliblib
-Version: 0.1
+Version: 0.3
 Summary: Collection of machine learning tools
-Author: .
+Author: Anonymus
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7

{matplotliblib-0.1 → matplotliblib-0.3}/setup.py

@@ -2,10 +2,10 @@ from setuptools import setup, find_packages
 
 setup(
     name="matplotliblib",
-    version="0.1",
+    version="0.3",
     packages=find_packages(),
 
-    author=".",
+    author="Anonymus",
     description="Collection of machine learning tools",
     
     python_requires=">=3.7",
@@ -14,4 +14,4 @@ setup(
         "Programming Language :: Python :: 3",
         "Operating System :: OS Independent",
     ],
-)
+)