Upload jijifi.txt

jijifi.txt

@@ -0,0 +1,247 @@
+# K Means Clustering w elbow plot
+#importing libraries
+from sklearn.cluster import KMeans
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+import matplotlib.pyplot as plt
+#import dataset
+df = pd.read_csv("C:datasets\.csv")
+df.head()
+plt.scatter(df.Age, df.Income)
+plt.xlabel('Age')
+plt.ylabel('Income')
+scaler = MinMaxScaler()
+scaler.fit(df[['Income']])
+df['Income'] = scaler.transform(df[['Income']])
+
+scaler.fit(df[['Age']])
+df['Age'] = scaler.transform(df[['Age']])
+
+#Elbow plot
+sse = []
+k_rng = range(1, 10)
+for k in k_rng:
+    km = KMeans(n_clusters = k)
+    km.fit(df[['Age', 'Income']])
+    sse.append(km.inertia_)
+plt.xlabel('K')
+plt.ylabel('Sum of squared error')
+plt.plot(k_rng,sse)
+km = KMeans(n_clusters = 3)
+y_predicted = km.fit_predict(df[['Age', 'Income']])
+y_predicted
+km.cluster_centers_
+df['cluster']=y_predicted
+df.head()
+df1 = df[df.cluster == 0]
+df2 = df[df.cluster == 1]
+df3 = df[df.cluster == 2]
+
+plt.scatter(df1.Age, df1.Income, color = 'black')
+plt.scatter(df2.Age, df2.Income, color = 'orange')
+plt.scatter(df3.Age, df3.Income, color = 'maroon')
+plt.scatter(km.cluster_centers_[:,0], km.cluster_centers_[:,1], color = 'purple', marker = '*', label = 'centroid')
+plt.xlabel('Age')
+plt.ylabel('Income in $')
+
+#Association Rule Mining
+#!pip install --no-binary :all: mlxtend
+import pandas as pd
+from mlxtend.preprocessing import TransactionEncoder
+from mlxtend.frequent_patterns import apriori
+dataset = [["Milk", "Cola", "Beer"], 
+          ["Milk", "Pepsi", "Juice"], 
+          ["Milk", "Beer"],
+          ["Cola", "Juice"],
+          ["Milk", "Pepsi", "Beer"]]
+dataset
+var = TransactionEncoder()
+var_arr = var.fit(dataset).transform(dataset)
+df = pd.DataFrame(var_arr, columns = var.columns_)
+df
+#from mlxtend.frequent_patterns import apriori
+fq_is = apriori(df, min_support = 0.5, use_colnames = True)
+fq_is
+from mlxtend.frequent_patterns import association_rules
+rules_ap = association_rules(fq_is, metric = "confidence", min_threshold = 0.01)
+rules_ap
+
+##Decision Tree
+
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from sklearn import tree
+df = pd.read_csv('C:/Users/datasets/lung cancer.csv')
+df.head()
+df.isnull().any()
+le_GENDER = LabelEncoder()
+le_LUNG_CANCER = LabelEncoder()
+
+df['Gender'] = le_GENDER.fit_transform(df['GENDER'])
+df['LungCancer'] = le_LUNG_CANCER.fit_transform(df['LUNG_CANCER'])
+
+df.head()
+df = df.drop(['GENDER','LUNG_CANCER'], axis = 1)
+df.head()
+inputs = df.drop('LungCancer', axis = 1)
+target = df['LungCancer']
+inputs.head()
+print(target)
+from sklearn import tree
+model = tree.DecisionTreeClassifier()
+model.fit(inputs, target)
+model.score(inputs, target)
+print(model.predict([[63,1,2,2,1,2,1,1,2,1,2,1,1,2,2]]))
+tree.plot_tree(model) 
+
+##SVM bank loan
+
+# libraries
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn
+import sklearn
+from sklearn import model_selection
+from sklearn.model_selection import train_test_split
+from sklearn import svm
+from sklearn.svm import SVC
+from sklearn import metrics
+from sklearn.metrics import confusion_matrix
+from sklearn.metrics import classification_report
+from sklearn.metrics import roc_curve, auc 
+bl = pd.read_csv("C:/fifi.csv")
+bl = pd.DataFrame(bl)
+bl_data = bl.drop(['address','ed','debtinc','employ'],1)
+bl_data.head(3)
+x = bl_data.drop('default', axis = 1)
+y = bl_data.default
+x.head()
+y.head()
+x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=0)
+# building an SVM having penalty 10 and gamma auto optimized
+svct = SVC(kernel = 'linear',
+               C = 10, gamma = 'auto', 
+               probability = True).fit(x_train, y_train)
+
+print(svct)
+y_pred = svct.predict(x_test)
+y_pred
+cnf = confusion_matrix(y_test, y_pred)
+cnf
+# ROC Curve with AUC Plotting
+# finding probabilities for 0 and 1 classses
+preds1 = svct.predict_proba(x_test)[:,1]
+print(preds1)
+from sklearn.metrics import roc_curve, auc 
+fpr1, tpr1, thresholds1 = metrics.roc_curve(y_test, preds1)
+fpr1
+tpr1
+thresholds1	
+df1 = pd.DataFrame(dict(fpr = fpr1, tpr = tpr1))
+auc = metrics.auc(fpr1, tpr1)
+# plotting
+plt.figure()
+plt.plot(fpr1, tpr1, color = 'darkorange', label = 'ROC CURVE(area = %0.2f)' % auc)
+plt.plot([0,1], [0,1], color = 'navy')
+plt.xlim([0.0, 1.0])
+plt.ylim([0.0, 1.05])
+plt.xlabel('False Positive Rate')
+plt.ylabel('True Positive Rate')
+plt.title('ROC example')
+plt.legend(loc = 'lower right')
+plt.show()
+
+##SVM Iris
+from sklearn import svm
+import pandas as pd
+df = pd.read_csv("C:datasets/iris_df.csv")
+df.head(5)
+df.columns = ['X4','X3','X1','X2','Y']
+df = df.drop(['X4','X3'],1)
+df.head()
+from sklearn.model_selection import train_test_split
+from sklearn import svm
+x = df.drop("Y", axis = 1)
+y = df.Y
+
+support = svm.SVC()
+
+
+trainx, testx, trainy, testy = train_test_split(x,y, test_size = 0.3)
+support.fit(trainx, trainy)
+print('Accuracy:/n', support.score(testx, testy))
+
+pred = support.predict(testx)
+import pandas as pd
+import numpy as np
+from sklearn import linear_model
+import matplotlib.pyplot as plt
+df = pd.read_csv("C:datasets/house_price.csv")
+df.head()
+plt.xlabel('area')
+plt.ylabel('price')
+plt.scatter(df.area,df.price,color = 'blue')
+reg = linear_model.LinearRegression()
+reg.fit(df[['area']], df.price)
+# prediction
+reg.predict([[3100]])
+reg.coef_
+reg.intercept_
+plt.xlabel('area')
+plt.ylabel('price')
+plt.scatter(df.area,df.price,color='green')
+plt.plot(df.area,reg.predict(df[['area']]), color = 'red')
+
+##Linear Regression Multiple Variable
+# pandas numpy
+from sklearn import linear_model
+df = pd.read_csv("C:/house_pricemodel.csv")
+df.head()
+df.isnull()
+df.bedrooms.median()
+df.bedrooms = df.bedrooms.fillna(df.bedrooms.median())
+df
+reg = linear_model.LinearRegression()
+reg.fit(df.drop('price', axis = 1), df.price)
+reg.coef_
+reg.predict([[3200,3,10]])
+##SImple Logistic Regression
+# pandas, matplotlib
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+df = pd.read_csv("C:/Users//Datasets/insurance_age.csv")
+df.head()
+plt.scatter(df.age,df.bought_insurance, marker ='*', color = 'purple')
+x_train, x_test, y_train, y_test = train_test_split(df[['age']], df.bought_insurance, train_size=0.8)
+model = LogisticRegression()
+model.fit(x_train, y_train)
+y_predicted = model.predict(x_test)
+model.predict_proba(x_test)
+model.score(x_test, y_test)
+y_predicted
+model.predict([[45]])
+##Gradient descent simple
+import numpy as np
+import matplotlib.pyplot as plt
+def gradient_descent(x,y):
+    m_curr = b_curr = 0
+    iterations = 10000
+    n = len(x)     # length of x
+    learning_rate = 0.001
+    #learning rate = .00001
+    
+    
+    
+    for i in range(iterations):
+        y_predicted = m_curr * x + b_curr
+        cost = (1/n) * sum([val**2 for val in (y-y_predicted)])
+        md = -(2/n)*sum(x*(y-y_predicted))     # m derivative
+        bd = -(2/n)*sum(y-y_predicted)         # b derivative
+        m_curr = m_curr - learning_rate * md
+        b_curr = b_curr - learning_rate * bd
+        #print ("m {}, b {}, iteration {}".format(m_curr,b_curr, i))
+        print ("m {}, b {}, cost {} iteration {}".format(m_curr,b_curr,cost, i))    # each iteration to print the values
+x = np.array([1,2,3,4,5])
+y = np.array([5,7,9,11,13])
+gradient_descent(x,y)