myawesomepkg 0.1.8__py3-none-any.whl

myawesomepkg/TSAPY1/p5_2_k_nearest_neighbour_algorithm.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""P5-2-k-Nearest Neighbour algorithm.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/11ueW4m9D1Cgcs82q8_mtcg4Vgh5Qb0zi
+"""
+
+import pandas as pd
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn import preprocessing
+from sklearn.model_selection import train_test_split
+iris= pd.read_csv('/content/iris.csv') # Import the iris.csv dataset
+iris.head() #Display the iris dataset
+iris.shape #Display the dimensions of the iris dataset
+iris['variety'].value_counts()#Dislay the no of instances belonging to every value of the dependent variable
+iris.columns #Display the column_headers of the iris dataset
+iris.values #Display the values of the dataset
+X=iris.iloc[:,:4] #Define the independent variable vector X
+X.head()#Display X
+y=iris.iloc[:,-1] #Define the dependent variable y
+y.head()#Display y
+X=preprocessing.StandardScaler().fit_transform(X)#Preprocess the data to achieve a mean of 0 and standard deviation of 1
+X[0:4] #Display the preprocessed data
+X_train, X_test, Y_train, Y_test = train_test_split(X,y,test_size=0.3) #Create the training set and the testing set
+Y_test.shape #Display the dimensions of Y_test
+knnmodel=KNeighborsClassifier(n_neighbors=3) #Build the KNN model for k=3
+knnmodel.fit(X_train,Y_train) #Train the KNN Model
+Y_pred = knnmodel.predict(X_test) #Use the KNN model for predicting the class of the test set
+Y_pred #Display the result of prediction
+
+#Calculate the accuracy of the model
+from sklearn.metrics import accuracy_score
+accuracy_score(Y_test,Y_pred)
+
+#Constructing the confusion matrix
+from sklearn.metrics import confusion_matrix
+cm=confusion_matrix(Y_test.values,Y_pred)
+cm
+
+#Visualization of the output
+
+cm1=pd.DataFrame(data=cm,index=['Setosa','Versicolor','Virginica'],columns=['Setosa','Versicolor','Virginica'])
+cm1
+pred_output=pd.DataFrame(data=[Y_test.values,Y_pred],index=['Y_test','Y_pred'])
+pred_output.transpose()
+
+# Import necessary libraries
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay
+
+# Load the dataset
+iris = pd.read_csv(r"/content/iris.csv")
+
+# Display basic information
+print("Dataset Head:\n", iris.head())
+print("\nShape of dataset:", iris.shape)
+print("\nClass distribution:\n", iris['variety'].value_counts())
+
+# Split data into features and target
+X = iris.iloc[:, :-1]   # Independent variables
+y = iris.iloc[:, -1]    # Target variable
+
+# Standardize the features
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+# Split into train and test sets
+X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42, stratify=y)
+
+# Build and train the KNN model
+knn_model = KNeighborsClassifier(n_neighbors=3)
+knn_model.fit(X_train, y_train)
+
+# Make predictions
+y_pred = knn_model.predict(X_test)
+
+# Calculate model accuracy
+accuracy = accuracy_score(y_test, y_pred)
+print("\nModel Accuracy: {:.2f}%".format(accuracy * 100))
+
+# Construct the confusion matrix
+cm = confusion_matrix(y_test, y_pred)
+cm_df = pd.DataFrame(cm, index=iris['variety'].unique(), columns=iris['variety'].unique())
+print("\nConfusion Matrix:\n", cm_df)
+
+# Visualize confusion matrix
+disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=iris['variety'].unique())
+disp.plot(cmap='Blues')
+plt.title("Confusion Matrix - KNN Classifier")
+plt.show()
+
+# Combine predictions and actual values for comparison
+pred_output = pd.DataFrame({'Actual': y_test.values, 'Predicted': y_pred})
+print("\nPrediction Results:\n", pred_output.head(10))
+

myawesomepkg/TSAPY1/p6_1_id3_algorithm_.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""P6-1-ID3 Algorithm .ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/145Q19eQyjP4BwvvSJCQ3_q12QGmQJ-il
+"""
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import pandas as pd
+from pandas import DataFrame
+
+df_tennis = pd.DataFrame(data=pd.read_csv('/content/PlayTennis.csv'))
+df_tennis.head()
+
+#Entropy formula procedure
+def entropy(probs):
+    import math
+    return sum([-prob*math.log(prob,2)for prob in probs])
+
+#Entropy calculation for the attributes
+def entropy_of_list(a_list): #Input list of class labels
+    from collections import Counter
+    cnt=Counter(x for x in a_list) #Counter calculates the proportion of class
+    num_instances=len(a_list)*1.0  #=14
+    probs=[x/num_instances for x in cnt.values()] #x means number of YES/NO 9/14 and 5/14
+    return entropy(probs) #Call Entropy
+
+#Calculating the Entropy of the target variable
+total_entropy=entropy_of_list(df_tennis['PlayTennis'])
+print('\n The total Entropy is:\n',total_entropy)
+
+#Calculating Information Gain
+def information_gain(df,split_attribute_name,target_attribute_name,trace=0):
+    df_split=df.groupby(split_attribute_name)#Split datasets into groups or subsets by literals
+    nobs=len(df.index)*1.0 #count total no of observations
+    #Compute Entropy and Proportion for each group
+    df_agg_ent=df_split.agg({target_attribute_name:[entropy_of_list,lambda x:len(x)/nobs]})[target_attribute_name]
+    df_agg_ent.columns=['Entropy','PropObservations'] #Renaming columns
+    new_entropy=sum(df_agg_ent['Entropy']*df_agg_ent['PropObservations'])
+    old_entropy=entropy_of_list(df[target_attribute_name])
+    return old_entropy-new_entropy
+
+"""Explanation:df_split.agg()
+For each group, aggregate (agg) the target_attribute_name (PlayTennis) using two functions:
+
+entropy_of_list → entropy of that group’s labels.
+
+lambda x: len(x)/nobs → proportion of total rows that belong to this group.
+
+Example for "Outlook":
+
+Group "Sunny" (5 rows): entropy ≈ 0.971, proportion = 5/14.
+
+Group "Overcast" (4 rows): entropy = 0.0, proportion = 4/14.
+
+Group "Rain" (5 rows): entropy ≈ 0.971, proportion = 5/14.
+
+The [target_attribute_name] selects only the part of the DataFrame we care about.
+"""
+
+def id3(df,target_attribute_name,attribute_names,default_class=None):
+    from collections import Counter
+    cnt=Counter(x for x in df[target_attribute_name])# Count class labels YES/NO
+    if len(cnt)==1:#Pure subset indicating only one class left
+	    return next(iter(cnt))#next input data set, or raises StopIteration when EOF is hit
+    elif df.empty or (not attribute_names):
+	    return default_class #Return None for empty data set or no attributes left
+    else:
+	    default_class=max(cnt.keys())#Assign the default class as the max between Yes/No
+        #Compute Information Gain for each attribute
+	    gainz=[information_gain(df,attr,target_attribute_name)for attr in attribute_names]
+        #Select best attribute with maximum information gain
+	    index_of_max=gainz.index(max(gainz))#Index of Best_Attribute
+	    best_attr=attribute_names[index_of_max]
+	    tree={best_attr:{}}#Initiate the tree with the best attribute as a node
+        #After choosing the best attribute, it’s removed from the list
+	    remaining_attribute_names=[i for i in attribute_names if i!=best_attr]
+        #Recursive splitting and building subtrees
+	    for attr_val,data_subset in df.groupby(best_attr):
+		    subtree=id3(data_subset,target_attribute_name,remaining_attribute_names,default_class)
+		    tree[best_attr][attr_val]=subtree # Attach the resulting subtree to the main tree
+	    return tree
+
+attribute_names=list(df_tennis.columns)
+attribute_names.remove('PlayTennis')#Remove the class attirbute
+
+#Run Algorithm:
+from pprint import pprint
+tree=id3(df_tennis,'PlayTennis',attribute_names)
+print("\n The resulatnt DECISION TREE is:\n")
+pprint(tree)
+
+#Result for new instance
+def classify(instance,tree,default=None):
+	attribute=next(iter(tree)) #Get first attribute from the tree
+	if instance[attribute] in tree[attribute].keys(): #Check if instance value exists in the tree
+		result=tree[attribute][instance[attribute]] #Get the subtree
+		if isinstance(result,dict):#Recursive case: if result is still a tree
+			return classify(instance,result)
+		else:
+			return result
+
+"""Get subtree:
+If instance["Outlook"] = "Sunny", then
+result = {'Humidity': {'High': 'No', 'Normal': 'Yes'}}
+"""
+
+#Creation of Training set
+training_data=df_tennis.iloc[0:-4]
+print(training_data)
+
+#Test set
+test_data=df_tennis.iloc[-4:]
+print(test_data)
+
+train_tree=id3(training_data,'PlayTennis',attribute_names)
+
+#Prediction on new Data
+test_data['predicted']=test_data.apply(classify,axis=1,args=(train_tree,'yes'))
+print(test_data['predicted'])
+
+import pandas as pd
+import numpy as np
+import math
+from collections import Counter
+from pprint import pprint
+import warnings
+warnings.filterwarnings("ignore")
+
+# Load dataset
+df = pd.read_csv(r"/content/PlayTennis.csv")
+print("Dataset:\n", df.head())
+
+# ---------- Step 1: Entropy Calculation ----------
+def entropy(values):
+    probs = [v / len(values) for v in Counter(values).values()]
+    return -sum(p * math.log2(p) for p in probs)
+
+# ---------- Step 2: Information Gain ----------
+def information_gain(df, attr, target):
+    total_entropy = entropy(df[target])
+    vals, counts = np.unique(df[attr], return_counts=True)
+    weighted_entropy = sum(
+        (counts[i] / len(df)) * entropy(df[df[attr] == vals[i]][target])
+        for i in range(len(vals))
+    )
+    return total_entropy - weighted_entropy
+
+# ---------- Step 3: ID3 Algorithm ----------
+def id3(df, target, attributes):
+    # Base cases
+    if len(df[target].unique()) == 1:
+        return df[target].iloc[0]
+    if not attributes:
+        return df[target].mode()[0]
+
+    # Choose best attribute
+    gains = [information_gain(df, attr, target) for attr in attributes]
+    best_attr = attributes[np.argmax(gains)]
+
+    # Build tree recursively
+    tree = {best_attr: {}}
+    for val in df[best_attr].unique():
+        subset = df[df[best_attr] == val]
+        subtree = id3(subset, target, [a for a in attributes if a != best_attr])
+        tree[best_attr][val] = subtree
+    return tree
+
+# ---------- Step 4: Train the Model ----------
+attributes = list(df.columns)
+attributes.remove('PlayTennis')
+tree = id3(df, 'PlayTennis', attributes)
+
+print("\nDecision Tree:")
+pprint(tree)
+
+# ---------- Step 5: Classification ----------
+def classify(instance, tree):
+    attr = next(iter(tree))
+    val = instance[attr]
+    subtree = tree[attr].get(val, None)
+    if isinstance(subtree, dict):
+        return classify(instance, subtree)
+    return subtree
+
+# ---------- Step 6: Train-Test Split ----------
+train = df.iloc[:-4]
+test = df.iloc[-4:]
+
+tree_train = id3(train, 'PlayTennis', attributes)
+
+# Predict for test set
+test['Predicted'] = test.apply(classify, axis=1, args=(tree_train,))
+print("\nPredictions:\n", test[['PlayTennis', 'Predicted']])
+

myawesomepkg/TSAPY1/p7_1_ann_backpropagation_algorithm.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""P7-1-ANN Backpropagation algorithm.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1m_PxuQ8-4tq235R3C2j8vSIODh7TXBmq
+"""
+
+import numpy as np
+
+X = np.array(([2, 9], [1, 5], [3, 6]), dtype=float)#two inputs [sleep,study]
+y = np.array(([92], [86], [89]), dtype=float)#one output expected perecntage in exam
+X = X/np.amax(X,axis=0) #maximum of X array longitudinally
+y = y/100 #Convert to fraction
+
+#Variable initialization
+epoch=5 #Setting training iterations
+lr=0.1 #Setting learning rate
+inputlayer_neurons = 2 #number of features in data set
+hiddenlayer_neurons = 3 #number of hidden layers neurons
+output_neurons = 1 #number of neurons at output layer
+
+#weight and bias initialization
+wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))
+bh=np.random.uniform(size=(1,hiddenlayer_neurons))
+wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))
+bout=np.random.uniform(size=(1,output_neurons))
+
+#Sigmoid Function
+def sigmoid (x):
+    return 1/(1 + np.exp(-x))
+
+#Derivative of Sigmoid Function
+def derivatives_sigmoid(x):
+    return x * (1 - x)
+
+#draws a random range of numbers uniformly of dim x*y
+for i in range(epoch):
+    #Forward Propogation
+    hinp1=np.dot(X,wh)
+    hinp=hinp1 + bh
+    hlayer_act = sigmoid(hinp)
+    outinp1=np.dot(hlayer_act,wout)
+    outinp= outinp1+bout
+    output = sigmoid(outinp)
+    #Backpropagation
+    EO = y-output
+    outgrad = derivatives_sigmoid(output)
+    d_output = EO * outgrad
+    EH = d_output.dot(wout.T)
+    hiddengrad = derivatives_sigmoid(hlayer_act)#how much hidden layer wts contributed to error
+    d_hiddenlayer = EH * hiddengrad
+
+    wout += hlayer_act.T.dot(d_output) *lr   # dotproduct of nextlayererror and currentlayerop
+    wh += X.T.dot(d_hiddenlayer) *lr
+
+    print ("-----------Epoch-", i+1, "Starts----------")
+    print("Input: \n" + str(X))
+    print("Actual Output: \n" + str(y))
+    print("Predicted Output: \n" ,output)
+    print ("-----------Epoch-", i+1, "Ends----------\n")
+
+print("Input: \n" + str(X))
+print("Actual Output: \n" + str(y))
+print("Predicted Output: \n" ,output)
+
+import numpy as np
+
+# Input (Sleep, Study hours) and Output (Exam %)
+X = np.array([[2, 9], [1, 5], [3, 6]], dtype=float)
+y = np.array([[92], [86], [89]], dtype=float)
+
+# Normalize input and output
+X = X / np.max(X, axis=0)
+y = y / 100
+
+# Hyperparameters
+epochs = 5
+lr = 0.1
+input_neurons, hidden_neurons, output_neurons = 2, 3, 1
+
+# Weight & Bias initialization
+wh = np.random.rand(input_neurons, hidden_neurons)
+bh = np.random.rand(1, hidden_neurons)
+wout = np.random.rand(hidden_neurons, output_neurons)
+bout = np.random.rand(1, output_neurons)
+
+# Activation functions
+def sigmoid(x): return 1 / (1 + np.exp(-x))
+def sigmoid_derivative(x): return x * (1 - x)
+
+# Training loop
+for epoch in range(epochs):
+    # Forward Propagation
+    hidden_input = np.dot(X, wh) + bh
+    hidden_output = sigmoid(hidden_input)
+    final_input = np.dot(hidden_output, wout) + bout
+    output = sigmoid(final_input)
+
+    # Backpropagation
+    error = y - output
+    d_output = error * sigmoid_derivative(output)
+    d_hidden = d_output.dot(wout.T) * sigmoid_derivative(hidden_output)
+
+    # Weight & bias updates
+    wout += hidden_output.T.dot(d_output) * lr
+    wh += X.T.dot(d_hidden) * lr
+
+    # Display progress
+    print(f"\n---- Epoch {epoch+1} ----")
+    print("Predicted Output:\n", output)
+
+# Final results
+print("\nFinal Predicted Output:\n", output)
+

myawesomepkg/TSAPY1/p7_2_bds_association_rule_mining.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+"""P7-2 BDS Association Rule Mining.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1Uk4gqoyuXgyg-PkXLM8bEVdLG-W-CwAa
+"""
+
+pip install apyori
+
+pip install mlxtend
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+#from apyori import apriori
+
+data = pd.read_csv("/content/bread_basket.csv")
+data.head()
+
+transactions = []
+# Combine items in the same transaction into one place
+for i in data.Transaction.unique():
+    list_trans = list(set(data[data.Transaction == i]["Item"]))
+    if len(list_trans) > 0:
+        transactions.append(list_trans)
+
+print(transactions)
+
+"""The Apriori module requires a data frame with values of 0 and 1 or True and False. Therefore, we will use One Hot Encode the data to meet the requirement of the Apriori module given by mlxtend library"""
+
+import mlxtend
+from mlxtend.preprocessing import TransactionEncoder
+from mlxtend.frequent_patterns import association_rules, apriori
+
+trans_encoding = TransactionEncoder()
+df2 = trans_encoding.fit(transactions).transform(transactions)
+df3 = pd.DataFrame(df2, columns=trans_encoding.columns_)
+
+df3.head()
+
+"""The frequent sets are found using the apriori function. We will use the min_support = 0.05 , which implies the minimum support required for an itemset to be chosen. Meanwhile,use_colnames = True keeps column names for itemsets to make them more understandable."""
+
+frequent_set = apriori(df3, min_support = 0.05, use_colnames = True)
+
+frequent_set
+
+"""From these frequent sets, We want to find the association rules which determine if A is bought, then B is also purchased"""
+
+rules = association_rules(frequent_set, metric = 'lift', min_threshold = 1)
+
+rules
+
+"""Conclusion:
+As we can see, the results consist of two association rules only. Cake and Coffee are bought more frequently than random with the lift = 1.1 and 53% confidence.
+"""
+
+# Install required libraries
+# pip install mlxtend
+
+import pandas as pd
+from mlxtend.preprocessing import TransactionEncoder
+from mlxtend.frequent_patterns import apriori, association_rules
+
+# Step 1: Load the dataset
+data = pd.read_csv("/content/bread_basket.csv")
+print(data.head())
+
+# Step 2: Create a list of transactions
+transactions = []
+for t_id in data["Transaction"].unique():
+    items = list(set(data[data["Transaction"] == t_id]["Item"]))
+    if items:
+        transactions.append(items)
+
+print(f"\nTotal Transactions: {len(transactions)}")
+
+# Step 3: Convert to one-hot encoded DataFrame
+te = TransactionEncoder()
+encoded_data = te.fit(transactions).transform(transactions)
+df = pd.DataFrame(encoded_data, columns=te.columns_)
+
+print("\nOne-hot encoded data sample:")
+print(df.head())
+
+# Step 4: Generate frequent itemsets using Apriori
+frequent_items = apriori(df, min_support=0.05, use_colnames=True)
+print("\nFrequent Itemsets:")
+print(frequent_items)
+
+# Step 5: Generate association rules
+rules = association_rules(frequent_items, metric="lift", min_threshold=1)
+print("\nAssociation Rules:")
+print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])
+
+# Step 6: Summary
+print("\nConclusion:")
+print("Items like Cake and Coffee are often bought together with high support and confidence.")

myawesomepkg/TSAPY1/p8_1_gaussian_naive_bayes_.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""P8-1 Gaussian Naive Bayes .ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1hPQd9ZfvblikDc3KJosyOf3atsItL260
+"""
+
+import numpy as np
+import pandas as pd
+
+#Import dataset
+from sklearn import datasets
+
+#Load dataset
+wine = datasets.load_wine()
+print(wine)
+
+#print the names of the 13 features
+
+print ("Features: ", wine.feature_names)
+
+#print the label type of wine
+
+print ("Labels: ", wine.target_names)
+
+X=pd.DataFrame(wine['data'])
+print(X.head())
+
+#Checking the dimensions of the dataset
+print(wine.data.shape)
+
+#print the wine labels (0:Class_0, 1:class_2, 2:class_2)
+y=print (wine.target)
+
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(wine.data, wine.target, test_size=0.30,random_state=109)
+
+#Import Gaussian Naive Bayes model
+from sklearn.naive_bayes import GaussianNB
+
+#Create a Gaussian Classifier
+gnb = GaussianNB()
+
+#Train the model using the training sets
+gnb.fit(X_train, y_train)
+
+#Predict the response for test dataset
+y_pred = gnb.predict(X_test)
+print(y_pred)
+
+#Import scikit-learn metrics module for accuracy calculation
+from sklearn import metrics
+
+# Model Accuracy
+print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
+
+#confusion matrix
+from sklearn.metrics import  confusion_matrix
+cm=np.array(confusion_matrix(y_test,y_pred))
+cm
+
+# Simple Gaussian Naive Bayes Example using Wine Dataset
+
+
+#my code+++++++++++++
+
+from sklearn.datasets import load_wine
+from sklearn.model_selection import train_test_split
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score, confusion_matrix
+
+# Load dataset
+wine = load_wine()
+
+# Features and labels
+X = wine.data
+y = wine.target
+
+# Split the data into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Create and train the model
+model = GaussianNB()
+model.fit(X_train, y_train)
+
+# Predict on test data
+y_pred = model.predict(X_test)
+
+# Print results
+print("Feature names:", wine.feature_names)
+print("Target names:", wine.target_names)
+print("\nPredicted labels:", y_pred)
+print("Accuracy:", accuracy_score(y_test, y_pred))
+print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
+